mir-opt: Eliminate dead statements even if they are used by debuginfos

dianqk · dianqk · commit 1b79b87715c0 · 2025-07-21T23:06:37.000+08:00
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -109,50 +109,54 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     pub(crate) fn codegen_stmt_debuginfo(&mut self, bx: &mut Bx, debuginfo: &StmtDebugInfo<'tcx>) {
         match debuginfo {
             StmtDebugInfo::AssignRef(dest, place) => {
-                let place_ref = match self.locals[place.local] {
-                    LocalRef::Place(place_ref) | LocalRef::UnsizedPlace(place_ref) => {
-                        Some(place_ref)
-                    }
-                    LocalRef::Operand(operand_ref) => match operand_ref.val {
-                        OperandValue::Immediate(v) => {
-                            Some(PlaceRef::new_sized(v, operand_ref.layout))
+                let assign_ref = if let Some(place) = place {
+                    let place_ref = match self.locals[place.local] {
+                        LocalRef::Place(place_ref) | LocalRef::UnsizedPlace(place_ref) => {
+                            Some(place_ref)
                         }
-                        OperandValue::Ref(_)
-                        | OperandValue::Pair(_, _)
-                        | OperandValue::ZeroSized => None,
-                    },
-                    LocalRef::PendingOperand => None,
-                }
-                .filter(|place_ref| {
-                    // Drop unsupported projections.
-                    // FIXME: Add a test case.
-                    place.projection.iter().all(|p| p.can_use_in_debuginfo()) &&
-                    // Only pointers can calculate addresses.
-                    bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
-                });
-                let (val, layout, projection) =
+                        LocalRef::Operand(operand_ref) => match operand_ref.val {
+                            OperandValue::Immediate(v) => {
+                                Some(PlaceRef::new_sized(v, operand_ref.layout))
+                            }
+                            OperandValue::Ref(_)
+                            | OperandValue::Pair(_, _)
+                            | OperandValue::ZeroSized => None,
+                        },
+                        LocalRef::PendingOperand => None,
+                    }
+                    .filter(|place_ref| {
+                        // Drop unsupported projections.
+                        // FIXME: Add a test case.
+                        place.projection.iter().all(|p| p.can_use_in_debuginfo()) &&
+                        // Only pointers can calculate addresses.
+                        bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
+                    });
                     match (place_ref, place.is_indirect_first_projection()) {
                         (Some(place_ref), false) => {
-                            (place_ref.val, place_ref.layout, place.projection.as_slice())
+                            Some((place_ref.val, place_ref.layout, place.projection.as_slice()))
                         }
                         (Some(place_ref), true) => {
                             let projected_ty =
                                 place_ref.layout.ty.builtin_deref(true).unwrap_or_else(|| {
                                     bug!("deref of non-pointer {:?}", place_ref)
                                 });
                             let layout = bx.cx().layout_of(projected_ty);
-                            (place_ref.val, layout, &place.projection[1..])
+                            Some((place_ref.val, layout, &place.projection[1..]))
                         }
-                        _ => {
-                            // If the address cannot be computed, use poison to indicate that the value has been optimized out.
-                            let ty = self.monomorphize(self.mir.local_decls[*dest].ty);
-                            let layout = bx.cx().layout_of(ty);
-                            let to_backend_ty = bx.cx().immediate_backend_type(layout);
-                            let place_ref =
-                                PlaceRef::new_sized(bx.cx().const_poison(to_backend_ty), layout);
-                            (place_ref.val, layout, [].as_slice())
-                        }
-                    };
+                        _ => None,
+                    }
+                } else {
+                    None
+                };
+                let (val, layout, projection) = assign_ref.unwrap_or_else(|| {
+                    // If the address cannot be computed, use poison to indicate that the value has been optimized out.
+                    let ty = self.monomorphize(self.mir.local_decls[*dest].ty);
+                    let layout = bx.cx().layout_of(ty);
+                    let to_backend_ty = bx.cx().immediate_backend_type(layout);
+                    let place_ref =
+                        PlaceRef::new_sized(bx.cx().const_poison(to_backend_ty), layout);
+                    (place_ref.val, layout, [].as_slice())
+                });
                 self.debug_new_value_to_local(bx, *dest, val, layout, projection);
             }
         }
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -901,7 +901,8 @@ impl Debug for StmtDebugInfo<'_> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
         match self {
             StmtDebugInfo::AssignRef(local, place) => {
-                write!(fmt, "{local:?} = &{place:?}")
+                write!(fmt, "{local:?} = &")?;
+                if let Some(place) = place { write!(fmt, "{place:?}") } else { write!(fmt, "?") }
             }
         }
     }
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
@@ -79,7 +79,7 @@ impl<'tcx> StatementKind<'tcx> {
             StatementKind::Assign(box (place, Rvalue::Ref(_, _, ref_place)))
                 if let Some(local) = place.as_local() =>
             {
-                Some(StmtDebugInfo::AssignRef(local, *ref_place))
+                Some(StmtDebugInfo::AssignRef(local, Some(*ref_place)))
             }
             _ => None,
         }
