[DWARF] Fix reading 64-bit DWARF type units.

[ikudrin]

Summary

• The type_offset field is 8 bytes long in DWARF64. The patch extends TypeOffset to uint64_t and fixes its reading.
• The patch also fixes the check for of TypeOffset bounds because it was inaccurate in DWARF64 case.

[probinson]

Hi @MaskRay please remember to post a comment along with approval so Phab will send an email to the commits list. Thanks!

[MaskRay]

In D66465#1637292, @probinson wrote:

Hi @MaskRay please remember to post a comment along with approval so Phab will send an email to the commits list. Thanks!

Sorry.. I didn't know otherwise there is no email.

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

DWARFTypeUnit(DWARFContext &Context, const DWARFSection &Section,
                 const DWARFSection *RS, const DWARFSection *LocSection,
                 StringRef SS, const DWARFSection &SOS, const DWARFSection *AOS,
                 const DWARFSection &LS, bool LE, bool IsDWO,
                 const DWARFUnitVector &UnitVector)
       : DWARFUnit(Context, Section, Header, DA, RS, LocSection, SS, SOS, AOS,
                   LS, LE, IsDWO, UnitVector) {}
 
   uint64_t getTypeHash() const { return getHeader().getTypeHash(); }
-  uint32_t getTypeOffset() const { return getHeader().getTypeOffset(); }
+  uint64_t getTypeOffset() const { return getHeader().getTypeOffset(); }
 
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
   // Enable LLVM-style RTTI.
   static bool classof(const DWARFUnit *U) { return U->isTypeUnit(); }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFTYPEUNIT_H

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

class DWARFUnitHeader {
   uint64_t Length = 0;
   uint64_t AbbrOffset = 0;
 
   // For DWO units only.
   const DWARFUnitIndex::Entry *IndexEntry = nullptr;
 
   // For type units only.
   uint64_t TypeHash = 0;
-  uint32_t TypeOffset = 0;
+  uint64_t TypeOffset = 0;
 
   // For v5 split or skeleton compile units only.
   Optional<uint64_t> DWOId;
 
   // Unit type as parsed, or derived from the section kind.
   uint8_t UnitType = 0;
 
