compiler/rustc_mir_transform/src/lower_intrinsics.rs

   1 //! Lowers intrinsic calls
   2
   3 use crate::MirPass;
   4 use rustc_middle::mir::*;
   5 use rustc_middle::ty::subst::SubstsRef;
   6 use rustc_middle::ty::{self, Ty, TyCtxt};
   7 use rustc_span::symbol::{sym, Symbol};
   8 use rustc_span::Span;
   9 use rustc_target::spec::abi::Abi;
  10
  11 pub struct LowerIntrinsics;
  12
  13 impl<'tcx> MirPass<'tcx> for LowerIntrinsics {
  14     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
  15         let (basic_blocks, local_decls) = body.basic_blocks_and_local_decls_mut();
  16         for block in basic_blocks {
  17             let terminator = block.terminator.as_mut().unwrap();
  18             if let TerminatorKind::Call { func, args, destination, .. } = &mut terminator.kind {
  19                 let func_ty = func.ty(local_decls, tcx);
  20                 let Some((intrinsic_name, substs)) = resolve_rust_intrinsic(tcx, func_ty) else {
  21                     continue;
  22                 };
  23                 match intrinsic_name {
  24                     sym::unreachable => {
  25                         terminator.kind = TerminatorKind::Unreachable;
  26                     }
  27                     sym::forget => {
  28                         if let Some((destination, target)) = *destination {
  29                             block.statements.push(Statement {
  30                                 source_info: terminator.source_info,
  31                                 kind: StatementKind::Assign(Box::new((
  32                                     destination,
  33                                     Rvalue::Use(Operand::Constant(Box::new(Constant {
  34                                         span: terminator.source_info.span,
  35                                         user_ty: None,
  36                                         literal: ty::Const::zero_sized(tcx, tcx.types.unit).into(),
  37                                     }))),
  38                                 ))),
  39                             });
  40                             terminator.kind = TerminatorKind::Goto { target };
  41                         }
  42                     }
  43                     sym::copy_nonoverlapping => {
  44                         let target = destination.unwrap().1;
  45                         let mut args = args.drain(..);
  46                         block.statements.push(Statement {
  47                             source_info: terminator.source_info,
  48                             kind: StatementKind::CopyNonOverlapping(Box::new(
  49                                 rustc_middle::mir::CopyNonOverlapping {
  50                                     src: args.next().unwrap(),
  51                                     dst: args.next().unwrap(),
  52                                     count: args.next().unwrap(),
  53                                 },
  54                             )),
  55                         });
  56                         assert_eq!(
  57                             args.next(),
  58                             None,
  59                             "Extra argument for copy_non_overlapping intrinsic"
  60                         );
  61                         drop(args);
  62                         terminator.kind = TerminatorKind::Goto { target };
  63                     }
  64                     sym::wrapping_add | sym::wrapping_sub | sym::wrapping_mul => {
  65                         if let Some((destination, target)) = *destination {
  66                             let lhs;
  67                             let rhs;
  68                             {
  69                                 let mut args = args.drain(..);
  70                                 lhs = args.next().unwrap();
  71                                 rhs = args.next().unwrap();
  72                             }
  73                             let bin_op = match intrinsic_name {
  74                                 sym::wrapping_add => BinOp::Add,
  75                                 sym::wrapping_sub => BinOp::Sub,
  76                                 sym::wrapping_mul => BinOp::Mul,
  77                                 _ => bug!("unexpected intrinsic"),
  78                             };
  79                             block.statements.push(Statement {
  80                                 source_info: terminator.source_info,
  81                                 kind: StatementKind::Assign(Box::new((
  82                                     destination,
  83                                     Rvalue::BinaryOp(bin_op, Box::new((lhs, rhs))),
  84                                 ))),
  85                             });
  86                             terminator.kind = TerminatorKind::Goto { target };
  87                         }
  88                     }
  89                     sym::add_with_overflow | sym::sub_with_overflow | sym::mul_with_overflow => {
  90                         // The checked binary operations are not suitable target for lowering here,
  91                         // since their semantics depend on the value of overflow-checks flag used
  92                         // during codegen. Issue #35310.
  93                     }
  94                     sym::size_of | sym::min_align_of => {
  95                         if let Some((destination, target)) = *destination {
  96                             let tp_ty = substs.type_at(0);
  97                             let null_op = match intrinsic_name {
  98                                 sym::size_of => NullOp::SizeOf,
  99                                 sym::min_align_of => NullOp::AlignOf,
 100                                 _ => bug!("unexpected intrinsic"),
 101                             };
 102                             block.statements.push(Statement {
 103                                 source_info: terminator.source_info,
 104                                 kind: StatementKind::Assign(Box::new((
 105                                     destination,
 106                                     Rvalue::NullaryOp(null_op, tp_ty),
 107                                 ))),
 108                             });
 109                             terminator.kind = TerminatorKind::Goto { target };
 110                         }
 111                     }
 112                     sym::discriminant_value => {
 113                         if let (Some((destination, target)), Some(arg)) =
 114                             (*destination, args[0].place())
 115                         {
 116                             let arg = tcx.mk_place_deref(arg);
 117                             block.statements.push(Statement {
 118                                 source_info: terminator.source_info,
 119                                 kind: StatementKind::Assign(Box::new((
 120                                     destination,
 121                                     Rvalue::Discriminant(arg),
 122                                 ))),
 123                             });
 124                             terminator.kind = TerminatorKind::Goto { target };
 125                         }
 126                     }
 127                     _ if intrinsic_name.as_str().starts_with("simd_shuffle") => {
 128                         validate_simd_shuffle(tcx, args, terminator.source_info.span);
 129                     }
 130                     _ => {}
 131                 }
 132             }
 133         }
 134     }
 135 }
 136
 137 fn resolve_rust_intrinsic<'tcx>(
 138     tcx: TyCtxt<'tcx>,
 139     func_ty: Ty<'tcx>,
 140 ) -> Option<(Symbol, SubstsRef<'tcx>)> {
 141     if let ty::FnDef(def_id, substs) = *func_ty.kind() {
 142         let fn_sig = func_ty.fn_sig(tcx);
 143         if let Abi::RustIntrinsic | Abi::PlatformIntrinsic = fn_sig.abi() {
 144             return Some((tcx.item_name(def_id), substs));
 145         }
 146     }
 147     None
 148 }
 149
 150 fn validate_simd_shuffle<'tcx>(tcx: TyCtxt<'tcx>, args: &[Operand<'tcx>], span: Span) {
 151     match &args[2] {
 152         Operand::Constant(_) => {} // all good
 153         _ => {
 154             let msg = "last argument of `simd_shuffle` is required to be a `const` item";
 155             tcx.sess.span_err(span, msg);
 156         }
 157     }
 158 }