[DebugInfo][4/N] Adjust x86 location-list tests for instruction referencing

[jmorse]

Summary

This patch updates location lists in various x86 tests to reflect what instruction referencing produces. There are two flavours of change:

• Not following a register copy immediately, because instruction referencing can make some slightly smarter decisions,
• Extended ranges, due to having additional information.

The register changes aren't that interesting, it's just a choice between equally legitimate registers that instr-ref does differently. The extended ranges are largely due to following stack restores better.

[Orlando]

Test changes LGTM (just one non-blocking inline question), but wouldn't we want to preserve the -experimental-debug-variable-locations=false coverage that these tests are currently (pre-patch) providing too?

llvm/test/DebugInfo/COFF/register-variables.ll

48–50

Non-blocking question: why do we get c <- undef here? The non-instr-ref location c <- $eax looks correct AFAICT.

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-4.ll

9

Nice!

[jmorse]

Orlando wrote:

wouldn't we want to preserve the -experimental-debug-variable-locations=false coverage that these tests are currently (pre-patch) providing

Yes and no; I think it's a question of what parts of the codegen pipeline are being tested. Most of these tests are checking parts of the DWARF emitter so that, for example, basic block sections have location lists divided on block boundaries (I think that's what it's doing?). Which isn't something affected by instruction referencing at all. In an ideal world these things would be MIR tests feeding into the DWARF emitter, however I suspect they were written before MIR existed / was good enough.

sdag-combine.ll is testing something that's likely to diverge between instr-ref and DBG_VALUEs, I guess that part does need duplicate test coverage.

llvm/test/DebugInfo/COFF/register-variables.ll

48–50

Looking at the IR, there's some tail-folding happening, where two instances of:

dbg.value
tail call void @putint(

on either side of a branch get merged together. In DBG_VALUE mode, I believe this works by coincidence: the tails get merged, debug instructions ignored, and the variable location preserved because one code sequence is spliced into the common tail. If there was only a dbg.value on one side, we'd end up with a false location.

With instruction referencing there's still one DBG_INSTR_REF preserved, but LiveDebugValues can tell that it isn't dominated by the definition it's referring to, so drops the location.

IMO this is a good demonstration that instruction referencing soundly drops questionable locations; exactly how to fix it is a wider question, and probably needs a little more instrumentation. I'll fold a note in remarking on the limitation.

[Orlando]

Ok, LGTM with the duplicated test and folded-in limitation remark. Thanks!

llvm/test/DebugInfo/COFF/register-variables.ll

48–50

Aha, that is quite interesting. Thanks for the explanation.

llvm/test/DebugInfo/COFF/pieces.ll

-; RUN: llc < %s -experimental-debug-variable-locations=false | FileCheck %s --check-prefix=ASM
-; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=false | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s -experimental-debug-variable-locations=true | FileCheck %s --check-prefix=ASM
+; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=true | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 
 ; Compile with -O1 as C
 
 ; struct IntPair { int x, y; };
 ; struct PadRight { long a; int b; };
 ; struct PadLeft { int a; long b; };
 ; struct Nested { struct PadLeft a[2]; };
 ;

 ; ASM:         retq
 ; ASM: [[pad_right_end:\.Lfunc_end1]]:
 
 
 ; ASM-LABEL: pad_left: # @pad_left
 ; ASM:         .cv_loc 2 1 24 3                # t.c:24:3
 ; ASM:         movq    %rcx, %rax
 ; ASM: [[pad_left_tmp:\.Ltmp[0-9]+]]:
-; ASM:         #DEBUG_VALUE: pad_left:o <- [DW_OP_LLVM_fragment 0 32] $eax
+; ASM:         #DEBUG_VALUE: pad_left:o <- [DW_OP_LLVM_fragment 0 32] $ecx
 ; ASM:         retq
 ; ASM: [[pad_left_end:\.Lfunc_end2]]:
 
 
 ; ASM-LABEL: nested: # @nested
 ; ASM:         #DEBUG_VALUE: nested:o <- [DW_OP_deref] [$rcx+0]
 ; ASM:         movl    12(%rcx), %eax
 ; ASM: [[p_start:\.Ltmp[0-9]+]]:
 ; ASM:         #DEBUG_VALUE: nested:p <- [DW_OP_LLVM_fragment 32 32] $eax
 ; ASM:         retq
 
 ; ASM-LABEL: bitpiece_spill: # @bitpiece_spill
 ; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 0 32] 0
 ; ASM:         xorl    %ecx, %ecx
 ; ASM:         callq   g
 ; ASM:         movl    %eax, [[offset_o_x:[0-9]+]](%rsp)          # 4-byte Spill
 ; ASM: [[spill_o_x_start:\.Ltmp[0-9]+]]:
 ; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offset_o_x]], DW_OP_LLVM_fragment 32 32] [$rsp+0]
 ; ASM:         #APP
 ; ASM:         #NO_APP
 ; ASM:         movl    [[offset_o_x]](%rsp), %eax          # 4-byte Reload
+; ASM: [[spill_o_x_end:\.Ltmp[0-9]+]]:
+; ASM:         #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 32 32] $eax
 ; ASM:         retq
-; ASM-NEXT: [[spill_o_x_end:\.Ltmp[0-9]+]]:
+; ASM: [[spill_o_x_end_func:\.Ltmp[0-9]+]]:
 ; ASM-NEXT: .Lfunc_end4:
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "loop_csr"              # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
 ; ASM:        .cv_def_range    [[oy_ox_start]] [[ox_start]], subfield_reg, 24, 0

 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "pad_left"              # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[pad_left_tmp]] [[pad_left_end]], subfield_reg, 17, 0
+; ASM:        .cv_def_range    [[pad_left_tmp]] [[pad_left_end]], subfield_reg, 18, 0
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: pad_left
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }
 ; OBJ:       DefRangeSubfieldRegisterSym {
-; OBJ:         Register: EAX (0x11)
+; OBJ:         Register: ECX (0x12)
 ; OBJ:         MayHaveNoName: 0
 ; OBJ:         OffsetInParent: 0
 ; OBJ:         LocalVariableAddrRange {
 ; OBJ:         }
 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 

 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "bitpiece_spill"        # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    [[spill_o_x_start]] .Lfunc_end4, reg_rel, 335, 65, 36
+; ASM:        .cv_def_range    [[spill_o_x_start]] [[spill_o_x_end]], reg_rel, 335, 65, 36
+; ASM:        .cv_def_range    [[spill_o_x_end]] .Lfunc_end4, subfield_reg, 17, 4
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: bitpiece_spill
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }

llvm/test/DebugInfo/COFF/register-variables.ll