   // Size as parsed. uint8_t for compactness.
public:
   uint64_t getAbbrOffset() const { return AbbrOffset; }
   Optional<uint64_t> getDWOId() const { return DWOId; }
   void setDWOId(uint64_t Id) {
     assert((!DWOId || *DWOId == Id) && "setting DWOId to a different value");
     DWOId = Id;
   }
   const DWARFUnitIndex::Entry *getIndexEntry() const { return IndexEntry; }
   uint64_t getTypeHash() const { return TypeHash; }
-  uint32_t getTypeOffset() const { return TypeOffset; }
+  uint64_t getTypeOffset() const { return TypeOffset; }
   uint8_t getUnitType() const { return UnitType; }
   bool isTypeUnit() const {
     return UnitType == dwarf::DW_UT_type || UnitType == dwarf::DW_UT_split_type;
   }
   uint8_t getSize() const { return Size; }
   uint8_t getUnitLengthFieldByteSize() const {
     return dwarf::getUnitLengthFieldByteSize(FormParams.Format);
   }

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

OS << format("0x%08" PRIx64, getOffset()) << ": Type Unit:"
      << " 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())
      << " name = '" << Name << "'"
      << " type_signature = " << format("0x%016" PRIx64, getTypeHash())
-     << " type_offset = " << format("0x%04x", getTypeOffset())
+     << " 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/trunk/lib/DebugInfo/DWARF/DWARFUnit.cpp

bool DWARFUnitHeader::extract(DWARFContext &Context,
                               const DWARFUnitIndex *Index,
                               const DWARFUnitIndex::Entry *Entry) {
   Offset = *offset_ptr;
   IndexEntry = Entry;
   if (!IndexEntry && Index)
     IndexEntry = Index->getFromOffset(*offset_ptr);
   Length = debug_info.getRelocatedValue(4, offset_ptr);
   FormParams.Format = DWARF32;
-  unsigned SizeOfLength = 4;
   if (Length == dwarf::DW_LENGTH_DWARF64) {
     Length = debug_info.getU64(offset_ptr);
     FormParams.Format = DWARF64;
-    SizeOfLength = 8;
   }
   FormParams.Version = debug_info.getU16(offset_ptr);
   if (FormParams.Version >= 5) {
     UnitType = debug_info.getU8(offset_ptr);
     FormParams.AddrSize = debug_info.getU8(offset_ptr);
     AbbrOffset = debug_info.getRelocatedValue(FormParams.getDwarfOffsetByteSize(), offset_ptr);
   } else {
     AbbrOffset = debug_info.getRelocatedValue(FormParams.getDwarfOffsetByteSize(), offset_ptr);
if (!UnitContrib || UnitContrib->Length != (Length + 4))
       return false;
     auto *AbbrEntry = IndexEntry->getOffset(DW_SECT_ABBREV);
     if (!AbbrEntry)
       return false;
     AbbrOffset = AbbrEntry->Offset;
   }
   if (isTypeUnit()) {
     TypeHash = debug_info.getU64(offset_ptr);
-    TypeOffset = debug_info.getU32(offset_ptr);
+    TypeOffset =
+        debug_info.getUnsigned(offset_ptr, FormParams.getDwarfOffsetByteSize());
   } else if (UnitType == DW_UT_split_compile || UnitType == DW_UT_skeleton)
     DWOId = debug_info.getU64(offset_ptr);
 
   // Header fields all parsed, capture the size of this unit header.
   assert(*offset_ptr - Offset <= 255 && "unexpected header size");
   Size = uint8_t(*offset_ptr - Offset);
 
   // Type offset is unit-relative; should be after the header and before
   // the end of the current unit.
   bool TypeOffsetOK =
       !isTypeUnit()
           ? true
-          : TypeOffset >= Size && TypeOffset < getLength() + SizeOfLength;
+          : TypeOffset >= Size &&
+                TypeOffset < getLength() + getUnitLengthFieldByteSize();
   bool LengthOK = debug_info.isValidOffset(getNextUnitOffset() - 1);
   bool VersionOK = DWARFContext::isSupportedVersion(getVersion());
   bool AddrSizeOK = getAddressByteSize() == 4 || getAddressByteSize() == 8;
 
   if (!LengthOK || !VersionOK || !AddrSizeOK || !TypeOffsetOK)
     return false;
 
   // Keep track of the highest DWARF version we encounter across all units.

llvm/trunk/test/tools/llvm-dwarfdump/X86/typeunit-v4-dwarf64.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-unknown-elf -o - | \
+# RUN:   llvm-dwarfdump -debug-types - | \
+# RUN:   FileCheck %s
+
+        .section .debug_abbrev,"",@progbits
+        .byte 0x01  # Abbrev code
+        .byte 0x41  # DW_TAG_type_unit
+        .byte 0x01  # DW_CHILDREN_yes
+        .byte 0x17  # DW_AT_visibility
+        .byte 0x0b  # DW_FORM_data1
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x02  # Abbrev code
+        .byte 0x13  # DW_TAG_structure_type
+        .byte 0x00  # DW_CHILDREN_no (no members)
+        .byte 0x17  # DW_AT_visibility
+        .byte 0x0b  # DW_FORM_data1
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x00  # EOM(3)
+
+        .section .debug_types,"",@progbits
+# CHECK: .debug_types contents:
+# CHECK-NEXT: 0x00000000: Type Unit:
+TU_4_64_start:
+        .long 0xffffffff            # DWARF64 mark
+        .quad TU_4_64_end-TU_4_64_version  # Length of Unit
+# CHECK-SAME: length = 0x00000021
+TU_4_64_version:
+        .short 4                    # DWARF version number
+# CHECK-SAME: version = 0x0004
+        .quad .debug_abbrev         # Offset Into Abbrev. Section
+# CHECK-SAME: abbr_offset = 0x0000
+        .byte 8                     # Address Size (in bytes)
+# CHECK-SAME: addr_size = 0x08
+# CHECK-SAME: name = ''
+        .quad 0x0011223344556677    # Type Signature
+# CHECK-SAME: type_signature = 0x0011223344556677
+        .quad TU_4_64_type-TU_4_64_start # Type offset
+# CHECK-SAME: type_offset = 0x0029
+# CHECK-SAME: (next unit at 0x0000002d)
+
+        .byte 1                     # Abbreviation code
+# CHECK: 0x00000027: DW_TAG_type_unit
+        .byte 1                     # DW_VIS_local
+# CHECK-NEXT: DW_AT_visibility (DW_VIS_local)
+
+TU_4_64_type:
+        .byte 2                     # Abbreviation code
+# CHECK: 0x00000029: DW_TAG_structure_type
+        .byte 1                     # DW_VIS_local
+# CHECK-NEXT: DW_AT_visibility (DW_VIS_local)
+
+        .byte 0 # NULL
+# CHECK: 0x0000002b: NULL
+        .byte 0 # NULL
+TU_4_64_end:

llvm/trunk/test/tools/llvm-dwarfdump/X86/typeunit-v5-dwarf64.s

+# RUN: llvm-mc %s -filetype obj -triple x86_64-unknown-elf -o - | \
+# RUN:   llvm-dwarfdump -debug-info - | \
+# RUN:   FileCheck %s
+
+        .section .debug_abbrev,"",@progbits
+        .byte 0x01  # Abbrev code
+        .byte 0x41  # DW_TAG_type_unit
+        .byte 0x01  # DW_CHILDREN_yes
+        .byte 0x17  # DW_AT_visibility
+        .byte 0x0b  # DW_FORM_data1
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x02  # Abbrev code
+        .byte 0x13  # DW_TAG_structure_type
+        .byte 0x00  # DW_CHILDREN_no (no members)
+        .byte 0x17  # DW_AT_visibility
+        .byte 0x0b  # DW_FORM_data1
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+        .byte 0x00  # EOM(3)
+
+        .section .debug_info,"",@progbits
+# CHECK: .debug_info contents:
+# CHECK-NEXT: 0x00000000: Type Unit:
+TU_5_64_start:
+        .long 0xffffffff            # DWARF64 mark
+        .quad TU_5_64_end-TU_5_64_version  # Length of Unit
+# CHECK-SAME: length = 0x00000022
+TU_5_64_version:
+        .short 5                    # DWARF version number
+# CHECK-SAME: version = 0x0005
+        .byte 2                     # DW_UT_type
+        .byte 8                     # Address Size (in bytes)
+        .quad .debug_abbrev         # Offset Into Abbrev. Section
+# CHECK-SAME: abbr_offset = 0x0000
+# CHECK-SAME: addr_size = 0x08
+# CHECK-SAME: name = ''
+        .quad 0x0011223344556677    # Type Signature
+# CHECK-SAME: type_signature = 0x0011223344556677
+        .quad TU_5_64_type-TU_5_64_start # Type offset
+# CHECK-SAME: type_offset = 0x002a
+# CHECK-SAME: (next unit at 0x0000002e)
+
+        .byte 1                     # Abbreviation code
+# CHECK: 0x00000028: DW_TAG_type_unit
+        .byte 1                     # DW_VIS_local
+# CHECK-NEXT: DW_AT_visibility (DW_VIS_local)
+
+TU_5_64_type:
+        .byte 2                     # Abbreviation code
+# CHECK: 0x0000002a: DW_TAG_structure_type
+        .byte 1                     # DW_VIS_local
+# CHECK-NEXT: DW_AT_visibility (DW_VIS_local)
+
+        .byte 0 # NULL
+# CHECK: 0x0000002c: NULL
+        .byte 0 # NULL
+TU_5_64_end: