[DebugInfo] Add a DW_OP_LLVM_entry_value operation

Summary:
Internally in LLVM's metadata we use DW_OP_entry_value operations with
the same semantics as DWARF; that is, its operand specifies the number
of bytes that the entry value covers.

At the time of emitting entry values we don't know the emitted size of
the DWARF expression that the entry value will cover. Currently the size
is hardcoded to 1 in DIExpression, and other values causes the verifier
to fail. As the size is 1, that effectively means that we can only have
valid entry values for registers that can be encoded in one byte, which
are the registers with DWARF numbers 0 to 31 (as they can be encoded as
single-byte DW_OP_reg0..DW_OP_reg31 rather than a multi-byte
DW_OP_regx). It is a bit confusing, but it seems like llvm-dwarfdump
will print an operation "correctly", even if the byte size is less than
that, which may make it seem that we emit correct DWARF for registers
with DWARF numbers > 31. If you instead use readelf for such cases, it
will interpret the number of specified bytes as a DWARF expression. This
seems like a limitation in llvm-dwarfdump.

As suggested in D66746, a way forward would be to add an internal
variant of DW_OP_entry_value, DW_OP_LLVM_entry_value, whose operand
instead specifies the number of operations that the entry value covers,
and we then translate that into the byte size at the time of emission.

In this patch that internal operation is added. This patch keeps the
limitation that a entry value can only be applied to simple register
locations, but it will fix the issue with the size operand being
incorrect for DWARF numbers > 31.

Reviewers: aprantl, vsk, djtodoro, NikolaPrica

Reviewed By: aprantl

Subscribers: jyknight, fedor.sergeev, hiraditya, llvm-commits

Tags: #debug-info, #llvm

Differential Revision: https://reviews.llvm.org/D67492

llvm-svn: 374881

11 files changed, 229 insertions, 15 deletions

diff --git a/llvm/test/DebugInfo/ARM/entry-value-multi-byte-expr.ll b/llvm/test/DebugInfo/ARM/entry-value-multi-byte-expr.ll
new file mode 100644
index 00000000000..6c482754cda
--- /dev/null
+++ b/llvm/test/DebugInfo/ARM/entry-value-multi-byte-expr.ll
@@ -0,0 +1,91 @@
+; RUN: llc -debug-entry-values -filetype=asm -o - %s | FileCheck %s
+
+; Verify that the size operands of the DW_OP_GNU_entry_value operations are
+; correct for the multi-byte DW_OP_regx expressions.
+
+; Based on the following C reproducer:
+;
+; extern void clobber();
+; double global;
+; int f(double a, double b) {
+;   global = a + b;
+;   clobber();
+;   return 1;
+; }
+
+; This test checks the assembly output rather than the output from
+; llvm-dwarfdump, as the latter printed the DW_OP_regx D0 correctly, even
+; though the entry value's size operand did not fully cover that:
+
+; DW_OP_GNU_entry_value(DW_OP_regx D0), DW_OP_stack_value
+;
+; whereas readelf interpreted it as an DW_OP_GNU_entry_value covering one byte,
+; resulting in garbage data:
+;
+; DW_OP_GNU_entry_value: (DW_OP_regx: 0 (r0)); DW_OP_breg16 (r16): 2; DW_OP_stack_value
+
+; CHECK:      .byte   243       @ DW_OP_GNU_entry_value
+; CHECK-NEXT: .byte   3         @ 3
+; CHECK-NEXT: .byte   144       @ DW_OP_regx
+; CHECK-NEXT: .byte   128       @ 256
+; CHECK-NEXT: .byte   2         @
+; CHECK-NEXT: .byte   159       @ DW_OP_stack_value
+
+; CHECK:      .byte   243       @ DW_OP_GNU_entry_value
+; CHECK-NEXT: .byte   3         @ 3
+; CHECK-NEXT: .byte   144       @ DW_OP_regx
+; CHECK-NEXT: .byte   129       @ 257
+; CHECK-NEXT: .byte   2         @
+; CHECK-NEXT: .byte   159       @ DW_OP_stack_value
+
+target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
+target triple = "armv7-unknown-unknown"
+
+@global = common global double 0.000000e+00, align 8, !dbg !0
+
+; Function Attrs: nounwind
+define arm_aapcs_vfpcc i32 @f(double %a, double %b) #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata double %a, metadata !17, metadata !DIExpression()), !dbg !19
+  call void @llvm.dbg.value(metadata double %b, metadata !18, metadata !DIExpression()), !dbg !19
+  %add = fadd double %a, %b, !dbg !20
+  store double %add, double* @global, align 8, !dbg !20
+  tail call arm_aapcs_vfpcc void @clobber(), !dbg !21
+  ret i32 1, !dbg !22
+}
+
+declare arm_aapcs_vfpcc void @clobber()
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 4, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "entry-value-multi-byte-expr.c", directory: "/")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "double", size: 64, encoding: DW_ATE_float)
+!7 = !{i32 2, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{i32 1, !"min_enum_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "f", scope: !3, file: !3, line: 6, type: !13, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!15, !6, !6}
+!15 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!16 = !{!17, !18}
+!17 = !DILocalVariable(name: "a", arg: 1, scope: !12, file: !3, line: 6, type: !6, flags: DIFlagArgumentNotModified)
+!18 = !DILocalVariable(name: "b", arg: 2, scope: !12, file: !3, line: 6, type: !6, flags: DIFlagArgumentNotModified)
+!19 = !DILocation(line: 0, scope: !12)
+!20 = !DILocation(line: 7, scope: !12)
+!21 = !DILocation(line: 8, scope: !12)
+!22 = !DILocation(line: 9, scope: !12)
diff --git a/llvm/test/DebugInfo/MIR/Hexagon/live-debug-values-bundled-entry-values.mir b/llvm/test/DebugInfo/MIR/Hexagon/live-debug-values-bundled-entry-values.mir
index b7881b42e29..2db3b22cdd9 100644
--- a/llvm/test/DebugInfo/MIR/Hexagon/live-debug-values-bundled-entry-values.mir
+++ b/llvm/test/DebugInfo/MIR/Hexagon/live-debug-values-bundled-entry-values.mir
@@ -98,7 +98,7 @@ body:             |
 # CHECK-NEXT: $r29 = S2_allocframe $r29, 0
 # CHECK-NEXT: J2_call @clobber
 # CHECK-NEXT: }
-# CHECK-NEXT: DBG_VALUE $r0, $noreg, !16, !DIExpression(DW_OP_entry_value, 1)
+# CHECK-NEXT: DBG_VALUE $r0, $noreg, !16, !DIExpression(DW_OP_LLVM_entry_value, 1)
 
 ---
 name:            bar
@@ -136,4 +136,4 @@ body:             |
 # CHECK-NEXT: $r29 = S2_allocframe $r29, 0
 # CHECK-NEXT: J2_call @clobber
 # CHECK-NEXT: }
-# CHECK-NEXT: DBG_VALUE $r0, $noreg, !22, !DIExpression(DW_OP_entry_value, 1)
+# CHECK-NEXT: DBG_VALUE $r0, $noreg, !22, !DIExpression(DW_OP_LLVM_entry_value, 1)
diff --git a/llvm/test/DebugInfo/MIR/X86/avoid-single-entry-value-location.mir b/llvm/test/DebugInfo/MIR/X86/avoid-single-entry-value-location.mir
index 075d356c6bd..845fafd99ec 100644
--- a/llvm/test/DebugInfo/MIR/X86/avoid-single-entry-value-location.mir
+++ b/llvm/test/DebugInfo/MIR/X86/avoid-single-entry-value-location.mir
@@ -61,7 +61,7 @@ body:             |
     DBG_VALUE $edi, $noreg, !16, !DIExpression(), debug-location !18
     DBG_VALUE $edi, $noreg, !17, !DIExpression(), debug-location !18
     $edi = KILL renamable $edi, implicit killed $rdi, debug-location !18
-    DBG_VALUE $rdi, $noreg, !16, !DIExpression(DW_OP_entry_value, 1), debug-location !18
+    DBG_VALUE $rdi, $noreg, !16, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !18
     TAILJMPd64 @fn2, csr_64, implicit $rsp, implicit $ssp, implicit $rsp, implicit $ssp, implicit killed $edi, debug-location !18
 
 ...
diff --git a/llvm/test/DebugInfo/MIR/X86/dbgcall-site-interpretation.mir b/llvm/test/DebugInfo/MIR/X86/dbgcall-site-interpretation.mir
index f4857ccd7e8..2cadef6e425 100644
--- a/llvm/test/DebugInfo/MIR/X86/dbgcall-site-interpretation.mir
+++ b/llvm/test/DebugInfo/MIR/X86/dbgcall-site-interpretation.mir
@@ -190,10 +190,10 @@ body:             |
     $rbx = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
     CFI_INSTRUCTION def_cfa_offset 24, debug-location !21
     $r14 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
-    DBG_VALUE $ecx, $noreg, !17, !DIExpression(DW_OP_entry_value, 1), debug-location !21
+    DBG_VALUE $ecx, $noreg, !17, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !21
     CFI_INSTRUCTION def_cfa_offset 16, debug-location !21
     $r15 = frame-destroy POP64r implicit-def $rsp, implicit $rsp, debug-location !21
-    DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_entry_value, 1), debug-location !21
+    DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location !21
     CFI_INSTRUCTION def_cfa_offset 8, debug-location !21
     RETQ $eax, debug-location !21
 
diff --git a/llvm/test/DebugInfo/MIR/X86/dbginfo-entryvals.mir b/llvm/test/DebugInfo/MIR/X86/dbginfo-entryvals.mir
index 445a2065941..dc49d058add 100644
--- a/llvm/test/DebugInfo/MIR/X86/dbginfo-entryvals.mir
+++ b/llvm/test/DebugInfo/MIR/X86/dbginfo-entryvals.mir
@@ -14,8 +14,8 @@
 #  fn2 (a);
 #  u --;
 #}
-# CHECK: DBG_VALUE $edi, $noreg, !14, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
-# CHECK: DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $edi, $noreg, !14, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $esi, $noreg, !15, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
 
 --- |
   ; ModuleID = 'test.c'
diff --git a/llvm/test/DebugInfo/MIR/X86/multiple-param-dbg-value-entry.mir b/llvm/test/DebugInfo/MIR/X86/multiple-param-dbg-value-entry.mir
index c885460239a..54307c2fe2d 100644
--- a/llvm/test/DebugInfo/MIR/X86/multiple-param-dbg-value-entry.mir
+++ b/llvm/test/DebugInfo/MIR/X86/multiple-param-dbg-value-entry.mir
@@ -7,11 +7,11 @@
 #  return 123;
 #}
 #
-# Verify that DW_OP_entry_values are generated for parameters with multiple
+# Verify that DW_OP_LLVM_entry_values are generated for parameters with multiple
 # DBG_VALUEs at entry block.
-# CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
-# CHECK: DBG_VALUE $edx, $noreg, !{{.*}}, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
-# CHECK: DBG_VALUE $esi, $noreg, !{{.*}}, !DIExpression(DW_OP_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $edi, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $edx, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
+# CHECK: DBG_VALUE $esi, $noreg, !{{.*}}, !DIExpression(DW_OP_LLVM_entry_value, 1), debug-location {{.*}}
 
 --- |
   ; ModuleID = 'multiple-param-dbg-value-entry.ll'
diff --git a/llvm/test/DebugInfo/Sparc/entry-value-complex-reg-expr.ll b/llvm/test/DebugInfo/Sparc/entry-value-complex-reg-expr.ll
new file mode 100644
index 00000000000..07a3e9da1dd
--- /dev/null
+++ b/llvm/test/DebugInfo/Sparc/entry-value-complex-reg-expr.ll
@@ -0,0 +1,79 @@
+; RUN: llc -debug-entry-values -filetype=asm -o - %s | FileCheck %s
+
+; Verify that the entry value covers both of the DW_OP_regx pieces. Previously
+; the size operand of the entry value would be hardcoded to one.
+;
+; XXX: Is this really what should be emitted, or should we instead emit one
+; entry value operation per DW_OP_regx? GDB can currently not understand
+; entry values containing complex expressions like this.
+
+target datalayout = "E-m:e-i64:64-n32:64-S128"
+target triple = "sparc64"
+
+; Based on the following C reproducer:
+;
+; volatile long double global;
+; extern void clobber();
+; int foo(long double p) {
+;   global = p;
+;   clobber();
+;   return 123;
+; }
+
+; CHECK:      .byte   243       ! DW_OP_GNU_entry_value
+; CHECK-NEXT: .byte   8         ! 8
+; CHECK-NEXT: .byte   144       ! sub-register DW_OP_regx
+; CHECK-NEXT: .byte   72        ! 72
+; CHECK-NEXT: .byte   147       ! DW_OP_piece
+; CHECK-NEXT: .byte   8         ! 8
+; CHECK-NEXT: .byte   144       ! sub-register DW_OP_regx
+; CHECK-NEXT: .byte   73        ! 73
+; CHECK-NEXT: .byte   147       ! DW_OP_piece
+; CHECK-NEXT: .byte   8         ! 8
+; CHECK-NEXT: .byte   159       ! DW_OP_stack_value
+
+@global = common global fp128 0xL00000000000000000000000000000000, align 16, !dbg !0
+
+; Function Attrs: nounwind
+define signext i32 @foo(fp128 %p) #0 !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata fp128 %p, metadata !17, metadata !DIExpression()), !dbg !18
+  store volatile fp128 %p, fp128* @global, align 16, !dbg !19
+  tail call void @clobber(), !dbg !20
+  ret i32 123, !dbg !21
+}
+
+declare void @clobber()
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "global", scope: !2, file: !3, line: 1, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "entry-value-complex-reg-expr.c", directory: "/")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "long double", size: 128, encoding: DW_ATE_float)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 3, type: !13, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !16)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!15, !7}
+!15 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!16 = !{!17}
+!17 = !DILocalVariable(name: "p", arg: 1, scope: !12, file: !3, line: 3, type: !7, flags: DIFlagArgumentNotModified)
+!18 = !DILocation(line: 0, scope: !12)
+!19 = !DILocation(line: 4, scope: !12)
+!20 = !DILocation(line: 5, scope: !12)
+!21 = !DILocation(line: 6, scope: !12)
diff --git a/llvm/test/Verifier/diexpression-dwarf-entry-value.ll b/llvm/test/Verifier/diexpression-dwarf-entry-value.ll
new file mode 100644
index 00000000000..cc7b41da4af
--- /dev/null
+++ b/llvm/test/Verifier/diexpression-dwarf-entry-value.ll
@@ -0,0 +1,8 @@
+; RUN: not opt -S < %s 2>&1 | FileCheck %s
+
+; We can only use the internal variant of the entry value operation,
+; DW_OP_LLVM_entry_value, in DIExpressions.
+
+!named = !{!0}
+; CHECK: invalid expression
+!0 = !DIExpression(DW_OP_entry_value, 1)
diff --git a/llvm/test/Verifier/diexpression-entry-value-llvm-ir.ll b/llvm/test/Verifier/diexpression-entry-value-llvm-ir.ll
new file mode 100644
index 00000000000..99143297acf
--- /dev/null
+++ b/llvm/test/Verifier/diexpression-entry-value-llvm-ir.ll
@@ -0,0 +1,31 @@
+; RUN: llvm-as -disable-output <%s 2>&1| FileCheck %s
+
+; The DW_OP_LLVM_entry_value operation can only be used in MIR.
+
+; CHECK: Entry values are only allowed in MIR
+; CHECK: call void @llvm.dbg.value(metadata i32 %param, metadata !{{.*}}, metadata !DIExpression(DW_OP_LLVM_entry_value, 1))
+; CHECK: warning: ignoring invalid debug info
+
+define void @foo(i32 %param) !dbg !4 {
+entry:
+  call void @llvm.dbg.value(metadata i32 %param, metadata !8, metadata !DIExpression(DW_OP_LLVM_entry_value, 1)), !dbg !9
+  ret void
+}
+
+declare void @llvm.dbg.value(metadata, metadata, metadata) #0
+
+attributes #0 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!2, !3}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, emissionKind: FullDebug)
+!1 = !DIFile(filename: "a.c", directory: "/")
+!2 = !{i32 2, !"Dwarf Version", i32 4}
+!3 = !{i32 2, !"Debug Info Version", i32 3}
+!4 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, type: !5, unit: !0)
+!5 = !DISubroutineType(types: !6)
+!6 = !{null, !7}
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !DILocalVariable(name: "param", arg: 1, scope: !4, file: !1, type: !7)
+!9 = !DILocation(line: 0, scope: !4)
diff --git a/llvm/test/Verifier/diexpression-entry-value.ll b/llvm/test/Verifier/diexpression-entry-value.ll
index 477b20079aa..34b1bceb053 100644
--- a/llvm/test/Verifier/diexpression-entry-value.ll
+++ b/llvm/test/Verifier/diexpression-entry-value.ll
@@ -2,6 +2,11 @@
 
 !named = !{!0, !1, !2}
 ; CHECK: invalid expression
