[DebugInfo] Stop changing labels for register-described parameter DBG_VALUEs

[dstenb]

Summary

This is a follow-up to D57510. This patch removes the code from
DebugHandlerBase::beginFunction() which changes the starting label for
the first non-overlapping register-described DBG_VALUEs of parameters
to the beginning of the function. That code does not consider what defines the
registers, which can result in the ranges for the debug values starting before
their defining instructions. The code also violates the DbgValueHistoryMap's
ranges, which I think can make it quite confusing when troubleshooting.
We currently do not emit debug values for constant values directly at the
start of the function, so this code is still useful for such values, but my
intention is to remove the code from beginFunction() completely when we
get there.

In D57510, PrologEpilogInserter was amended so that parameter
DBG_VALUEs are kept at the start of the entry block, even after emission of
prologue code. That was done to reduce the degradation of debug
completeness from this patch. PR40638 is another example, where the
lexical-scope trimming that LDV does results in instructions after the prologue
being left without locations. There might be other cases where the
DBG_VALUEs are pushed further down, for which the DebugHandlerBase code
may be helpful, but as it now quite often result in incorrect locations,
even after the prologue, it seems better to remove that code, and try to
work our way up with accurate locations.

In the long run we should maybe not aim to provide accurate locations
inside the prologue. Some single location descriptions, at least those
referring to stack values, generate inaccurate values inside the
epilogue, so we maybe should not aim to achieve accuracy for location
lists. However, it seems that we now emit line number programs that can
result in GDB and LLDB stopping inside the prologue when doing line
number stepping into functions. See PR40188 for more information.

A summary of some of the changed test cases is available in PR40188#c2.

[jmorse]

LGTM, although I'll wait for someone else to approve.

[aprantl]

Does this have a noticeable effect on the debug info size?
Do we know about any remaining bugs where the first DBG_VALUE comes after the prologue_end and we would have a valid location at prologue_end? With constants perhaps? If yes, this would be a noticeable usability regression. Otherwise this just improves accuracy, which is always great.

[dstenb]

In D57511#1379750, @aprantl wrote:

Does this have a noticeable effect on the debug info size?

I will check this.

Do we know about any remaining bugs where the first DBG_VALUE comes after the prologue_end and we would have a valid location at prologue_end? With constants perhaps? If yes, this would be a noticeable usability regression. Otherwise this just improves accuracy, which is always great.

I reverted this patch (but kept D57510), and added the following patch (https://reviews.llvm.org/D57587) which prints whether or not the debug values that beginFunction() move are inside the prologue (using the same check as DwarfDebug's findPrologueEndLoc()).

I built a RelWithDebInfo-profiled Clang trunk binary with X86 as target using the above.

This resulted in the following numbers:

$ grep prologue a.log | sort | uniq -c
   4301   $noreg outside prologue
 220636   already inside prologue
     37   other type of value outside prologue
    813   reg value outside prologue

As seen, we have some $noreg debug values for parameters that are placed outside the prologue. Not moving those to the top of the function shouldn't affect the value in the debugger (it should be "unavailable" either way), but I guess that it may result in more location lists (I haven't verified this yet). For other values ("other type of value" in the table above), e.g. constants, this situation seems rare, only happening 37 times in a Clang build.

[aprantl]

I'm slightly worried that if we merge this patch too early we will get lots of complaints that variables are no longer visible in the debugger (because as an end-user you don't know whether the variable would become visible after the first single-step). The statistics will help us make that call, thanks!

[dstenb]

I have divided this into three measurements:

• "before": Without this patch
• "regs": Without this patch, but stop changing the label for values that are described by registers.
• "after": With this patch

As before, I built a clang binary from trunk using -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_TARGETS_TO_BUILD=X86.

Here are the diffs from llvm-dwarfdump -statistics when stepping between the variants:

$ diff -u before.txt regs.txt
--- before.txt  2019-02-04 15:17:06.985994932 +0100
+++ regs.txt    2019-02-04 15:14:27.799763830 +0100
@@ -1,7 +1,7 @@
 {
 "call site entries": 0,
-"scope bytes covered": 365024733,
-"scope bytes total": 703739122,
+"scope bytes covered": 364668389,
+"scope bytes total": 703739115,
 "format": "ELF64-x86-64",
 "source functions": 330578,
 "total function size": 43819231,
@@ -9,7 +9,7 @@
 "source variables": 7617628,
 "variables with location": 5251165,
 "version": 1,
-"file": "clang-before",
+"file": "clang-regs",
 "inlined functions": 3846999,
 "unique source variables": 1041245
 }

$ diff -u regs.txt after.txt
--- regs.txt    2019-02-04 15:14:27.799763830 +0100
+++ after.txt   2019-02-04 15:19:18.815674181 +0100
@@ -1,7 +1,7 @@
 {
 "call site entries": 0,
-"scope bytes covered": 364668389,
-"scope bytes total": 703739115,
+"scope bytes covered": 364655966,
+"scope bytes total": 703739101,
 "format": "ELF64-x86-64",
 "source functions": 330578,
 "total function size": 43819231,
@@ -9,7 +9,7 @@
 "source variables": 7617628,
 "variables with location": 5251165,
 "version": 1,
-"file": "clang-regs",
+"file": "clang-after",
 "inlined functions": 3846999,
 "unique source variables": 1041245
 }

$ ls clang-* | xargs -n1 stat --format='%s %n' | sort -h
1313541136 clang-before
1313541344 clang-regs
1313541592 clang-after

I'm not very familiar with interpreting llvm-dwarfdump's statistics dump, but I'd thought I would at least post it while I try to understand it.

Are there any more measurements I should do?

I guess that a first step could be to only drop beginFunction's behavior for register-described debug values, as it is for those it misbehaves, and we actively try to place such debug values at the start of the function e.g. in SelectionDAG.

[aprantl]

Thanks. As expected, it drives the number of variables that are not available at function entry down a bit. But my understanding is that we are pretty confident that most of them were incorrect before and I suppose we'll be more incentivized to get correct locations at the function entry with this patch applied than without it; even if it involves more disappointed end-users. It's a tough call, but I highly value correctness and reliability in the debugger, so let's do it! It will be the right thing in the long run.

test/DebugInfo/COFF/fp-stack.ll

13 ↗

