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