[DWARF] Verifier now handles .debug_types sections.

[probinson]

Summary

This will incidentally make it really easy to handle multiple .debug_info sections for v5.

[JDevlieghere]

Thanks Paul! One nit, otherwise this LGTM.

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

166 ↗

(On Diff #159755)

I believe we are moving to returning unsigneds instead of booleans. I'd do the same here, even if the first error is fatal. Maybe you can do the same for verifyUnitContents for consistency?

[probinson]

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

166 ↗

(On Diff #159755)

Done in the commit, coming soon.

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

 //===- DWARFVerifier.h ----------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
 #define LLVM_DEBUGINFO_DWARF_DWARFVERIFIER_H
 
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFAddressRange.h"
 #include "llvm/DebugInfo/DWARF/DWARFDie.h"
+#include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 
 #include <cstdint>
 #include <map>
 #include <set>
 
 namespace llvm {
 class raw_ostream;
 struct DWARFAttribute;
private:
   /// name.
   ///
   /// \param Abbrev Pointer to the abbreviations section we are verifying
   /// Abbrev can be a pointer to either .debug_abbrev or debug_abbrev.dwo.
   ///
   /// \returns The number of errors that occurred during verification.
   unsigned verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev);
 
-  /// Verifies the header of a unit in the .debug_info section.
+  /// Verifies the header of a unit in a .debug_info or .debug_types section.
   ///
   /// This function currently checks for:
   /// - Unit is in 32-bit DWARF format. The function can be modified to
   /// support 64-bit format.
   /// - The DWARF version is valid
   /// - The unit type is valid (if unit is in version >=5)
-  /// - The unit doesn't extend beyond .debug_info section
+  /// - The unit doesn't extend beyond the containing section
   /// - The address size is valid
   /// - The offset in the .debug_abbrev section is valid
   ///
-  /// \param DebugInfoData The .debug_info section data
+  /// \param DebugInfoData The section data
   /// \param Offset A reference to the offset start of the unit. The offset will
-  /// be updated to point to the next unit in .debug_info
+  /// be updated to point to the next unit in the section
   /// \param UnitIndex The index of the unit to be verified
   /// \param UnitType A reference to the type of the unit
   /// \param isUnitDWARF64 A reference to a flag that shows whether the unit is
   /// in 64-bit format.
   ///
   /// \returns true if the header is verified successfully, false otherwise.
   bool verifyUnitHeader(const DWARFDataExtractor DebugInfoData,
                         uint32_t *Offset, unsigned UnitIndex, uint8_t &UnitType,
                         bool &isUnitDWARF64);
 
-  /// Verifies the header of a unit in the .debug_info section.
+  /// Verifies the header of a unit in a .debug_info or .debug_types section.
   ///
   /// This function currently verifies:
   ///  - The debug info attributes.
   ///  - The debug info form=s.
   ///  - The presence of a root DIE.
   ///  - That the root DIE is a unit DIE.
   ///  - If a unit type is provided, that the unit DIE matches the unit type.
   ///  - The DIE ranges.
   ///
-  /// \param Unit      The DWARF Unit to verifiy.
+  /// \param Unit      The DWARF Unit to verify.
   /// \param UnitType  An optional unit type which will be used to verify the
   ///                  type of the unit DIE.
   ///
-  /// \returns true if the content is verified successfully, false otherwise.
-  bool verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType = 0);
+  /// \returns The number of errors that occurred during verification.
+  unsigned verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType = 0);
+
+  /// Verifies the unit headers and contents in a .debug_info or .debug_types
+  /// section.
+  ///
+  /// \param S           The DWARF Section to verify.
+  /// \param SectionKind The object-file section kind that S comes from.
+  ///
+  /// \returns The number of errors that occurred during verification.
+  unsigned verifyUnitSection(const DWARFSection &S,
+                             DWARFSectionKind SectionKind);
 
   /// 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);
 
   /// Verifies the attribute's DWARF attribute and its value.
   ///
   /// This function currently checks for:
   /// - DW_AT_ranges values is a valid .debug_ranges offset
   /// - DW_AT_stmt_list is a valid .debug_line offset
   ///
   /// \param Die          The DWARF DIE that owns the attribute value
   /// \param AttrValue    The DWARF attribute value to check
   ///
   /// \returns NumErrors The number of errors occurred during verification of