-; RUN: llc < %s -experimental-debug-variable-locations=false | FileCheck %s --check-prefix=ASM
-; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=false | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
+; RUN: llc < %s -experimental-debug-variable-locations=true | FileCheck %s --check-prefix=ASM
+; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=true | llvm-readobj --codeview - | FileCheck %s --check-prefix=OBJ
 
 ; Generated from:
 ; volatile int x;
 ; int getint(void);
 ; void putint(int);
 ; static inline int inlineinc(int a) {
 ;   int b = a + 1;
 ;   ++x;

 ; ASM: f:                                      # @f
 ; ASM: .Lfunc_begin0:
 ; ASM: # %bb.0:                                 # %entry
 ; ASM:         #DEBUG_VALUE: f:p <- $ecx
 ; ASM:         pushq   %rsi
 ; ASM:         subq    $32, %rsp
 ; ASM:         movl    %ecx, %esi
 ; ASM: [[p_ecx_esi:\.Ltmp.*]]:
-; ASM:         #DEBUG_VALUE: f:p <- $esi
 ; ASM:         callq   getint
 ; ASM: [[after_getint:\.Ltmp.*]]:
 ; ASM:         testl   %esi, %esi
 ; ASM:         je      .LBB0_2
 ; ASM: [[after_je:\.Ltmp.*]]:
 ; ASM: # %bb.1:                                 # %if.then
 ; ASM-DAG:     #DEBUG_VALUE: inlineinc:a <- $eax
 ; ASM-DAG:     #DEBUG_VALUE: a <- $eax
 ; ASM-DAG:     #DEBUG_VALUE: f:p <- $esi
 ; ASM:         addl    $1, %eax
 ; ASM: [[after_inc_eax:\.Ltmp.*]]:
 ; ASM:         #DEBUG_VALUE: inlineinc:b <- $eax
 ; ASM:         addl    $1, x(%rip)
 ; ASM: [[after_if:\.Ltmp.*]]:
 ; ASM: .LBB0_2:                                # %if.else
 ; ASM:         #DEBUG_VALUE: f:p <- $esi
-; ASM:         #DEBUG_VALUE: c <- $eax
+;; FIXME: tail-merging causes the location of "c" to be dropped in instruction
+;; referencing mode.
+; ASM:         #DEBUG_VALUE: c <- undef
 ; ASM:         movl    %eax, %ecx
 ; ASM:         addq    $32, %rsp
 ; ASM:         popq    %rsi
 ; ASM: [[func_end:\.Ltmp.*]]:
 ; ASM:         jmp     putint                  # TAILCALL
 ; ASM: [[func_finished:\.Ltmp.*]]:
 
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "p"
-; ASM:         .cv_def_range    .Lfunc_begin0 [[p_ecx_esi]], reg, 18
-; ASM:         .cv_def_range    [[p_ecx_esi]] [[func_end]], reg, 23
+; ASM:         .cv_def_range    .Lfunc_begin0 [[after_getint]], reg, 18
+; ASM:         .cv_def_range    [[after_getint]] [[func_end]], reg, 23
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "c"
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "a"
 ; ASM:         .cv_def_range    [[after_je]] [[after_inc_eax]], reg, 17
 ; ASM:         .short  4414                    # Record kind: S_LOCAL
 ; ASM:         .asciz  "b"
 

 ; OBJ:     ]
 ; OBJ:     VarName: p
 ; OBJ:   }
 ; OBJ:   DefRangeRegisterSym {
 ; OBJ:     Register: ECX (0x12)
 ; OBJ:     LocalVariableAddrRange {
 ; OBJ:       OffsetStart: .text+0x0
 ; OBJ:       ISectStart: 0x0
-; OBJ:       Range: 0x7
+; OBJ:       Range: 0xC
 ; OBJ:     }
 ; OBJ:   }
 ; OBJ:   DefRangeRegisterSym {
 ; OBJ:     Register: ESI (0x17)
 ; OBJ:     LocalVariableAddrRange {
-; OBJ:       OffsetStart: .text+0x7
+; OBJ:       OffsetStart: .text+0xC
 ; OBJ:       ISectStart: 0x0
-; OBJ:       Range: 0x1A
+; OBJ:       Range: 0x15
 ; OBJ:     }
 ; OBJ:   }
 ; OBJ:   LocalSym {
 ; OBJ:     Type: int (0x74)
 ; OBJ:     Flags [ (0x100)
 ; OBJ:       IsOptimizedOut (0x100)
 ; OBJ:     ]
 ; OBJ:     VarName: c

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-4.ll

-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s
-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s
-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s
-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s
 
 ; CHECK:      DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location
-; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value)
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg0 RAX)
 ; CHECK-NEXT: DW_AT_name  ("i")
 
 ; Source to generate the IR below:
 ; void f1();
 ; int f2();
 ; void test() {
 ;   // constant value through partial scope, no BB boundary
 ;   // Shouldn't change with BB-sections

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-5.ll

-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s
-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s
-; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=4 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=none -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s
+; RUN: llc %s -mtriple=x86_64-unknown-linux-gnu --dwarf-version=5 --basic-block-sections=all -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s --check-prefix=CHECK --check-prefix=SECTIONS
 
 ; CHECK:      DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location
 ; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
 ; SECTIONS-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
 ; SECTIONS-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_consts +7, DW_OP_stack_value
+; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg0 RAX)
 ; CHECK-NEXT: DW_AT_name  ("i")
 
 ; In the test below, i's constant value of 7 is only valid partially as
 ; it is redefined at the end.  This forces the use of a loclist with basic
 ; block sections.  Without basic block sections, a single entry location
 ; list would be used to mark the entire scope in which value of i is 7.
 
 ; Source to generate the IR below:

llvm/test/DebugInfo/X86/live-debug-values-remove-range.ll

-; RUN: llc -mtriple=x86_64-unknown-unknown %s -o - -stop-after=livedebugvalues -experimental-debug-variable-locations=false | FileCheck %s
+; RUN: llc -mtriple=x86_64-unknown-unknown %s -o - -stop-after=livedebugvalues -experimental-debug-variable-locations=true | FileCheck %s
 ;
 ; In the simple loop below, the location of the variable "toast" is %bar in
 ; the entry block, then set to constant zero at the end of the loop. We cannot
 ; know the location of "toast" at the start of the %loop block. Test that no
 ; location is given until after the call to @booler.
 ;
 ; Second function @baz added with an even tighter loop -- this tests different
 ; code-paths through LiveDebugValues. Any blocks with an incoming backedge need

 ; CHECK-NOT:   DBG_VALUE
 ; CHECK-LABEL: CALL64pcrel32 @booler
 ; CHECK:       DBG_VALUE 0, $noreg, ![[BAZVARNUM]]
 ;
 ; quux tests -- the variable arrives in $edi, should get a non-undef location
 ; before the loop, and its position re-stated in each block.
 ; CHECK-LABEL: name: quux
 ; CHECK:       DBG_VALUE $edi, $noreg, ![[QUUXVARNUM]]
-; CHECK:       DBG_VALUE [[QUUXLOC:[a-zA-Z0-9$_]+]], $noreg, ![[QUUXVARNUM]]
 ; CHECK-LABEL: bb.1.loop
-; CHECK:       DBG_VALUE [[QUUXLOC]], $noreg, ![[QUUXVARNUM]]
+; CHECK:       DBG_VALUE $ebx, $noreg, ![[QUUXVARNUM]]
 ; CHECK-NOT:   DBG_VALUE $noreg
 ; CHECK-LABEL: bb.2.exit
