compiler/rustc_mir_transform/src/add_moves_for_packed_drops.rs

   1 use rustc_middle::mir::*;
   2 use rustc_middle::ty::TyCtxt;
   3
   4 use crate::util;
   5 use crate::MirPass;
   6 use rustc_middle::mir::patch::MirPatch;
   7
   8 /// This pass moves values being dropped that are within a packed
   9 /// struct to a separate local before dropping them, to ensure that
  10 /// they are dropped from an aligned address.
  11 ///
  12 /// For example, if we have something like
  13 /// ```ignore (ilustrative)
  14 /// #[repr(packed)]
  15 /// struct Foo {
  16 ///     dealign: u8,
  17 ///     data: Vec<u8>
  18 /// }
  19 ///
  20 /// let foo = ...;
  21 /// ```
  22 ///
  23 /// We want to call `drop_in_place::<Vec<u8>>` on `data` from an aligned
  24 /// address. This means we can't simply drop `foo.data` directly, because
  25 /// its address is not aligned.
  26 ///
  27 /// Instead, we move `foo.data` to a local and drop that:
  28 /// ```ignore (ilustrative)
  29 ///     storage.live(drop_temp)
  30 ///     drop_temp = foo.data;
  31 ///     drop(drop_temp) -> next
  32 /// next:
  33 ///     storage.dead(drop_temp)
  34 /// ```
  35 ///
  36 /// The storage instructions are required to avoid stack space
  37 /// blowup.
  38 pub struct AddMovesForPackedDrops;
  39
  40 impl<'tcx> MirPass<'tcx> for AddMovesForPackedDrops {
  41     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
  42         debug!("add_moves_for_packed_drops({:?} @ {:?})", body.source, body.span);
  43         add_moves_for_packed_drops(tcx, body);
  44     }
  45 }
  46
  47 pub fn add_moves_for_packed_drops<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
  48     let patch = add_moves_for_packed_drops_patch(tcx, body);
  49     patch.apply(body);
  50 }
  51
  52 fn add_moves_for_packed_drops_patch<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) -> MirPatch<'tcx> {
  53     let def_id = body.source.def_id();
  54     let mut patch = MirPatch::new(body);
  55     let param_env = tcx.param_env(def_id);
  56
  57     for (bb, data) in body.basic_blocks.iter_enumerated() {
  58         let loc = Location { block: bb, statement_index: data.statements.len() };
  59         let terminator = data.terminator();
  60
  61         match terminator.kind {
  62             TerminatorKind::Drop { place, .. }
  63                 if util::is_disaligned(tcx, body, param_env, place) =>
  64             {
  65                 add_move_for_packed_drop(tcx, body, &mut patch, terminator, loc, data.is_cleanup);
  66             }
  67             TerminatorKind::DropAndReplace { .. } => {
  68                 span_bug!(terminator.source_info.span, "replace in AddMovesForPackedDrops");
  69             }
  70             _ => {}
  71         }
  72     }
  73
  74     patch
  75 }
  76
  77 fn add_move_for_packed_drop<'tcx>(
  78     tcx: TyCtxt<'tcx>,
  79     body: &Body<'tcx>,
  80     patch: &mut MirPatch<'tcx>,
  81     terminator: &Terminator<'tcx>,
  82     loc: Location,
  83     is_cleanup: bool,
  84 ) {
  85     debug!("add_move_for_packed_drop({:?} @ {:?})", terminator, loc);
  86     let TerminatorKind::Drop { ref place, target, unwind } = terminator.kind else {
  87         unreachable!();
  88     };
  89
  90     let source_info = terminator.source_info;
  91     let ty = place.ty(body, tcx).ty;
  92     let temp = patch.new_temp(ty, terminator.source_info.span);
  93
  94     let storage_dead_block = patch.new_block(BasicBlockData {
  95         statements: vec![Statement { source_info, kind: StatementKind::StorageDead(temp) }],
  96         terminator: Some(Terminator { source_info, kind: TerminatorKind::Goto { target } }),
  97         is_cleanup,
  98     });
  99
 100     patch.add_statement(loc, StatementKind::StorageLive(temp));
 101     patch.add_assign(loc, Place::from(temp), Rvalue::Use(Operand::Move(*place)));
 102     patch.patch_terminator(
 103         loc.block,
 104         TerminatorKind::Drop { place: Place::from(temp), target: storage_dead_block, unwind },
 105     );
 106 }