codegen: emit the debugging information for the dead code

Author: dianqk

compiler/rustc_codegen_gcc/src/debuginfo.rs

@@ -26,7 +26,8 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
         &mut self,
         _dbg_var: Self::DIVariable,
         _dbg_loc: Self::DILocation,
-        _variable_alloca: Self::Value,
+        _is_declared: bool,
+        _val: Self::Value,
         _direct_offset: Size,
         _indirect_offsets: &[Size],
         _fragment: Option<Range<Size>>,

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -154,7 +154,8 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         &mut self,
         dbg_var: &'ll DIVariable,
         dbg_loc: &'ll DILocation,
-        variable_alloca: Self::Value,
+        is_declared: bool,
+        val: Self::Value,
         direct_offset: Size,
         indirect_offsets: &[Size],
         fragment: Option<Range<Size>>,
@@ -183,17 +184,30 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
             addr_ops.push((fragment.end - fragment.start).bits() as u64);
         }
 
-        unsafe {
-            // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
-            llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
-                DIB(self.cx()),
-                variable_alloca,
-                dbg_var,
-                addr_ops.as_ptr(),
-                addr_ops.len() as c_uint,
-                dbg_loc,
-                self.llbb(),
-            );
+        if is_declared {
+            unsafe {
+                llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
+                    DIB(self.cx()),
+                    val,
+                    dbg_var,
+                    addr_ops.as_ptr(),
+                    addr_ops.len() as c_uint,
+                    dbg_loc,
+                    self.llbb(),
+                );
+            }
+        } else {
+            unsafe {
+                llvm::LLVMRustDIBuilderInsertDbgValueAtEnd(
+                    DIB(self.cx()),
+                    val,
+                    dbg_var,
+                    addr_ops.as_ptr(),
+                    addr_ops.len() as c_uint,
+                    dbg_loc,
+                    self.llbb(),
+                );
+            }
         }
     }
 

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -2301,6 +2301,16 @@ unsafe extern "C" {
         InsertAtEnd: &'a BasicBlock,
     );
 
+    pub(crate) fn LLVMRustDIBuilderInsertDbgValueAtEnd<'a>(
+        Builder: &DIBuilder<'a>,
+        Val: &'a Value,
+        VarInfo: &'a DIVariable,
+        AddrOps: *const u64,
+        AddrOpsCount: c_uint,
+        DL: &'a DILocation,
+        InsertAtEnd: &'a BasicBlock,
+    );
+
     pub(crate) fn LLVMRustDIBuilderCreateEnumerator<'a>(
         Builder: &DIBuilder<'a>,
         Name: *const c_char,

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -378,6 +378,52 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         }
     }
 
