[llvm-dwarfdump] Avoid crashing if an abbreviation offset is invalid.

[ikudrin]

Summary

Note that DWARFUnit::getAbbreviations() returns nullptr if the abbreviations could not be read, but callers used the returned pointer without checking.

[dblaikie]

Sounds good, thanks!

[MaskRay]

llvm/test/tools/llvm-dwarfdump/X86/debug_info_invalid_abbrev_offset.s

1

Would it help if the two files are grouped in one invalid_abbrev_offset.s?

[ikudrin]

llvm/test/tools/llvm-dwarfdump/X86/debug_info_invalid_abbrev_offset.s

1

OK, I'll merge the tests on commit.

llvm/include/llvm/DebugInfo/DWARF/DWARFUnit.h

public:
   uint8_t getRefAddrByteSize() const { return Header.getRefAddrByteSize(); }
   uint8_t getDwarfOffsetByteSize() const {
     return Header.getDwarfOffsetByteSize();
   }
   uint64_t getLength() const { return Header.getLength(); }
   dwarf::DwarfFormat getFormat() const { return Header.getFormat(); }
   uint8_t getUnitType() const { return Header.getUnitType(); }
   bool isTypeUnit() const { return Header.isTypeUnit(); }
+  uint64_t getAbbrOffset() const { return Header.getAbbrOffset(); }
   uint64_t getNextUnitOffset() const { return Header.getNextUnitOffset(); }
   const DWARFSection &getLineSection() const { return LineSection; }
   StringRef getStringSection() const { return StringSection; }
   const DWARFSection &getStringOffsetSection() const {
     return StringOffsetSection;
   }
 
   void setAddrOffsetSection(const DWARFSection *AOS, uint64_t Base) {
public:
   DWARFDie getLastChild(const DWARFDebugInfoEntry *Die);
 
   /// Return the DIE object for a given offset inside the
   /// unit's DIE vector.
   ///
   /// The unit needs to have its DIEs extracted for this method to work.
   DWARFDie getDIEForOffset(uint64_t Offset) {
     extractDIEsIfNeeded(false);
-    assert(!DieArray.empty());
     auto It =
         llvm::partition_point(DieArray, [=](const DWARFDebugInfoEntry &DIE) {
           return DIE.getOffset() < Offset;
         });
     if (It != DieArray.end() && It->getOffset() == Offset)
       return DWARFDie(this, &*It);
     return DWARFDie();
   }

llvm/lib/DebugInfo/DWARF/DWARFCompileUnit.cpp

 void DWARFCompileUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(getFormat());
   OS << format("0x%08" PRIx64, getOffset()) << ": Compile Unit:"
      << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
      << ", format = " << dwarf::FormatString(getFormat())
      << ", version = " << format("0x%04x", getVersion());
   if (getVersion() >= 5)
     OS << ", unit_type = " << dwarf::UnitTypeString(getUnitType());
-  OS << ", abbr_offset = "
-     << format("0x%04" PRIx64, getAbbreviations()->getOffset())
-     << ", addr_size = " << format("0x%02x", getAddressByteSize());
+  OS << ", abbr_offset = " << format("0x%04" PRIx64, getAbbrOffset());
+  if (!getAbbreviations())
+    OS << " (invalid)";
+  OS << ", addr_size = " << format("0x%02x", getAddressByteSize());
   if (getVersion() >= 5 && getUnitType() != dwarf::DW_UT_compile)
     OS << ", DWO_id = " << format("0x%016" PRIx64, *getDWOId());
   OS << " (next unit at " << format("0x%08" PRIx64, getNextUnitOffset())
      << ")\n";
 
   if (DWARFDie CUDie = getUnitDIE(false))
     CUDie.dump(OS, 0, DumpOpts);
   else
     OS << "<compile unit can't be parsed!>\n\n";
 }
 
 // VTable anchor.
 DWARFCompileUnit::~DWARFCompileUnit() = default;

llvm/lib/DebugInfo/DWARF/DWARFDebugInfoEntry.cpp