-  /// attributes' values in a .debug_info section unit
+  /// attributes' values in a unit
   unsigned verifyDebugInfoAttribute(const DWARFDie &Die,
                                     DWARFAttribute &AttrValue);
 
   /// Verifies the attribute's DWARF form.
   ///
   /// This function currently checks for:
   /// - All DW_FORM_ref values that are CU relative have valid CU offsets
-  /// - All DW_FORM_ref_addr values have valid .debug_info offsets
+  /// - All DW_FORM_ref_addr values have valid section offsets
   /// - All DW_FORM_strp values have valid .debug_str offsets
   ///
   /// \param Die          The DWARF DIE that owns the attribute value
   /// \param AttrValue    The DWARF attribute value to check
   ///
   /// \returns NumErrors The number of errors occurred during verification of
-  /// attributes' forms in a .debug_info section unit
+  /// attributes' forms in a unit
   unsigned verifyDebugInfoForm(const DWARFDie &Die, DWARFAttribute &AttrValue);
 
   /// Verifies the all valid references that were found when iterating through
   /// all of the DIE attributes.
   ///
   /// This function will verify that all references point to DIEs whose DIE
   /// offset matches. This helps to ensure if a DWARF link phase moved things
   /// around, that it doesn't create invalid references by failing to relocate
   /// CU relative and absolute references.
   ///
   /// \returns NumErrors The number of errors occurred during verification of
-  /// references for the .debug_info section
+  /// references for the .debug_info and .debug_types sections
   unsigned verifyDebugInfoReferences();
 
   /// Verify the DW_AT_stmt_list encoding and value and ensure that no
   /// compile units that have the same DW_AT_stmt_list value.
   void verifyDebugLineStmtOffsets();
 
   /// Verify that all of the rows in the line table are valid.
   ///
public:
   ///
   /// Any errors are reported to the stream that was this object was
   /// constructed with.
   ///
   /// \returns true if .debug_abbrev and .debug_abbrev.dwo verify successfully,
   /// false otherwise.
   bool handleDebugAbbrev();
 
-  /// Verify the information in the .debug_info section.
+  /// Verify the information in the .debug_info and .debug_types sections.
   ///
-  /// Any errors are reported to the stream that was this object was
+  /// Any errors are reported to the stream that this object was
   /// constructed with.
   ///
-  /// \returns true if the .debug_info verifies successfully, false otherwise.
+  /// \returns true if all sections verify successfully, false otherwise.
   bool handleDebugInfo();
 
   /// Verify the information in the .debug_line section.
   ///
   /// Any errors are reported to the stream that was this object was
   /// constructed with.
   ///
   /// \returns true if the .debug_line verifies successfully, false otherwise.

llvm/trunk/lib/DebugInfo/DWARF/DWARFVerifier.cpp

if (!ValidAbbrevOffset)
             "not valid.\n";
     if (!ValidAddrSize)
       note() << "The address size is unsupported.\n";
   }
   *Offset = OffsetStart + Length + 4;
   return Success;
 }
 