+    pub(crate) fn debug_new_value_to_local(
+        &self,
+        bx: &mut Bx,
+        local: mir::Local,
+        base: PlaceValue<Bx::Value>,
+        layout: TyAndLayout<'tcx>,
+        projection: &[mir::PlaceElem<'tcx>],
+    ) {
+        let full_debug_info = bx.sess().opts.debuginfo == DebugInfo::Full;
+        if !full_debug_info {
+            return;
+        }
+
+        let vars = match &self.per_local_var_debug_info {
+            Some(per_local) => &per_local[local],
+            None => return,
+        };
+
+        for var in vars.iter().cloned() {
+            self.debug_new_value_to_local_as_var(bx, base, layout, projection, var);
+        }
+    }
+
+    fn debug_new_value_to_local_as_var(
+        &self,
+        bx: &mut Bx,
+        base: PlaceValue<Bx::Value>,
+        layout: TyAndLayout<'tcx>,
+        projection: &[mir::PlaceElem<'tcx>],
+        var: PerLocalVarDebugInfo<'tcx, Bx::DIVariable>,
+    ) {
+        let Some(dbg_var) = var.dbg_var else { return };
+        let Some(dbg_loc) = self.dbg_loc(var.source_info) else { return };
+        let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
+            calculate_debuginfo_offset(bx, projection, layout);
+        bx.dbg_var_addr(
+            dbg_var,
+            dbg_loc,
+            false,
+            base.llval,
+            direct_offset,
+            &indirect_offsets,
+            var.fragment,
+        );
+    }
+
     fn debug_introduce_local_as_var(
         &self,
         bx: &mut Bx,
@@ -387,7 +433,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
     ) {
         let Some(dbg_var) = var.dbg_var else { return };
         let Some(dbg_loc) = self.dbg_loc(var.source_info) else { return };
-
         let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
             calculate_debuginfo_offset(bx, var.projection, base.layout);
 
@@ -422,6 +467,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             bx.dbg_var_addr(
                 dbg_var,
                 dbg_loc,
+                true,
                 alloca.val.llval,
                 Size::ZERO,
                 &[Size::ZERO],
@@ -431,6 +477,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             bx.dbg_var_addr(
                 dbg_var,
                 dbg_loc,
+                true,
                 base.val.llval,
                 direct_offset,
                 &indirect_offsets,
@@ -456,7 +503,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let base = FunctionCx::spill_operand_to_stack(operand, Some(name), bx);
                 bx.clear_dbg_loc();
 
-                bx.dbg_var_addr(dbg_var, dbg_loc, base.val.llval, Size::ZERO, &[], fragment);
+                bx.dbg_var_addr(dbg_var, dbg_loc, true, base.val.llval, Size::ZERO, &[], fragment);
             }
         }
     }

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -1,8 +1,14 @@
+use std::ops::Deref;
+
 use rustc_middle::mir::{self, NonDivergingIntrinsic};
-use rustc_middle::span_bug;
+use rustc_middle::ty::layout::HasTyCtxt;
+use rustc_middle::ty::{Ty, TyCtxt};
+use rustc_middle::{bug, span_bug};
 use tracing::instrument;
 
 use super::{FunctionCx, LocalRef};
+use crate::mir::operand::{OperandRef, OperandValue};
+use crate::mir::place::PlaceRef;
 use crate::traits::*;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
@@ -94,8 +100,65 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             | mir::StatementKind::PlaceMention(..)
             | mir::StatementKind::BackwardIncompatibleDropHint { .. } => {}
             mir::StatementKind::Nop(ref stmt) => {
-                if stmt.is_some() {
-                    todo!("add debugging information")
+                if let Some(box stmt_kind) = stmt {
+                    match stmt_kind {
+                        mir::StatementKind::Assign(box (dest, rvalue)) => {
+                            if let Some(index) = dest.as_local()
+                                && let mir::Rvalue::Ref(_, _, place) = *rvalue
+                            {
+                                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::Ref(_place_value) => {
+                                            todo!("OperandValue::Ref")
+                                        }
+                                        OperandValue::Immediate(v) => {
+                                            Some(PlaceRef::new_sized(v, operand_ref.layout))
+                                        }
+                                        OperandValue::Pair(_, _) => None,
+                                        OperandValue::ZeroSized => None,
+                                    },
+                                    LocalRef::PendingOperand => None,
+                                };
+                                let (val, layout, projection) =
+                                    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), 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..])
+                                        }
+                                        _ => {
+                                            let ty =
+                                                self.monomorphize(self.mir.local_decls[index].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, index, val, layout, projection);
+                            } else {
+                                todo!("add debugging information")
+                            }
+                        }
+                        _ => {}
+                    }
                 }
             }
         }

compiler/rustc_codegen_ssa/src/traits/debuginfo.rs

@@ -71,7 +71,8 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
         &mut self,
         dbg_var: Self::DIVariable,
         dbg_loc: Self::DILocation,
-        variable_alloca: Self::Value,
+        is_declared: bool,
+        val: Self::Value,
         direct_offset: Size,
         // NB: each offset implies a deref (i.e. they're steps in a pointer chain).
         indirect_offsets: &[Size],

compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp

@@ -1247,6 +1247,18 @@ LLVMRustDIBuilderInsertDeclareAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef V,
       DebugLoc(cast<MDNode>(unwrap(DL))), unwrap(InsertAtEnd));
 }
 