@@ -963,5 +963,5 @@ impl RawPtrKind {
 
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
 pub enum StmtDebugInfo<'tcx> {
-    AssignRef(Local, Place<'tcx>),
+    AssignRef(Local, Option<Place<'tcx>>),
 }
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -420,11 +420,13 @@ macro_rules! make_mir_visitor {
                             PlaceContext::NonUse(NonUseContext::VarDebugInfo),
                             location
                         );
-                        self.visit_place(
-                            place,
-                            PlaceContext::NonUse(NonUseContext::VarDebugInfo),
-                            location
-                        );
+                        if let Some(place) = place {
+                            self.visit_place(
+                                place,
+                                PlaceContext::NonUse(NonUseContext::VarDebugInfo),
+                                location
+                            );
+                        }
                     },
                 }
             }
diff --git a/compiler/rustc_mir_dataflow/src/debuginfo.rs b/compiler/rustc_mir_dataflow/src/debuginfo.rs
@@ -12,8 +12,6 @@ pub fn debuginfo_locals(body: &Body<'_>) -> DenseBitSet<Local> {
 struct DebuginfoLocals(DenseBitSet<Local>);
 
 impl Visitor<'_> for DebuginfoLocals {
-    const VISIT_DEBUG_INFO: bool = true;
-
     fn visit_local(&mut self, local: Local, place_context: PlaceContext, _: Location) {
         if place_context == PlaceContext::NonUse(NonUseContext::VarDebugInfo) {
             self.0.insert(local);
diff --git a/compiler/rustc_mir_dataflow/src/impls/liveness.rs b/compiler/rustc_mir_dataflow/src/impls/liveness.rs
@@ -282,9 +282,6 @@ impl<'a, 'tcx> Analysis<'tcx> for MaybeTransitiveLiveLocals<'a> {
         if let Some(destination) =
             Self::can_be_removed_if_dead(&statement.kind, &self.always_live, &self.debuginfo_locals)
             && !state.contains(destination.local)
-            // FIXME: We can eliminate the statement, but we'll need the statements it depends on
-            // for debuginfos. We need a way to handle this.
-            && !self.debuginfo_locals.contains(destination.local)
         {
             // This store is dead
             return;
diff --git a/compiler/rustc_mir_transform/src/simplify.rs b/compiler/rustc_mir_transform/src/simplify.rs
@@ -663,6 +663,19 @@ fn remove_unused_definitions_helper(used_locals: &mut UsedLocals, body: &mut Bod
     }
 }
 
+struct InvalidPlace<'a> {
+    map: &'a IndexVec<Local, Option<Local>>,
+    is_invalid: bool,
+}
+
+impl<'tcx, 'a> Visitor<'tcx> for InvalidPlace<'a> {
+    fn visit_local(&mut self, local: Local, _: PlaceContext, _: Location) {
+        if self.map[local].is_none() {
+            self.is_invalid = true;
+        }
+    }
+}
+
 struct LocalUpdater<'tcx> {
     map: IndexVec<Local, Option<Local>>,
     tcx: TyCtxt<'tcx>,
@@ -675,6 +688,29 @@ impl<'tcx> MutVisitor<'tcx> for LocalUpdater<'tcx> {
         self.tcx
     }
 
+    fn visit_statement_debuginfo(
+        &mut self,
+        stmt_debuginfo: &mut StmtDebugInfo<'tcx>,
+        location: Location,
+    ) {
+        match stmt_debuginfo {
+            StmtDebugInfo::AssignRef(_, place) => {
+                if place.is_some_and(|ref place| {
+                    let mut invalid_place = InvalidPlace { map: &self.map, is_invalid: false };
+                    invalid_place.visit_place(
+                        place,
+                        PlaceContext::NonUse(visit::NonUseContext::VarDebugInfo),
+                        location,
+                    );
+                    invalid_place.is_invalid
+                }) {
+                    *place = None;
+                }
+            }
+        }
+        self.super_statement_debuginfo(stmt_debuginfo, location);
+    }
+
     fn visit_local(&mut self, l: &mut Local, _: PlaceContext, _: Location) {
         *l = self.map[*l].unwrap();
     }
diff --git a/compiler/rustc_mir_transform/src/strip_debuginfo.rs b/compiler/rustc_mir_transform/src/strip_debuginfo.rs
@@ -1,5 +1,6 @@
 use rustc_middle::mir::*;
 use rustc_middle::ty::TyCtxt;
+use rustc_mir_dataflow::debuginfo::debuginfo_locals;
 use rustc_session::config::MirStripDebugInfo;
 
 /// Conditionally remove some of the VarDebugInfo in MIR.
@@ -30,6 +31,18 @@ impl<'tcx> crate::MirPass<'tcx> for StripDebugInfo {
                     if place.local.as_usize() <= body.arg_count && place.local != RETURN_PLACE,
             )
         });
+
+        let debuginfo_locals = debuginfo_locals(body);
+        for data in body.basic_blocks.as_mut_preserves_cfg() {
+            for stmt in data.statements.iter_mut() {
+                stmt.debuginfos.retain(|debuginfo| match debuginfo {
+                    StmtDebugInfo::AssignRef(local, _) => debuginfo_locals.contains(*local),
+                });
+            }
+            data.after_last_stmt_debuginfos.retain(|debuginfo| match debuginfo {
+                StmtDebugInfo::AssignRef(local, _) => debuginfo_locals.contains(*local),
+            });
+        }
     }
 
     fn is_required(&self) -> bool {
diff --git a/tests/codegen/debuginfo-dse.rs b/tests/codegen/debuginfo-dse.rs
@@ -1,4 +1,4 @@
-//@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir
+//@ compile-flags: -Copt-level=3 -g -Zverify-llvm-ir -Zmerge-functions=disabled
 //@ revisions: CODEGEN OPTIMIZED
 //@[CODEGEN] compile-flags: -Cno-prepopulate-passes
 
@@ -8,6 +8,13 @@
 #[derive(Clone, Copy)]
 pub struct Foo(i32, i64, i32);
 
+#[repr(C)]
+pub struct Bar<'a> {
+    a: i32,
+    b: i64,
+    foo: &'a Foo,
+}
+
 #[no_mangle]
 fn r#ref(ref_foo: &Foo) -> i32 {
     // CHECK-LABEL: define {{.*}} i32 @ref
@@ -58,11 +65,20 @@ pub fn fragment(fragment_v1: Foo, mut fragment_v2: Foo) -> Foo {
     fragment_v2
 }
 
+#[no_mangle]
+pub fn deref(bar: Bar) -> i32 {
+    // CHECK-LABEL: define {{.*}} i32 @deref
+    // We are unable to represent dereference within this expression.
+    // CHECK: #dbg_value(ptr poison, [[VAR_deref_dead:![0-9]+]], !DIExpression()
+    let deref_dead = &bar.foo.2;
+    bar.a
+}
+
 #[no_mangle]
 pub fn tuple(foo: (i32, &Foo)) -> i32 {
     // CHECK-LABEL: define {{.*}} i32 @tuple
-    // CHECK-SAME: (i32 {{.*}}, ptr {{.*}} [[ARG_tuple_foo_1:%.*]])
-    // CHECK: #dbg_value(ptr [[ARG_tuple_foo_1]], [[VAR_tuple_dead:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    // Although there is no dereference here, there is a dereference in the MIR.
+    // CHECK: #dbg_value(ptr poison, [[VAR_tuple_dead:![0-9]+]], !DIExpression()
     let tuple_dead = &foo.1.2;
     foo.1.0
 }