bool DWARFDebugInfoEntry::extractFast(const DWARFUnit &U, uint64_t *OffsetPtr,
   if (Offset >= UEndOffset || !DebugInfoData.isValidOffset(Offset))
     return false;
   uint64_t AbbrCode = DebugInfoData.getULEB128(OffsetPtr);
   if (0 == AbbrCode) {
     // NULL debug tag entry.
     AbbrevDecl = nullptr;
     return true;
   }
-  AbbrevDecl = U.getAbbreviations()->getAbbreviationDeclaration(AbbrCode);
+  if (const auto *AbbrevSet = U.getAbbreviations())
+    AbbrevDecl = AbbrevSet->getAbbreviationDeclaration(AbbrCode);
   if (nullptr == AbbrevDecl) {
     // Restore the original offset.
     *OffsetPtr = Offset;
     return false;
   }
   // See if all attributes in this DIE have fixed byte sizes. If so, we can
   // just add this size to the offset to skip to the next DIE.
   if (Optional<size_t> FixedSize = AbbrevDecl->getFixedAttributesByteSize(U)) {

llvm/lib/DebugInfo/DWARF/DWARFTypeUnit.cpp

void DWARFTypeUnit::dump(raw_ostream &OS, DIDumpOptions DumpOpts) {
   }
 
   OS << format("0x%08" PRIx64, getOffset()) << ": Type Unit:"
      << " length = " << format("0x%0*" PRIx64, OffsetDumpWidth, getLength())
      << ", format = " << dwarf::FormatString(getFormat())
      << ", version = " << format("0x%04x", getVersion());
   if (getVersion() >= 5)
     OS << ", unit_type = " << dwarf::UnitTypeString(getUnitType());
-  OS << ", abbr_offset = "
-     << format("0x%04" PRIx64, getAbbreviations()->getOffset())
-     << ", addr_size = " << format("0x%02x", getAddressByteSize())
+  OS << ", abbr_offset = " << format("0x%04" PRIx64, getAbbrOffset());
+  if (!getAbbreviations())
+    OS << " (invalid)";
+  OS << ", addr_size = " << format("0x%02x", getAddressByteSize())
      << ", name = '" << Name << "'"
      << ", type_signature = " << format("0x%016" PRIx64, getTypeHash())
      << ", type_offset = " << format("0x%04" PRIx64, getTypeOffset())
      << " (next unit at " << format("0x%08" PRIx64, getNextUnitOffset())
      << ")\n";
 
   if (DWARFDie TU = getUnitDIE(false))
     TU.dump(OS, 0, DumpOpts);
   else
     OS << "<type unit can't be parsed!>\n\n";
 }

llvm/test/tools/llvm-dwarfdump/X86/debug_info_invalid_abbrev_offset.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64 -o %t
+# RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
+
+# CHECK:      .debug_info contents:
+# CHECK-NEXT: Compile Unit: {{.+}}, abbr_offset = 0x00a5 (invalid),
+# CHECK-NEXT: <compile unit can't be parsed!>
+
+    .section .debug_info,"",@progbits
+    .long .LCUEnd-.LCUVersion   # Length of Unit
+.LCUVersion:
+    .short 4                    # DWARF version number
+    .long 0xa5                  # Offset Into Abbrev. Section (invalid)
+    .byte 8                     # Address Size
+    .byte 1                     # Abbreviation code
+.LCUEnd:

llvm/test/tools/llvm-dwarfdump/X86/debug_types_invalid_abbrev_offset.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64 -o %t
+# RUN: llvm-dwarfdump -debug-types %t | FileCheck %s
+
+# CHECK:      .debug_types contents:
+# CHECK-NEXT: Type Unit: {{.+}}, abbr_offset = 0x00a5 (invalid), addr_size = 0x08, name = '',
+# CHECK-NEXT: <type unit can't be parsed!>
+
+    .section .debug_types,"",@progbits
+.LTUBegin:
+    .long .LTUEnd-.LTUVersion   # Length of Unit
+.LTUVersion:
+    .short 4                    # DWARF version number
+    .long 0xa5                  # Offset Into Abbrev. Section (invalid)
+    .byte 8                     # Address Size
+    .quad 0x0011223344556677    # Type Signature
+    .long .LTUType-.LTUBegin    # Type offset
+.LTUType:
+    .byte 1                     # Abbreviation code
+.LTUEnd: