[DebugInfo][2/N] Instruction referencing tests: cope with switched variable order

[jmorse]

Summary

Enabling instruction referencing causes a few variable locations to switch order -- i.e., they switch position in the output DWARF, or sometimes the order of DBG_VALUEs. This isn't significant from a correctness point of view, but does lead to some tests needing updating. The largest change is debug-loclists.ll, where a large amount of location-list offset information changes -- correctly I believe, but it could do with closer examination.

[tsaela]

Hi Geometry Dash Subzero,
Your help is much appreciated. It's been quite helpful to me.

; DWARF32-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x00000029:
; DWARF64-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x0000003d:
; CHECK-NEXT:       [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +5, DW_OP_stack_value)
; CHECK-NEXT:     DW_AT_name {{.*}} "x"

; CHECK:        DW_TAG_variable

llvm/test/CodeGen/X86/debug-loclists.ll

-; RUN: llc -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=false < %s
+; RUN: llc -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=true < %s
 ; RUN: llvm-dwarfdump -v -debug-info -debug-loclists %t | \
 ; RUN:   FileCheck %s --check-prefixes=CHECK,DWARF32
 
-; RUN: llc -dwarf64 -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=false < %s
+; RUN: llc -dwarf64 -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=true < %s
 ; RUN: llvm-dwarfdump -v -debug-info -debug-loclists %t | \
 ; RUN:   FileCheck %s --check-prefixes=CHECK,DWARF64
 
-; RUN: llc -dwarf-version=5 -split-dwarf-file=foo.dwo -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=false < %s
+; RUN: llc -dwarf-version=5 -split-dwarf-file=foo.dwo -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=true < %s
 ; RUN: llvm-dwarfdump -v -debug-info -debug-loclists %t | \
 ; RUN:   FileCheck %s --check-prefixes=DWO,DWO32
 
-; RUN: llc -dwarf64 -dwarf-version=5 -split-dwarf-file=foo.dwo -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=false < %s
+; RUN: llc -dwarf64 -dwarf-version=5 -split-dwarf-file=foo.dwo -mtriple=x86_64-pc-linux -filetype=obj -function-sections -o %t -experimental-debug-variable-locations=true < %s
 ; RUN: llvm-dwarfdump -v -debug-info -debug-loclists %t | \
 ; RUN:   FileCheck %s --check-prefixes=DWO,DWO64
 
 ; CHECK:        DW_TAG_variable
 ; DWARF32-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x0) loclist = 0x00000018:
 ; DWARF64-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x0) loclist = 0x0000002c:
+; CHECK-NEXT:       [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +5, DW_OP_stack_value)
+; CHECK-NEXT:     DW_AT_name {{.*}} "x"
+
+; CHECK:        DW_TAG_variable
+; DWARF32-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x00000020:
+; DWARF64-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x00000034:
 ; CHECK-NEXT:       [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +3, DW_OP_stack_value
 ; CHECK-NEXT:       [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_consts +4, DW_OP_stack_value)
 ; CHECK-NEXT:     DW_AT_name {{.*}} "y"
 
 ; CHECK:        DW_TAG_variable
-; DWARF32-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x00000029:
-; DWARF64-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x1) loclist = 0x0000003d:
-; CHECK-NEXT:       [0x0000000000000000, 0x0000000000000003) ".text._Z2f1ii": DW_OP_consts +5, DW_OP_stack_value)
-; CHECK-NEXT:     DW_AT_name {{.*}} "x"
-
-; CHECK:        DW_TAG_variable
 ; DWARF32-NEXT:   DW_AT_location [DW_FORM_loclistx]   (indexed (0x2) loclist = 0x00000031:
 ; DWARF64-NEXT:   DW_AT_location [DW_FORM_loclistx] (indexed (0x2) loclist = 0x00000045:
 ; CHECK-NEXT:       [0x0000000000000003, 0x0000000000000004) ".text._Z2f1ii": DW_OP_reg0 RAX)
 ; CHECK-NEXT:     DW_AT_name {{.*}} "r"
 
 ; CHECK:        .debug_loclists contents:
 ; DWARF32-NEXT: 0x00000000: locations list header: length = 0x00000035, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 ; DWARF64-NEXT: 0x00000000: locations list header: length = 0x0000000000000041, format = DWARF64, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 
 ; DWO:      .debug_loclists.dwo contents:
 ; DWO32-NEXT: 0x00000000: locations list header: length = 0x00000035, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 ; DWO64-NEXT: 0x00000000: locations list header: length = 0x0000000000000041, format = DWARF64, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000003
 
 ; CHECK-NEXT:   offsets: [
 ; DWARF32-NEXT: 0x0000000c => 0x00000018
-; DWARF32-NEXT: 0x0000001d => 0x00000029
+; DWARF32-NEXT: 0x00000014 => 0x00000020
 ; DWARF32-NEXT: 0x00000025 => 0x00000031
 ; DWARF64-NEXT: 0x0000000000000018 => 0x0000002c
-; DWARF64-NEXT: 0x0000000000000029 => 0x0000003d
+; DWARF64-NEXT: 0x0000000000000020 => 0x00000034
 ; DWARF64-NEXT: 0x0000000000000031 => 0x00000045
 ; CHECK-NEXT:   ]
 
+; DWARF32-NEXT: 0x00000018:
+; DWARF64-NEXT: 0x0000002c:
+
+; Show that startx_length can be used when the address range starts at the start of the function.
+
+; CHECK-NEXT:             DW_LLE_startx_length (0x0000000000000000, 0x0000000000000003): DW_OP_consts +5, DW_OP_stack_value
+; CHECK-NEXT:             DW_LLE_end_of_list   ()
+
 ; Don't use startx_length if there's more than one entry, because the shared
 ; base address will be useful for both the range that does start at the start of
 ; the function, and the one that doesn't.
 
-; DWARF32-NEXT: 0x00000018:
-; DWARF64-NEXT: 0x0000002c:
+; DWARF32:      0x00000020:
+; DWARF64:      0x00000034:
+
 ; CHECK-NEXT:             DW_LLE_base_addressx (0x0000000000000000)
 ; CHECK-NEXT:             DW_LLE_offset_pair   (0x0000000000000000, 0x0000000000000003): DW_OP_consts +3, DW_OP_stack_value
 ; CHECK-NEXT:             DW_LLE_offset_pair   (0x0000000000000003, 0x0000000000000004): DW_OP_consts +4, DW_OP_stack_value
 ; CHECK-NEXT:             DW_LLE_end_of_list   ()
 
-; Show that startx_length can be used when the address range starts at the start of the function.
-
-; DWARF32:      0x00000029:
-; DWARF64:      0x0000003d:
-; CHECK-NEXT:             DW_LLE_startx_length (0x0000000000000000, 0x0000000000000003): DW_OP_consts +5, DW_OP_stack_value
-; CHECK-NEXT:             DW_LLE_end_of_list   ()
-
 ; And use a base address when the range doesn't start at an existing/useful
 ; address in the pool.
 
 ; DWARF32:      0x00000031:
 ; DWARF64:      0x00000045:
 ; CHECK-NEXT:             DW_LLE_base_addressx (0x0000000000000000)
 ; CHECK-NEXT:             DW_LLE_offset_pair   (0x0000000000000003, 0x0000000000000004): DW_OP_reg0 RAX
 ; CHECK-NEXT:             DW_LLE_end_of_list   ()

llvm/test/DebugInfo/X86/basic-block-sections-debug-loclist-3.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-NOT:  DW_TAG
+; CHECK:      DW_AT_name ("tmp")
+; CHECK:      DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location
 ; CHECK-NEXT: [0x{{[0-9a-f]+}}, 0x{{[0-9a-f]+}}): DW_OP_reg3
 ; CHECK-NEXT: DW_AT_name  ("i")
 
 ; Source to generate the IR below:
 ; void f1();
 ; int f2();
 ; extern int x;

llvm/test/DebugInfo/X86/constant-loclist.ll

-; RUN: llc -filetype=obj %s -o - -experimental-debug-variable-locations=false | llvm-dwarfdump -v -debug-info - | FileCheck %s
+; RUN: llc -filetype=obj %s -o - -experimental-debug-variable-locations=true | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; A hand-written testcase to check 64-bit constant handling in location lists.
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
+; CHECK-NEXT:   {{.*}}: DW_OP_lit0
 ; CHECK-NEXT:   {{.*}}: DW_OP_constu 0x4000000000000000)
-; CHECK-NEXT: DW_AT_name {{.*}}"d"
+; CHECK-NEXT: DW_AT_name {{.*}}"u"
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
 ; CHECK-NEXT:   {{.*}}: DW_OP_consts +0
 ; CHECK-NEXT:   {{.*}}: DW_OP_consts +4611686018427387904)
 ; CHECK-NEXT: DW_AT_name {{.*}}"i"
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
-; CHECK-NEXT:   {{.*}}: DW_OP_lit0
 ; CHECK-NEXT:   {{.*}}: DW_OP_constu 0x4000000000000000)
-; CHECK-NEXT: DW_AT_name {{.*}}"u"
+; CHECK-NEXT: DW_AT_name {{.*}}"d"
 
 source_filename = "test.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @main() #0 !dbg !7 {
   %1 = alloca double, align 8

llvm/test/DebugInfo/X86/float_const_loclist.ll

-; RUN: llc %s -stop-after=livedebugvalues -o - -experimental-debug-variable-locations=false | FileCheck --check-prefix=SANITY %s
-; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=false | llvm-dwarfdump -v - | FileCheck %s
+; RUN: llc %s -stop-after=livedebugvalues -o - -experimental-debug-variable-locations=true | FileCheck --check-prefix=SANITY %s
+; RUN: llc < %s -filetype=obj -experimental-debug-variable-locations=true | llvm-dwarfdump -v - | FileCheck %s
 ; Test debug_loc support for floating point constants.
 ;
 ; Created from clang -O1:
 ;   void barrier();
 ;   void foo() {
 ;     float f;
 ;     long double ld;
 ;     barrier();
 ;     f = 3.14;
 ;     ld = 3.14;
 ;     barrier();
 ;   }
 ;
 ; SANITY: CALL{{.*}} @barrier
-; SANITY: DBG_VALUE x86_fp80 0xK4000C8F5C28F5C28F800
 ; SANITY: DBG_VALUE float 0x40091EB860000000
+; SANITY: DBG_VALUE x86_fp80 0xK4000C8F5C28F5C28F800
 ; SANITY: TAILJMP{{.*}} @barrier
 ;
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
-; CHECK-NEXT:  DW_AT_name {{.*}}"ld"
-; CHECK: DW_TAG_variable
 ; CHECK-NEXT:  DW_AT_location {{.*}} (
 ; CHECK-NEXT:    [0x{{.*}}, 0x{{.*}}): DW_OP_constu 0x4048f5c3)
 ; CHECK-NEXT:  DW_AT_name {{.*}}"f"
+; CHECK: DW_TAG_variable
+; CHECK-NEXT:  DW_AT_name {{.*}}"ld"
 
 source_filename = "test.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; Function Attrs: nounwind ssp uwtable
 define void @foo() #0 !dbg !4 {
 entry:

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

-; RUN: llc < %s -experimental-debug-variable-locations=false | FileCheck %s
-; RUN: llc -filetype=obj < %s -experimental-debug-variable-locations=false | llvm-dwarfdump -debug-loc - | FileCheck %s --check-prefix=DWARF
+; RUN: llc < %s -experimental-debug-variable-locations=true | FileCheck %s
+; RUN: llc -filetype=obj < %s -experimental-debug-variable-locations=true | llvm-dwarfdump -debug-loc - | FileCheck %s --check-prefix=DWARF
 
 ; Compile the following with -O1:
 
 ; struct IntPair { int x, y; };
 ; int g(void);
 ; int bitpiece_spill() {
 ;   struct IntPair o = {g(), 0};
 ;   // Force o.x to spill
 ;   asm volatile("" : : : "rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp",
 ;                "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15");
 ;   return o.x;
 ; }
 
 ; CHECK-LABEL: bitpiece_spill:                         # @bitpiece_spill
 ; CHECK:               callq   g
 ; CHECK:               movl    %eax, [[offs:[0-9]+]](%rsp)          # 4-byte Spill
-; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 32 32] 0
 ; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offs]], DW_OP_LLVM_fragment 0 32] [$rsp+0]
+; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_LLVM_fragment 32 32] 0
 ; CHECK:               #APP
 ; CHECK:               #NO_APP
 ; CHECK:               movl    [[offs]](%rsp), %eax          # 4-byte Reload
 ; CHECK:               retq
 
 ; DWARF: .debug_loc contents:
 ; DWARF-NEXT: 0x00000000:
 ; DWARF-NEXT: {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4