compiler/rustc_mir_transform/src/elaborate_box_derefs.rs

   1 //! This pass transforms derefs of Box into a deref of the pointer inside Box.
   2 //!
   3 //! Box is not actually a pointer so it is incorrect to dereference it directly.
   4
   5 use crate::MirPass;
   6 use rustc_hir::def_id::DefId;
   7 use rustc_index::vec::Idx;
   8 use rustc_middle::mir::patch::MirPatch;
   9 use rustc_middle::mir::visit::MutVisitor;
  10 use rustc_middle::mir::*;
  11 use rustc_middle::ty::subst::Subst;
  12 use rustc_middle::ty::{Ty, TyCtxt};
  13
  14 /// Constructs the types used when accessing a Box's pointer
  15 pub fn build_ptr_tys<'tcx>(
  16     tcx: TyCtxt<'tcx>,
  17     pointee: Ty<'tcx>,
  18     unique_did: DefId,
  19     nonnull_did: DefId,
  20 ) -> (Ty<'tcx>, Ty<'tcx>, Ty<'tcx>) {
  21     let substs = tcx.intern_substs(&[pointee.into()]);
  22     let unique_ty = tcx.bound_type_of(unique_did).subst(tcx, substs);
  23     let nonnull_ty = tcx.bound_type_of(nonnull_did).subst(tcx, substs);
  24     let ptr_ty = tcx.mk_imm_ptr(pointee);
  25
  26     (unique_ty, nonnull_ty, ptr_ty)
  27 }
  28
  29 // Constructs the projection needed to access a Box's pointer
  30 pub fn build_projection<'tcx>(
  31     unique_ty: Ty<'tcx>,
  32     nonnull_ty: Ty<'tcx>,
  33     ptr_ty: Ty<'tcx>,
  34 ) -> [PlaceElem<'tcx>; 3] {
  35     [
  36         PlaceElem::Field(Field::new(0), unique_ty),
  37         PlaceElem::Field(Field::new(0), nonnull_ty),
  38         PlaceElem::Field(Field::new(0), ptr_ty),
  39     ]
  40 }
  41
  42 struct ElaborateBoxDerefVisitor<'tcx, 'a> {
  43     tcx: TyCtxt<'tcx>,
  44     unique_did: DefId,
  45     nonnull_did: DefId,
  46     local_decls: &'a mut LocalDecls<'tcx>,
  47     patch: MirPatch<'tcx>,
  48 }
  49
  50 impl<'tcx, 'a> MutVisitor<'tcx> for ElaborateBoxDerefVisitor<'tcx, 'a> {
  51     fn tcx(&self) -> TyCtxt<'tcx> {
  52         self.tcx
  53     }
  54
  55     fn visit_place(
  56         &mut self,
  57         place: &mut Place<'tcx>,
  58         context: visit::PlaceContext,
  59         location: Location,
  60     ) {
  61         let tcx = self.tcx;
  62
  63         let base_ty = self.local_decls[place.local].ty;
  64
  65         // Derefer ensures that derefs are always the first projection
  66         if place.projection.first() == Some(&PlaceElem::Deref) && base_ty.is_box() {
  67             let source_info = self.local_decls[place.local].source_info;
  68
  69             let (unique_ty, nonnull_ty, ptr_ty) =
  70                 build_ptr_tys(tcx, base_ty.boxed_ty(), self.unique_did, self.nonnull_did);
  71
  72             let ptr_local = self.patch.new_internal(ptr_ty, source_info.span);
  73
  74             self.patch.add_assign(
  75                 location,
  76                 Place::from(ptr_local),
  77                 Rvalue::Use(Operand::Copy(
  78                     Place::from(place.local)
  79                         .project_deeper(&build_projection(unique_ty, nonnull_ty, ptr_ty), tcx),
  80                 )),
  81             );
  82
  83             place.local = ptr_local;
  84         }
  85
  86         self.super_place(place, context, location);
  87     }
  88 }
  89
  90 pub struct ElaborateBoxDerefs;
  91
  92 impl<'tcx> MirPass<'tcx> for ElaborateBoxDerefs {
  93     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
  94         if let Some(def_id) = tcx.lang_items().owned_box() {
  95             let unique_did = tcx.adt_def(def_id).non_enum_variant().fields[0].did;
  96
  97             let Some(nonnull_def) = tcx.type_of(unique_did).ty_adt_def() else {
  98                 span_bug!(tcx.def_span(unique_did), "expected Box to contain Unique")
  99             };
 100
 101             let nonnull_did = nonnull_def.non_enum_variant().fields[0].did;
 102
 103             let patch = MirPatch::new(body);
 104
 105             let local_decls = &mut body.local_decls;
 106
 107             let mut visitor =
 108                 ElaborateBoxDerefVisitor { tcx, unique_did, nonnull_did, local_decls, patch };
 109
 110             for (block, data) in body.basic_blocks.as_mut_preserves_cfg().iter_enumerated_mut() {
 111                 visitor.visit_basic_block_data(block, data);
 112             }
 113
 114             visitor.patch.apply(body);
 115
 116             for debug_info in body.var_debug_info.iter_mut() {
 117                 if let VarDebugInfoContents::Place(place) = &mut debug_info.value {
 118                     let mut new_projections: Option<Vec<_>> = None;
 119                     let mut last_deref = 0;
 120
 121                     for (i, (base, elem)) in place.iter_projections().enumerate() {
 122                         let base_ty = base.ty(&body.local_decls, tcx).ty;
 123
 124                         if elem == PlaceElem::Deref && base_ty.is_box() {
 125                             let new_projections = new_projections.get_or_insert_default();
 126
 127                             let (unique_ty, nonnull_ty, ptr_ty) =
 128                                 build_ptr_tys(tcx, base_ty.boxed_ty(), unique_did, nonnull_did);
 129
 130                             new_projections.extend_from_slice(&base.projection[last_deref..]);
 131                             new_projections.extend_from_slice(&build_projection(
 132                                 unique_ty, nonnull_ty, ptr_ty,
 133                             ));
 134                             new_projections.push(PlaceElem::Deref);
 135
 136                             last_deref = i;
 137                         }
 138                     }
 139
 140                     if let Some(mut new_projections) = new_projections {
 141                         new_projections.extend_from_slice(&place.projection[last_deref..]);
 142                         place.projection = tcx.intern_place_elems(&new_projections);
 143                     }
 144                 }
 145             }
 146         } else {
 147             // box is not present, this pass doesn't need to do anything
 148         }
 149     }
 150 }