(On Diff #184495)

this definitely looks more correct.

[dstenb]

I have changed the patch so that it still changes the labels for non-register debug values. This is done to reduce the regressions. I have not been able to find a C program where moving a constant-described value results in false positives. I will write a PR about getting SelectionDAG to emit debug values for constant arguments directly at the start of the function, which hopefully should make it possible to remove the rest of beginFunction() without as many regressions.

I have spent some time looking at regressions on 32- and 64-bits x86 for register-described values with this patch. The one type of regression I have found yet is due to https://bugs.llvm.org/show_bug.cgi?id=40638. The lexical-scope trimming that LiveDebugVariables does move debug values down, and we can then land in situations where we schedule up an instruction with a debug location above the moved debug value, effectively ending the prologue before the parameter is described. I started looking into stopping (or at least limiting) the trimming for non-inlined parameters, so that we keep the debug values directly at the start of the function, but I don't have a patch for that yet. However, in a majority of the cases where we were left with uncovered instructions after the prologue, it would have been incorrect to move the label, so it seems to me that this patch is worth getting in, even without a patch for PR40638.

Most of the cases I looked at where we moved the debug value above the defining instructions seems to be for constant parameters that we currently can't emit as constant debug values, e.g. GlobalValues, and various constant expressions, which we instead rely on lowered values somewhere down in the function.

[aprantl]

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

240 ↗

(On Diff #185780)

Does this become more readable by changing it to

 if (!std::all_of(...))
  break;
if (!IsDescribedByRef(...))

?

[dstenb]

Update after comment.

[dstenb]

lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

240 ↗

(On Diff #185780)

Yes; thanks! I inverted it to an any_of() also.

[dstenb]

Thanks for the reviews! Unless there are any more comments, I'm planning on merging this tomorrow or Thursday.

llvm/trunk/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   LLVM_DEBUG(DbgValues.dump());
 
   // Request labels for the full history.
   for (const auto &I : DbgValues) {
     const auto &Ranges = I.second;
     if (Ranges.empty())
       continue;
 
-    // The first mention of a function argument gets the CurrentFnBegin
-    // label, so arguments are visible when breaking at function entry.
+    auto IsDescribedByReg = [](const MachineInstr *MI) {
+      return MI->getOperand(0).isReg() && MI->getOperand(0).getReg();
+    };
+
+    // The first mention of a function argument gets the CurrentFnBegin label,
+    // so arguments are visible when breaking at function entry.
+    //
+    // We do not change the label for values that are described by registers,
+    // as that could place them above their defining instructions. We should
+    // ideally not change the labels for constant debug values either, since
+    // doing that violates the ranges that are calculated in the history map.
+    // However, we currently do not emit debug values for constant arguments
+    // directly at the start of the function, so this code is still useful.
     const DILocalVariable *DIVar = Ranges.front().first->getDebugVariable();
     if (DIVar->isParameter() &&
         getDISubprogram(DIVar->getScope())->describes(&MF->getFunction())) {
+      if (!IsDescribedByReg(Ranges.front().first))
         LabelsBeforeInsn[Ranges.front().first] = Asm->getFunctionBegin();
       if (Ranges.front().first->getDebugExpression()->isFragment()) {
         // Mark all non-overlapping initial fragments.
         for (auto I = Ranges.begin(); I != Ranges.end(); ++I) {
           const DIExpression *Fragment = I->first->getDebugExpression();
-          if (std::all_of(Ranges.begin(), I,
+          if (std::any_of(Ranges.begin(), I,
                           [&](DbgValueHistoryMap::InstrRange Pred) {
-                            return !Fragment->fragmentsOverlap(
+                            return Fragment->fragmentsOverlap(
                                 Pred.first->getDebugExpression());
                           }))
-            LabelsBeforeInsn[I->first] = Asm->getFunctionBegin();
-          else
             break;
+          if (!IsDescribedByReg(I->first))
+            LabelsBeforeInsn[I->first] = Asm->getFunctionBegin();
         }
       }
     }
 
     for (const auto &Range : Ranges) {
       requestLabelBeforeInsn(Range.first);
       if (Range.second)
         requestLabelAfterInsn(Range.second);

llvm/trunk/test/CodeGen/AMDGPU/llvm.dbg.value.ll

 ; RUN: llc -O0 -march=amdgcn -mtriple=amdgcn-unknown-amdhsa -verify-machineinstrs < %s | FileCheck -check-prefixes=GCN,NOOPT %s
 ; RUN: llc -march=amdgcn -mtriple=amdgcn-unknown-amdhsa -verify-machineinstrs < %s | FileCheck -check-prefixes=GCN,OPT %s
 
 ; GCN-LABEL: {{^}}test_debug_value:
 ; NOOPT: .loc 1 1 42 prologue_end     ; /tmp/test_debug_value.cl:1:42
 ; NOOPT-NEXT: s_load_dwordx2 s[4:5], s[4:5], 0x0
+; NOOPT-NEXT: .Ltmp
 ; NOOPT-NEXT: ;DEBUG_VALUE: test_debug_value:globalptr_arg <- $sgpr4_sgpr5
 
 ; GCN: flat_store_dword
 ; GCN: s_endpgm
 define amdgpu_kernel void @test_debug_value(i32 addrspace(1)* nocapture %globalptr_arg) #0 !dbg !4 {
 entry:
   tail call void @llvm.dbg.value(metadata i32 addrspace(1)* %globalptr_arg, metadata !10, metadata !13), !dbg !14
   store i32 123, i32 addrspace(1)* %globalptr_arg, align 4

llvm/trunk/test/DebugInfo/AArch64/asan-stack-vars.mir

 #
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_subprogram
 # CHECK-NEXT:   DW_AT_low_pc [DW_FORM_addr]     (0x0000000000000000)
 # CHECK-NEXT:   DW_AT_high_pc [DW_FORM_addr]    ([[FN_END:.*]])
 # CHECK: "_cmd"
 # CHECK: DW_TAG_formal_parameter
 # CHECK-NEXT: DW_AT_location
-# CHECK-NEXT:   [0x{{0*}}, 0x{{.*}}):
+# CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}):
 # CHECK-NOT:    DW_AT_
 # CHECK:        [0x{{.*}}, [[FN_END]]):
 # CHECK-NEXT: DW_AT_name {{.*}}"imageSize"
 --- |
   ; ModuleID = 'test/DebugInfo/AArch64/asan-stack-vars.ll'
   source_filename = "m.m"
   target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
   target triple = "arm64-apple-ios"

llvm/trunk/test/DebugInfo/ARM/partial-subreg.ll

 ; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump -v - | FileCheck %s
 ; This tests a fragment that partially covers subregister compositions.
 ;
 ; Our fragment is 96 bits long and lies in a 128-bit register, which
 ; in turn has to be composed out of its two 64-bit subregisters.
 
 ; CHECK: .debug_info
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}}"subscript.get"
 ; CHECK:  DW_TAG_formal_parameter
 ; CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] ({{.*}}
+; CHECK-NEXT:  [0x{{.*}}, 0x{{.*}}): DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4
 ; CHECK-NEXT:  [0x{{.*}}, 0x{{.*}}): DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4, DW_OP_regx D16, DW_OP_piece 0x8, DW_OP_regx D17, DW_OP_piece 0x4
 
 source_filename = "simd.ll"
 target datalayout = "e-m:o-p:32:32-f64:32:64-v64:32:64-v128:32:128-a:0:32-n32-S32"
 target triple = "armv7-apple-ios7.0"
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata) #0

llvm/trunk/test/DebugInfo/COFF/fp-stack.ll

 ; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s --check-prefix=ASM
 ; RUN: llc -mtriple=i686-windows-msvc < %s -filetype=obj | llvm-readobj -codeview - | FileCheck %s --check-prefix=OBJ
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i686-pc-windows-msvc18.0.0"
 
 define double @f(double %p1) !dbg !4 {
 entry:
   %sub = fsub double -0.000000e+00, %p1, !dbg !16
   tail call void @llvm.dbg.value(metadata double %sub, metadata !10, metadata !14), !dbg !15
   ret double %sub
 }
 
-; ASM:         .cv_def_range    Lfunc_begin0 Lfunc_end0, "A\021\200\000\000\000"
+; ASM:         .cv_def_range    Ltmp1 Lfunc_end0, "A\021\200\000\000\000"
 ; OBJ:    DefRangeRegisterSym {
 ; OBJ:      Register: ST0 (0x80)
 ; OBJ:      MayHaveNoName: 0
 ; OBJ:      LocalVariableAddrRange {
-; OBJ:        OffsetStart: .text+0x0
+; OBJ:        OffsetStart: .text+0x6
 ; OBJ:        ISectStart: 0x0
-; OBJ:        Range: 0x7
+; OBJ:        Range: 0x1
 ; OBJ:      }
 ; OBJ:    }
 
 ; Function Attrs: nounwind readnone
 declare void @llvm.dbg.value(metadata, metadata, metadata)
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!11, !12}

llvm/trunk/test/DebugInfo/COFF/fpo-stack-protect.ll

 
 ; CHECK:         calll   _escape
 ; CHECK:         calll   @__security_check_cookie@4
 
 ; CHECK:         movl    %esi, %eax
 ; CHECK:         addl    $20, %esp
 ; CHECK:         popl    %esi
 ; CHECK:         retl
-; CHECK: Ltmp2:
+; CHECK: Ltmp3:
 ; CHECK:         .cv_fpo_endproc
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i386-pc-windows-msvc19.11.25508"
 
 ; Function Attrs: nounwind sspstrong

llvm/trunk/test/DebugInfo/COFF/pieces.ll

 ; OBJ:       }
 ; OBJ:       ProcEnd {
 ; OBJ:       }
 
 ; ASM-LABEL:  .short  4423                    # Record kind: S_GPROC32_ID
 ; ASM:        .asciz  "pad_right"             # Function name
 ; ASM:        .short  4414                    # Record kind: S_LOCAL
 ; ASM:        .asciz  "o"
-; ASM:        .cv_def_range    .Lfunc_begin1 .Ltmp8, "C\021\021\000\000\000\004\000\000\000"
+; ASM:        .cv_def_range    .Ltmp8 .Ltmp8, "C\021\021\000\000\000\004\000\000\000"
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: pad_right
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }
 ; OBJ:       DefRangeSubfieldRegisterSym {
 ; OBJ:         Register: EAX (0x11)
 ; OBJ:         MayHaveNoName: 0
 ; OBJ:         OffsetInParent: 4
 ; OBJ:         LocalVariableAddrRange {
 ; OBJ:         }
 ; 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    .Lfunc_begin2 .Ltmp10, "C\021\021\000\000\000\000\000\000\000"
+; ASM:        .cv_def_range    .Ltmp10 .Ltmp10, "C\021\021\000\000\000\000\000\000\000"
 
 ; OBJ-LABEL: GlobalProcIdSym {
 ; OBJ:         Kind: S_GPROC32_ID (0x1147)
 ; OBJ:         DisplayName: pad_left
 ; OBJ:       }
 ; OBJ:       LocalSym {
 ; OBJ:         VarName: o
 ; OBJ:       }

llvm/trunk/test/DebugInfo/MIR/AArch64/clobber-sp.mir

 # RUN: llc -start-after=livedebugvalues -filetype=obj -o - %s \
 # RUN:   | llvm-dwarfdump - | FileCheck %s
 # CHECK: .debug_info contents:
 # CHECK: DW_TAG_formal_parameter
 # CHECK: DW_TAG_formal_parameter
 # CHECK-NEXT: DW_AT_location
-# CHECK-NEXT:   [0x0000000000000000, 0x0000000000000014): DW_OP_reg1 W1
+# CHECK-NEXT:   [0x0000000000000010, 0x0000000000000014): DW_OP_reg1 W1
 # CHECK-NEXT:   [0x0000000000000014, 0x0000000000000038): DW_OP_breg31 WSP+8
 # CHECK-NEXT: DW_AT_name {{.*}}"y"
 
 --- |
   ; Generated at -Os from:
   ;   struct Rect {
   ;     double x, y, w, h;
   ;   };

llvm/trunk/test/DebugInfo/NVPTX/debug-info.ll

 ; CHECK-NEXT: .b8 42                               // Abbrev [42] 0x26f7:0x17 DW_TAG_inlined_subroutine
 ; CHECK-NEXT: .b32 9785                            // DW_AT_abstract_origin
 ; CHECK-NEXT: .b64 Ltmp2                           // DW_AT_low_pc
 ; CHECK-NEXT: .b64 Ltmp3                           // DW_AT_high_pc
 ; CHECK-NEXT: .b8 12                               // DW_AT_call_file
 ; CHECK-NEXT: .b8 6                                // DW_AT_call_line
 ; CHECK-NEXT: .b8 43                               // Abbrev [43] 0x270e:0x22 DW_TAG_inlined_subroutine
 ; CHECK-NEXT: .b32 9791                            // DW_AT_abstract_origin
-; CHECK-NEXT: .b64 Ltmp9                           // DW_AT_low_pc
-; CHECK-NEXT: .b64 Ltmp10                          // DW_AT_high_pc
+; CHECK-NEXT: .b64 Ltmp10                          // DW_AT_low_pc
+; CHECK-NEXT: .b64 Ltmp11                          // DW_AT_high_pc
 ; CHECK-NEXT: .b8 12                               // DW_AT_call_file
 ; CHECK-NEXT: .b8 8                                // DW_AT_call_line
 ; CHECK-NEXT: .b8 44                               // Abbrev [44] 0x2725:0x5 DW_TAG_formal_parameter
 ; CHECK-NEXT: .b32 9811                            // DW_AT_abstract_origin
 ; CHECK-NEXT: .b8 44                               // Abbrev [44] 0x272a:0x5 DW_TAG_formal_parameter
 ; CHECK-NEXT: .b32 9820                            // DW_AT_abstract_origin
 ; CHECK-NEXT: .b8 0                                // End Of Children Mark
 ; CHECK-NEXT: .b8 0                                // End Of Children Mark

llvm/trunk/test/DebugInfo/X86/debug-loc-asan.mir

 #
 # CHECK:        movq    %rbp, %rsp
 # CHECK-NEXT: [[END_LABEL:.Ltmp[0-9]+]]:
 #
 # CHECK: .Ldebug_loc{{[0-9]+}}:
 # We expect two location ranges for the variable.
 #
 # First, its address is stored in %rcx:
-# CHECK:      .quad .Lfunc_begin0-.Lfunc_begin0
+# CHECK:      .quad .Ltmp0-.Lfunc_begin0
 # CHECK-NEXT: .quad [[START_LABEL]]-.Lfunc_begin0
 # CHECK: DW_OP_breg2
 # DWARF:       DW_TAG_formal_parameter
 # DWARF:         DW_AT_location
 # DWARF-NEXT:      [{{.*}}, {{.*}}): DW_OP_breg2 RCX+0, DW_OP_deref
 #
 # Then it's addressed via %rsp:
 # CHECK:      .quad [[START_LABEL]]-.Lfunc_begin0

llvm/trunk/test/DebugInfo/X86/debug-loc-offset.mir

 #
 # CHECK: DW_TAG_subprogram
 # CHECK-NOT: DW_TAG
 # CHECK: DW_AT_linkage_name [DW_FORM_strp]{{.*}}"_Z3baz1A"
 # CHECK-NOT: {{DW_TAG|NULL}}
 # CHECK: DW_TAG_formal_parameter
 # CHECK-NOT: DW_TAG
 # CHECK:       DW_AT_location [DW_FORM_sec_offset]   ({{.*}}
-# CHECK-NEXT:    [0x00000020, 0x00000037): DW_OP_breg0 EAX+0, DW_OP_deref
+# CHECK-NEXT:    [0x00000029, 0x00000037): DW_OP_breg0 EAX+0, DW_OP_deref
 # CHECK-NEXT:    [0x00000037, 0x00000063): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 # CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"a"
 #
 # CHECK: DW_TAG_variable
 # CHECK: DW_AT_location [DW_FORM_exprloc]
 # CHECK-NOT: DW_AT_location
 #
 # CHECK: DW_TAG_compile_unit

 # CHECK-NEXT:    [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value)
 # CHECK-NEXT:  DW_AT_name [DW_FORM_strp]{{.*}}"b"
 #
 # CHECK: .debug_loc contents:
 # CHECK:       0x00000000:
 # CHECK-NEXT:    [0x00000000, 0x0000000a): DW_OP_consts +0, DW_OP_stack_value
 # CHECK-NEXT:    [0x0000000a, 0x00000017): DW_OP_consts +1, DW_OP_stack_value
 # CHECK:       0x00000022:
-# CHECK-NEXT:    [0x00000000, 0x00000017): DW_OP_breg0 EAX+0, DW_OP_deref
+# CHECK-NEXT:    [0x00000009, 0x00000017): DW_OP_breg0 EAX+0, DW_OP_deref
 # CHECK-NEXT:    [0x00000017, 0x00000043): DW_OP_breg5 EBP-8, DW_OP_deref, DW_OP_deref
 --- |
   target triple = "i386-unknown-linux-gnu"
   
   %struct.A = type { i32 (...)**, i32 }
   
   ; Function Attrs: nounwind
   define i32 @_Z3bari(i32 %b) #0 !dbg !10 {

llvm/trunk/test/DebugInfo/X86/dw_op_minus_direct.ll

 
 ; DWARF2: .debug_info
 ; DWARF2: DW_TAG_formal_parameter
 ; DWARF2-NEXT: DW_AT_name {{.*}}"i"
 ; DWARF2-NOT:      DW_AT_location
 
 ; CHECK: .debug_loc contents:
 ; CHECK: 0x00000000:
-; CHECK-NEXT:   [0x0000000000000000, 0x0000000000000004): DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_lit1, DW_OP_minus, DW_OP_stack_value
+; CHECK-NEXT:   [0x0000000000000003, 0x0000000000000004): DW_OP_breg0 RAX+0, DW_OP_constu 0xffffffff, DW_OP_and, DW_OP_lit1, DW_OP_minus, DW_OP_stack_value
 ;        rax+0, constu 0xffffffff, and, constu 0x00000001, minus, stack-value
 
 source_filename = "minus.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 define i32 @inc(i32 %i) local_unnamed_addr #1 !dbg !7 {
 entry: