[DebugInfo][3/N] Instruction referencing tests: add extra instr-ref mode lines to several tests

[jmorse]

Summary

In these test updates for instruction referencing, I've added specific instruction-referencing modes, and kept the DBG_VALUE-based variable location check lines. This is because argument handling is really fiddly, and I figured it's worth duplicating the testing to ensure it's definitely correct. There's also (dbg-value-superreg-copy2.mir) a test for where variable locations go when virtual registers are coalesced together. I don't think there's an instruction referencing specific test for this, so figured that's worth duplicating too.

[Orlando]

LGTM

[sapey]

Hi Snow Rider 3D
Your help is much appreciated.

;; In instruction referencing mode, we should refer to the instruction number
;; of the earlier DBG_PHIs.
; INSTRREF:     ADJCALLSTACKUP
; INSTRREF-NOT: DBG_
; INSTRREF-DAG: DBG_INSTR_REF 1, 0, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
; INSTRREF-DAG: DBG_INSTR_REF 2, 0, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)

; And then no more DBG_ instructions before the add.
; COMMON-NOT: DBG_
; COMMON:     ADD32rr

llvm/test/CodeGen/X86/dbg-value-superreg-copy2.mir

+# RUN: llc -O1 -start-after simple-register-coalescing -o - %s -experimental-debug-variable-locations=true | FileCheck %s
+
+--- |
+  target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+  target triple = "x86_64-pc-linux-gnu"
+
+  define i16 @foo(i8 %zzz) !dbg !4 {
+  entry:
+    ret i16 1
+  }
+
+  ; Function Attrs: nounwind readnone speculatable
+  declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+  !llvm.dbg.cu = !{!0}
+  !llvm.module.flags = !{!3}
+
+  !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !2)
+  !1 = !DIFile(filename: "test.c", directory: "")
+  !2 = !{}
+  !3 = !{i32 1, !"Debug Info Version", i32 3}
+  !4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 3, type: !5, isLocal: false, isDefinition: true, scopeLine: 3, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0)
+  !5 = !DISubroutineType(types: !6)
+  !6 = !{null}
+  !7 = !DILocalVariable(name: "zzz", arg: 1, scope: !4, file: !1, line: 3, type: !8)
+  !8 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed)
+  !9 = !DILocation(line: 0, scope: !4)
+  !10 = !DILocation(line: 4, column: 22, scope: !11)
+  !11 = distinct !DILexicalBlock(scope: !4, file: !1, line: 3, column: 19)
+
+...
+---
+name:            foo
+tracksRegLiveness: true
+debugValueSubstitutions:
+  - { srcinst: 2, srcop: 0, dstinst: 1, dstop: 0, subreg: 2 }
+body:             |
+  bb.0:
+    %0:gr16_abcd = MOV16ri 1, debug-instr-number 1, debug-location !9
+
+  bb.1:
+    DBG_INSTR_REF 2, 0, !7, !DIExpression(), debug-location !9
+    %1:gr16 = COPY %0, debug-location !9
+    %2:gr16 = COPY %0
+
+  bb.2:
+    $ax = COPY %1, debug-location !9
+    $dx = COPY %2
+    RET64 killed $ax, killed $dx, debug-location !9
+...
+
+# This test is an instruction-referencing flavour of the
+# dbg-value-superreg-copy.mir test. Over there, we ran into difficulties where
+# register coalescing would transform DBG_VALUEs of subregisters such as:
+#
+#   DBG_VALUE %0.sub_8bit_hi, $noreg,
+#
+# Into references to larger registers, potentially with the wrong offset. We
+# can't refer to vregs in instruction referencing mode, so this test replicates
+# the same scenario in a new test. The defining storing load gets an instruction
+# number, and we encode which subregister we want through a substitution. Check
+# that it comes out the other end of regalloc through coalescing still in a
+# high register.
+#
+# CHECK-NOT:    #DEBUG_VALUE:
+# CHECK:        #DEBUG_VALUE: foo:zzz <- ${{[abcd]+}}h
+# CHECK-NOT:    #DEBUG_VALUE:

llvm/test/DebugInfo/X86/dbg-value-arg-movement.ll

-; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare -stop-before=finalize-isel %s -o - -experimental-debug-variable-locations=false | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare -stop-before=finalize-isel %s -o - -experimental-debug-variable-locations=false | FileCheck %s --check-prefixes=COMMON,CHECK
+; RUN: llc -mtriple=x86_64-unknown-unknown -start-after=codegenprepare -stop-before=finalize-isel %s -o - -experimental-debug-variable-locations=true | FileCheck %s --check-prefixes=COMMON,INSTRREF
 
 ; Test the movement of dbg.values of arguments. SelectionDAG tries to be
 ; helpful and places DBG_VALUEs of Arguments at the start of functions.
 ; Unfortunately, this doesn't necessarily make sense, as one can specify an
 ; Argument IR Value as a variable location anywhere in the program.
 ;
 ; Distinguish cases where we want to hoist DBG_VALUEs, and those where we
 ; don't, by whether the referred to variable is a parameter to the current
 ; function. In the test below, 'xyzzy' is a parameter to an inlined function,
 ; but should not be hoisted to the start of the function.
 ;
+; With instruction referencing, accuracy becomes more important than coverage,
+; so debug instructions are placed wherever they were in the IR.
+;
 ; Original test case, in which 'xyzzy' became unavailable because its DBG_VALUE
 ; landed far from any uses, compiled "clang -O2 -g" with inlining,
 ;
 ;    int ext(void);
 ;
 ;    int
 ;    foo(int xyzzy)
 ;    {

 ;      case 99999:     fish = -1;       break;
 ;      default:        fish = 12;
 ;      }
 ;      qux %= fish;
 ;      qux += foo(baz);
 ;      return qux;
 ;    }
 
-; CHECK: [[BAZVAR:![0-9]+]] = !DILocalVariable(name: "baz",
-; CHECK: [[XYZVAR:![0-9]+]] = !DILocalVariable(name: "xyzzy",
+; COMMON: [[BAZVAR:![0-9]+]] = !DILocalVariable(name: "baz",
+; COMMON: [[XYZVAR:![0-9]+]] = !DILocalVariable(name: "xyzzy",
 
 ; Start of MIR function block,
 ; CHECK-LABEL: body
 ; Expect DBG_VALUE of physreg,
 ; CHECK:       DBG_VALUE $edi, $noreg, [[BAZVAR]]
 ; Expect DBG_VALUE of virtreg,
 ; CHECK:       DBG_VALUE [[ARGREG:%[0-9]+]], $noreg, [[BAZVAR]]
 ; Label for next block,
 ; CHECK-LABEL: bb.1.next
 ; Correctly place dbg.value in the 'next' block.
 ; CHECK:       DBG_VALUE [[ARGREG]], $noreg, [[XYZVAR]]
 
+; INSTRREF-LABEL: body
+; INSTRREF: DBG_PHI $edi, 1
+; INSTRREF: DBG_VALUE $edi, $noreg, [[BAZVAR]]
+; INSTRREF-LABEL: bb.1.next
+; INSTRREF: DBG_INSTR_REF 1, 0, [[XYZVAR]],
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i32 @ext()
 
 define dso_local i32 @bar(i32, i32) local_unnamed_addr !dbg !7 {
   %3 = srem i32 %1, %0, !dbg !15
   call void @llvm.dbg.value(metadata i32 %0, metadata !12, metadata !DIExpression()), !dbg !16

llvm/test/DebugInfo/X86/dbg-value-funcarg.ll

-; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=false | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=false | FileCheck %s --check-prefixes=COMMON,CHECK
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=true | FileCheck %s --check-prefixes=COMMON,INSTRREF
 
 ; Input to this test looked like this and was compiled using: clang -g -O1 -mllvm -stop-after=codegenprepare -S
 ;
 ;    extern void bar(int);
 ;
 ;    void foo_local(int t1a) {
 ;      int local = 123;
 ;      bar(local);

 ;      bar(t3a);
 ;      t3a = tmp;
 ;      bar(t3a);
 ;    }
 ;
 
 ; Catch metadata references for involved variables.
 ;
-; CHECK-DAG: ![[T1A:.*]] = !DILocalVariable(name: "t1a"
-; CHECK-DAG: ![[LOCAL:.*]] = !DILocalVariable(name: "local"
-; CHECK-DAG: ![[T2A:.*]] = !DILocalVariable(name: "t2a"
-; CHECK-DAG: ![[T2B:.*]] = !DILocalVariable(name: "t2b"
-; CHECK-DAG: ![[T3A:.*]] = !DILocalVariable(name: "t3a"
-; CHECK-DAG: ![[TMP:.*]] = !DILocalVariable(name: "tmp"
+; COMMON-DAG: ![[T1A:.*]] = !DILocalVariable(name: "t1a"
+; COMMON-DAG: ![[LOCAL:.*]] = !DILocalVariable(name: "local"
+; COMMON-DAG: ![[T2A:.*]] = !DILocalVariable(name: "t2a"
+; COMMON-DAG: ![[T2B:.*]] = !DILocalVariable(name: "t2b"
+; COMMON-DAG: ![[T3A:.*]] = !DILocalVariable(name: "t3a"
+; COMMON-DAG: ![[TMP:.*]] = !DILocalVariable(name: "tmp"
 
 
 define dso_local void @foo_local(i32 %t1a) local_unnamed_addr #0 !dbg !7 {
 ; CHECK-LABEL: name:            foo_local
 ; CHECK-NOT: DBG_VALUE
 ; CHECK:      DBG_VALUE $edi, $noreg, ![[T1A]], !DIExpression(),
 ; CHECK-NEXT: %0:gr32 = COPY $edi
 ; CHECK-NEXT: DBG_VALUE %0, $noreg, ![[T1A]], !DIExpression(),
 ; CHECK-NEXT: DBG_VALUE 123, $noreg, ![[LOCAL]], !DIExpression(),
 ; CHECK-NOT: DBG_VALUE
 ; CHECK:    CALL64pcrel32 @bar,
 ; CHECK:    DBG_VALUE %0, $noreg, ![[LOCAL]], !DIExpression(),
 ; CHECK:    DBG_VALUE $edi, $noreg, ![[T1A]], !DIExpression(),
 ; CHECK-NOT: DBG_VALUE
 ; CHECK:    TCRETURNdi64 @bar,
+; INSTRREF-LABEL: name:            foo_local
+; INSTRREF-NOT: DBG_
+; INSTRREF:      DBG_PHI $edi, 1
+; INSTRREF:      DBG_VALUE $edi, $noreg, ![[T1A]], !DIExpression(),
+; INSTRREF-NEXT: %0:gr32 = COPY $edi
+; INSTRREF-NEXT: DBG_VALUE 123, $noreg, ![[LOCAL]], !DIExpression(),
+; INSTRREF:      CALL64pcrel32 @bar,
+; INSTRREF-NEXT: ADJCALLSTACKUP64
+; INSTRREF:      DBG_INSTR_REF 1, 0, ![[LOCAL]], !DIExpression(),
+; INSTRREF-NOT: DBG_
+; INSTRREF:    TCRETURNdi64 @bar,
+
 entry:
   call void @llvm.dbg.value(metadata i32 %t1a, metadata !12, metadata !DIExpression()), !dbg !14
   call void @llvm.dbg.value(metadata i32 123, metadata !13, metadata !DIExpression()), !dbg !15
   tail call void @bar(i32 123) #3, !dbg !16
   call void @llvm.dbg.value(metadata i32 %t1a, metadata !13, metadata !DIExpression()), !dbg !15
   tail call void @bar(i32 %t1a) #3, !dbg !17
   ret void, !dbg !18
 }
 
 define dso_local void @foo_other_param(i32 %t2a, i32 %t2b) local_unnamed_addr #0 !dbg !19 {
 ; CHECK-LABEL: name:            foo_other_param
 ; CHECK: DBG_VALUE $edi, $noreg, ![[T2A]], !DIExpression(),
 ; CHECK: DBG_VALUE $esi, $noreg, ![[T2B]], !DIExpression(),
 ; CHECK: %1:gr32 = COPY $esi
 ; CHECK: DBG_VALUE %1, $noreg, ![[T2B]], !DIExpression(),
 ; CHECK: %0:gr32 = COPY $edi
 ; CHECK: DBG_VALUE %0, $noreg, ![[T2A]], !DIExpression(),
 ; CHECK: DBG_VALUE $edi, $noreg, ![[T2B]], !DIExpression(),
 ; CHECK: CALL64pcrel32 @bar,
 ; CHECK: DBG_VALUE 123, $noreg, ![[T2B]], !DIExpression(),
 ; CHECK: CALL64pcrel32 @bar,
 ; CHECK: DBG_VALUE %0, $noreg, ![[T2B]], !DIExpression(),
 ; CHECK: DBG_VALUE $edi, $noreg, ![[T2A]], !DIExpression(),
 ; CHECK: TCRETURNdi64 @bar,
+; INSTRREF-LABEL: name:            foo_other_param
+; INSTRREF: DBG_PHI $edi, 1
+; INSTRREF: DBG_VALUE $edi, $noreg, ![[T2A]], !DIExpression(),
+; INSTRREF: DBG_VALUE $esi, $noreg, ![[T2B]], !DIExpression(),
+; INSTRREF: CALL64pcrel32 @bar,
+; INSTRREF: DBG_VALUE 123, $noreg, ![[T2B]], !DIExpression(),
+; INSTRREF: CALL64pcrel32 @bar,
+; INSTRREF: DBG_INSTR_REF 1, 0, ![[T2B]], !DIExpression(),
+; INSTRREF: TCRETURNdi64 @bar,
 
 entry:
   call void @llvm.dbg.value(metadata i32 %t2a, metadata !23, metadata !DIExpression()), !dbg !25
   call void @llvm.dbg.value(metadata i32 %t2b, metadata !24, metadata !DIExpression()), !dbg !26
   tail call void @bar(i32 %t2b) #3, !dbg !27
   call void @llvm.dbg.value(metadata i32 123, metadata !24, metadata !DIExpression()), !dbg !26
   tail call void @bar(i32 123) #3, !dbg !28
   call void @llvm.dbg.value(metadata i32 %t2a, metadata !24, metadata !DIExpression()), !dbg !26
   tail call void @bar(i32 %t2a) #3, !dbg !29
   ret void, !dbg !30
 }
 
 define dso_local void @foo_same_param(i32 %t3a) local_unnamed_addr #0 !dbg !31 {
 ; CHECK-LABEL: name:            foo_same_param
 ; CHECK: DBG_VALUE $edi, $noreg, ![[T3A]], !DIExpression(),
 ; CHECK: %0:gr32 = COPY $edi
 ; CHECK: DBG_VALUE %0, $noreg, ![[T3A]], !DIExpression(),
 ; CHECK: CALL64pcrel32 @bar,
 ; CHECK: DBG_VALUE %0, $noreg, ![[TMP]], !DIExpression(),
 ; CHECK: DBG_VALUE 123, $noreg, ![[T3A]], !DIExpression(),
 ; CHECK: CALL64pcrel32 @bar,
 ; CHECK: DBG_VALUE %0, $noreg, ![[T3A]], !DIExpression(),
 ; CHECK: TCRETURNdi64 @bar,
+; INSTRREF-LABEL: name:            foo_same_param
+; INSTRREF: DBG_PHI $edi, 2
+; INSTRREF: DBG_PHI $edi, 1
+; INSTRREF: DBG_VALUE $edi, $noreg, ![[T3A]], !DIExpression(),
+; INSTRREF: CALL64pcrel32 @bar,
+; INSTRREF: DBG_INSTR_REF 1, 0, ![[TMP]], !DIExpression(),
+; INSTRREF: DBG_VALUE 123, $noreg, ![[T3A]], !DIExpression(),
+; INSTRREF: CALL64pcrel32 @bar,
+; INSTRREF: DBG_INSTR_REF 2, 0, ![[T3A]], !DIExpression(),
+; INSTRREF: TCRETURNdi64 @bar,
 entry:
   call void @llvm.dbg.value(metadata i32 %t3a, metadata !33, metadata !DIExpression()), !dbg !35
   tail call void @bar(i32 %t3a) #3, !dbg !36
   call void @llvm.dbg.value(metadata i32 %t3a, metadata !34, metadata !DIExpression()), !dbg !37
   call void @llvm.dbg.value(metadata i32 123, metadata !33, metadata !DIExpression()), !dbg !35
   tail call void @bar(i32 123) #3, !dbg !38
   call void @llvm.dbg.value(metadata i32 %t3a, metadata !33, metadata !DIExpression()), !dbg !35
   tail call void @bar(i32 %t3a) #3, !dbg !39

llvm/test/DebugInfo/X86/dbg-value-funcarg2.ll

-; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=false | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=false | FileCheck %s --check-prefixes=CHECK,COMMON
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=true | FileCheck %s --check-prefixes=INSTRREF,COMMON
 
 ; Test case was generated from the following C code,
 ; using: clang -g -O1 -S -emit-llvm s.c -o s.ll
 ;
 ; struct s { long long int i, j; };
 ;
 ; extern void bar(struct s, struct s, struct s);
 ;
 ; int f(struct s s1, struct s s2) {
 ;   volatile struct s tmp = {0};
 ;   bar(s1, s2, tmp);
 ;   s1.i = s2.i;
 ;   s1.j = s2.j;
 ;   return s1.j + s1.j;
 ; }
 
 ; Catch metadata references for involved variables.
 ;
-; CHECK-DAG: ![[S1:.*]] = !DILocalVariable(name: "s1"
-; CHECK-DAG: ![[S2:.*]] = !DILocalVariable(name: "s2"
+; COMMON-DAG: ![[S1:.*]] = !DILocalVariable(name: "s1"
+; COMMON-DAG: ![[S2:.*]] = !DILocalVariable(name: "s2"
 
 define dso_local i32 @f(i64 %s1.coerce0, i64 %s1.coerce1, i64 %s2.coerce0, i64 %s2.coerce1) local_unnamed_addr #0 !dbg !7 {
 ; We expect DBG_VALUE instructions for the arguments at the entry.
-; CHECK-LABEL: name:            f
-; CHECK-NOT: DBG_VALUE
-; CHECK-DAG: DBG_VALUE $rdi, $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
-; CHECK-DAG: DBG_VALUE $rsi, $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
-; CHECK-DAG: DBG_VALUE $rdx, $noreg, ![[S2]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
-; CHECK-DAG: DBG_VALUE $rcx, $noreg, ![[S2]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
-; CHECK-NOT: DBG_VALUE
+; In instr-ref mode, there'll be some DBG_PHIs in there too.
+; COMMON-LABEL: name:            f
+; COMMON-NOT: DBG_VALUE
+; INSTRREF-DAG: DBG_PHI $rcx, 2
+; INSTRREF-DAG: DBG_PHI $rdx, 1
+; COMMON-DAG: DBG_VALUE $rdi, $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
+; COMMON-DAG: DBG_VALUE $rsi, $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
+; COMMON-DAG: DBG_VALUE $rdx, $noreg, ![[S2]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
+; COMMON-DAG: DBG_VALUE $rcx, $noreg, ![[S2]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
+; COMMON-NOT: DBG_
 
 ; Then arguments are copied to virtual registers.
 ; CHECK-NOT: DBG_VALUE
 ; CHECK-DAG: %[[R1:.*]]:gr64 = COPY $rcx
 ; CHECK-DAG: DBG_VALUE %[[R1]], $noreg, ![[S2]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
 ; CHECK-DAG: %[[R2:.*]]:gr64 = COPY $rdx
 ; CHECK-DAG: DBG_VALUE %[[R2]], $noreg, ![[S2]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
 ; CHECK-DAG: %[[R3:.*]]:gr64 = COPY $rsi
 ; CHECK-DAG: DBG_VALUE %[[R3]], $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
 ; CHECK-DAG: %[[R4:.*]]:gr64 = COPY $rdi
 ; CHECK-DAG: DBG_VALUE %[[R4]], $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
 ; CHECK-NOT: DBG_VALUE
 
 ; We have the call to bar.
-; CHECK:     ADJCALLSTACKDOWN
-; CHECK:     CALL64pcrel32 @bar
+; COMMON:     ADJCALLSTACKDOWN
+; COMMON:     CALL64pcrel32 @bar
 
 ; After the call we expect to find new DBG_VALUE instructions for "s1".
 ; CHECK:     ADJCALLSTACKUP
 ; CHECK-NOT: DBG_VALUE
 ; CHECK-DAG: DBG_VALUE %[[R2]], $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
 ; CHECK-DAG: DBG_VALUE %[[R1]], $noreg, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
 
-; And then no more DBG_VALUE instructions before the add.
-; CHECK-NOT: DBG_VALUE
-; CHECK:     ADD32rr
+;; In instruction referencing mode, we should refer to the instruction number
+;; of the earlier DBG_PHIs.
+; INSTRREF:     ADJCALLSTACKUP
+; INSTRREF-NOT: DBG_
+; INSTRREF-DAG: DBG_INSTR_REF 1, 0, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 0, 64)
+; INSTRREF-DAG: DBG_INSTR_REF 2, 0, ![[S1]], !DIExpression(DW_OP_LLVM_fragment, 64, 64)
+
+; And then no more DBG_ instructions before the add.
+; COMMON-NOT: DBG_
+; COMMON:     ADD32rr
 
 entry:
   %tmp.sroa.0 = alloca i64, align 8
   %tmp.sroa.4 = alloca i64, align 8
   call void @llvm.dbg.declare(metadata i64* %tmp.sroa.0, metadata !19, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg !21
   call void @llvm.dbg.declare(metadata i64* %tmp.sroa.4, metadata !19, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg !21
   call void @llvm.dbg.value(metadata i64 %s1.coerce0, metadata !17, metadata !DIExpression(DW_OP_LLVM_fragment, 0, 64)), !dbg !22
   call void @llvm.dbg.value(metadata i64 %s1.coerce1, metadata !17, metadata !DIExpression(DW_OP_LLVM_fragment, 64, 64)), !dbg !22

llvm/test/DebugInfo/X86/dbg-value-funcarg3.ll

 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=false | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-linux-gnu -start-after=codegenprepare -stop-before=finalize-isel -o - %s -experimental-debug-variable-locations=true | FileCheck %s --check-prefixes=INSTRREF
 
 ; Input to this test looked like this and was compiled using: clang -g -O1 -mllvm -stop-after=codegenprepare -S
 ;
 ;    int fn1(long t1) {
 ;      return t;
 ;    }
 ;
 
 ; Catch metadata references for involved variables.
 ;
 ; CHECK-DAG: ![[T1:.*]] = !DILocalVariable(name: "t1"
+; INSTRREF-DAG: ![[T1:.*]] = !DILocalVariable(name: "t1"
 
 
 define dso_local i32 @fn1(i64 %t1) local_unnamed_addr #0 !dbg !7 {
 ; We expect that the same width COPY reuses the debug location,
 ; but the width narrowing COPY does not.
 ; 
 ; CHECK-LABEL: name:            fn1
 ; CHECK: DBG_VALUE $rdi, $noreg, ![[T1]], !DIExpression(),
 ; CHECK-NEXT: %0:gr64 = COPY $rdi
 ; CHECK-NEXT: DBG_VALUE %0, $noreg, ![[T1]], !DIExpression(),
 ; CHECK-NEXT: %1:gr32 = COPY %0.sub_32bit
 ; CHECK-NEXT: COPY
 ; CHECK-NEXT: RET
+;
+;; For instr-ref, no copies should be considered. Because argumenst are
+;; Special, we don't label them in the same way, and currently emit a
+;; DBG_VALUE for the physreg.
+; INSTRREF-LABEL: name:            fn1
+; INSTRREF: DBG_VALUE $rdi, $noreg, ![[T1]], !DIExpression(),
+; INSTRREF-NEXT: %0:gr64 = COPY $rdi
+; INSTRREF-NEXT: %1:gr32 = COPY %0.sub_32bit
+; INSTRREF-NEXT: COPY
+; INSTRREF-NEXT: RET
+
 entry:
   call void @llvm.dbg.value(metadata i64 %t1, metadata !13, metadata !DIExpression()), !dbg !14
   %0 = trunc i64 %t1 to i32, !dbg !15
   ret i32 %0, !dbg !16
 }
 
 declare void @llvm.dbg.value(metadata, metadata, metadata) #1