fixup! codegen: Generate dbg_value for the ref statement

`&_1` is only valid if the pass mode is indirect.

Author: dianqk

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -1,10 +1,10 @@
-use rustc_middle::mir::{self, NonDivergingIntrinsic, StmtDebugInfo};
+use rustc_middle::mir::{self, NonDivergingIntrinsic, RETURN_PLACE, 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::operand::OperandValue;
 use crate::mir::place::PlaceRef;
 use crate::traits::*;
 
@@ -113,21 +113,27 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     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))
-                        }
-                        OperandValue::Ref(_)
-                        | OperandValue::Pair(_, _)
-                        | OperandValue::ZeroSized => None,
-                    },
+                    LocalRef::Operand(operand_ref) => {
+                        let pointer = operand_ref.val.pointer_parts().0;
+                        Some(PlaceRef::new_sized(pointer, operand_ref.layout))
+                    }
                     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) &&
                     // Drop unsupported projections.
                     // FIXME: Add a test case.
                     place.projection.iter().all(|p| p.can_use_in_debuginfo()) &&
-                        // Only pointers can calculate addresses.
+                        // Only pointers can be calculated addresses.
                         bx.type_kind(bx.val_ty(place_ref.val.llval)) == TypeKind::Pointer
                 });
                 if let Some(local_ref) = local_ref {

tests/codegen-llvm/debuginfo-dse.rs

@@ -21,9 +21,11 @@ fn r#ref(ref_foo: &Foo) -> i32 {
     // CHECK-LABEL: define {{.*}} i32 @ref
     // CHECK-SAME: (ptr {{.*}} [[ARG_ref_foo:%.*]])
     // OPTIMIZED: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_foo:![0-9]+]], !DIExpression()
+    // CHECK: #dbg_value(ptr poison, [[VAR_invalid_ref_of_ref_foo:![0-9]+]], !DIExpression()
     // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v0:![0-9]+]], !DIExpression()
     // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v1:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
     // CHECK: #dbg_value(ptr [[ARG_ref_foo]], [[VAR_ref_v2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let invalid_ref_of_ref_foo = &ref_foo;
     let ref_v0 = &ref_foo.0;
     let ref_v1 = &ref_foo.1;
     let ref_v2 = &ref_foo.2;
@@ -49,9 +51,11 @@ pub fn dead_first(dead_first_foo: &Foo) -> &i32 {
 fn ptr(ptr_foo: Foo) -> i32 {
     // CHECK-LABEL: define {{.*}} i32 @ptr
     // CHECK-SAME: (ptr {{.*}} [[ARG_ptr_foo:%.*]])
+    // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[ref_ptr_foo:![0-9]+]], !DIExpression()
     // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v0:![0-9]+]], !DIExpression()
     // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v1:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 8, DW_OP_stack_value)
     // CHECK: #dbg_value(ptr [[ARG_ptr_foo]], [[VAR_ptr_v2:![0-9]+]], !DIExpression(DW_OP_plus_uconst, 16, DW_OP_stack_value)
+    let ref_ptr_foo = &ptr_foo;
     let ptr_v0 = &ptr_foo.0;
     let ptr_v1 = &ptr_foo.1;
     let ptr_v2 = &ptr_foo.2;
@@ -99,10 +103,12 @@ pub fn tuple(foo: (i32, &Foo)) -> i32 {
     foo.1.0
 }
 
+// CHECK-DAG: [[VAR_invalid_ref_of_ref_foo]] = !DILocalVariable(name: "invalid_ref_of_ref_foo"
 // OPTIMIZED-DAG: [[VAR_ref_foo]] = !DILocalVariable(name: "ref_foo"
 // CHECK-DAG: [[VAR_ref_v0]] = !DILocalVariable(name: "ref_v0"
 // CHECK-DAG: [[VAR_ref_v1]] = !DILocalVariable(name: "ref_v1"
 // CHECK-DAG: [[VAR_ref_v2]] = !DILocalVariable(name: "ref_v2"
+// CHECK-DAG: [[ref_ptr_foo]] = !DILocalVariable(name: "ref_ptr_foo"
 // CHECK-DAG: [[VAR_ptr_v0]] = !DILocalVariable(name: "ptr_v0"
 // CHECK-DAG: [[VAR_ptr_v1]] = !DILocalVariable(name: "ptr_v1"
 // CHECK-DAG: [[VAR_ptr_v2]] = !DILocalVariable(name: "ptr_v2"