-!0 = !DIExpression(DW_OP_entry_value, 4, DW_OP_constu, 0, DW_OP_stack_value)
-!1 = !DIExpression(DW_OP_constu, 0, DW_OP_entry_value, 1, DW_OP_constu, 0)
-!2 = !DIExpression(DW_OP_entry_value, 100, DW_OP_constu, 0)
+; CHECK-NEXT: !DIExpression
+; CHECK: invalid expression
+; CHECK-NEXT: !DIExpression
+; CHECK: invalid expression
+; CHECK-NEXT: !DIExpression
+!0 = !DIExpression(DW_OP_LLVM_entry_value, 4, DW_OP_constu, 0, DW_OP_stack_value)
+!1 = !DIExpression(DW_OP_constu, 0, DW_OP_LLVM_entry_value, 1, DW_OP_constu, 0)
+!2 = !DIExpression(DW_OP_LLVM_entry_value, 100, DW_OP_constu, 0)
diff --git a/llvm/test/Verifier/diexpression-valid-entry-value.ll b/llvm/test/Verifier/diexpression-valid-entry-value.ll
index e162b8a50ed..9a4b64ddb92 100644
--- a/llvm/test/Verifier/diexpression-valid-entry-value.ll
+++ b/llvm/test/Verifier/diexpression-valid-entry-value.ll
@@ -2,4 +2,4 @@
 
 !named = !{!0}
 ; CHECK-NOT: invalid expression
-!0 = !DIExpression(DW_OP_entry_value, 1)
+!0 = !DIExpression(DW_OP_LLVM_entry_value, 1)