+extern "C" void
+LLVMRustDIBuilderInsertDbgValueAtEnd(LLVMDIBuilderRef Builder, LLVMValueRef V,
+                                     LLVMMetadataRef VarInfo, uint64_t *AddrOps,
+                                     unsigned AddrOpsCount, LLVMMetadataRef DL,
+                                     LLVMBasicBlockRef InsertAtEnd) {
+  unwrap(Builder)->insertDbgValueIntrinsic(
+      unwrap(V), unwrap<DILocalVariable>(VarInfo),
+      unwrap(Builder)->createExpression(
+          llvm::ArrayRef<uint64_t>(AddrOps, AddrOpsCount)),
+      DebugLoc(cast<MDNode>(unwrap(DL))), unwrap(InsertAtEnd));
+}
+
 extern "C" LLVMMetadataRef
 LLVMRustDIBuilderCreateEnumerator(LLVMDIBuilderRef Builder, const char *Name,
                                   size_t NameLen, const uint64_t Value[2],

tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-abort.diff

@@ -221,23 +221,18 @@
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
 +         StorageLive(_45);
-+         StorageLive(_46);
 +         StorageLive(_50);
 +         StorageLive(_42);
 +         StorageLive(_43);
-+         StorageLive(_44);
 +         Nop(Assign((_46, &mut _19)));
-+         StorageLive(_47);
 +         Nop(Assign((_47, &mut (_19.0: &mut std::future::Ready<()>))));
 +         _45 = copy (_19.0: &mut std::future::Ready<()>);
-+         StorageDead(_47);
 +         Nop(Assign((_44, &mut ((*_45).0: std::option::Option<()>))));
 +         StorageLive(_48);
 +         _48 = Option::<()>::None;
 +         _43 = copy ((*_45).0: std::option::Option<()>);
 +         ((*_45).0: std::option::Option<()>) = copy _48;
 +         StorageDead(_48);
-+         StorageDead(_44);
 +         StorageLive(_49);
 +         _49 = discriminant(_43);
 +         switchInt(move _49) -> [0: bb11, 1: bb12, otherwise: bb5];
@@ -313,7 +308,6 @@
 +         _18 = Poll::<()>::Ready(move _42);
 +         StorageDead(_42);
 +         StorageDead(_50);
-+         StorageDead(_46);
 +         StorageDead(_45);
 +         StorageDead(_22);
 +         StorageDead(_19);

tests/mir-opt/inline_coroutine_body.run2-{closure#0}.Inline.panic-unwind.diff

@@ -238,23 +238,18 @@
 +         _22 = &mut (*_23);
 +         StorageDead(_24);
 +         StorageLive(_47);
-+         StorageLive(_48);
 +         StorageLive(_52);
 +         StorageLive(_44);
 +         StorageLive(_45);
-+         StorageLive(_46);
 +         Nop(Assign((_48, &mut _19)));
-+         StorageLive(_49);
 +         Nop(Assign((_49, &mut (_19.0: &mut std::future::Ready<()>))));
 +         _47 = copy (_19.0: &mut std::future::Ready<()>);
-+         StorageDead(_49);
 +         Nop(Assign((_46, &mut ((*_47).0: std::option::Option<()>))));
 +         StorageLive(_50);
 +         _50 = Option::<()>::None;
 +         _45 = copy ((*_47).0: std::option::Option<()>);
 +         ((*_47).0: std::option::Option<()>) = copy _50;
 +         StorageDead(_50);
-+         StorageDead(_46);
 +         StorageLive(_51);
 +         _51 = discriminant(_45);
 +         switchInt(move _51) -> [0: bb16, 1: bb17, otherwise: bb7];
@@ -354,7 +349,6 @@
 +         _18 = Poll::<()>::Ready(move _44);
 +         StorageDead(_44);
 +         StorageDead(_52);
-+         StorageDead(_48);
 +         StorageDead(_47);
 +         StorageDead(_22);
 +         StorageDead(_19);

tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-abort.diff

@@ -37,15 +37,9 @@
       }
 
       bb2: {
-          StorageLive(_7);
           Nop(Assign((_7, &(*_2)[0 of 3])));
-          StorageLive(_8);
           Nop(Assign((_8, &(*_2)[1 of 3])));
-          StorageLive(_9);
           Nop(Assign((_9, &(*_2)[2 of 3])));
-          StorageDead(_9);
-          StorageDead(_8);
-          StorageDead(_7);
           StorageDead(_4);
           return;
       }

tests/mir-opt/issue_76432.test.SimplifyComparisonIntegral.panic-unwind.diff

@@ -37,15 +37,9 @@
       }
 
       bb2: {
-          StorageLive(_7);
           Nop(Assign((_7, &(*_2)[0 of 3])));
-          StorageLive(_8);
           Nop(Assign((_8, &(*_2)[1 of 3])));
-          StorageLive(_9);
           Nop(Assign((_9, &(*_2)[2 of 3])));
-          StorageDead(_9);
-          StorageDead(_8);
-          StorageDead(_7);
           StorageDead(_4);
           return;
       }

tests/mir-opt/pre-codegen/clone_as_copy.clone_as_copy.PreCodegen.after.mir

@@ -12,10 +12,8 @@ fn clone_as_copy(_1: &NestCopy) -> NestCopy {
     }
 
     bb0: {
-        StorageLive(_2);
         Nop(Assign((_2, &((*_1).1: AllCopy))));
         _0 = copy (*_1);
-        StorageDead(_2);
         return;
     }
 }