compiler/rustc_typeck/src/check/intrinsic.rs

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