[DWARFVerifier] Verify GNU extensions of call site DWARF symbols

[djtodoro]

Summary

This patch verifies that the call site DWARF symbols (added during the implementation of the debug entry values feature) are
generated properly.

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

208

Adding GNU tags to existing functionality seems like it should be its own patch.

230

Adding GNU attributes to existing functionality seems like it should be its own patch.

530

Should this also check DW_TAG_call_site?

[djtodoro]

@probinson Thanks a lot for your comments!

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

208

I could split this into two patches.

530

This only checks for the DW_AT_abstract_origin DWARF attribute that was used only by GNU call site extensions. After DWARF 5 Standard release, DW_TAG_call_site uses DW_AT_call_origin for the same purpose.

[aprantl]

llvm/test/tools/llvm-dwarfdump/X86/valid-call-site-parameters.ll

4

Seems like this test also passes without your patch applied?

[djtodoro]

llvm/test/tools/llvm-dwarfdump/X86/valid-call-site-parameters.ll

4

Actually the test case won't pass without the patch applied.

[djtodoro]

-Verify only GNU extensions in this patch

[aprantl]

Ah because we didn't accept the GNU entry value attributes before?

[djtodoro]

@aprantl Thanks for the review!

Ah because we didn't accept the GNU entry value attributes before?

We generate GNU entry value attributes for the GDB + DWARF 4 tune, because GDB has fully support for reading the debug entry values feature and users of the tune (and that debugger) can see benefits of the feature implemented now.
The functionality added with this patch was missing and we should have added this when we have introduced the attributes.

llvm/include/llvm/DebugInfo/DWARF/DWARFVerifier.h

unsigned verifyUnitSection(const DWARFSection &S,
                              DWARFSectionKind SectionKind);
 
   /// Verifies that a call site entry is nested within a subprogram with a
   /// DW_AT_call attribute.
   ///
   /// \returns Number of errors that occurred during verification.
   unsigned verifyDebugInfoCallSite(const DWARFDie &Die);
 
+  /// Verifies that a call site parameter entry has proper attributes
+  /// generated.
+  ///
+  /// \returns Number of errors that occurred during verification.
+  unsigned verifyDebugInfoCallSiteParameter(const DWARFDie &Die);
+
   /// Verify that all Die ranges are valid.
   ///
   /// This function currently checks for:
   /// - cases in which lowPC >= highPC
   ///
   /// \returns Number of errors that occurred during verification.
   unsigned verifyDieRanges(const DWARFDie &Die, DieRangeInfo &ParentRI);
 

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (Die.getTag() == DW_TAG_null)
       continue;
 
     for (auto AttrValue : Die.attributes()) {
       NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue);
       NumUnitErrors += verifyDebugInfoForm(Die, AttrValue);
     }
 
     NumUnitErrors += verifyDebugInfoCallSite(Die);
+    NumUnitErrors += verifyDebugInfoCallSiteParameter(Die);
   }
 
   DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false);
   if (!Die) {
     error() << "Compilation unit without DIE.\n";
     NumUnitErrors++;
     return NumUnitErrors;
   }
unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit) {
 
   DieRangeInfo RI;
   NumUnitErrors += verifyDieRanges(Die, RI);
 
   return NumUnitErrors;
 }
 
 unsigned DWARFVerifier::verifyDebugInfoCallSite(const DWARFDie &Die) {
-  if (Die.getTag() != DW_TAG_call_site)
+  if (Die.getTag() != DW_TAG_call_site &&
+      Die.getTag() != DW_TAG_GNU_call_site)
     return 0;
 
   DWARFDie Curr = Die.getParent();
   for (; Curr.isValid() && !Curr.isSubprogramDIE(); Curr = Die.getParent()) {
     if (Curr.getTag() == DW_TAG_inlined_subroutine) {
       error() << "Call site entry nested within inlined subroutine:";
       Curr.dump(OS);
       return 1;
     }
   }
 
   if (!Curr.isValid()) {
     error() << "Call site entry not nested within a valid subprogram:";
     Die.dump(OS);
     return 1;
   }
 
   Optional<DWARFFormValue> CallAttr =
       Curr.find({DW_AT_call_all_calls, DW_AT_call_all_source_calls,
-                 DW_AT_call_all_tail_calls});
+                 DW_AT_call_all_tail_calls, DW_AT_GNU_all_call_sites,
+                 DW_AT_GNU_all_source_call_sites,
+                 DW_AT_GNU_all_tail_call_sites});
   if (!CallAttr) {
     error() << "Subprogram with call site entry has no DW_AT_call attribute:";
     Curr.dump(OS);
     Die.dump(OS, /*indent*/ 1);
     return 1;
   }
 
   return 0;
 }
 
