debuginfo: Use LocalRef to simplify reference debuginfos

If the `LocalRef` is `LocalRef::Place`, we can refer to it directly,
because the local of place is an indirect pointer.
Such a statement is `_1 = &_2.1`.
If the `LocalRef` is `LocalRef::Operand`,
the `OperandRef` should provide the pointer of the reference.
Such a statement is `_1 = &(*_2).1`.

But there is a special case that hasn't been handled, scalar pairs like `(&[i32; 16], i32)`.

Author: dianqk

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -259,7 +259,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         &self,
         bx: &mut Bx,
         local: mir::Local,
-        base: PlaceValue<Bx::Value>,
+        base: Bx::Value,
         layout: TyAndLayout<'tcx>,
         projection: &[mir::PlaceElem<'tcx>],
     ) {
@@ -285,7 +285,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             bx.dbg_var_value(
                 dbg_var,
                 dbg_loc,
-                base.llval,
+                base,
                 direct_offset,
                 &indirect_offsets,
                 &var.fragment,
@@ -298,7 +298,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         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, &[]);
+        self.debug_new_val_to_local(bx, local, place_ref.val.llval, layout, &[]);
     }
 
     /// Apply debuginfo and/or name, after creating the `alloca` for a local,

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -1,11 +1,9 @@
-use rustc_middle::mir::{self, NonDivergingIntrinsic, RETURN_PLACE, StmtDebugInfo};
+use rustc_middle::mir::{self, NonDivergingIntrinsic, StmtDebugInfo};
 use rustc_middle::{bug, span_bug};
-use rustc_target::callconv::PassMode;
 use tracing::instrument;
 
 use super::{FunctionCx, LocalRef};
 use crate::common::TypeKind;
-use crate::mir::place::PlaceRef;
 use crate::traits::*;
 
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
@@ -110,48 +108,43 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         match debuginfo {
             StmtDebugInfo::AssignRef(dest, place) => {
                 let local_ref = match self.locals[place.local] {
+                    // For an rvalue like `&_1.1`, when `BackendRepr` is `BackendRepr::Memory`, we allocate a block of memory to this place.
+                    // The place is an indirect pointer, we can refer to it directly.
                     LocalRef::Place(place_ref) | LocalRef::UnsizedPlace(place_ref) => {
-                        Some(place_ref)
+                        Some((place_ref.val.llval, place.projection.as_slice(), place_ref.layout))
                     }
-                    LocalRef::Operand(operand_ref) => operand_ref
-                        .val
-                        .try_pointer_parts()
-                        .map(|(pointer, _)| PlaceRef::new_sized(pointer, operand_ref.layout)),
+                    // For an rvalue like `&(*_1).1`, we are calculating the address of `_1.1`,
+                    // so we should drop the deref projection.
+                    LocalRef::Operand(operand_ref) if place.is_indirect_first_projection() => {
+                        operand_ref.val.try_pointer_parts().and_then(|(pointer, _)| {
+                            // The value may be a scalar, but only pointers can be calculated addresses.
+                            if bx.type_kind(bx.val_ty(pointer)) != TypeKind::Pointer {
+                                return None;
+                            }
+                            let deref_ty = operand_ref
+                                .layout
+                                .ty
+                                .builtin_deref(true)
+                                .unwrap_or_else(|| bug!("deref of non-pointer {:?}", place));
+                            Some((pointer, &place.projection[1..], bx.cx().layout_of(deref_ty)))
+                        })
+                    }
+                    // For an rvalue like `&1`, when `BackendRepr` is `BackendRepr::Scalar`,
+                    // we cannot get the address.
+                    // FIXME: For scalar pairs like `(&[i32; 16], i32)` or `(i32, &[i32; 16])`,
+                    // we can also calculate the offset when accessing the offset of array elements,
+                    // but the `&pair.1[1]` is two MIR statements.
+                    LocalRef::Operand(_) => None,
                     LocalRef::PendingOperand => None,
                 }
-                .filter(|place_ref| {
-                    // For the reference of an argument (e.x. `&_1`), it's only valid if the pass mode is indirect, and its reference is
-                    // llval.
-                    let local_ref_pass_mode = place.as_local().and_then(|local| {
-                        if local == RETURN_PLACE {
-                            None
-                        } else {
-                            self.fn_abi.args.get(local.as_usize() - 1).map(|arg| &arg.mode)
-                        }
-                    });
-                    matches!(local_ref_pass_mode, Some(&PassMode::Indirect {..}) | None) &&
+                .filter(|(_, projection, _)| {
                     // Drop unsupported projections.
-                    place.projection.iter().all(|p| p.can_use_in_debuginfo()) &&
-                    // Only pointers can be calculated addresses.
-                    bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
+                    projection.iter().all(|p| p.can_use_in_debuginfo())
                 });
-                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);
-                        (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);
+                if let Some((val, projection, layout)) = local_ref {
+                    self.debug_new_val_to_local(bx, *dest, val, layout, projection);
                 } else {
-                    // If the address cannot be computed, use poison to indicate that the value has been optimized out.
+                    // If the address cannot be calculated, use poison to indicate that the value has been optimized out.
                     self.debug_poison_to_local(bx, *dest);
                 }
             }