-; CHECK:       DBG_VALUE [[QUUXLOC]], $noreg, ![[QUUXVARNUM]]
+; CHECK:       DBG_VALUE $ebx, $noreg, ![[QUUXVARNUM]]
 ; CHECK-NOT:   DBG_VALUE $noreg
 
 declare dso_local i1 @booler()
 declare dso_local void @escape(i32)
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 @glob = global i32 0
 
 define i32 @foo(i32 %bar) !dbg !4 {

llvm/test/DebugInfo/X86/pieces-3.ll

-; RUN: llc %s -filetype=obj -o - -experimental-debug-variable-locations=false | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc %s -filetype=obj -o - -experimental-debug-variable-locations=true | llvm-dwarfdump -v - | FileCheck %s
 ;
 ;    // Compile with -O1
 ;    typedef struct {
 ;      int a;
 ;      int b;
 ;    } Inner;
 ;
 ;    typedef struct {
 ;      Inner inner[2];
 ;    } Outer;
 ;
 ;    int foo(Outer outer) {
 ;      Inner i1 = outer.inner[1];
 ;      return i1.a;
 ;    }
 ;
 ; CHECK: DW_TAG_formal_parameter [3]
 ; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        (
-; CHECK-NEXT:     [0x0000000000000000, 0x0000000000000007): DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_piece 0x4, DW_OP_reg4 RSI, DW_OP_piece 0x4
-; CHECK-NEXT:     [0x0000000000000007, 0x0000000000000009): DW_OP_reg5 RDI, DW_OP_piece 0x8
+; CHECK-NEXT:     [0x0000000000000000, 0x0000000000000009): DW_OP_reg5 RDI, DW_OP_piece 0x8, DW_OP_piece 0x4, DW_OP_reg4 RSI, DW_OP_piece 0x4
 ; CHECK-NEXT:   DW_AT_name {{.*}}"outer"
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        (0x00000044
-; CHECK-NEXT:     [0x0000000000000007, 0x0000000000000009): DW_OP_reg0 RAX, DW_OP_piece 0x4)
+; CHECK-NEXT:   DW_AT_location [DW_FORM_data4]        (0x0000002a
+; CHECK-NEXT:     [0x0000000000000007, 0x0000000000000009): DW_OP_reg4 RSI, DW_OP_piece 0x4)
 ; CHECK-NEXT:   "i1"
 
 ; ModuleID = '/Volumes/Data/llvm/test/DebugInfo/X86/sroasplit-2.ll'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.9.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define i32 @foo(i64 %outer.coerce0, i64 %outer.coerce1) #0 !dbg !4 {

llvm/test/DebugInfo/X86/sdag-combine.ll

-; RUN: llc %s -stop-after=livedebugvars -o - -experimental-debug-variable-locations=false | FileCheck %s
+; RUN: llc %s -stop-after=livedebugvars -o - -experimental-debug-variable-locations=false | FileCheck %s --check-prefix=CHECK
+; RUN: llc %s -stop-after=livedebugvars -o - -experimental-debug-variable-locations=true | FileCheck %s --check-prefix=INSTRREF
 source_filename = "/tmp/t.ll"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.13"
 
 %TSb = type <{ i1 }>
 
 declare swiftcc i1 @f()
 
 ; Function Attrs: nounwind readnone speculatable
 declare void @llvm.dbg.declare(metadata, metadata, metadata) #0
 
 ; Function Attrs: nounwind readnone speculatable
 define swiftcc void @g() #0 !dbg !5 {
 entry:
   %0 = alloca %TSb, align 1
   %1 = call swiftcc i1 @f(), !dbg !7
-  ; CHECK: DBG_VALUE $rcx, $noreg, !8, !DIExpression(), debug-location !7
+  ; CHECK: DBG_VALUE $rcx, $noreg, !8, !DIExpression(),
+  ; INSTRREF: DBG_VALUE $ecx, $noreg, !8, !DIExpression(),
   call void @llvm.dbg.value(metadata i1 %1, metadata !8, metadata !DIExpression()), !dbg !7
   %2 = getelementptr inbounds %TSb, %TSb* %0, i32 0, i32 0, !dbg !7
   store i1 %1, i1* %2, align 1, !dbg !7
   %3 = zext i1 %1 to i64, !dbg !7
   call void asm sideeffect "", "r"(i64 %3), !dbg !7
   ret void, !dbg !7
 }
 

llvm/test/DebugInfo/X86/spill-nospill.ll

-; RUN: llc < %s -experimental-debug-variable-locations=false | FileCheck %s
-; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=false | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
+; RUN: llc < %s -experimental-debug-variable-locations=true | FileCheck %s
+; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=true | llvm-dwarfdump - | FileCheck %s --check-prefix=DWARF
 
 ; This test creates two UserValues in LiveDebugVariables with one location
 ; each. x must be spilled, but y will be allocated to a CSR. x's location
 ; should be indirect, but y's should be direct.
 
 ; C source:
 ; #define FORCE_SPILL() \
 ;   __asm volatile("" : : : \

 ; CHECK: callq   g
 ; CHECK: movl    [[X_OFFS]](%rsp), %eax          # 4-byte Reload
 ; CHECK: #DEBUG_VALUE: f:x <- $eax
 ; CHECK: addl    %[[CSR]], %eax
 
 ; DWARF:      DW_TAG_variable
 ; DWARF-NEXT:   DW_AT_location        (
 ; DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_breg7 RSP+36
-; DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_reg0 RAX)
+; DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_reg0 RAX
+; DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_breg7 RSP+36)
 ; DWARF-NEXT:   DW_AT_name    ("x")
 
 ; DWARF:      DW_TAG_variable
 ; DWARF-NEXT:   DW_AT_location        (
 ; DWARF-NEXT:      [{{.*}},  {{.*}}): DW_OP_reg4 RSI)
 ; DWARF-NEXT:   DW_AT_name    ("y")
 
 ; ModuleID = 'spill-nospill.c'