@@ -77,3 +93,4 @@ pub fn tuple(foo: (i32, &Foo)) -> i32 {
 // CODEGEN-DAG: [[VAR_val_ref]] = !DILocalVariable(name: "val_ref"
 // CHECK-DAG: [[VAR_fragment_f]] = !DILocalVariable(name: "fragment_f"
 // CHECK-DAG: [[VAR_tuple_dead]] = !DILocalVariable(name: "tuple_dead"
+// CHECK-DAG: [[VAR_deref_dead]] = !DILocalVariable(name: "deref_dead"
diff --git a/tests/mir-opt/dead-store-elimination/ref.rs b/tests/mir-opt/dead-store-elimination/ref.rs
@@ -11,9 +11,7 @@ pub fn tuple(v: (i32, &Foo)) -> i32 {
     // CHECK-LABEL: fn tuple
     // CHECK: debug _dead => [[dead:_[0-9]+]];
     // CHECK: bb0:
-    // FIXME: Preserve `tmp` for debuginfo, but we can merge it into the debuginfo.
-    // CHECK-NEXT: [[tmp:_[0-9]+]] = deref_copy (_1.1: &Foo);
-    // CHECK-NEXT: DBG: [[dead]] = &((*[[tmp]]).2: i32)
+    // CHECK-NEXT: DBG: [[dead]] = &((*_3).2: i32)
     let _dead = &v.1.c;
     v.1.a
 }
diff --git a/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff b/tests/mir-opt/dead-store-elimination/ref.tuple.DeadStoreElimination-initial.diff
@@ -13,7 +13,7 @@
   
       bb0: {
 -         StorageLive(_2);
-          _3 = deref_copy (_1.1: &Foo);
+-         _3 = deref_copy (_1.1: &Foo);
 -         _2 = &((*_3).2: i32);
 +         // DBG: _2 = &((*_3).2: i32)
           _4 = deref_copy (_1.1: &Foo);
diff --git a/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff b/tests/mir-opt/inline/inline_shims.drop.Inline.panic-abort.diff
diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-abort.mir
diff --git a/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/vec_deref.vec_deref_to_slice.PreCodegen.after.panic-unwind.mir

Original file line number	Diff line number	Diff line change
`@@ -901,7 +901,8 @@ impl Debug for StmtDebugInfo<'_> {`
`901`	`901`	`fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {`
`902`	`902`	`match self {`
`903`	`903`	`StmtDebugInfo::AssignRef(local, place) => {`
`904`		`- write!(fmt, "{local:?} = &{place:?}")`
	`904`	`+ write!(fmt, "{local:?} = &")?;`
	`905`	`+ if let Some(place) = place { write!(fmt, "{place:?}") } else { write!(fmt, "?") }`
`905`	`906`	`}`
`906`	`907`	`}`
`907`	`908`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ impl<'tcx> StatementKind<'tcx> {`
`79`	`79`	`StatementKind::Assign(box (place, Rvalue::Ref(_, _, ref_place)))`
`80`	`80`	`if let Some(local) = place.as_local() =>`
`81`	`81`	`{`
`82`		`- Some(StmtDebugInfo::AssignRef(local, *ref_place))`
	`82`	`+ Some(StmtDebugInfo::AssignRef(local, Some(*ref_place)))`
`83`	`83`	`}`
`84`	`84`	`_ => None,`
`85`	`85`	`}`
`@@ -963,5 +963,5 @@ impl RawPtrKind {`
`963`	`963`
`964`	`964`	`#[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]`
`965`	`965`	`pub enum StmtDebugInfo<'tcx> {`
`966`		`- AssignRef(Local, Place<'tcx>),`
	`966`	`+ AssignRef(Local, Option<Place<'tcx>>),`
`967`	`967`	`}`