Merge places for debuginfo.

Author: cjgillot

compiler/rustc_mir_transform/src/gvn.rs

@@ -102,6 +102,7 @@ use smallvec::SmallVec;
 use std::borrow::Cow;
 
 use crate::dataflow_const_prop::DummyMachine;
+use crate::simplify::UsedLocals;
 use crate::ssa::{AssignedValue, SsaLocals};
 use either::Either;
 
@@ -163,14 +164,16 @@ fn propagate_ssa<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
     state.next_opaque = None;
 
     let reverse_postorder = body.basic_blocks.reverse_postorder().to_vec();
-    for dbg in body.var_debug_info.iter_mut() {
-        state.visit_var_debug_info(dbg);
-    }
     for bb in reverse_postorder {
         let data = &mut body.basic_blocks.as_mut_preserves_cfg()[bb];
         state.visit_basic_block_data(bb, data);
     }
 
+    let mut used_locals = UsedLocals::new(body, false);
+    for dbg in body.var_debug_info.iter_mut() {
+        state.reduce_debuginfo(dbg, &mut used_locals);
+    }
+
     // For each local that is reused (`y` above), we remove its storage statements do avoid any
     // difficulty. Those locals are SSA, so should be easy to optimize by LLVM without storage
     // statements.
@@ -1256,45 +1259,93 @@ impl<'tcx> VnState<'_, 'tcx> {
             .find(|&&other| self.ssa.assignment_dominates(self.dominators, other, loc))
             .copied()
     }