+unsigned DWARFVerifier::verifyDebugInfoCallSiteParameter(const DWARFDie &Die) {
+  if (Die.getTag() != DW_TAG_call_site_parameter &&
+      Die.getTag() != DW_TAG_GNU_call_site_parameter)
+    return 0;
+
+  if (!Die.find(DW_AT_location)) {
+    error() << "Call site parameter has no DW_AT_location attribute:";
+    Die.dump(OS);
+    return 1;
+  }
+
+  Optional<DWARFFormValue> CallValueAttr =
+      Die.find({DW_AT_call_value, DW_AT_GNU_call_site_value});
+  if (!CallValueAttr) {
+    error() << "Call site parameter has no DW_AT_call_value attribute:";
+    Die.dump(OS);
+    return 1;
+  }
+
+  return 0;
+}
+
 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
   unsigned NumErrors = 0;
   if (Abbrev) {
     const DWARFAbbreviationDeclarationSet *AbbrDecls =
         Abbrev->getAbbreviationDeclarationSet(0);
     for (auto AbbrDecl : *AbbrDecls) {
       SmallDenseSet<uint16_t> AttributeSet;
       for (auto Attribute : AbbrDecl.attributes()) {
if (auto ReferencedDie = Die.getAttributeValueAsReferencedDie(Attr)) {
       auto DieTag = Die.getTag();
       auto RefTag = ReferencedDie.getTag();
       if (DieTag == RefTag)
         break;
       if (DieTag == DW_TAG_inlined_subroutine && RefTag == DW_TAG_subprogram)
         break;
       if (DieTag == DW_TAG_variable && RefTag == DW_TAG_member)
         break;
+      // This might be reference to a function declaration.
+      if (DieTag == DW_TAG_GNU_call_site && RefTag == DW_TAG_subprogram)
+        break;
       ReportError("DIE with tag " + TagString(DieTag) + " has " +
                   AttributeString(Attr) +
                   " that points to DIE with "
                   "incompatible tag " +
                   TagString(RefTag));
     }
     break;
   }

llvm/test/tools/llvm-dwarfdump/X86/valid-call-site-parameters.ll

+; RUN: llc -debug-entry-values %s -o - -filetype=obj \
+; RUN:   | llvm-dwarfdump -verify - | FileCheck %s
+;
+; CHECK: No errors.
+;
+; The source code of the test case:
+;
+;extern int fn1();
+;extern int fn3(int);
+;
+;__attribute__((noinline))
+;void
+;fn2 (int *arg) {
+;  int a = ++(*arg);
+;  fn3 (a);
+;}
+;
+;__attribute__((noinline))
+;int f() {
+;  int x = fn1();
+;  fn2 (&x);
+;  return 0;
+;}
+;
+; ModuleID = 'test.c'
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local void @fn2(i32* nocapture %arg) local_unnamed_addr !dbg !15 {
+entry:
+  call void @llvm.dbg.value(metadata i32* %arg, metadata !20, metadata !DIExpression()), !dbg !22
+  %0 = load i32, i32* %arg, align 4, !dbg !23
+  %inc = add nsw i32 %0, 1, !dbg !23
+  store i32 %inc, i32* %arg, align 4, !dbg !23
+  call void @llvm.dbg.value(metadata i32 %inc, metadata !21, metadata !DIExpression()), !dbg !22
+  %call = tail call i32 @fn3(i32 %inc), !dbg !23
+  ret void, !dbg !23
+}
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
+
+declare !dbg !4 dso_local i32 @fn3(i32) local_unnamed_addr
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)
+
+; Function Attrs: noinline nounwind uwtable
+define dso_local i32 @f() local_unnamed_addr !dbg !24 {
+entry:
+  %x = alloca i32, align 4
+  %0 = bitcast i32* %x to i8*, !dbg !29
+  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %0), !dbg !29
+  %call = tail call i32 (...) @fn1() #4, !dbg !29
+  call void @llvm.dbg.value(metadata i32 %call, metadata !28, metadata !DIExpression()), !dbg !30
+  store i32 %call, i32* %x, align 4, !dbg !29
+  call void @llvm.dbg.value(metadata i32* %x, metadata !28, metadata !DIExpression(DW_OP_deref)), !dbg !30
+  call void @fn2(i32* nonnull %x), !dbg !29
+  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %0), !dbg !29
+  ret i32 0, !dbg !29
+}
+
+declare !dbg !8 dso_local i32 @fn1(...) local_unnamed_addr
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12, !13}
+!llvm.ident = !{!14}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, retainedTypes: !3, nameTableKind: None)
+!1 = !DIFile(filename: "test.c", directory: "dir")
+!2 = !{}
+!3 = !{!4, !8}
+!4 = !DISubprogram(name: "fn3", scope: !1, file: !1, line: 2, type: !5, flags: DIFlagPrototyped, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!5 = !DISubroutineType(types: !6)
+!6 = !{!7, !7}
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !DISubprogram(name: "fn1", scope: !1, file: !1, line: 1, type: !9, spFlags: DISPFlagOptimized, retainedNodes: !2)
+!9 = !DISubroutineType(types: !10)
+!10 = !{!7, null}
+!11 = !{i32 2, !"Dwarf Version", i32 4}
+!12 = !{i32 2, !"Debug Info Version", i32 3}
+!13 = !{i32 1, !"wchar_size", i32 4}
+!14 = !{!"clang version 10.0.0"}
+!15 = distinct !DISubprogram(name: "fn2", scope: !1, file: !1, line: 6, type: !16, scopeLine: 6, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !19)
+!16 = !DISubroutineType(types: !17)
+!17 = !{null, !18}
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!19 = !{!20, !21}
+!20 = !DILocalVariable(name: "arg", arg: 1, scope: !15, file: !1, line: 6, type: !18, flags: DIFlagArgumentNotModified)
+!21 = !DILocalVariable(name: "a", scope: !15, file: !1, line: 7, type: !7)
+!22 = !DILocation(line: 0, scope: !15)
+!23 = !DILocation(line: 7, column: 11, scope: !15)
+!24 = distinct !DISubprogram(name: "f", scope: !1, file: !1, line: 12, type: !25, scopeLine: 12, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !27)
+!25 = !DISubroutineType(types: !17)
+!26 = !{!7}
+!27 = !{!28}
+!28 = !DILocalVariable(name: "x", scope: !24, file: !1, line: 13, type: !7)
+!29 = !DILocation(line: 13, column: 3, scope: !24)
+!30 = !DILocation(line: 0, scope: !24)