src/librustc_typeck/check/intrinsic.rs

   1 //! Type-checking for the rust-intrinsic and platform-intrinsic
   2 //! intrinsics that the compiler exposes.
   3
   4 use crate::require_same_types;
   5
   6 use rustc_errors::struct_span_err;
   7 use rustc_hir as hir;
   8 use rustc_hir::def_id::DefId;
   9 use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
  10 use rustc_middle::ty::subst::Subst;
  11 use rustc_middle::ty::{self, Ty, TyCtxt};
  12 use rustc_span::symbol::{kw, sym, Symbol};
  13 use rustc_target::spec::abi::Abi;
  14
  15 use std::iter;
  16
  17 fn equate_intrinsic_type<'tcx>(
  18     tcx: TyCtxt<'tcx>,
  19     it: &hir::ForeignItem<'_>,
  20     def_id: DefId,
  21     n_tps: usize,
  22     abi: Abi,
  23     safety: hir::Unsafety,
  24     inputs: Vec<Ty<'tcx>>,
  25     output: Ty<'tcx>,
  26 ) {
  27     match it.kind {
  28         hir::ForeignItemKind::Fn(..) => {}
  29         _ => {
  30             struct_span_err!(tcx.sess, it.span, E0622, "intrinsic must be a function")
  31                 .span_label(it.span, "expected a function")
  32                 .emit();
  33             return;
  34         }
  35     }
  36
  37     let i_n_tps = tcx.generics_of(def_id).own_counts().types;
  38     if i_n_tps != n_tps {
  39         let span = match it.kind {
  40             hir::ForeignItemKind::Fn(_, _, ref generics) => generics.span,
  41             _ => bug!(),
  42         };
  43
  44         struct_span_err!(
  45             tcx.sess,
  46             span,
  47             E0094,
  48             "intrinsic has wrong number of type \
  49                          parameters: found {}, expected {}",
  50             i_n_tps,
  51             n_tps
  52         )
  53         .span_label(span, format!("expected {} type parameter", n_tps))
  54         .emit();
  55         return;
  56     }
  57
  58     let fty = tcx.mk_fn_ptr(ty::Binder::bind(tcx.mk_fn_sig(
  59         inputs.into_iter(),
  60         output,
  61         false,
  62         safety,
  63         abi,
  64     )));
  65     let cause = ObligationCause::new(it.span, it.hir_id, ObligationCauseCode::IntrinsicType);
  66     require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(def_id)), fty);
  67 }
  68
  69 /// Returns `true` if the given intrinsic is unsafe to call or not.
  70 pub fn intrinsic_operation_unsafety(intrinsic: Symbol) -> hir::Unsafety {
  71     match intrinsic {
  72         sym::abort
  73         | sym::size_of
  74         | sym::min_align_of
  75         | sym::needs_drop
  76         | sym::caller_location
  77         | sym::size_of_val
  78         | sym::min_align_of_val
  79         | sym::add_with_overflow
  80         | sym::sub_with_overflow
  81         | sym::mul_with_overflow
  82         | sym::wrapping_add
  83         | sym::wrapping_sub
  84         | sym::wrapping_mul
  85         | sym::saturating_add
  86         | sym::saturating_sub
  87         | sym::rotate_left
  88         | sym::rotate_right
  89         | sym::ctpop
  90         | sym::ctlz
  91         | sym::cttz
  92         | sym::bswap
  93         | sym::bitreverse
  94         | sym::discriminant_value
  95         | sym::type_id
  96         | sym::likely
  97         | sym::unlikely
  98         | sym::ptr_guaranteed_eq
  99         | sym::ptr_guaranteed_ne
 100         | sym::minnumf32
 101         | sym::minnumf64
 102         | sym::maxnumf32
 103         | sym::rustc_peek
 104         | sym::maxnumf64
 105         | sym::type_name
 106         | sym::variant_count => hir::Unsafety::Normal,
 107         _ => hir::Unsafety::Unsafe,
 108     }
 109 }
 110
 111 /// Remember to add all intrinsics here, in librustc_codegen_llvm/intrinsic.rs,
 112 /// and in libcore/intrinsics.rs
 113 pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 114     let param = |n| tcx.mk_ty_param(n, Symbol::intern(&format!("P{}", n)));
 115     let def_id = tcx.hir().local_def_id(it.hir_id).to_def_id();
 116     let intrinsic_name = tcx.item_name(def_id);
 117     let name_str = intrinsic_name.as_str();
 118
 119     let mk_va_list_ty = |mutbl| {
 120         tcx.lang_items().va_list().map(|did| {
 121             let region = tcx.mk_region(ty::ReLateBound(ty::INNERMOST, ty::BrAnon(0)));
 122             let env_region = ty::ReLateBound(ty::INNERMOST, ty::BrEnv);
 123             let va_list_ty = tcx.type_of(did).subst(tcx, &[region.into()]);
 124             (
 125                 tcx.mk_ref(tcx.mk_region(env_region), ty::TypeAndMut { ty: va_list_ty, mutbl }),
 126                 va_list_ty,
 127             )
 128         })
 129     };
 130
 131     let (n_tps, inputs, output, unsafety) = if name_str.starts_with("atomic_") {
 132         let split: Vec<&str> = name_str.split('_').collect();
 133         assert!(split.len() >= 2, "Atomic intrinsic in an incorrect format");
 134
 135         //We only care about the operation here
 136         let (n_tps, inputs, output) = match split[1] {
 137             "cxchg" | "cxchgweak" => (
 138                 1,
 139                 vec![tcx.mk_mut_ptr(param(0)), param(0), param(0)],
 140                 tcx.intern_tup(&[param(0), tcx.types.bool]),
 141             ),
 142             "load" => (1, vec![tcx.mk_imm_ptr(param(0))], param(0)),
 143             "store" => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
 144
 145             "xchg" | "xadd" | "xsub" | "and" | "nand" | "or" | "xor" | "max" | "min" | "umax"
 146             | "umin" => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], param(0)),
 147             "fence" | "singlethreadfence" => (0, Vec::new(), tcx.mk_unit()),
 148             op => {
 149                 struct_span_err!(
 150                     tcx.sess,
 151                     it.span,
 152                     E0092,
 153                     "unrecognized atomic operation function: `{}`",
 154                     op
 155                 )
 156                 .span_label(it.span, "unrecognized atomic operation")
 157                 .emit();
 158                 return;
 159             }
 160         };
 161         (n_tps, inputs, output, hir::Unsafety::Unsafe)
 162     } else {
 163         let unsafety = intrinsic_operation_unsafety(intrinsic_name);
 164         let (n_tps, inputs, output) = match intrinsic_name {
 165             sym::abort => (0, Vec::new(), tcx.types.never),
 166             sym::unreachable => (0, Vec::new(), tcx.types.never),
 167             sym::breakpoint => (0, Vec::new(), tcx.mk_unit()),
 168             sym::size_of | sym::pref_align_of | sym::min_align_of | sym::variant_count => {
 169                 (1, Vec::new(), tcx.types.usize)
 170             }
 171             sym::size_of_val | sym::min_align_of_val => {
 172                 (1, vec![tcx.mk_imm_ptr(param(0))], tcx.types.usize)
 173             }
 174             sym::rustc_peek => (1, vec![param(0)], param(0)),
 175             sym::caller_location => (0, vec![], tcx.caller_location_ty()),
 176             sym::assert_inhabited | sym::assert_zero_valid | sym::assert_uninit_valid => {
 177                 (1, Vec::new(), tcx.mk_unit())
 178             }
 179             sym::forget => (1, vec![param(0)], tcx.mk_unit()),
 180             sym::transmute => (2, vec![param(0)], param(1)),
 181             sym::move_val_init => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
 182             sym::prefetch_read_data
 183             | sym::prefetch_write_data
 184             | sym::prefetch_read_instruction
 185             | sym::prefetch_write_instruction => (
 186                 1,
 187                 vec![
 188                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
 189                     tcx.types.i32,
 190                 ],
 191                 tcx.mk_unit(),
 192             ),
 193             sym::drop_in_place => (1, vec![tcx.mk_mut_ptr(param(0))], tcx.mk_unit()),
 194             sym::needs_drop => (1, Vec::new(), tcx.types.bool),
 195
 196             sym::type_name => (1, Vec::new(), tcx.mk_static_str()),
 197             sym::type_id => (1, Vec::new(), tcx.types.u64),
 198             sym::offset | sym::arith_offset => (
 199                 1,
 200                 vec![
 201                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
 202                     tcx.types.isize,
 203                 ],
 204                 tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
 205             ),
 206             sym::copy | sym::copy_nonoverlapping => (
 207                 1,
 208                 vec![
 209                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
 210                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }),
 211                     tcx.types.usize,
 212                 ],
 213                 tcx.mk_unit(),
 214             ),
 215             sym::volatile_copy_memory | sym::volatile_copy_nonoverlapping_memory => (
 216                 1,
 217                 vec![
 218                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }),
 219                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Not }),
 220                     tcx.types.usize,
 221                 ],
 222                 tcx.mk_unit(),
 223             ),
 224             sym::write_bytes | sym::volatile_set_memory => (
 225                 1,
 226                 vec![
 227                     tcx.mk_ptr(ty::TypeAndMut { ty: param(0), mutbl: hir::Mutability::Mut }),
 228                     tcx.types.u8,
 229                     tcx.types.usize,
 230                 ],
 231                 tcx.mk_unit(),
 232             ),
 233             sym::sqrtf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 234             sym::sqrtf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 235             sym::powif32 => (0, vec![tcx.types.f32, tcx.types.i32], tcx.types.f32),
 236             sym::powif64 => (0, vec![tcx.types.f64, tcx.types.i32], tcx.types.f64),
 237             sym::sinf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 238             sym::sinf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 239             sym::cosf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 240             sym::cosf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 241             sym::powf32 => (0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
 242             sym::powf64 => (0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
 243             sym::expf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 244             sym::expf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 245             sym::exp2f32 => (0, vec![tcx.types.f32], tcx.types.f32),
 246             sym::exp2f64 => (0, vec![tcx.types.f64], tcx.types.f64),
 247             sym::logf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 248             sym::logf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 249             sym::log10f32 => (0, vec![tcx.types.f32], tcx.types.f32),
 250             sym::log10f64 => (0, vec![tcx.types.f64], tcx.types.f64),
 251             sym::log2f32 => (0, vec![tcx.types.f32], tcx.types.f32),
 252             sym::log2f64 => (0, vec![tcx.types.f64], tcx.types.f64),
 253             sym::fmaf32 => (0, vec![tcx.types.f32, tcx.types.f32, tcx.types.f32], tcx.types.f32),
 254             sym::fmaf64 => (0, vec![tcx.types.f64, tcx.types.f64, tcx.types.f64], tcx.types.f64),
 255             sym::fabsf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 256             sym::fabsf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 257             sym::minnumf32 => (0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
 258             sym::minnumf64 => (0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
 259             sym::maxnumf32 => (0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
 260             sym::maxnumf64 => (0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
 261             sym::copysignf32 => (0, vec![tcx.types.f32, tcx.types.f32], tcx.types.f32),
 262             sym::copysignf64 => (0, vec![tcx.types.f64, tcx.types.f64], tcx.types.f64),
 263             sym::floorf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 264             sym::floorf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 265             sym::ceilf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 266             sym::ceilf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 267             sym::truncf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 268             sym::truncf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 269             sym::rintf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 270             sym::rintf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 271             sym::nearbyintf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 272             sym::nearbyintf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 273             sym::roundf32 => (0, vec![tcx.types.f32], tcx.types.f32),
 274             sym::roundf64 => (0, vec![tcx.types.f64], tcx.types.f64),
 275
 276             sym::volatile_load | sym::unaligned_volatile_load => {
 277                 (1, vec![tcx.mk_imm_ptr(param(0))], param(0))
 278             }
 279             sym::volatile_store | sym::unaligned_volatile_store => {
 280                 (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit())
 281             }
 282
 283             sym::ctpop
 284             | sym::ctlz
 285             | sym::ctlz_nonzero
 286             | sym::cttz
 287             | sym::cttz_nonzero
 288             | sym::bswap
 289             | sym::bitreverse => (1, vec![param(0)], param(0)),
 290
 291             sym::add_with_overflow | sym::sub_with_overflow | sym::mul_with_overflow => {
 292                 (1, vec![param(0), param(0)], tcx.intern_tup(&[param(0), tcx.types.bool]))
 293             }
 294
 295             sym::ptr_guaranteed_eq | sym::ptr_guaranteed_ne => {
 296                 (1, vec![tcx.mk_imm_ptr(param(0)), tcx.mk_imm_ptr(param(0))], tcx.types.bool)
 297             }
 298
 299             sym::ptr_offset_from => {
 300                 (1, vec![tcx.mk_imm_ptr(param(0)), tcx.mk_imm_ptr(param(0))], tcx.types.isize)
 301             }
 302             sym::unchecked_div | sym::unchecked_rem | sym::exact_div => {
 303                 (1, vec![param(0), param(0)], param(0))
 304             }
 305             sym::unchecked_shl | sym::unchecked_shr | sym::rotate_left | sym::rotate_right => {
 306                 (1, vec![param(0), param(0)], param(0))
 307             }
 308             sym::unchecked_add | sym::unchecked_sub | sym::unchecked_mul => {
 309                 (1, vec![param(0), param(0)], param(0))
 310             }
 311             sym::wrapping_add | sym::wrapping_sub | sym::wrapping_mul => {
 312                 (1, vec![param(0), param(0)], param(0))
 313             }
 314             sym::saturating_add | sym::saturating_sub => (1, vec![param(0), param(0)], param(0)),
 315             sym::fadd_fast | sym::fsub_fast | sym::fmul_fast | sym::fdiv_fast | sym::frem_fast => {
 316                 (1, vec![param(0), param(0)], param(0))
 317             }
 318             sym::float_to_int_unchecked => (2, vec![param(0)], param(1)),
 319
 320             sym::assume => (0, vec![tcx.types.bool], tcx.mk_unit()),
 321             sym::likely => (0, vec![tcx.types.bool], tcx.types.bool),
 322             sym::unlikely => (0, vec![tcx.types.bool], tcx.types.bool),
 323
 324             sym::discriminant_value => {
 325                 let assoc_items =
 326                     tcx.associated_items(tcx.lang_items().discriminant_kind_trait().unwrap());
 327                 let discriminant_def_id = assoc_items.in_definition_order().next().unwrap().def_id;
 328
 329                 (
 330                     1,
 331                     vec![tcx.mk_imm_ref(
 332                         tcx.mk_region(ty::ReLateBound(ty::INNERMOST, ty::BrAnon(0))),
 333                         param(0),
 334                     )],
 335                     tcx.mk_projection(discriminant_def_id, tcx.mk_substs([param(0).into()].iter())),
 336                 )
 337             }
 338
 339             kw::Try => {
 340                 let mut_u8 = tcx.mk_mut_ptr(tcx.types.u8);
 341                 let try_fn_ty = ty::Binder::bind(tcx.mk_fn_sig(
 342                     iter::once(mut_u8),
 343                     tcx.mk_unit(),
 344                     false,
 345                     hir::Unsafety::Normal,
 346                     Abi::Rust,
 347                 ));
 348                 let catch_fn_ty = ty::Binder::bind(tcx.mk_fn_sig(
 349                     [mut_u8, mut_u8].iter().cloned(),
 350                     tcx.mk_unit(),
 351                     false,
 352                     hir::Unsafety::Normal,
 353                     Abi::Rust,
 354                 ));
 355                 (
 356                     0,
 357                     vec![tcx.mk_fn_ptr(try_fn_ty), mut_u8, tcx.mk_fn_ptr(catch_fn_ty)],
 358                     tcx.types.i32,
 359                 )
 360             }
 361
 362             sym::va_start | sym::va_end => match mk_va_list_ty(hir::Mutability::Mut) {
 363                 Some((va_list_ref_ty, _)) => (0, vec![va_list_ref_ty], tcx.mk_unit()),
 364                 None => bug!("`va_list` language item needed for C-variadic intrinsics"),
 365             },
 366
 367             sym::va_copy => match mk_va_list_ty(hir::Mutability::Not) {
 368                 Some((va_list_ref_ty, va_list_ty)) => {
 369                     let va_list_ptr_ty = tcx.mk_mut_ptr(va_list_ty);
 370                     (0, vec![va_list_ptr_ty, va_list_ref_ty], tcx.mk_unit())
 371                 }
 372                 None => bug!("`va_list` language item needed for C-variadic intrinsics"),
 373             },
 374
 375             sym::va_arg => match mk_va_list_ty(hir::Mutability::Mut) {
 376                 Some((va_list_ref_ty, _)) => (1, vec![va_list_ref_ty], param(0)),
 377                 None => bug!("`va_list` language item needed for C-variadic intrinsics"),
 378             },
 379
 380             sym::nontemporal_store => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
 381
 382             sym::count_code_region => (
 383                 0,
 384                 vec![
 385                     tcx.types.u64,
 386                     tcx.types.u32,
 387                     tcx.mk_static_str(),
 388                     tcx.types.u32,
 389                     tcx.types.u32,
 390                     tcx.types.u32,
 391                     tcx.types.u32,
 392                 ],
 393                 tcx.mk_unit(),
 394             ),
 395
 396             sym::coverage_counter_add | sym::coverage_counter_subtract => (
 397                 0,
 398                 vec![
 399                     tcx.types.u32,
 400                     tcx.types.u32,
 401                     tcx.types.u32,
 402                     tcx.mk_static_str(),
 403                     tcx.types.u32,
 404                     tcx.types.u32,
 405                     tcx.types.u32,
 406                     tcx.types.u32,
 407                 ],
 408                 tcx.mk_unit(),
 409             ),
 410
 411             sym::coverage_unreachable => (
 412                 0,
 413                 vec![
 414                     tcx.mk_static_str(),
 415                     tcx.types.u32,
 416                     tcx.types.u32,
 417                     tcx.types.u32,
 418                     tcx.types.u32,
 419                 ],
 420                 tcx.mk_unit(),
 421             ),
 422
 423             other => {
 424                 struct_span_err!(
 425                     tcx.sess,
 426                     it.span,
 427                     E0093,
 428                     "unrecognized intrinsic function: `{}`",
 429                     other,
 430                 )
 431                 .span_label(it.span, "unrecognized intrinsic")
 432                 .emit();
 433                 return;
 434             }
 435         };
 436         (n_tps, inputs, output, unsafety)
 437     };
 438     equate_intrinsic_type(tcx, it, def_id, n_tps, Abi::RustIntrinsic, unsafety, inputs, output)
 439 }
 440
 441 /// Type-check `extern "platform-intrinsic" { ... }` functions.
 442 pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 443     let param = |n| {
 444         let name = Symbol::intern(&format!("P{}", n));
 445         tcx.mk_ty_param(n, name)
 446     };
 447
 448     let def_id = tcx.hir().local_def_id(it.hir_id).to_def_id();
 449     let name = it.ident.name;
 450
 451     let (n_tps, inputs, output) = match name {
 452         sym::simd_eq | sym::simd_ne | sym::simd_lt | sym::simd_le | sym::simd_gt | sym::simd_ge => {
 453             (2, vec![param(0), param(0)], param(1))
 454         }
 455         sym::simd_add
 456         | sym::simd_sub
 457         | sym::simd_mul
 458         | sym::simd_rem
 459         | sym::simd_div
 460         | sym::simd_shl
 461         | sym::simd_shr
 462         | sym::simd_and
 463         | sym::simd_or
 464         | sym::simd_xor
 465         | sym::simd_fmin
 466         | sym::simd_fmax
 467         | sym::simd_fpow
 468         | sym::simd_saturating_add
 469         | sym::simd_saturating_sub => (1, vec![param(0), param(0)], param(0)),
 470         sym::simd_fsqrt
 471         | sym::simd_fsin
 472         | sym::simd_fcos
 473         | sym::simd_fexp
 474         | sym::simd_fexp2
 475         | sym::simd_flog2
 476         | sym::simd_flog10
 477         | sym::simd_flog
 478         | sym::simd_fabs
 479         | sym::simd_floor
 480         | sym::simd_ceil => (1, vec![param(0)], param(0)),
 481         sym::simd_fpowi => (1, vec![param(0), tcx.types.i32], param(0)),
 482         sym::simd_fma => (1, vec![param(0), param(0), param(0)], param(0)),
 483         sym::simd_gather => (3, vec![param(0), param(1), param(2)], param(0)),
 484         sym::simd_scatter => (3, vec![param(0), param(1), param(2)], tcx.mk_unit()),
 485         sym::simd_insert => (2, vec![param(0), tcx.types.u32, param(1)], param(0)),
 486         sym::simd_extract => (2, vec![param(0), tcx.types.u32], param(1)),
 487         sym::simd_cast => (2, vec![param(0)], param(1)),
 488         sym::simd_bitmask => (2, vec![param(0)], param(1)),
 489         sym::simd_select | sym::simd_select_bitmask => {
 490             (2, vec![param(0), param(1), param(1)], param(1))
 491         }
 492         sym::simd_reduce_all | sym::simd_reduce_any => (1, vec![param(0)], tcx.types.bool),
 493         sym::simd_reduce_add_ordered | sym::simd_reduce_mul_ordered => {
 494             (2, vec![param(0), param(1)], param(1))
 495         }
 496         sym::simd_reduce_add_unordered
 497         | sym::simd_reduce_mul_unordered
 498         | sym::simd_reduce_and
 499         | sym::simd_reduce_or
 500         | sym::simd_reduce_xor
 501         | sym::simd_reduce_min
 502         | sym::simd_reduce_max
 503         | sym::simd_reduce_min_nanless
 504         | sym::simd_reduce_max_nanless => (2, vec![param(0)], param(1)),
 505         name if name.as_str().starts_with("simd_shuffle") => {
 506             match name.as_str()["simd_shuffle".len()..].parse() {
 507                 Ok(n) => {
 508                     let params = vec![param(0), param(0), tcx.mk_array(tcx.types.u32, n)];
 509                     (2, params, param(1))
 510                 }
 511                 Err(_) => {
 512                     struct_span_err!(
 513                         tcx.sess,
 514                         it.span,
 515                         E0439,
 516                         "invalid `simd_shuffle`, needs length: `{}`",
 517                         name
 518                     )
 519                     .emit();
 520                     return;
 521                 }
 522             }
 523         }
 524         _ => {
 525             let msg = format!("unrecognized platform-specific intrinsic function: `{}`", name);
 526             tcx.sess.struct_span_err(it.span, &msg).emit();
 527             return;
 528         }
 529     };
 530
 531     equate_intrinsic_type(
 532         tcx,
 533         it,
 534         def_id,
 535         n_tps,
 536         Abi::PlatformIntrinsic,
 537         hir::Unsafety::Unsafe,
 538         inputs,
 539         output,
 540     )
 541 }