fixup! codegen: Generate dbg_value for the ref statement

Add `debug_new_val_to_local`
Inline `debug_new_value_to_local_as_var`

Author: dianqk

compiler/rustc_codegen_gcc/src/debuginfo.rs

@@ -29,7 +29,7 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
         _variable_alloca: Self::Value,
         _direct_offset: Size,
         _indirect_offsets: &[Size],
-        _fragment: Option<Range<Size>>,
+        _fragment: &Option<Range<Size>>,
     ) {
         // FIXME(tempdragon): Not sure if this is correct, probably wrong but still keep it here.
         #[cfg(feature = "master")]
@@ -38,15 +38,12 @@ impl<'a, 'gcc, 'tcx> DebugInfoBuilderMethods for Builder<'a, 'gcc, 'tcx> {
 
     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>>,
+        _dbg_var: Self::DIVariable,
+        _dbg_loc: Self::DILocation,
+        _value: Self::Value,
+        _direct_offset: Size,
+        _indirect_offsets: &[Size],
+        _fragment: &Option<Range<Size>>,
     ) {
     }
 

compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

@@ -163,7 +163,7 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         variable_alloca: Self::Value,
         direct_offset: Size,
         indirect_offsets: &[Size],
-        fragment: Option<Range<Size>>,
+        fragment: &Option<Range<Size>>,
     ) {
         use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst};
 
@@ -209,7 +209,7 @@ impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
         value: Self::Value,
         direct_offset: Size,
         indirect_offsets: &[Size],
-        fragment: Option<Range<Size>>,
+        fragment: &Option<Range<Size>>,
     ) {
         use dwarf_const::{DW_OP_LLVM_fragment, DW_OP_deref, DW_OP_plus_uconst, DW_OP_stack_value};
 

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -253,7 +253,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         spill_slot
     }
 
-    pub(crate) fn debug_new_value_to_local(
+    // Indicates that local is set to a new value. The `layout` and `projection` are used to
+    // calculate the offset.
+    pub(crate) fn debug_new_val_to_local(
         &self,
         bx: &mut Bx,
         local: mir::Local,
@@ -271,31 +273,32 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             None => return,
         };
 
-        for var in vars.iter().cloned() {
-            self.debug_new_value_to_local_as_var(bx, base, layout, projection, var);
+        let DebugInfoOffset { direct_offset, indirect_offsets, result: _ } =
+            calculate_debuginfo_offset(bx, projection, layout);
+        for var in vars.iter() {
+            let Some(dbg_var) = var.dbg_var else {
+                continue;
+            };
+            let Some(dbg_loc) = self.dbg_loc(var.source_info) else {
+                continue;
+            };
+            bx.dbg_var_value(
+                dbg_var,
+                dbg_loc,
+                base.llval,
+                direct_offset,
+                &indirect_offsets,
+                &var.fragment,
+            );
         }
     }
 
-    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_value(
-            dbg_var,
-            dbg_loc,
-            base.llval,
-            direct_offset,
-            &indirect_offsets,
-            var.fragment,
-        );
+    pub(crate) fn debug_poison_to_local(&self, bx: &mut Bx, local: mir::Local) {
+        let ty = self.monomorphize(self.mir.local_decls[local].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);
+        self.debug_new_val_to_local(bx, local, place_ref.val, layout, &[]);
     }
 
     /// Apply debuginfo and/or name, after creating the `alloca` for a local,
@@ -469,7 +472,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 alloca.val.llval,
                 Size::ZERO,
                 &[Size::ZERO],
-                var.fragment,
+                &var.fragment,
             );
         } else {
             bx.dbg_var_addr(
@@ -478,7 +481,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 base.val.llval,
                 direct_offset,
                 &indirect_offsets,
-                var.fragment,
+                &var.fragment,
             );
         }
     }
@@ -500,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, base.val.llval, Size::ZERO, &[], &fragment);
             }
         }
     }

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -130,38 +130,28 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         // Only pointers can calculate addresses.
                         bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
                 });
-                let assign_ref = match (local_ref, place.is_indirect_first_projection()) {
-                    (Some(local_ref), false) => {
-                        Some((local_ref.val, local_ref.layout, place.projection.as_slice()))
-                    }
-                    (Some(local_ref), true) => {
+                if let Some(local_ref) = local_ref {
+                    let (base_layout, projection) = if place.is_indirect_first_projection() {
+                        // For `_n = &((*_1).0: i32);`, we are calculating the address of `_1.0`, so
+                        // we should drop the deref projection.
                         let projected_ty = local_ref
                             .layout
                             .ty
                             .builtin_deref(true)
                             .unwrap_or_else(|| bug!("deref of non-pointer {:?}", local_ref));
                         let layout = bx.cx().layout_of(projected_ty);
-                        Some((local_ref.val, layout, &place.projection[1..]))
-                    }
-                    _ => None,
-                };
-                let (val, layout, projection) = assign_ref.unwrap_or_else(|| {
+                        (layout, &place.projection[1..])
+                    } else {
+                        (local_ref.layout, place.projection.as_slice())
+                    };
+                    self.debug_new_val_to_local(bx, *dest, local_ref.val, base_layout, projection);
+                } 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);
+                    self.debug_poison_to_local(bx, *dest);
+                }
             }
             StmtDebugInfo::InvalidAssign(local) => {
-                let ty = self.monomorphize(self.mir.local_decls[*local].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);
-                self.debug_new_value_to_local(bx, *local, place_ref.val, layout, &[]);
+                self.debug_poison_to_local(bx, *local);
             }
         }
     }

compiler/rustc_codegen_ssa/src/traits/debuginfo.rs

@@ -77,7 +77,7 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
         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>>,
+        fragment: &Option<Range<Size>>,
     );
     fn dbg_var_value(
         &mut self,
@@ -89,7 +89,7 @@ pub trait DebugInfoBuilderMethods: BackendTypes {
         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>>,
+        fragment: &Option<Range<Size>>,
     );
     fn set_dbg_loc(&mut self, dbg_loc: Self::DILocation);
     fn clear_dbg_loc(&mut self);