-}
-
-impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
-    fn tcx(&self) -> TyCtxt<'tcx> {
-        self.tcx
-    }
-
-    fn visit_var_debug_info(&mut self, var_debug_info: &mut VarDebugInfo<'tcx>) {
-        let mut replace_dereffed = |place: &mut Place<'tcx>| -> Option<!> {
-            let last_deref = place.projection.iter().rposition(|e| e == PlaceElem::Deref)?;
 
-            // Another place that holds the same value.
+    fn reduce_debuginfo(
+        &mut self,
+        var_debug_info: &mut VarDebugInfo<'tcx>,
+        used_locals: &mut UsedLocals,
+    ) {
+        let mut simplify_place = |place: &mut Place<'tcx>| -> Option<ConstOperand<'tcx>> {
+            // Another place that points to the same memory.
             let mut place_ref = place.as_ref();
             let mut value = self.locals[place.local]?;
 
-            for (index, &proj) in place.projection[..last_deref].iter().enumerate() {
-                if let Some(candidates) = self.rev_locals.get(value)
-                    && let Some(&local) = candidates.first()
+            // The position of the last deref projection. If there is one, the place preceding it
+            // can be treated and simplified as a value. Afterwards, projections need to be treated
+            // as a memory place.
+            let last_deref = place.projection.iter().rposition(|e| e == PlaceElem::Deref);
+
+            for (index, proj) in place.projection.iter().enumerate() {
+                // We are before the last projection, so we can treat as a value.
+                if last_deref.map_or(false, |ld| index <= ld)
+                    && let Some(candidates) = self.rev_locals.get(value)
+                    // Do not introduce an unused local.
+                    && let Some(&local) = candidates.iter().find(|&&l| used_locals.is_used(l))
                 {
                     place_ref = PlaceRef { local, projection: &place.projection[index..] };
                 }
 
+                // We are at the last projection, treat as a value if possible.
+                if Some(index) == last_deref {
+                    *place = place_ref.project_deeper(&[], self.tcx);
+
+                    // If the base local is used, do not bother trying to simplify anything.
+                    if used_locals.is_used(place_ref.local) {
+                        return None;
+                    }
+                }
+
                 let place_upto =
                     PlaceRef { local: place.local, projection: &place.projection[..index] };
                 if let Some(projected) = self.project(place_upto, value, proj) {
                     value = projected;
                 } else {
-                    if place_ref.projection.len() < place.projection.len() {
+                    if last_deref.map_or(false, |ld| index <= ld)
+                        && place_ref.projection.len() < place.projection.len()
+                    {
                         *place = place_ref.project_deeper(&[], self.tcx);
                     }
                     return None;
                 }
             }
 
-            if let Some(candidates) = self.rev_locals.get(value)
-                && let Some(&local) = candidates.first()
-            {
-                let place_ref = PlaceRef { local, projection: &place.projection[last_deref..] };
-                *place = place_ref.project_deeper(&[], self.tcx);
+            if let Some(constant) = self.try_as_constant(value) {
+                return Some(constant);
+            }
+
+            let mut projections = vec![];
+            loop {
+                if let Some(candidates) = self.rev_locals.get(value)
+                    // Do not reintroduce an unused local.
+                    && let Some(&local) = candidates.iter().find(|&&l| used_locals.is_used(l))
+                {
+                    projections.reverse();
+                    *place = Place {
+                        local,
+                        projection: self.tcx.mk_place_elems_from_iter(projections.into_iter()),
+                    };
+                    return None;
+                }
+
+                let Value::Projection(base, elem) = *self.get(value) else {
+                    break;
+                };
+
+                let elem = match elem {
+                    ProjectionElem::Deref => ProjectionElem::Deref,
+                    ProjectionElem::Downcast(name, read_variant) => {
+                        ProjectionElem::Downcast(name, read_variant)
+                    }
+                    ProjectionElem::Field(f, ty) => ProjectionElem::Field(f, ty),
+                    ProjectionElem::ConstantIndex { offset, min_length, from_end: false } => {
+                        ProjectionElem::ConstantIndex { offset, min_length, from_end: false }
+                    }
+                    // Not allowed in debuginfo.
+                    _ => return None,
+                };
+
+                projections.push(elem);
+                value = base;
             }
 
             return None;
@@ -1303,10 +1354,20 @@ impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
         match &mut var_debug_info.value {
             VarDebugInfoContents::Const(_) => {}
             VarDebugInfoContents::Place(place) => {
-                replace_dereffed(place);
+                if let Some(constant) = simplify_place(place) {
+                    var_debug_info.value = VarDebugInfoContents::Const(constant);
+                } else {
+                    used_locals.use_count[place.local] += 1;
+                }
             }
         }
     }
+}
+
+impl<'tcx> MutVisitor<'tcx> for VnState<'_, 'tcx> {
+    fn tcx(&self) -> TyCtxt<'tcx> {
+        self.tcx
+    }
 
     fn visit_place(&mut self, place: &mut Place<'tcx>, _: PlaceContext, location: Location) {
         self.simplify_place_projection(place, location);

compiler/rustc_mir_transform/src/simplify.rs

@@ -28,7 +28,9 @@
 //! return.
 
 use rustc_index::{Idx, IndexSlice, IndexVec};
-use rustc_middle::mir::visit::{MutVisitor, MutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{
+    MutVisitor, MutatingUseContext, NonUseContext, PlaceContext, Visitor,
+};
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
 use smallvec::SmallVec;
@@ -382,7 +384,7 @@ impl<'tcx> MirPass<'tcx> for SimplifyLocals {
 
 pub fn remove_unused_definitions<'tcx>(body: &mut Body<'tcx>) {
     // First, we're going to get a count of *actual* uses for every `Local`.
-    let mut used_locals = UsedLocals::new(body);
+    let mut used_locals = UsedLocals::new(body, true);
 
     // Next, we're going to remove any `Local` with zero actual uses. When we remove those
     // `Locals`, we're also going to subtract any uses of other `Locals` from the `used_locals`
@@ -394,7 +396,7 @@ pub fn remove_unused_definitions<'tcx>(body: &mut Body<'tcx>) {
 
 pub fn simplify_locals<'tcx>(body: &mut Body<'tcx>, tcx: TyCtxt<'tcx>) {
     // First, we're going to get a count of *actual* uses for every `Local`.
-    let mut used_locals = UsedLocals::new(body);
+    let mut used_locals = UsedLocals::new(body, true);
 
     // Next, we're going to remove any `Local` with zero actual uses. When we remove those
     // `Locals`, we're also going to subtract any uses of other `Locals` from the `used_locals`
@@ -441,19 +443,21 @@ fn make_local_map<V>(
 }
 
 /// Keeps track of used & unused locals.
-struct UsedLocals {
+pub(crate) struct UsedLocals {
     increment: bool,
     arg_count: u32,
-    use_count: IndexVec<Local, u32>,
+    pub(crate) use_count: IndexVec<Local, u32>,
+    with_debuginfo: bool,
 }
 
 impl UsedLocals {
     /// Determines which locals are used & unused in the given body.
-    fn new(body: &Body<'_>) -> Self {
+    pub(crate) fn new(body: &Body<'_>, with_debuginfo: bool) -> Self {
         let mut this = Self {
             increment: true,
             arg_count: body.arg_count.try_into().unwrap(),
             use_count: IndexVec::from_elem(0, &body.local_decls),
+            with_debuginfo,
         };
         this.visit_body(body);
         this
@@ -462,7 +466,7 @@ impl UsedLocals {
     /// Checks if local is used.
     ///
     /// Return place and arguments are always considered used.
-    fn is_used(&self, local: Local) -> bool {
+    pub(crate) fn is_used(&self, local: Local) -> bool {
         trace!("is_used({:?}): use_count: {:?}", local, self.use_count[local]);
         local.as_u32() <= self.arg_count || self.use_count[local] != 0
     }
@@ -526,7 +530,11 @@ impl<'tcx> Visitor<'tcx> for UsedLocals {
         }
     }
 
-    fn visit_local(&mut self, local: Local, _ctx: PlaceContext, _location: Location) {
+    fn visit_local(&mut self, local: Local, ctx: PlaceContext, _location: Location) {
+        if matches!(ctx, PlaceContext::NonUse(NonUseContext::VarDebugInfo)) && !self.with_debuginfo
+        {
+            return;
+        };
         if self.increment {
             self.use_count[local] += 1;
         } else {

tests/mir-opt/const_debuginfo.main.ConstDebugInfo.diff

@@ -11,20 +11,16 @@
       let mut _14: u32;
       let mut _15: u32;
       scope 1 {
--         debug x => _1;
-+         debug x => const 1_u8;
+          debug x => const 1_u8;
           let _2: u8;
           scope 2 {
--             debug y => _2;
-+             debug y => const 2_u8;
+              debug y => const 2_u8;
               let _3: u8;
               scope 3 {
--                 debug z => _3;
-+                 debug z => const 3_u8;
+                  debug z => const 3_u8;
                   let _4: u8;
                   scope 4 {
--                     debug sum => _4;
-+                     debug sum => const 6_u8;
+                      debug sum => const 6_u8;
                       let _9: &str;
                       scope 5 {
 -                         debug s => _9;
@@ -34,16 +30,13 @@
                               debug f => _10;
                               let _11: std::option::Option<u16>;
                               scope 7 {
--                                 debug o => _11;
-+                                 debug o => const Option::<u16>::Some(99_u16);
+                                  debug o => const Option::<u16>::Some(99_u16);
                                   let _12: Point;
                                   scope 8 {
--                                     debug p => _12;
-+                                     debug p => const Point {{ x: 32_u32, y: 32_u32 }};
+                                      debug p => const Point {{ x: 32_u32, y: 32_u32 }};
                                       let _13: u32;
                                       scope 9 {
--                                         debug a => _13;
-+                                         debug a => const 64_u32;
+                                          debug a => const 64_u32;
                                       }
                                   }
                               }

tests/mir-opt/const_prop/aggregate.foo.GVN.panic-abort.diff

@@ -12,10 +12,12 @@
       let mut _8: (u8, i32);
       let mut _9: u8;
       scope 1 {
-          debug first => _2;
+-         debug first => _2;
++         debug first => const 1_i32;
           let _6: i32;
           scope 2 {
-              debug second => _6;
+-             debug second => _6;
++             debug second => const 3_i32;
           }
       }
 

tests/mir-opt/const_prop/aggregate.foo.GVN.panic-unwind.diff

@@ -12,10 +12,12 @@
       let mut _8: (u8, i32);
       let mut _9: u8;
       scope 1 {
-          debug first => _2;
+-         debug first => _2;
++         debug first => const 1_i32;
           let _6: i32;
           scope 2 {
-              debug second => _6;
+-             debug second => _6;
++             debug second => const 3_i32;
           }
       }
 

tests/mir-opt/const_prop/aggregate.main.GVN.panic-abort.diff

@@ -9,7 +9,8 @@
       let _4: ();
       let mut _5: u8;
       scope 1 {
-          debug x => _1;
+-         debug x => _1;
++         debug x => const 1_u8;
       }
 
       bb0: {

tests/mir-opt/const_prop/aggregate.main.GVN.panic-unwind.diff

@@ -9,7 +9,8 @@
       let _4: ();
       let mut _5: u8;
       scope 1 {
-          debug x => _1;
+-         debug x => _1;
++         debug x => const 1_u8;
       }
 
       bb0: {

tests/mir-opt/const_prop/aggregate.rs

@@ -5,9 +5,7 @@
 // EMIT_MIR aggregate.main.GVN.diff
 fn main() {
     // CHECK-LABEL: fn main(
-    // CHECK: debug x => [[x:_.*]];
-    // CHECK-NOT: = Add(
-    // CHECK: [[x]] = const 1_u8;
+    // CHECK: debug x => const 1_u8;
     // CHECK-NOT: = Add(
     // CHECK: foo(const 1_u8)
     let x = (0, 1, 2).1 + 0;
@@ -18,12 +16,9 @@ fn main() {
 // EMIT_MIR aggregate.foo.GVN.diff
 fn foo(x: u8) {
     // CHECK-LABEL: fn foo(
-    // CHECK: debug first => [[first:_.*]];
-    // CHECK: debug second => [[second:_.*]];
-    // CHECK-NOT: = Add(
-    // CHECK: [[first]] = const 1_i32;
+    // CHECK: debug first => const 1_i32;
+    // CHECK: debug second => const 3_i32;
     // CHECK-NOT: = Add(
-    // CHECK: [[second]] = const 3_i32;
     let first = (0, x).0 + 1;
     let second = (x, 1).1 + 2;
 }

tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-abort.diff

@@ -9,7 +9,8 @@
       let mut _4: usize;
       let mut _5: bool;
       scope 1 {
-          debug x => _1;
+-         debug x => _1;
++         debug x => const 2_u32;
       }
 
       bb0: {

tests/mir-opt/const_prop/array_index.main.GVN.32bit.panic-unwind.diff

@@ -9,7 +9,8 @@
       let mut _4: usize;
       let mut _5: bool;
       scope 1 {
-          debug x => _1;
+-         debug x => _1;
++         debug x => const 2_u32;
       }
 
       bb0: {