From: Adrian Prantl Date: Fri, 16 Jun 2017 22:40:04 +0000 (+0000) Subject: Improve the accuracy of variable ranges .debug_loc location lists. X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=e97626f47211a59bf16ae23d8352b769586bb879;p=llvm Improve the accuracy of variable ranges .debug_loc location lists. For the following motivating example bool c(); void f(); bool start() { bool result = c(); if (!c()) { result = false; goto exit; } f(); result = true; exit: return result; } we would previously generate a single DW_AT_const_value(1) because only the DBG_VALUE in the second-to-last basic block survived codegen. This patch improves the heuristic used to determine when a DBG_VALUE is available at the beginning of its variable's enclosing lexical scope: - Stop giving singular constants blanket permission to take over the entire scope. There is still a special case for constants in the function prologue that we also miight want to retire later. - Use the lexical scope information to determine available-at-entry instead of proximity to the function prologue. After this patch we generate a location list with a more accurate narrower availability for the constant true value. As a pleasant side effect, we also generate inline locations instead of location lists where a loacation covers the entire range of the enclosing lexical scope. Measured on compiling llc with four targets this doesn't have an effect on compile time and reduces the size of the debug info for llc by ~600K. rdar://problem/30286912 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@305599 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp index 75eb355bfb5..d392e372863 100644 --- a/lib/CodeGen/AsmPrinter/DwarfDebug.cpp +++ b/lib/CodeGen/AsmPrinter/DwarfDebug.cpp @@ -972,16 +972,60 @@ DbgVariable *DwarfDebug::createConcreteVariable(DwarfCompileUnit &TheCU, return ConcreteVariables.back().get(); } -// Determine whether this DBG_VALUE is valid at the beginning of the function. -static bool validAtEntry(const MachineInstr *MInsn) { - auto MBB = MInsn->getParent(); - // Is it in the entry basic block? - if (!MBB->pred_empty()) +/// Determine whether a *singular* DBG_VALUE is valid for the entirety of its +/// enclosing lexical scope. The check ensures there are no other instructions +/// in the same lexical scope preceding the DBG_VALUE and that its range is +/// either open or otherwise rolls off the end of the scope. +static bool validThroughout(LexicalScopes &LScopes, + const MachineInstr *DbgValue, + const MachineInstr *RangeEnd) { + assert(DbgValue->getDebugLoc() && "DBG_VALUE without a debug location"); + auto MBB = DbgValue->getParent(); + auto DL = DbgValue->getDebugLoc(); + auto *LScope = LScopes.findLexicalScope(DL); + // Scope doesn't exist; this is a dead DBG_VALUE. + if (!LScope) return false; - for (MachineBasicBlock::const_reverse_iterator I(MInsn); I != MBB->rend(); ++I) - if (!(I->isDebugValue() || I->getFlag(MachineInstr::FrameSetup))) + auto &LSRange = LScope->getRanges(); + if (LSRange.size() == 0) + return false; + + // Determine if the DBG_VALUE is valid at the beginning of its lexical block. + const MachineInstr *LScopeBegin = LSRange.front().first; + // Early exit if the lexical scope begins outside of the current block. + if (LScopeBegin->getParent() != MBB) + return false; + MachineBasicBlock::const_reverse_iterator Pred(DbgValue); + for (++Pred; Pred != MBB->rend(); ++Pred) { + if (Pred->getFlag(MachineInstr::FrameSetup)) + break; + auto PredDL = Pred->getDebugLoc(); + if (!PredDL || Pred->isDebugValue()) + continue; + // Check whether the instruction preceding the DBG_VALUE is in the same + // (sub)scope as the DBG_VALUE. + if (DL->getScope() == PredDL->getScope() || + LScope->dominates(LScopes.findLexicalScope(PredDL))) return false; - return true; + } + + // If the range of the DBG_VALUE is open-ended, report success. + if (!RangeEnd) + return true; + + // Fail if there are instructions belonging to our scope in another block. + const MachineInstr *LScopeEnd = LSRange.back().second; + if (LScopeEnd->getParent() != MBB) + return false; + + // Single, constant DBG_VALUEs in the prologue are promoted to be live + // throughout the function. This is a hack, presumably for DWARF v2 and not + // necessarily correct. It would be much better to use a dbg.declare instead + // if we know the constant is live throughout the scope. + if (DbgValue->getOperand(0).isImm() && MBB->pred_empty()) + return true; + + return false; } // Find variables for each lexical scope. @@ -1016,11 +1060,9 @@ void DwarfDebug::collectVariableInfo(DwarfCompileUnit &TheCU, const MachineInstr *MInsn = Ranges.front().first; assert(MInsn->isDebugValue() && "History must begin with debug value"); - // Check if there is a single DBG_VALUE, valid throughout the function. - // A single constant is also considered valid for the entire function. + // Check if there is a single DBG_VALUE, valid throughout the var's scope. if (Ranges.size() == 1 && - (MInsn->getOperand(0).isImm() || - (validAtEntry(MInsn) && Ranges.front().second == nullptr))) { + validThroughout(LScopes, MInsn, Ranges.front().second)) { RegVar->initializeDbgValue(MInsn); continue; } diff --git a/test/DebugInfo/Generic/partial-constant.ll b/test/DebugInfo/Generic/partial-constant.ll new file mode 100644 index 00000000000..c3abccbc45c --- /dev/null +++ b/test/DebugInfo/Generic/partial-constant.ll @@ -0,0 +1,82 @@ +; RUN: %llc_dwarf -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s +; Generated at -O2 from: +; bool c(); +; void f(); +; bool start() { +; bool result = c(); +; if (!c()) { +; result = false; +; goto exit; +; } +; f(); +; result = true; +; exit: +; return result; +; } +; +; The constant should NOT be available for the entire function. +; CHECK-NOT: DW_AT_const_value +; CHECK: .debug_loc +; CHECK: Location description: 10 01 9f +; constu 0x00000001, stack-value +source_filename = "test.ii" +target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" +target triple = "x86_64-apple-macosx10.12.0" + +; Function Attrs: noimplicitfloat noredzone nounwind optsize +define zeroext i1 @_Z5startv() local_unnamed_addr #0 !dbg !7 { +entry: + %call = tail call zeroext i1 @_Z1cv() #3, !dbg !13 + %call1 = tail call zeroext i1 @_Z1cv() #3, !dbg !14 + br i1 %call1, label %if.end, label %exit, !dbg !16 + +if.end: ; preds = %entry + tail call void @_Z1fv() #3, !dbg !17 + tail call void @llvm.dbg.value(metadata i8 1, i64 0, metadata !12, metadata !18), !dbg !19 + br label %exit, !dbg !20 + +exit: ; preds = %entry, %if.end + %result.0 = phi i1 [ true, %if.end ], [ false, %entry ] + ret i1 %result.0, !dbg !21 +} + +; Function Attrs: noimplicitfloat noredzone optsize +declare zeroext i1 @_Z1cv() local_unnamed_addr #1 + +; Function Attrs: noimplicitfloat noredzone optsize +declare void @_Z1fv() local_unnamed_addr #1 + +; Function Attrs: nounwind readnone speculatable +declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2 + +attributes #0 = { noimplicitfloat noredzone nounwind optsize } +attributes #1 = { noimplicitfloat noredzone optsize } +attributes #2 = { nounwind readnone speculatable } +attributes #3 = { nobuiltin noimplicitfloat noredzone nounwind optsize } + +!llvm.dbg.cu = !{!0} +!llvm.module.flags = !{!3, !4, !5} +!llvm.ident = !{!6} + +!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 5.0.0 (trunk 303873) (llvm/trunk 303897)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2) +!1 = !DIFile(filename: "test.ii", directory: "/") +!2 = !{} +!3 = !{i32 2, !"Dwarf Version", i32 4} +!4 = !{i32 2, !"Debug Info Version", i32 3} +!5 = !{i32 1, !"wchar_size", i32 4} +!6 = !{!"clang version 5.0.0 (trunk 303873) (llvm/trunk 303897)"} +!7 = distinct !DISubprogram(name: "start", linkageName: "_Z5startv", scope: !1, file: !1, line: 3, type: !8, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: true, unit: !0, variables: !11) +!8 = !DISubroutineType(types: !9) +!9 = !{!10} +!10 = !DIBasicType(name: "bool", size: 8, encoding: DW_ATE_boolean) +!11 = !{!12} +!12 = !DILocalVariable(name: "result", scope: !7, file: !1, line: 4, type: !10) +!13 = !DILocation(line: 4, column: 17, scope: !7) +!14 = !DILocation(line: 5, column: 8, scope: !15) +!15 = distinct !DILexicalBlock(scope: !7, file: !1, line: 5, column: 7) +!16 = !DILocation(line: 5, column: 7, scope: !7) +!17 = !DILocation(line: 9, column: 3, scope: !7) +!18 = !DIExpression() +!19 = !DILocation(line: 4, column: 8, scope: !7) +!20 = !DILocation(line: 10, column: 3, scope: !7) +!21 = !DILocation(line: 12, column: 3, scope: !7) diff --git a/test/DebugInfo/Generic/sugared-constants.ll b/test/DebugInfo/Generic/sugared-constants.ll index 2bee2a94032..97d4d60cd0e 100644 --- a/test/DebugInfo/Generic/sugared-constants.ll +++ b/test/DebugInfo/Generic/sugared-constants.ll @@ -3,47 +3,23 @@ ; RUN: %llc_dwarf -O0 -filetype=obj %s -o - | llvm-dwarfdump -debug-dump=info - | FileCheck %s ; Use correct signedness when emitting constants of derived (sugared) types. -; Test compiled to IR from clang with -O1 and the following source: - -; void func(int); -; void func(unsigned); -; void func(char16_t); -; int main() { -; const int i = 42; -; func(i); -; const unsigned j = 117; -; func(j); -; char16_t c = 7; -; func(c); -; } - ; CHECK: DW_AT_const_value [DW_FORM_sdata] (42) ; CHECK: DW_AT_const_value [DW_FORM_udata] (117) ; CHECK: DW_AT_const_value [DW_FORM_udata] (7) ; Function Attrs: uwtable -define i32 @main() #0 !dbg !4 { +define void @main() #0 !dbg !4 { entry: tail call void @llvm.dbg.value(metadata i32 42, i64 0, metadata !10, metadata !DIExpression()), !dbg !21 - tail call void @_Z4funci(i32 42), !dbg !22 tail call void @llvm.dbg.value(metadata i32 117, i64 0, metadata !12, metadata !DIExpression()), !dbg !24 - tail call void @_Z4funcj(i32 117), !dbg !25 tail call void @llvm.dbg.value(metadata i16 7, i64 0, metadata !15, metadata !DIExpression()), !dbg !27 - tail call void @_Z4funcDs(i16 zeroext 7), !dbg !28 - ret i32 0, !dbg !29 + ret void, !dbg !29 } -declare void @_Z4funci(i32) #1 - -declare void @_Z4funcj(i32) #1 - -declare void @_Z4funcDs(i16 zeroext) #1 - ; Function Attrs: nounwind readnone declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2 -attributes #0 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } -attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { uwtable } attributes #2 = { nounwind readnone } !llvm.dbg.cu = !{!0} diff --git a/test/DebugInfo/MIR/X86/bit-piece-dh.mir b/test/DebugInfo/MIR/X86/bit-piece-dh.mir index 34a10bd3f65..d4b897eaac9 100644 --- a/test/DebugInfo/MIR/X86/bit-piece-dh.mir +++ b/test/DebugInfo/MIR/X86/bit-piece-dh.mir @@ -1,13 +1,9 @@ -# RUN: llc -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s +# RUN: llc -filetype=obj -o - %s | llvm-dwarfdump --debug-dump=info - | FileCheck %s # CHECK: .debug_info contents: # CHECK: DW_TAG_variable -# CHECK-NEXT: DW_AT_location [DW_FORM_sec_offset] ([[OFS:.*]]) -# CHECK-NEXT: DW_AT_name {{.*}}"dh" -# CHECK: .debug_loc contents: -# CHECK: [[OFS]]: Beginning address offset: 0x0000000000000002 -# CHECK: Ending address offset: 0x000000000000000c -# CHECK: Location description: 51 9d 08 08 # rdx, bit-piece 8 8 +# CHECK-NEXT: DW_AT_location {{.*}} 51 9d 08 08 +# CHECK-NEXT: DW_AT_name {{.*}}"dh" --- | ; Manually created after: ; char f(int i) { diff --git a/test/DebugInfo/X86/dbg-merge-loc-entry.ll b/test/DebugInfo/X86/dbg-merge-loc-entry.ll index 17fd0d54d40..272ee0b6c8e 100644 --- a/test/DebugInfo/X86/dbg-merge-loc-entry.ll +++ b/test/DebugInfo/X86/dbg-merge-loc-entry.ll @@ -6,6 +6,7 @@ target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" target triple = "x86_64-apple-darwin8" +; Test that consecutive, identical DBG_VALUEs are merged. ;CHECK: DW_AT_location{{.*}}(<0x1> 55 ) %0 = type { i64, i1 } @@ -19,6 +20,7 @@ entry: br i1 undef, label %bb2, label %bb4, !dbg !22 bb2: ; preds = %entry + tail call void @llvm.dbg.value(metadata i128 %u, i64 0, metadata !14, metadata !DIExpression()), !dbg !15 br label %bb4, !dbg !23 bb4: ; preds = %bb2, %entry diff --git a/test/DebugInfo/X86/inlined-formal-parameter.ll b/test/DebugInfo/X86/inlined-formal-parameter.ll index 78dc905f5e4..3b603c954fb 100644 --- a/test/DebugInfo/X86/inlined-formal-parameter.ll +++ b/test/DebugInfo/X86/inlined-formal-parameter.ll @@ -1,5 +1,5 @@ ; RUN: llc -filetype=obj -o %t.o %s -; RUN: llvm-dwarfdump -debug-dump=info %t.o | FileCheck %s +; RUN: llvm-dwarfdump %t.o | FileCheck %s ; Testcase generated using 'clang -g -O2 -S -emit-llvm' from the following: ;; void sink(void); @@ -10,6 +10,7 @@ ;; } ; Check that we have formal parameters for 'a' in both inlined subroutines. +; CHECK: .debug_info ; CHECK: DW_TAG_inlined_subroutine ; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "bar" ; CHECK: DW_TAG_formal_parameter @@ -18,9 +19,11 @@ ; CHECK: DW_TAG_inlined_subroutine ; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "bar" ; CHECK: DW_TAG_formal_parameter -; CHECK-NEXT: DW_AT_const_value +; CHECK-NEXT: DW_AT_location [DW_FORM_data4] (0x00000000) ; CHECK-NEXT: DW_AT_abstract_origin {{.*}} "a" - +; +; CHECK: .debug_loc +; CHECK: Location description: 11 00 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-apple-darwin" @@ -34,13 +37,12 @@ entry: ret void, !dbg !24 } -declare void @sink() #1 +declare void @sink() ; Function Attrs: nounwind readnone declare void @llvm.dbg.value(metadata, i64, metadata, metadata) #2 -attributes #0 = { nounwind ssp uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="core2" "unsafe-fp-math"="false" "use-soft-float"="false" } -attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="core2" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { nounwind ssp uwtable } attributes #2 = { nounwind readnone } attributes #3 = { nounwind } diff --git a/test/DebugInfo/X86/parameters.ll b/test/DebugInfo/X86/parameters.ll index a8494f9e963..26fb82df1f3 100644 --- a/test/DebugInfo/X86/parameters.ll +++ b/test/DebugInfo/X86/parameters.ll @@ -24,8 +24,9 @@ ; CHECK: debug_info contents ; 0x74 is DW_OP_breg4, showing that the parameter is accessed indirectly -; (with a zero offset) from the register parameter -; CHECK: DW_AT_location [DW_FORM_data4] ([[F_LOC:0x[0-9]*]]) +; (with a zero offset) from the register parameter. +; CHECK: DW_AT_location {{.*}} 74 00 06 + ; CHECK-NOT: DW_TAG ; CHECK: DW_AT_name{{.*}} = "f" ; @@ -34,9 +35,6 @@ ; CHECK: DW_AT_name{{.*}} = "g" ; ; CHECK: debug_loc contents -; CHECK: [[F_LOC]]: Beginning -; CHECK-NEXT: Ending -; CHECK-NEXT: Location description: 74 00 ; CHECK: [[G_LOC]]: Beginning ; CHECK-NEXT: Ending ; CHECK-NEXT: Location description: 74 00 @@ -77,11 +75,10 @@ if.end: ; preds = %if.then, %entry ret void, !dbg !32 } -declare void @_ZN7pr147634sinkEPv(i8*) #2 +declare void @_ZN7pr147634sinkEPv(i8*) -attributes #0 = { uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf"="true" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" "use-soft-float"="false" } +attributes #0 = { uwtable } attributes #1 = { nounwind readnone } -attributes #2 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf"="true" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "unsafe-fp-math"="false" "use-soft-float"="false" } !llvm.dbg.cu = !{!0} !llvm.module.flags = !{!21, !33} diff --git a/test/DebugInfo/X86/pieces-3.ll b/test/DebugInfo/X86/pieces-3.ll index fd5a8b8617a..0f80f71af68 100644 --- a/test/DebugInfo/X86/pieces-3.ll +++ b/test/DebugInfo/X86/pieces-3.ll @@ -19,7 +19,9 @@ ; CHECK-NEXT: DW_AT_location [DW_FORM_data4] ([[LOC1:.*]]) ; CHECK-NEXT: DW_AT_name {{.*}}"outer" ; CHECK: DW_TAG_variable -; CHECK-NEXT: DW_AT_location [DW_FORM_data4] ([[LOC2:.*]]) +; CHECK-NEXT: DW_AT_location +; rsi, piece 0x00000004 +; CHECK-SAME: 54 93 04 ; CHECK-NEXT: "i1" ; ; CHECK: .debug_loc @@ -32,10 +34,6 @@ ; CHECK: Beginning address offset: 0x0000000000000004 ; CHECK-NEXT: Ending address offset: 0x0000000000000008 ; CHECK-NEXT: Location description: 55 93 08 93 04 54 93 04 -; CHECK: [[LOC2]]: Beginning address offset: 0x0000000000000004 -; CHECK-NEXT: Ending address offset: 0x0000000000000008 -; rsi, piece 0x00000004 -; CHECK-NEXT: Location description: 54 93 04 ; ; ModuleID = '/Volumes/Data/llvm/test/DebugInfo/X86/sroasplit-2.ll' @@ -48,6 +46,7 @@ define i32 @foo(i64 %outer.coerce0, i64 %outer.coerce1) #0 !dbg !4 { call void @llvm.dbg.declare(metadata !{null}, metadata !27, metadata !28), !dbg !26 call void @llvm.dbg.value(metadata i64 %outer.coerce1, i64 0, metadata !29, metadata !30), !dbg !26 call void @llvm.dbg.declare(metadata !{null}, metadata !31, metadata !32), !dbg !26 + ; The 'trunc' generates no extra code, thus i1 is visible throughout its scope. %outer.sroa.1.8.extract.trunc = trunc i64 %outer.coerce1 to i32, !dbg !33 call void @llvm.dbg.value(metadata i32 %outer.sroa.1.8.extract.trunc, i64 0, metadata !34, metadata !35), !dbg !33 %outer.sroa.1.12.extract.shift = lshr i64 %outer.coerce1, 32, !dbg !33 diff --git a/test/DebugInfo/X86/reference-argument.ll b/test/DebugInfo/X86/reference-argument.ll index 52e9290eacc..4b8caa13b72 100644 --- a/test/DebugInfo/X86/reference-argument.ll +++ b/test/DebugInfo/X86/reference-argument.ll @@ -1,4 +1,5 @@ -; RUN: llc -mtriple=x86_64-apple-macosx10.9.0 -filetype=obj -O0 < %s | llvm-dwarfdump -debug-dump=all - | FileCheck %s +; RUN: llc -mtriple=x86_64-apple-macosx10.9.0 -filetype=obj -O0 < %s \ +; RUN: | llvm-dwarfdump -debug-dump=info - | FileCheck %s ; ModuleID = 'aggregate-indirect-arg.cpp' ; extracted from debuginfo-tests/aggregate-indirect-arg.cpp @@ -11,11 +12,10 @@ ; CHECK: DW_AT_name {{.*}} "this" ; CHECK-NOT: DW_TAG_subprogram ; CHECK: DW_TAG_formal_parameter -; CHECK-NEXT: DW_AT_location [DW_FORM_data4] (0x00000000) -; CHECK-NEXT: DW_AT_name {{.*}} "v" -; CHECK: .debug_loc contents: +; CHECK-NEXT: DW_AT_location ; rsi+0 -; CHECK: Location description: 74 00 +; CHECK-SAME: 74 00 +; CHECK-NEXT: DW_AT_name {{.*}} "v" target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128" target triple = "x86_64-apple-macosx10.9.0" diff --git a/test/DebugInfo/X86/this-stack_value.ll b/test/DebugInfo/X86/this-stack_value.ll index c292b67543d..6ea96c2538c 100644 --- a/test/DebugInfo/X86/this-stack_value.ll +++ b/test/DebugInfo/X86/this-stack_value.ll @@ -1,5 +1,5 @@ ; RUN: llc -filetype=asm -o - %s | FileCheck %s --check-prefix=ASM -; RUN: llc -filetype=obj -o - %s | llvm-dwarfdump - | FileCheck %s +; RUN: llc -filetype=obj -o - %s | llvm-dwarfdump --debug-dump=info - | FileCheck %s ; ; Generated at -O2 from: ; struct B; @@ -18,7 +18,7 @@ ; modified by the debugger. ; ; ASM: [DW_OP_stack_value] -; CHECK: Location description: 70 00 9f +; CHECK: DW_AT_location {{.*}} 70 00 9f ; rax+0, stack-value source_filename = "ab.cpp" target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"