compiler/rustc_mir/src/transform/const_debuginfo.rs

   1 //! Finds locals which are assigned once to a const and unused except for debuginfo and converts
   2 //! their debuginfo to use the const directly, allowing the local to be removed.
   3
   4 use rustc_middle::{
   5     mir::{
   6         visit::{PlaceContext, Visitor},
   7         Body, Constant, Local, Location, Operand, Rvalue, StatementKind, VarDebugInfoContents,
   8     },
   9     ty::TyCtxt,
  10 };
  11
  12 use crate::transform::MirPass;
  13 use rustc_index::{bit_set::BitSet, vec::IndexVec};
  14
  15 pub struct ConstDebugInfo;
  16
  17 impl<'tcx> MirPass<'tcx> for ConstDebugInfo {
  18     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
  19         if !tcx.sess.opts.debugging_opts.unsound_mir_opts {
  20             return;
  21         }
  22
  23         trace!("running ConstDebugInfo on {:?}", body.source);
  24
  25         for (local, constant) in find_optimization_oportunities(body) {
  26             for debuginfo in &mut body.var_debug_info {
  27                 if let VarDebugInfoContents::Place(p) = debuginfo.value {
  28                     if p.local == local && p.projection.is_empty() {
  29                         trace!(
  30                             "changing debug info for {:?} from place {:?} to constant {:?}",
  31                             debuginfo.name,
  32                             p,
  33                             constant
  34                         );
  35                         debuginfo.value = VarDebugInfoContents::Const(constant);
  36                     }
  37                 }
  38             }
  39         }
  40     }
  41 }
  42
  43 struct LocalUseVisitor {
  44     local_mutating_uses: IndexVec<Local, u8>,
  45     local_assignment_locations: IndexVec<Local, Option<Location>>,
  46 }
  47
  48 fn find_optimization_oportunities<'tcx>(body: &Body<'tcx>) -> Vec<(Local, Constant<'tcx>)> {
  49     let mut visitor = LocalUseVisitor {
  50         local_mutating_uses: IndexVec::from_elem(0, &body.local_decls),
  51         local_assignment_locations: IndexVec::from_elem(None, &body.local_decls),
  52     };
  53
  54     visitor.visit_body(body);
  55
  56     let mut locals_to_debuginfo = BitSet::new_empty(body.local_decls.len());
  57     for debuginfo in &body.var_debug_info {
  58         if let VarDebugInfoContents::Place(p) = debuginfo.value {
  59             if let Some(l) = p.as_local() {
  60                 locals_to_debuginfo.insert(l);
  61             }
  62         }
  63     }
  64
  65     let mut eligable_locals = Vec::new();
  66     for (local, mutating_uses) in visitor.local_mutating_uses.drain_enumerated(..) {
  67         if mutating_uses != 1 || !locals_to_debuginfo.contains(local) {
  68             continue;
  69         }
  70
  71         if let Some(location) = visitor.local_assignment_locations[local] {
  72             let bb = &body[location.block];
  73
  74             // The value is assigned as the result of a call, not a constant
  75             if bb.statements.len() == location.statement_index {
  76                 continue;
  77             }
  78
  79             if let StatementKind::Assign(box (p, Rvalue::Use(Operand::Constant(box c)))) =
  80                 &bb.statements[location.statement_index].kind
  81             {
  82                 if let Some(local) = p.as_local() {
  83                     eligable_locals.push((local, *c));
  84                 }
  85             }
  86         }
  87     }
  88
  89     eligable_locals
  90 }
  91
  92 impl<'tcx> Visitor<'tcx> for LocalUseVisitor {
  93     fn visit_local(&mut self, local: &Local, context: PlaceContext, location: Location) {
  94         if context.is_mutating_use() {
  95             self.local_mutating_uses[*local] = self.local_mutating_uses[*local].saturating_add(1);
  96
  97             if context.is_place_assignment() {
  98                 self.local_assignment_locations[*local] = Some(location);
  99             }
 100         }
 101     }
 102 }