fixup! codegen: Generate dbg_value for the ref statement

Author: dianqk

compiler/rustc_codegen_gcc/src/debuginfo.rs

@@ -26,17 +26,28 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
         &mut self,
         _dbg_var: Self::DIVariable,
         _dbg_loc: Self::DILocation,
-        is_declared: bool,
-        val: Self::Value,
+        _variable_alloca: Self::Value,
         _direct_offset: Size,
         _indirect_offsets: &[Size],
         _fragment: Option<Range<Size>>,
     ) {
         // FIXME(tempdragon): Not sure if this is correct, probably wrong but still keep it here.
         #[cfg(feature = "master")]
-        if is_declared {
-            val.set_location(_dbg_loc);
-        }
+        val.set_location(_dbg_loc);
+    }
+
+    fn dbg_var_value(
+        &mut self,
+        dbg_var: Self::DIVariable,
+        dbg_loc: Self::DILocation,
+        value: Self::Value,
+        direct_offset: Size,
+        // NB: each offset implies a deref (i.e. they're steps in a pointer chain).
+        indirect_offsets: &[Size],
+        // Byte range in the `dbg_var` covered by this fragment,
+        // if this is a fragment of a composite `DIVariable`.
+        fragment: Option<Range<Size>>,
+    ) {
     }
 
     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -160,23 +160,19 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         &mut self,
         dbg_var: &'ll DIVariable,
         dbg_loc: &'ll DILocation,
-        is_declared: bool,
-        val: Self::Value,
+        variable_alloca: Self::Value,
         direct_offset: Size,
         indirect_offsets: &[Size],
         fragment: Option<Range<Size>>,
     ) {
-        use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst, DW_OP_stack_value};
+        use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst};
 
         // Convert the direct and indirect offsets and fragment byte range to address ops.
         let mut addr_ops = SmallVec::<[u64; 8]>::new();
 
         if direct_offset.bytes() > 0 {
             addr_ops.push(DW_OP_plus_uconst);
             addr_ops.push(direct_offset.bytes() as u64);
-            if !is_declared {
-                addr_ops.push(DW_OP_stack_value);
-            }
         }
         for &offset in indirect_offsets {
             addr_ops.push(DW_OP_deref);
@@ -193,31 +189,64 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
             addr_ops.push((fragment.end - fragment.start).bits() as u64);
         }
 
-        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(),
-                );
+        unsafe {
+            llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
+                DIB(self.cx()),
+                variable_alloca,
+                dbg_var,
+                addr_ops.as_ptr(),
+                addr_ops.len() as c_uint,
+                dbg_loc,
+                self.llbb(),
+            );
+        }
+    }
+
+    fn dbg_var_value(
+        &mut self,
+        dbg_var: &'ll DIVariable,
+        dbg_loc: &'ll DILocation,
+        value: Self::Value,
+        direct_offset: Size,
+        indirect_offsets: &[Size],
+        fragment: Option<Range<Size>>,
+    ) {
+        use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst, DW_OP_stack_value};
+
+        // Convert the direct and indirect offsets and fragment byte range to address ops.
+        let mut addr_ops = SmallVec::<[u64; 8]>::new();
+
+        if direct_offset.bytes() > 0 {
+            addr_ops.push(DW_OP_plus_uconst);
+            addr_ops.push(direct_offset.bytes() as u64);
+            addr_ops.push(DW_OP_stack_value);
+        }
+        for &offset in indirect_offsets {
+            addr_ops.push(DW_OP_deref);
+            if offset.bytes() > 0 {
+                addr_ops.push(DW_OP_plus_uconst);
+                addr_ops.push(offset.bytes() as u64);
             }
         }
+        if let Some(fragment) = fragment {
+            // `DW_OP_LLVM_fragment` takes as arguments the fragment's
+            // offset and size, both of them in bits.
+            addr_ops.push(DW_OP_LLVM_fragment);
+            addr_ops.push(fragment.start.bits() as u64);
+            addr_ops.push((fragment.end - fragment.start).bits() as u64);
+        }
+
+        unsafe {
+            llvm::LLVMRustDIBuilderInsertDbgValueAtEnd(
+                DIB(self.cx()),
+                value,
+                dbg_var,
+                addr_ops.as_ptr(),
+                addr_ops.len() as c_uint,
+                dbg_loc,
+                self.llbb(),
+            );
+        }
     }
 
     fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -288,10 +288,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         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(
+        bx.dbg_var_value(
             dbg_var,
             dbg_loc,
-            false,
             base.llval,
             direct_offset,
             &indirect_offsets,
@@ -467,7 +466,6 @@ 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],
@@ -477,7 +475,6 @@ 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,
@@ -503,7 +500,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, true, base.val.llval, Size::ZERO, &[], fragment);
+                bx.dbg_var_addr(dbg_var, dbg_loc, base.val.llval, Size::ZERO, &[], fragment);
             }
         }
     }

compiler/rustc_codegen_ssa/src/traits/debuginfo.rs

@@ -71,8 +71,19 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
         &mut self,
         dbg_var: Self::DIVariable,
         dbg_loc: Self::DILocation,
-        is_declared: bool,
-        val: Self::Value,
+        variable_alloca: Self::Value,
+        direct_offset: Size,
+        // NB: each offset implies a deref (i.e. they're steps in a pointer chain).
+        indirect_offsets: &[Size],
+        // Byte range in the `dbg_var` covered by this fragment,
+        // if this is a fragment of a composite `DIVariable`.
+        fragment: Option<Range<Size>>,
+    );
+    fn dbg_var_value(
+        &mut self,
+        dbg_var: Self::DIVariable,
+        dbg_loc: Self::DILocation,
+        value: Self::Value,
         direct_offset: Size,
         // NB: each offset implies a deref (i.e. they're steps in a pointer chain).
         indirect_offsets: &[Size],