-bool DWARFVerifier::verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType) {
-  uint32_t NumUnitErrors = 0;
+unsigned DWARFVerifier::verifyUnitContents(DWARFUnit &Unit, uint8_t UnitType) {
+  unsigned NumUnitErrors = 0;
   unsigned NumDies = Unit.getNumDIEs();
   for (unsigned I = 0; I < NumDies; ++I) {
     auto Die = Unit.getDIEAtIndex(I);
     if (Die.getTag() == DW_TAG_null)
       continue;
     for (auto AttrValue : Die.attributes()) {
       NumUnitErrors += verifyDebugInfoAttribute(Die, AttrValue);
       NumUnitErrors += verifyDebugInfoForm(Die, AttrValue);
     }
   }
 
   DWARFDie Die = Unit.getUnitDIE(/* ExtractUnitDIEOnly = */ false);
   if (!Die) {
     error() << "Compilation unit without DIE.\n";
     NumUnitErrors++;
-    return NumUnitErrors == 0;
+    return NumUnitErrors;
   }
 
   if (!dwarf::isUnitType(Die.getTag())) {
     error() << "Compilation unit root DIE is not a unit DIE: "
             << dwarf::TagString(Die.getTag()) << ".\n";
     NumUnitErrors++;
   }
 
   if (UnitType != 0 &&
       !DWARFUnit::isMatchingUnitTypeAndTag(UnitType, Die.getTag())) {
     error() << "Compilation unit type (" << dwarf::UnitTypeString(UnitType)
             << ") and root DIE (" << dwarf::TagString(Die.getTag())
             << ") do not match.\n";
     NumUnitErrors++;
   }
 
   DieRangeInfo RI;
   NumUnitErrors += verifyDieRanges(Die, RI);
 
-  return NumUnitErrors == 0;
+  return NumUnitErrors;
 }
 
 unsigned DWARFVerifier::verifyAbbrevSection(const DWARFDebugAbbrev *Abbrev) {
   unsigned NumErrors = 0;
   if (Abbrev) {
     const DWARFAbbreviationDeclarationSet *AbbrDecls =
         Abbrev->getAbbreviationDeclarationSet(0);
     for (auto AbbrDecl : *AbbrDecls) {
bool DWARFVerifier::handleDebugAbbrev() {
   if (!noDebugAbbrev)
     NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrev());
 
   if (!noDebugAbbrevDWO)
     NumErrors += verifyAbbrevSection(DCtx.getDebugAbbrevDWO());
   return NumErrors == 0;
 }
 
-bool DWARFVerifier::handleDebugInfo() {
-  OS << "Verifying .debug_info Unit Header Chain...\n";
-
+unsigned DWARFVerifier::verifyUnitSection(const DWARFSection &S,
+                                          DWARFSectionKind SectionKind) {
   const DWARFObject &DObj = DCtx.getDWARFObj();
-  DWARFDataExtractor DebugInfoData(DObj, DObj.getInfoSection(),
-                                   DCtx.isLittleEndian(), 0);
-  uint32_t NumDebugInfoErrors = 0;
+  DWARFDataExtractor DebugInfoData(DObj, S, DCtx.isLittleEndian(), 0);
+  unsigned NumDebugInfoErrors = 0;
   uint32_t OffsetStart = 0, Offset = 0, UnitIdx = 0;
   uint8_t UnitType = 0;
   bool isUnitDWARF64 = false;
   bool isHeaderChainValid = true;
   bool hasDIE = DebugInfoData.isValidOffset(Offset);
   DWARFUnitVector UnitVector{};
   while (hasDIE) {
     OffsetStart = Offset;
     if (!verifyUnitHeader(DebugInfoData, &Offset, UnitIdx, UnitType,
                           isUnitDWARF64)) {
       isHeaderChainValid = false;
       if (isUnitDWARF64)
         break;
     } else {
       DWARFUnitHeader Header;
-      Header.extract(DCtx, DebugInfoData, &OffsetStart);
+      Header.extract(DCtx, DebugInfoData, &OffsetStart, SectionKind);
       std::unique_ptr<DWARFUnit> Unit;
       switch (UnitType) {
       case dwarf::DW_UT_type:
       case dwarf::DW_UT_split_type: {
         Unit.reset(new DWARFTypeUnit(
-            DCtx, DObj.getInfoSection(), Header, DCtx.getDebugAbbrev(),
-            &DObj.getRangeSection(), DObj.getStringSection(),
-            DObj.getStringOffsetSection(), &DObj.getAppleObjCSection(),
-            DObj.getLineSection(), DCtx.isLittleEndian(), false, UnitVector));
+            DCtx, S, Header, DCtx.getDebugAbbrev(), &DObj.getRangeSection(),
+            DObj.getStringSection(), DObj.getStringOffsetSection(),
+            &DObj.getAppleObjCSection(), DObj.getLineSection(),
+            DCtx.isLittleEndian(), false, UnitVector));
         break;
       }
       case dwarf::DW_UT_skeleton:
       case dwarf::DW_UT_split_compile:
       case dwarf::DW_UT_compile:
       case dwarf::DW_UT_partial:
       // UnitType = 0 means that we are
       // verifying a compile unit in DWARF v4.
       case 0: {
         Unit.reset(new DWARFCompileUnit(
-            DCtx, DObj.getInfoSection(), Header, DCtx.getDebugAbbrev(),
-            &DObj.getRangeSection(), DObj.getStringSection(),
-            DObj.getStringOffsetSection(), &DObj.getAppleObjCSection(),
-            DObj.getLineSection(), DCtx.isLittleEndian(), false, UnitVector));
+            DCtx, S, Header, DCtx.getDebugAbbrev(), &DObj.getRangeSection(),
+            DObj.getStringSection(), DObj.getStringOffsetSection(),
+            &DObj.getAppleObjCSection(), DObj.getLineSection(),
+            DCtx.isLittleEndian(), false, UnitVector));
         break;
       }
       default: { llvm_unreachable("Invalid UnitType."); }
       }
-      if (!verifyUnitContents(*Unit, UnitType))
-        ++NumDebugInfoErrors;
+      NumDebugInfoErrors += verifyUnitContents(*Unit, UnitType);
     }
     hasDIE = DebugInfoData.isValidOffset(Offset);
     ++UnitIdx;
   }
   if (UnitIdx == 0 && !hasDIE) {
-    warn() << ".debug_info is empty.\n";
+    warn() << "Section is empty.\n";
     isHeaderChainValid = true;
   }
+  if (!isHeaderChainValid)
+    ++NumDebugInfoErrors;
   NumDebugInfoErrors += verifyDebugInfoReferences();
-  return (isHeaderChainValid && NumDebugInfoErrors == 0);
+  return NumDebugInfoErrors;
+}
+
+bool DWARFVerifier::handleDebugInfo() {
+  const DWARFObject &DObj = DCtx.getDWARFObj();
+
+  OS << "Verifying .debug_info Unit Header Chain...\n";
+  unsigned result = verifyUnitSection(DObj.getInfoSection(), DW_SECT_INFO);
+
+  OS << "Verifying .debug_types Unit Header Chain...\n";
+  DObj.forEachTypesSections([&](const DWARFSection &S) {
+    result += verifyUnitSection(S, DW_SECT_TYPES);
+  });
+  return result == 0;
 }
 
 unsigned DWARFVerifier::verifyDieRanges(const DWARFDie &Die,
                                         DieRangeInfo &ParentRI) {
   unsigned NumErrors = 0;
 
   if (!Die.isValid())
     return NumErrors;

llvm/trunk/test/DebugInfo/X86/dwarfdump-header.s

 # Test object to verify dwarfdump handles v4 and v5 CU/TU/line headers.
 # We have a representative set of units: v4 CU, v5 CU, v4 TU, v5 split TU.
 # We have v4 and v5 line-table headers.
 #
-# RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
-# RUN: llvm-dwarfdump -v - | FileCheck %s
+# RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o
+# RUN: llvm-dwarfdump -v %t.o | FileCheck %s
+# RUN: llvm-dwarfdump -verify %t.o | FileCheck %s --check-prefix=VERIFY
 
         .section .debug_str,"MS",@progbits,1
 str_producer:
         .asciz "Handmade DWARF producer"
 str_CU_4:
         .asciz "V4_compile_unit"
 str_CU_5:
         .asciz "V5_compile_unit"

 # CHECK-NEXT: mod_time: 0x00000015
 # CHECK-NEXT: length: 0x00000025
 # CHECK: file_names[  1]:
 # CHECK-NEXT: name: "DWOFile5b"
 # CHECK-NEXT: dir_index: 1
 # CHECK-NEXT: mod_time: 0x00000035
 # CHECK-NEXT: length: 0x00000045
 # CHECK-NOT: file_names
+
+# VERIFY: Verifying .debug_types
+# VERIFY: No errors.