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