[llvm][dwwarf] Change CU/TU index to 64-bit

[ayermolo]

Summary

Changed contribution data structure to 64 bit. I added the 32bit and 64bit
accessors to make it explicit where we use 32bit and where we use 64bit. Also to
make sure sure we catch all the cases where this data structure is used.

[ayermolo]

Re-did D139379 after pushing it by mistake.

[ayermolo]

rebase

bolt/lib/Core/DebugData.cpp

if (!CUIndex.getRows().empty()) {
       // Handle DWP section contribution.
       const DWARFUnitIndex::Entry *DWOEntry =
           CUIndex.getFromHash(*Unit.getDWOId());
       if (!DWOEntry)
         return;
 
       const DWARFUnitIndex::Entry::SectionContribution *DWOContrubution =
           DWOEntry->getContribution(DWARFSectionKind::DW_SECT_ABBREV);
-      AbbrevContents = AbbrevSectionContents.substr(DWOContrubution->Offset,
-                                                    DWOContrubution->Length);
+      AbbrevContents = AbbrevSectionContents.substr(
+          DWOContrubution->getOffset(), DWOContrubution->getLength());
     } else if (!Unit.isDWOUnit()) {
       const uint64_t StartOffset = Unit.getAbbreviationsOffset();
 
       // We know where the unit's abbreviation set starts, but not where it ends
       // as such data is not readily available. Hence, we have to build a sorted
       // list of start addresses and find the next starting address to determine
       // the set boundaries.
       //

bolt/lib/Rewrite/DWARFRewriter.cpp

auto applyPatch = [&](DebugInfoBinaryPatcher *Patcher,
     Storage = Patcher->patchBinary(Data);
     return StringRef(Storage.c_str(), Storage.size());
   };
 
   using DWOSectionContribution =
       const DWARFUnitIndex::Entry::SectionContribution;
   auto getSliceData = [&](const DWARFUnitIndex::Entry *DWOEntry,
                           StringRef OutData, DWARFSectionKind Sec,
-                          uint32_t &DWPOffset) -> StringRef {
+                          uint64_t &DWPOffset) -> StringRef {
     if (DWOEntry) {
       DWOSectionContribution *DWOContrubution = DWOEntry->getContribution(Sec);
-      DWPOffset = DWOContrubution->Offset;
-      OutData = OutData.substr(DWPOffset, DWOContrubution->Length);
+      DWPOffset = DWOContrubution->getOffset();
+      OutData = OutData.substr(DWPOffset, DWOContrubution->getLength());
     }
     return OutData;
   };
 
   auto SectionIter = KnownSections.find(SectionName);
   if (SectionIter == KnownSections.end())
     return std::nullopt;
 
   Streamer.switchSection(SectionIter->second.first);
   StringRef OutData = SectionContents;
-  uint32_t DWPOffset = 0;
+  uint64_t DWPOffset = 0;
 
   switch (SectionIter->second.second) {
   default: {
     if (!SectionName.equals("debug_str.dwo"))
       errs() << "BOLT-WARNING: unsupported debug section: " << SectionName
              << "\n";
     return OutData;
   }
for (const uint64_t TUSignature : TypeSignaturesPerCU.at(DWOId)) {
     const DWARFUnitIndex::Entry::SectionContribution *C =
         TUDWOEntry->getContribution(DW_SECT_EXT_TYPES);
     TUContributions.emplace_back(TUSignature, C);
   }
 
   // Sorting so it's easy to compare output.
   // They should be sharing the same Abbrev.
   llvm::sort(TUContributions, [](const TUEntry &V1, const TUEntry &V2) -> bool {
-    return V1.second->Offset < V2.second->Offset;
+    return V1.second->getOffset() < V2.second->getOffset();
   });
 
   for (auto &PairEntry : TUContributions) {
     const DWARFUnitIndex::Entry::SectionContribution *C = PairEntry.second;
     const uint64_t TUSignature = PairEntry.first;
-    DWOTUSection.append(Contents.slice(C->Offset, C->Offset + C->Length).str());
-    TUContributionsToCU.push_back({TUSignature, C->Length});
+    DWOTUSection.append(
+        Contents.slice(C->getOffset(), C->getOffset() + C->getLength()).str());
+    TUContributionsToCU.push_back({TUSignature, C->getLength32()});
   }
   return DWOTUSection;
 }
 
 static void extractDWOTUFromDWO(StringRef Contents,
                                 TUContributionVector &TUContributionsToCU) {
   uint64_t Offset = 0;
   DataExtractor Data(Contents, true, 0);
const DWARFUnitIndex::Entry::SectionContribution *C =
         TUE->getContribution(DWARFSectionKind::DW_SECT_INFO);
     TUContributions.push_back(C);
   }
   // Sorting so it's easy to compare output.
   // They should be sharing the same Abbrev.
   llvm::sort(TUContributions,
              [](const DWARFUnitIndex::Entry::SectionContribution *V1,
                 const DWARFUnitIndex::Entry::SectionContribution *V2) -> bool {
-               return V1->Offset < V2->Offset;
+               return V1->getOffset() < V2->getOffset();
              });
   Streamer.switchSection(MCOFI.getDwarfInfoDWOSection());
   for (const auto *C : TUContributions)
-    Streamer.emitBytes(Contents.slice(C->Offset, C->Offset + C->Length));
+    Streamer.emitBytes(
+        Contents.slice(C->getOffset(), C->getOffset() + C->getLength()));
 }
 
 void DWARFRewriter::writeDWP(
     std::unordered_map<uint64_t, std::string> &DWOIdToName) {
   SmallString<0> OutputNameStr;
   StringRef OutputName;
   if (opts::DwarfOutputPath.empty()) {
     OutputName =
for (const SectionRef &Section : DWOFile->sections()) {
         // a known section.
         auto SectionIter = KnownSections.find(SectionName);
         if (SectionIter->second.second == DWARFSectionKind::DW_SECT_STR_OFFSETS)
           CurStrOffsetSection = OutData;
         else
           Streamer->emitBytes(OutData);
         auto Index =
             getContributionIndex(SectionIter->second.second, IndexVersion);
-        CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
-        CurEntry.Contributions[Index].Length = OutData.size();
-        ContributionOffsets[Index] += CurEntry.Contributions[Index].Length;
+        CurEntry.Contributions[Index].setOffset(ContributionOffsets[Index]);
+        CurEntry.Contributions[Index].setLength(OutData.size());
+        ContributionOffsets[Index] +=
+            CurEntry.Contributions[Index].getLength32();
       }
 
       // Strings are combined in to a new string section, and de-duplicated
       // based on hash.
       if (!StrSectionWrittenOut && !CurStrOffsetSection.empty() &&
           !CurStrSection.empty()) {
         writeStringsAndOffsets(*Streamer.get(), Strings, StrOffsetSection,
                                CurStrSection, CurStrOffsetSection,
for (const std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
 
     // Handling TU
     if (!TUContributionsToCU.empty()) {
       const unsigned Index =
           getContributionIndex(DW_SECT_EXT_TYPES, IndexVersion);
       for (const TUContribution &TUC : TUContributionsToCU) {
         UnitIndexEntry TUEntry = CurEntry;
         TUEntry.Contributions[0] = {};
-        TUEntry.Contributions[Index].Offset = ContributionOffsets[Index];
-        TUEntry.Contributions[Index].Length = TUC.Length;
-        ContributionOffsets[Index] += TUEntry.Contributions[Index].Length;
+        TUEntry.Contributions[Index].setOffset(ContributionOffsets[Index]);
+        TUEntry.Contributions[Index].setLength(TUC.Length);
+        ContributionOffsets[Index] +=
+            TUEntry.Contributions[Index].getLength32();
         TypeIndexEntries.insert(std::make_pair(TUC.Signature, TUEntry));
       }
     }
   }
 
   if (Version < 5) {
     // Lie about there being no info contributions so the TU index only includes
     // the type unit contribution for DWARF < 5. In DWARFv5 the TU index has a

lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 // may use DW_FORM_strx* forms pointing to its own .debug_str_offsets.dwo and
 // for that case, we should find the offset (skip the section header).
 void DWARFUnit::SetDwoStrOffsetsBase() {
   lldb::offset_t baseOffset = 0;
 
   if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
     if (const auto *contribution =
             entry->getContribution(llvm::DW_SECT_STR_OFFSETS))
-      baseOffset = contribution->Offset;
+      baseOffset = contribution->getOffset32();
     else
       return;
   }
 
   if (GetVersion() >= 5) {
     const DWARFDataExtractor &strOffsets =
         GetSymbolFileDWARF().GetDWARFContext().getOrLoadStrOffsetsData();
     uint64_t length = strOffsets.GetU32(&baseOffset);
if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
     const auto *contribution = entry->getContribution(llvm::DW_SECT_LOCLISTS);
     if (!contribution) {
       GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
           "Failed to find location list contribution for CU with DWO Id "
           "0x%" PRIx64,
           *GetDWOId());
       return;
     }
-    offset += contribution->Offset;
+    offset += contribution->getOffset32();
   }
   m_loclists_base = loclists_base;
 
   uint64_t header_size = llvm::DWARFListTableHeader::getHeaderSize(DWARF32);
   if (loclists_base < header_size)
     return;
 
   m_loclist_table_header.emplace(".debug_loclists", "locations");

 
 DWARFDataExtractor DWARFUnit::GetLocationData() const {
   DWARFContext &Ctx = GetSymbolFileDWARF().GetDWARFContext();
   const DWARFDataExtractor &data =
       GetVersion() >= 5 ? Ctx.getOrLoadLocListsData() : Ctx.getOrLoadLocData();
   if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
     if (const auto *contribution = entry->getContribution(
             GetVersion() >= 5 ? llvm::DW_SECT_LOCLISTS : llvm::DW_SECT_EXT_LOC))
-      return DWARFDataExtractor(data, contribution->Offset,
-                                contribution->Length);
+      return DWARFDataExtractor(data, contribution->getOffset32(),
+                                contribution->getLength32());
     return DWARFDataExtractor();
   }
   return data;
 }
 
 DWARFDataExtractor DWARFUnit::GetRnglistData() const {
   DWARFContext &Ctx = GetSymbolFileDWARF().GetDWARFContext();
   const DWARFDataExtractor &data = Ctx.getOrLoadRngListsData();
   if (const llvm::DWARFUnitIndex::Entry *entry = m_header.GetIndexEntry()) {
     if (const auto *contribution =
             entry->getContribution(llvm::DW_SECT_RNGLISTS))
-      return DWARFDataExtractor(data, contribution->Offset,
-                                contribution->Length);
+      return DWARFDataExtractor(data, contribution->getOffset32(),
+                                contribution->getLength32());
     GetSymbolFileDWARF().GetObjectFile()->GetModule()->ReportError(
         "Failed to find range list contribution for CU with signature "
         "0x%" PRIx64,
         entry->getSignature());
 
     return DWARFDataExtractor();
   }
   return data;
DWARFUnitHeader::extract(const DWARFDataExtractor &data,
 
   if (header.m_index_entry) {
     if (header.m_abbr_offset) {
       return llvm::createStringError(
           llvm::inconvertibleErrorCode(),
           "Package unit with a non-zero abbreviation offset");
     }
     auto *unit_contrib = header.m_index_entry->getContribution();
-    if (!unit_contrib || unit_contrib->Length != header.m_length + 4) {
+    if (!unit_contrib || unit_contrib->getLength32() != header.m_length + 4) {
       return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                      "Inconsistent DWARF package unit index");
     }
     auto *abbr_entry =
         header.m_index_entry->getContribution(llvm::DW_SECT_ABBREV);
     if (!abbr_entry) {
       return llvm::createStringError(
           llvm::inconvertibleErrorCode(),
           "DWARF package index missing abbreviation column");
     }
-    header.m_abbr_offset = abbr_entry->Offset;
+    header.m_abbr_offset = abbr_entry->getOffset32();
   }
 
   bool length_OK = data.ValidOffset(header.GetNextUnitOffset() - 1);
   bool version_OK = SymbolFileDWARF::SupportedVersion(header.m_version);
   bool addr_size_OK = (header.m_addr_size == 4) || (header.m_addr_size == 8);
   bool type_offset_OK =
       !header.IsTypeUnit() || (header.m_type_offset <= header.GetLength());
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

 }
 
 DWARFCompileUnit *SymbolFileDWARFDwo::GetDWOCompileUnitForHash(uint64_t hash) {
   if (const llvm::DWARFUnitIndex &index = m_context.GetAsLLVM().getCUIndex()) {
     if (const llvm::DWARFUnitIndex::Entry *entry = index.getFromHash(hash)) {
       if (auto *unit_contrib = entry->getContribution())
         return llvm::dyn_cast_or_null<DWARFCompileUnit>(
             DebugInfo().GetUnitAtOffset(DIERef::Section::DebugInfo,
-                                        unit_contrib->Offset));
+                                        unit_contrib->getOffset32()));
     }
     return nullptr;
   }
 
   DWARFCompileUnit *cu = FindSingleCompileUnit();
   if (!cu)
     return nullptr;
   llvm::Optional<uint64_t> dwo_id = cu->GetDWOId();

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

std::optional<uint32_t> getDIEIndexForOffset(uint64_t Offset) {
     if (It != DieArray.end() && It->getOffset() == Offset)
       return It - DieArray.begin();
     return std::nullopt;
   }
 
   uint32_t getLineTableOffset() const {
     if (auto IndexEntry = Header.getIndexEntry())
       if (const auto *Contrib = IndexEntry->getContribution(DW_SECT_LINE))
-        return Contrib->Offset;
+        return Contrib->getOffset32();
     return 0;
   }
 
   die_iterator_range dies() {
     extractDIEsIfNeeded(false);
     return die_iterator_range(DieArray.begin(), DieArray.end());
   }
 

llvm/include/llvm/DebugInfo/DWARF/DWARFUnitIndex.h

struct Header {
 
     bool parse(DataExtractor IndexData, uint64_t *OffsetPtr);
     void dump(raw_ostream &OS) const;
   };
 
 public:
   class Entry {
   public:
-    struct SectionContribution {
-      uint32_t Offset;
-      uint32_t Length;
+    class SectionContribution {
+    private:
+      uint64_t Fields[2];
+
+    public:
+      static constexpr unsigned OffsetFieldIndex = 0;
+      static constexpr unsigned LengthFieldIndex = 1;
+      SectionContribution() { memset(&Fields, 0, sizeof(Fields)); }
+      SectionContribution(uint64_t Offset, uint64_t Length) {
+        Fields[OffsetFieldIndex] = Offset;
+        Fields[LengthFieldIndex] = Length;
+      }
+
+      void setField(unsigned Index, uint64_t Value) { Fields[Index] = Value; }
+      void setOffset(uint64_t Value) { Fields[OffsetFieldIndex] = Value; }
+      void setLength(uint64_t Value) { Fields[LengthFieldIndex] = Value; }
+      uint64_t getField32(unsigned Index) const {
+        return (uint32_t)Fields[Index];
+      }
+      uint64_t getOffset() const { return Fields[OffsetFieldIndex]; }
+      uint64_t getLength() const { return Fields[LengthFieldIndex]; }
+      uint32_t getOffset32() const {
+        return (uint32_t)Fields[OffsetFieldIndex];
+      }
+      uint32_t getLength32() const {
+        return (uint32_t)Fields[LengthFieldIndex];
+      }
     };
 
   private:
     const DWARFUnitIndex *Index;
     uint64_t Signature;
     std::unique_ptr<SectionContribution[]> Contributions;
     friend class DWARFUnitIndex;
 
public:
 
   explicit operator bool() const { return Header.NumBuckets; }
 
   bool parse(DataExtractor IndexData);
   void dump(raw_ostream &OS) const;
 
   uint32_t getVersion() const { return Header.Version; }
 
-  const Entry *getFromOffset(uint32_t Offset) const;
+  const Entry *getFromOffset(uint64_t Offset) const;
   const Entry *getFromHash(uint64_t Offset) const;
 
   ArrayRef<DWARFSectionKind> getColumnKinds() const {
     return makeArrayRef(ColumnKinds.get(), Header.NumColumns);
   }
 
   ArrayRef<Entry> getRows() const {
     return makeArrayRef(Rows.get(), Header.NumBuckets);
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFUNITINDEX_H

llvm/lib/DWP/DWP.cpp

 }
 
 static StringRef getSubsection(StringRef Section,
                                const DWARFUnitIndex::Entry &Entry,
                                DWARFSectionKind Kind) {
   const auto *Off = Entry.getContribution(Kind);
   if (!Off)
     return StringRef();
-  return Section.substr(Off->Offset, Off->Length);
+  return Section.substr(Off->getOffset(), Off->getLength());
 }
 
 static void
 addAllTypesFromDWP(MCStreamer &Out,
                    MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries,
                    const DWARFUnitIndex &TUIndex, MCSection *OutputTypes,
                    StringRef Types, const UnitIndexEntry &TUEntry,
                    uint32_t &TypesOffset, unsigned TypesContributionIndex) {
   Out.switchSection(OutputTypes);
   for (const DWARFUnitIndex::Entry &E : TUIndex.getRows()) {
     auto *I = E.getContributions();
     if (!I)
       continue;
     auto P = TypeIndexEntries.insert(std::make_pair(E.getSignature(), TUEntry));
     if (!P.second)
       continue;
     auto &Entry = P.first->second;
     // Zero out the debug_info contribution
     Entry.Contributions[0] = {};
     for (auto Kind : TUIndex.getColumnKinds()) {
       if (!isSupportedSectionKind(Kind))
         continue;
       auto &C =
           Entry.Contributions[getContributionIndex(Kind, TUIndex.getVersion())];
-      C.Offset += I->Offset;
-      C.Length = I->Length;
+      C.setOffset(C.getOffset() + I->getOffset());
+      C.setLength(I->getLength());
       ++I;
     }
     auto &C = Entry.Contributions[TypesContributionIndex];
     Out.emitBytes(Types.substr(
-        C.Offset - TUEntry.Contributions[TypesContributionIndex].Offset,
-        C.Length));
-    C.Offset = TypesOffset;
-    TypesOffset += C.Length;
+        C.getOffset() -
+            TUEntry.Contributions[TypesContributionIndex].getOffset(),
+        C.getLength()));
+    C.setOffset(TypesOffset);
+    TypesOffset += C.getLength();
   }
 }
 
 static void addAllTypesFromTypesSection(
     MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries,
     MCSection *OutputTypes, const std::vector<StringRef> &TypesSections,
     const UnitIndexEntry &CUEntry, uint32_t &TypesOffset) {
   for (StringRef Types : TypesSections) {
     Out.switchSection(OutputTypes);
     uint64_t Offset = 0;
     DataExtractor Data(Types, true, 0);
     while (Data.isValidOffset(Offset)) {
       UnitIndexEntry Entry = CUEntry;
       // Zero out the debug_info contribution
       Entry.Contributions[0] = {};
       auto &C = Entry.Contributions[getContributionIndex(DW_SECT_EXT_TYPES, 2)];
-      C.Offset = TypesOffset;
+      C.setOffset(TypesOffset);
       auto PrevOffset = Offset;
       // Length of the unit, including the 4 byte length field.
-      C.Length = Data.getU32(&Offset) + 4;
+      C.setLength(Data.getU32(&Offset) + 4);
 
       Data.getU16(&Offset); // Version
       Data.getU32(&Offset); // Abbrev offset
       Data.getU8(&Offset);  // Address size
       auto Signature = Data.getU64(&Offset);
-      Offset = PrevOffset + C.Length;
+      Offset = PrevOffset + C.getLength32();
 
       auto P = TypeIndexEntries.insert(std::make_pair(Signature, Entry));
       if (!P.second)
         continue;
 
-      Out.emitBytes(Types.substr(PrevOffset, C.Length));
-      TypesOffset += C.Length;
+      Out.emitBytes(Types.substr(PrevOffset, C.getLength32()));
+      TypesOffset += C.getLength32();
     }
   }
 }
 
 static std::string buildDWODescription(StringRef Name, StringRef DWPName,
                                        StringRef DWOName) {
   std::string Text = "\'";
   Text += Name;
void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
   Out.emitBytes(Data.getBytes(&Offset, HeaderSize));
   while (Offset < Size) {
     auto OldOffset = Data.getU32(&Offset);
     auto NewOffset = OffsetRemapping[OldOffset];
     Out.emitIntValue(NewOffset, 4);
   }
 }
 
-void writeIndexTable(
-    MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets,
+void writeIndexTable(MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets,
                      const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
-    uint32_t DWARFUnitIndex::Entry::SectionContribution::*Field) {
+                     unsigned Index) {
   for (const auto &E : IndexEntries)
     for (size_t I = 0; I != std::size(E.second.Contributions); ++I)
       if (ContributionOffsets[I])
-        Out.emitIntValue(E.second.Contributions[I].*Field, 4);
+        Out.emitIntValue((E.second.Contributions[I].getField32(Index)), 4);
 }
 
 void writeIndex(MCStreamer &Out, MCSection *Section,
                 ArrayRef<unsigned> ContributionOffsets,
                 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
                 uint32_t IndexVersion) {
   if (IndexEntries.empty())
     return;
void writeIndex(MCStreamer &Out, MCSection *Section,
 
   // Write the column headers (which sections will appear in the table)
   for (size_t I = 0; I != ContributionOffsets.size(); ++I)
     if (ContributionOffsets[I])
       Out.emitIntValue(getOnDiskSectionId(I), 4);
 
   // Write the offsets.
   writeIndexTable(Out, ContributionOffsets, IndexEntries,
-                  &DWARFUnitIndex::Entry::SectionContribution::Offset);
+                  DWARFUnitIndex::Entry::SectionContribution::OffsetFieldIndex);
 
   // Write the lengths.
   writeIndexTable(Out, ContributionOffsets, IndexEntries,
-                  &DWARFUnitIndex::Entry::SectionContribution::Length);
+                  DWARFUnitIndex::Entry::SectionContribution::LengthFieldIndex);
 }
 
 Error buildDuplicateError(const std::pair<uint64_t, UnitIndexEntry> &PrevE,
                           const CompileUnitIdentifiers &ID, StringRef DWPName) {
   return make_error<DWPError>(
       std::string("duplicate DWO ID (") + utohexstr(PrevE.first) + ") in " +
       buildDWODescription(PrevE.second.Name, PrevE.second.DWPName,
                           PrevE.second.DWOName) +
if (Version == 0) {
       return make_error<DWPError>("incompatible DWARF compile unit versions.");
     }
 
     writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
                            CurStrOffsetSection, Header.Version);
 
     for (auto Pair : SectionLength) {
       auto Index = getContributionIndex(Pair.first, IndexVersion);
-      CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
-      ContributionOffsets[Index] +=
-          (CurEntry.Contributions[Index].Length = Pair.second);
+      CurEntry.Contributions[Index].setOffset(ContributionOffsets[Index]);
+      CurEntry.Contributions[Index].setLength(Pair.second);
+      ContributionOffsets[Index] += CurEntry.Contributions[Index].getLength32();
     }
 
     uint32_t &InfoSectionOffset =
         ContributionOffsets[getContributionIndex(DW_SECT_INFO, IndexVersion)];
     if (CurCUIndexSection.empty()) {
       bool FoundCUUnit = false;
       Out.switchSection(InfoSection);
       for (StringRef Info : CurInfoSection) {
         uint64_t UnitOffset = 0;
         while (Info.size() > UnitOffset) {
           Expected<InfoSectionUnitHeader> HeaderOrError =
               parseInfoSectionUnitHeader(Info.substr(UnitOffset, Info.size()));
           if (!HeaderOrError)
             return HeaderOrError.takeError();
           InfoSectionUnitHeader &Header = *HeaderOrError;
 
           UnitIndexEntry Entry = CurEntry;
           auto &C = Entry.Contributions[getContributionIndex(DW_SECT_INFO,
                                                              IndexVersion)];
-          C.Offset = InfoSectionOffset;
-          C.Length = Header.Length + 4;
+          C.setOffset(InfoSectionOffset);
+          C.setLength(Header.Length + 4);
 
           if (std::numeric_limits<uint32_t>::max() - InfoSectionOffset <
-              C.Length)
+              C.getLength32())
             return make_error<DWPError>(
                 "debug information section offset is greater than 4GB");
 
-          UnitOffset += C.Length;
+          UnitOffset += C.getLength32();
           if (Header.Version < 5 ||
               Header.UnitType == dwarf::DW_UT_split_compile) {
-            Expected<CompileUnitIdentifiers> EID =
-                getCUIdentifiers(Header, AbbrevSection,
-                                 Info.substr(UnitOffset - C.Length, C.Length),
-                                 CurStrOffsetSection, CurStrSection);
+            Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
+                Header, AbbrevSection,
+                Info.substr(UnitOffset - C.getLength32(), C.getLength32()),
 
             if (!EID)
               return createFileError(Input, EID.takeError());
             const auto &ID = *EID;
             auto P = IndexEntries.insert(std::make_pair(ID.Signature, Entry));
             if (!P.second)
               return buildDuplicateError(*P.first, ID, "");
             P.first->second.Name = ID.Name;
             P.first->second.DWOName = ID.DWOName;
 
             FoundCUUnit = true;
           } else if (Header.UnitType == dwarf::DW_UT_split_type) {
             auto P = TypeIndexEntries.insert(
                 std::make_pair(*Header.Signature, Entry));
             if (!P.second)
               continue;
           }
-          Out.emitBytes(Info.substr(UnitOffset - C.Length, C.Length));
-          InfoSectionOffset += C.Length;
+          Out.emitBytes(
+              Info.substr(UnitOffset - C.getLength32(), C.getLength32()));
+          InfoSectionOffset += C.getLength32();
         }
       }
 
       if (!FoundCUUnit)
         return make_error<DWPError>("no compile unit found in file: " + Input);
 
       if (IndexVersion == 2) {
         // Add types from the .debug_types section from DWARF < 5.
for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
       NewEntry.Name = ID.Name;
       NewEntry.DWOName = ID.DWOName;
       NewEntry.DWPName = Input;
       for (auto Kind : CUIndex.getColumnKinds()) {
         if (!isSupportedSectionKind(Kind))
           continue;
         auto &C =
             NewEntry.Contributions[getContributionIndex(Kind, IndexVersion)];
-        C.Offset += I->Offset;
-        C.Length = I->Length;
+        C.setOffset(C.getOffset() + I->getOffset());
+        C.setLength(I->getLength());
         ++I;
       }
       unsigned Index = getContributionIndex(DW_SECT_INFO, IndexVersion);
       auto &C = NewEntry.Contributions[Index];
       Out.emitBytes(CUInfoSection);
-      C.Offset = InfoSectionOffset;
-      InfoSectionOffset += C.Length;
+      C.setOffset(InfoSectionOffset);
+      InfoSectionOffset += C.getLength32();
     }
 
     if (!CurTUIndexSection.empty()) {
       llvm::DWARFSectionKind TUSectionKind;
       MCSection *OutSection;
       StringRef TypeInputSection;
       // Write type units into debug info section for DWARFv5.
       if (Version >= 5) {

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

 }
 
 DWARFUnit *
 DWARFUnitVector::getUnitForIndexEntry(const DWARFUnitIndex::Entry &E) {
   const auto *CUOff = E.getContribution(DW_SECT_INFO);
   if (!CUOff)
     return nullptr;
 
-  auto Offset = CUOff->Offset;
+  uint64_t Offset = CUOff->getOffset();
   auto end = begin() + getNumInfoUnits();
 
   auto *CU =
-      std::upper_bound(begin(), end, CUOff->Offset,
+      std::upper_bound(begin(), end, CUOff->getOffset(),
                        [](uint64_t LHS, const std::unique_ptr<DWARFUnit> &RHS) {
                          return LHS < RHS->getNextUnitOffset();
                        });
   if (CU != end && (*CU)->getOffset() <= Offset)
     return CU->get();
 
   if (!Parser)
     return nullptr;

 bool DWARFUnitHeader::applyIndexEntry(const DWARFUnitIndex::Entry *Entry) {
   assert(Entry);
   assert(!IndexEntry);
   IndexEntry = Entry;
   if (AbbrOffset)
     return false;
   auto *UnitContrib = IndexEntry->getContribution();
   if (!UnitContrib ||
-      UnitContrib->Length != (getLength() + getUnitLengthFieldByteSize()))
+      UnitContrib->getLength() != (getLength() + getUnitLengthFieldByteSize()))
     return false;
   auto *AbbrEntry = IndexEntry->getContribution(DW_SECT_ABBREV);
   if (!AbbrEntry)
     return false;
-  AbbrOffset = AbbrEntry->Offset;
+  AbbrOffset = AbbrEntry->getOffset();
   return true;
 }
 
 Error DWARFUnit::extractRangeList(uint64_t RangeListOffset,
                                   DWARFDebugRangeList &RangeList) const {
   // Require that compile unit is extracted.
   assert(!DieArray.empty());
   DWARFDataExtractor RangesData(Context.getDWARFObj(), *RangeSection,
Error DWARFUnit::tryExtractDIEsIfNeeded(bool CUDieOnly) {
   // DWARF v5 uses the .debug_rnglists and .debug_rnglists.dwo sections to
   // describe address ranges.
   if (getVersion() >= 5) {
     // In case of DWP, the base offset from the index has to be added.
     if (IsDWO) {
       uint64_t ContributionBaseOffset = 0;
       if (auto *IndexEntry = Header.getIndexEntry())
         if (auto *Contrib = IndexEntry->getContribution(DW_SECT_RNGLISTS))
-          ContributionBaseOffset = Contrib->Offset;
+          ContributionBaseOffset = Contrib->getOffset();
       setRangesSection(
           &Context.getDWARFObj().getRnglistsDWOSection(),
           ContributionBaseOffset +
               DWARFListTableHeader::getHeaderSize(Header.getFormat()));
     } else
       setRangesSection(&Context.getDWARFObj().getRnglistsSection(),
                        toSectionOffset(UnitDie.find(DW_AT_rnglists_base),
                                        DWARFListTableHeader::getHeaderSize(
                                            Header.getFormat())));
   }
 
   if (IsDWO) {
     // If we are reading a package file, we need to adjust the location list
     // data based on the index entries.
     StringRef Data = Header.getVersion() >= 5
                          ? Context.getDWARFObj().getLoclistsDWOSection().Data
                          : Context.getDWARFObj().getLocDWOSection().Data;
     if (auto *IndexEntry = Header.getIndexEntry())
       if (const auto *C = IndexEntry->getContribution(
               Header.getVersion() >= 5 ? DW_SECT_LOCLISTS : DW_SECT_EXT_LOC))
-        Data = Data.substr(C->Offset, C->Length);
+        Data = Data.substr(C->getOffset(), C->getLength());
 
     DWARFDataExtractor DWARFData(Data, IsLittleEndian, getAddressByteSize());
     LocTable =
         std::make_unique<DWARFDebugLoclists>(DWARFData, Header.getVersion());
     LocSectionBase = DWARFListTableHeader::getHeaderSize(Header.getFormat());
   } else if (getVersion() >= 5) {
     LocTable = std::make_unique<DWARFDebugLoclists>(
         DWARFDataExtractor(Context.getDWARFObj(),

 Expected<std::optional<StrOffsetsContributionDescriptor>>
 DWARFUnit::determineStringOffsetsTableContributionDWO(DWARFDataExtractor &DA) {
   assert(IsDWO);
   uint64_t Offset = 0;
   auto IndexEntry = Header.getIndexEntry();
   const auto *C =
       IndexEntry ? IndexEntry->getContribution(DW_SECT_STR_OFFSETS) : nullptr;
   if (C)
-    Offset = C->Offset;
+    Offset = C->getOffset();
   if (getVersion() >= 5) {
     if (DA.getData().data() == nullptr)
       return std::nullopt;
     Offset += Header.getFormat() == dwarf::DwarfFormat::DWARF32 ? 8 : 16;
     // Look for a valid contribution at the given offset.
     auto DescOrError = parseDWARFStringOffsetsTableHeader(DA, Header.getFormat(), Offset);
     if (!DescOrError)
       return DescOrError.takeError();
     return *DescOrError;
   }
   // Prior to DWARF v5, we derive the contribution size from the
   // index table (in a package file). In a .dwo file it is simply
   // the length of the string offsets section.
   StrOffsetsContributionDescriptor Desc;
   if (C)
-    Desc = StrOffsetsContributionDescriptor(C->Offset, C->Length, 4,
+    Desc = StrOffsetsContributionDescriptor(C->getOffset(), C->getLength(), 4,
                                             Header.getFormat());
   else if (!IndexEntry && !StringOffsetSection.Data.empty())
     Desc = StrOffsetsContributionDescriptor(0, StringOffsetSection.Data.size(),
                                             4, Header.getFormat());
   else
     return std::nullopt;
   auto DescOrError = Desc.validateContributionSize(DA);
   if (!DescOrError)

llvm/lib/DebugInfo/DWARF/DWARFUnitIndex.cpp

bool DWARFUnitIndex::parseImpl(DataExtractor IndexData) {
 
   if (InfoColumn == -1)
     return false;
 
   // Read Table of Section Offsets
   for (unsigned i = 0; i != Header.NumUnits; ++i) {
     auto *Contrib = Contribs[i];
     for (unsigned i = 0; i != Header.NumColumns; ++i)
-      Contrib[i].Offset = IndexData.getU32(&Offset);
+      Contrib[i].setOffset(IndexData.getU32(&Offset));
   }
 
   // Read Table of Section Sizes
   for (unsigned i = 0; i != Header.NumUnits; ++i) {
     auto *Contrib = Contribs[i];
     for (unsigned i = 0; i != Header.NumColumns; ++i)
-      Contrib[i].Length = IndexData.getU32(&Offset);
+      Contrib[i].setLength(IndexData.getU32(&Offset));
   }
 
   return true;
 }
 
 StringRef DWARFUnitIndex::getColumnHeader(DWARFSectionKind DS) {
   switch (DS) {
 #define HANDLE_DW_SECT(ID, NAME)                                               \
if (!*this)
     return;
 
   Header.dump(OS);
   OS << "Index Signature         ";
   for (unsigned i = 0; i != Header.NumColumns; ++i) {
     DWARFSectionKind Kind = ColumnKinds[i];
     StringRef Name = getColumnHeader(Kind);
     if (!Name.empty())
-      OS << ' ' << left_justify(Name, 24);
+      OS << ' '
+         << left_justify(Name,
+                         Kind == DWARFSectionKind::DW_SECT_INFO ? 40 : 24);
     else
       OS << format(" Unknown: %-15" PRIu32, RawSectionIds[i]);
   }
   OS << "\n----- ------------------";
-  for (unsigned i = 0; i != Header.NumColumns; ++i)
+  for (unsigned i = 0; i != Header.NumColumns; ++i) {
+    DWARFSectionKind Kind = ColumnKinds[i];
+    if (Kind == DWARFSectionKind::DW_SECT_INFO ||
+        Kind == DWARFSectionKind::DW_SECT_EXT_TYPES)
+      OS << " ----------------------------------------";
+    else
       OS << " ------------------------";
+  }
   OS << '\n';
   for (unsigned i = 0; i != Header.NumBuckets; ++i) {
     auto &Row = Rows[i];
     if (auto *Contribs = Row.Contributions.get()) {
       OS << format("%5u 0x%016" PRIx64 " ", i + 1, Row.Signature);
       for (unsigned i = 0; i != Header.NumColumns; ++i) {
         auto &Contrib = Contribs[i];
-        OS << format("[0x%08x, 0x%08x) ", Contrib.Offset,
-                     Contrib.Offset + Contrib.Length);
+        DWARFSectionKind Kind = ColumnKinds[i];
+        if (Kind == DWARFSectionKind::DW_SECT_INFO ||
+            Kind == DWARFSectionKind::DW_SECT_EXT_TYPES)
+          OS << format("[0x%016" PRIx64 ", 0x%016" PRIx64 ") ",
+                       Contrib.getOffset(),
+                       Contrib.getOffset() + Contrib.getLength());
+        else
+          OS << format("[0x%08" PRIx32 ", 0x%08" PRIx32 ") ",
+                       Contrib.getOffset(),
+                       Contrib.getOffset() + Contrib.getLength());
       }
       OS << '\n';
     }
   }
 }
 
 const DWARFUnitIndex::Entry::SectionContribution *
 DWARFUnitIndex::Entry::getContribution(DWARFSectionKind Sec) const {
   uint32_t i = 0;
   for (; i != Index->Header.NumColumns; ++i)
     if (Index->ColumnKinds[i] == Sec)
       return &Contributions[i];
   return nullptr;
 }
 
 const DWARFUnitIndex::Entry::SectionContribution *
 DWARFUnitIndex::Entry::getContribution() const {
   return &Contributions[Index->InfoColumn];
 }
 
 const DWARFUnitIndex::Entry *
-DWARFUnitIndex::getFromOffset(uint32_t Offset) const {
+DWARFUnitIndex::getFromOffset(uint64_t Offset) const {
   if (OffsetLookup.empty()) {
     for (uint32_t i = 0; i != Header.NumBuckets; ++i)
       if (Rows[i].Contributions)
         OffsetLookup.push_back(&Rows[i]);
     llvm::sort(OffsetLookup, [&](Entry *E1, Entry *E2) {
-      return E1->Contributions[InfoColumn].Offset <
-             E2->Contributions[InfoColumn].Offset;
+      return E1->Contributions[InfoColumn].getOffset() <
+             E2->Contributions[InfoColumn].getOffset();
     });
   }
   auto I = partition_point(OffsetLookup, [&](Entry *E2) {
-    return E2->Contributions[InfoColumn].Offset <= Offset;
+    return E2->Contributions[InfoColumn].getOffset() <= Offset;
   });
   if (I == OffsetLookup.begin())
     return nullptr;
   --I;
   const auto *E = *I;
   const auto &InfoContrib = E->Contributions[InfoColumn];
-  if ((InfoContrib.Offset + InfoContrib.Length) <= Offset)
+  if ((InfoContrib.getOffset() + InfoContrib.getLength()) <= Offset)
     return nullptr;
   return E;
 }
 
 const DWARFUnitIndex::Entry *DWARFUnitIndex::getFromHash(uint64_t S) const {
   uint64_t Mask = Header.NumBuckets - 1;
 
   auto H = S & Mask;

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

unsigned DWARFVerifier::verifyIndex(StringRef Name,
                                     StringRef IndexStr) {
   if (IndexStr.empty())
     return 0;
   OS << "Verifying " << Name << "...\n";
   DWARFUnitIndex Index(InfoColumnKind);
   DataExtractor D(IndexStr, DCtx.isLittleEndian(), 0);
   if (!Index.parse(D))
     return 1;
-  using MapType = IntervalMap<uint32_t, uint64_t>;
+  using MapType = IntervalMap<uint64_t, uint64_t>;
   MapType::Allocator Alloc;
   std::vector<std::unique_ptr<MapType>> Sections(Index.getColumnKinds().size());
   for (const DWARFUnitIndex::Entry &E : Index.getRows()) {
     uint64_t Sig = E.getSignature();
     if (!E.getContributions())
       continue;
     for (auto E : enumerate(InfoColumnKind == DW_SECT_INFO
                                 ? makeArrayRef(E.getContributions(),
                                                Index.getColumnKinds().size())
                                 : makeArrayRef(E.getContribution(), 1))) {
       const DWARFUnitIndex::Entry::SectionContribution &SC = E.value();
       int Col = E.index();
-      if (SC.Length == 0)
+      if (SC.getLength() == 0)
         continue;
       if (!Sections[Col])
         Sections[Col] = std::make_unique<MapType>(Alloc);
       auto &M = *Sections[Col];
-      auto I = M.find(SC.Offset);
-      if (I != M.end() && I.start() < (SC.Offset + SC.Length)) {
+      auto I = M.find(SC.getOffset());
+      if (I != M.end() && I.start() < (SC.getOffset() + SC.getLength())) {
         error() << llvm::formatv(
             "overlapping index entries for entries {0:x16} "
             "and {1:x16} for column {2}\n",
             *I, Sig, toString(Index.getColumnKinds()[Col]));
         return 1;
       }
-      M.insert(SC.Offset, SC.Offset + SC.Length - 1, Sig);
+      M.insert(SC.getOffset(), SC.getOffset() + SC.getLength() - 1, Sig);
     }
   }
 
   return 0;
 }
 
 bool DWARFVerifier::handleDebugCUIndex() {
   return verifyIndex(".debug_cu_index", DWARFSectionKind::DW_SECT_INFO,

llvm/test/DebugInfo/X86/debug-cu-index-unknown-section.s

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-cu-index - | \
 # RUN:   FileCheck %s --strict-whitespace
 
 # CHECK:      .debug_cu_index contents:
 # CHECK-NEXT: version = 2, units = 1, slots = 2
 # CHECK-EMPTY:
 # CHECK-NEXT: Index Signature          Unknown: 9               INFO
-# CHECK-NEXT: ----- ------------------ ------------------------ ------------------------
-# CHECK-NEXT:     1 0x1100001122222222 [0x00001000, 0x00001010) [0x00002000, 0x00002020)
+# CHECK-NEXT: ----- ------------------ ------------------------ ----------------------------------------
+# CHECK-NEXT:     1 0x1100001122222222 [0x00001000, 0x00001010) [0x0000000000002000, 0x0000000000002020)
 
     .section .debug_cu_index, "", @progbits
 ## Header:
     .long 2             # Version
     .long 2             # Section count
     .long 1             # Unit count
     .long 2             # Slot count
 ## Hash Table of Signatures:

llvm/test/DebugInfo/X86/dwp-v2-cu-index.s

 ## The test checks that we can parse and dump a pre-standard CU index section.
 ## See https://gcc.gnu.org/wiki/DebugFissionDWP for the proposal.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-cu-index - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_cu_index contents:
 # CHECK-NEXT: version = 2, units = 1, slots = 2
 # CHECK-EMPTY:
-# CHECK-NEXT: Index Signature          INFO                     ABBREV                   LINE                     LOC                      STR_OFFSETS              MACINFO                  MACRO
-# CHECK-NEXT: ----- ------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------
-# CHECK-NEXT:     1 0x1100001122222222 [0x00001000, 0x00001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040) [0x00005000, 0x00005050) [0x00006000, 0x00006060) [0x00007000, 0x00007070)
+# CHECK-NEXT: Index Signature          INFO                                     ABBREV                   LINE                     LOC                      STR_OFFSETS              MACINFO                  MACRO
+# CHECK-NEXT: ----- ------------------ ---------------------------------------- ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------
+# CHECK-NEXT:     1 0x1100001122222222 [0x0000000000001000, 0x0000000000001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040) [0x00005000, 0x00005050) [0x00006000, 0x00006060) [0x00007000, 0x00007070)
 
     .section .debug_cu_index, "", @progbits
 ## Header:
     .long 2             # Version
     .long 7             # Section count
     .long 1             # Unit count
     .long 2             # Slot count
 ## Hash Table of Signatures:

llvm/test/DebugInfo/X86/dwp-v2-tu-index.s

 ## The test checks that we can parse and dump a pre-standard TU index section.
 ## See https://gcc.gnu.org/wiki/DebugFissionDWP for the proposal.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-tu-index - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_tu_index contents:
 # CHECK-NEXT: version = 2, units = 1, slots = 2
 # CHECK-EMPTY:
-# CHECK-NEXT: Index Signature          TYPES                    ABBREV                   LINE                     STR_OFFSETS
-# CHECK-NEXT: ----- ------------------ ------------------------ ------------------------ ------------------------ ------------------------
-# CHECK-NEXT:     1 0x1100001122222222 [0x00001000, 0x00001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040)
+# CHECK-NEXT: Index Signature          TYPES                                    ABBREV                   LINE                     STR_OFFSETS
+# CHECK-NEXT: ----- ------------------ ---------------------------------------- ------------------------ ------------------------ ------------------------
+# CHECK-NEXT:     1 0x1100001122222222 [0x0000000000001000, 0x0000000000001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040)
 
     .section .debug_tu_index, "", @progbits
 ## Header:
     .long 2             # Version
     .long 4             # Section count
     .long 1             # Unit count
     .long 2             # Slot count
 ## Hash Table of Signatures:

llvm/test/DebugInfo/X86/dwp-v5-cu-index.s

 ## The test checks that we can parse and dump a CU index section that is
 ## compliant to the DWARFv5 standard.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-cu-index - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_cu_index contents:
 # CHECK-NEXT: version = 5, units = 1, slots = 2
 # CHECK-EMPTY:
-# CHECK-NEXT: Index Signature          INFO                     ABBREV                   LINE                     LOCLISTS                 STR_OFFSETS              MACRO                    RNGLISTS
-# CHECK-NEXT: ----- ------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------
-# CHECK-NEXT:     1 0x1100001122222222 [0x00001000, 0x00001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040) [0x00005000, 0x00005050) [0x00006000, 0x00006060) [0x00007000, 0x00007070)
+# CHECK-NEXT: Index Signature          INFO                                     ABBREV                   LINE                     LOCLISTS                 STR_OFFSETS              MACRO                    RNGLISTS
+# CHECK-NEXT: ----- ------------------ ---------------------------------------- ------------------------ ------------------------ ------------------------ ------------------------ ------------------------ ------------------------
+# CHECK-NEXT:     1 0x1100001122222222 [0x0000000000001000, 0x0000000000001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040) [0x00005000, 0x00005050) [0x00006000, 0x00006060) [0x00007000, 0x00007070)
 
     .section .debug_cu_index, "", @progbits
 ## Header:
     .short 5            # Version
     .space 2            # Padding
     .long 7             # Section count
     .long 1             # Unit count
     .long 2             # Slot count

llvm/test/DebugInfo/X86/dwp-v5-tu-index.s

 ## The test checks that we can parse and dump a TU index section that is
 ## compliant to the DWARFv5 standard.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o - | \
 # RUN:   llvm-dwarfdump -debug-tu-index - | \
 # RUN:   FileCheck %s
 
 # CHECK:      .debug_tu_index contents:
 # CHECK-NEXT: version = 5, units = 1, slots = 2
 # CHECK-EMPTY:
-# CHECK-NEXT: Index Signature          INFO                     ABBREV                   LINE                     STR_OFFSETS
-# CHECK-NEXT: ----- ------------------ ------------------------ ------------------------ ------------------------ ------------------------
-# CHECK-NEXT:     1 0x1100001122222222 [0x00001000, 0x00001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040)
+# CHECK-NEXT: Index Signature          INFO                                     ABBREV                   LINE                     STR_OFFSETS
+# CHECK-NEXT: ----- ------------------ ---------------------------------------- ------------------------ ------------------------ ------------------------
+# CHECK-NEXT:     1 0x1100001122222222 [0x0000000000001000, 0x0000000000001010) [0x00002000, 0x00002020) [0x00003000, 0x00003030) [0x00004000, 0x00004040)
 
     .section .debug_tu_index, "", @progbits
 ## Header:
     .short 5            # Version
     .space 2            # Padding
     .long 4             # Section count
     .long 1             # Unit count
     .long 2             # Slot count

llvm/test/DebugInfo/dwarfdump-dwp.test

 ; CHECK: Type Unit
 ; CHECK:   DW_TAG_type_unit
 ; CHECK:     DW_AT_stmt_list {{.*}}(0x00000000)
 ; CHECK:     DW_TAG_structure_type
 ; CHECK:       DW_AT_decl_file {{.*}} ("b.cpp")
 
 ; CHECK: .debug_cu_index contents:
 ; CHECK-NEXT: version = 2, units = 2, slots = 16
-; CHECK:      Index Signature          INFO                     ABBREV                   LINE                     STR_OFFSETS
-; CHECK-NEXT: ----- ------------------ ------------------------ ------------------------ ------------------------ ------------------------
-; CHECK-NEXT:     3 0xfef104c25502f092 [0x0000002d, 0x0000005f) [0x00000043, 0x0000008e) [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
-; CHECK-NEXT:     9 0x03c30756e2d45008 [0x00000000, 0x0000002d) [0x00000000, 0x00000043) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
+; CHECK:      Index Signature          INFO                                     ABBREV                   LINE                     STR_OFFSETS
+; CHECK-NEXT: ----- ------------------ ---------------------------------------- ------------------------ ------------------------ ------------------------
+; CHECK-NEXT:     3 0xfef104c25502f092 [0x000000000000002d, 0x000000000000005f) [0x00000043, 0x0000008e) [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
+; CHECK-NEXT:     9 0x03c30756e2d45008 [0x0000000000000000, 0x000000000000002d) [0x00000000, 0x00000043) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
 
 ; CHECK: .debug_tu_index contents:
 ; CHECK-NEXT: version = 2, units = 2, slots = 16
-; CHECK:      Index Signature          TYPES                    ABBREV                   LINE                     STR_OFFSETS
-; CHECK-NEXT: ----- ------------------ ------------------------ ------------------------ ------------------------ ------------------------
-; CHECK-NEXT:     9 0x1d02f3be30cc5688 [0x00000024, 0x00000048) [0x00000043, 0x0000008e) [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
-; CHECK-NEXT:    13 0x3875c0e21cda63fc [0x00000000, 0x00000024) [0x00000000, 0x00000043) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
+; CHECK:      Index Signature          TYPES                                    ABBREV                   LINE                     STR_OFFSETS
+; CHECK-NEXT: ----- ------------------ ---------------------------------------- ------------------------ ------------------------ ------------------------
+; CHECK-NEXT:     9 0x1d02f3be30cc5688 [0x0000000000000024, 0x0000000000000048) [0x00000043, 0x0000008e) [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
+; CHECK-NEXT:    13 0x3875c0e21cda63fc [0x0000000000000000, 0x0000000000000024) [0x00000000, 0x00000043) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
 
 ; TODO: use the index section offset info to correctly dump strings in debug info
 ; TODO: use the index section offset info to correctly dump file names in debug info

llvm/test/tools/llvm-dwp/X86/debug_macro_v5.s

 # This test checks the support for writing macro sections and their index (v5).
 
 # RUN: llvm-mc -triple x86_64-unknown-linux --filetype=obj --split-dwarf-file=%t.dwo -dwarf-version=5 %s -o %t.o
 # RUN: llvm-dwp %t.dwo -o %t.dwp 2>&1
 # RUN: llvm-dwarfdump -debug-macro -debug-cu-index %t.dwp | FileCheck %s
 
 # CHECK-DAG: .debug_macro.dwo contents:
 # CHECK: macro header: version = 0x0005, flags = 0x00, format = DWARF32
 # CHECK-NEXT: DW_MACRO_start_file - lineno: 0 filenum: 0
 # CHECK-NEXT: DW_MACRO_define_strx - lineno: 1 macro: x 5
 # CHECK-NEXT: DW_MACRO_end_file
 
 # CHECK-DAG: .debug_cu_index contents:
 # CHECK-NEXT: version = 5, units = 1, slots = 2
-# CHECK: Index Signature          INFO                     ABBREV                   STR_OFFSETS              MACRO
-# CHECK:     1 0x0000000000000000 [0x00000000, 0x00000019) [0x00000000, 0x00000008) [0x00000000, 0x0000000c) [0x00000000, 0x0000000b)
+# CHECK: Index Signature          INFO                                      ABBREV                   STR_OFFSETS              MACRO
+# CHECK:     1 0x0000000000000000 [0x0000000000000000, 0x0000000000000019) [0x00000000, 0x00000008) [0x00000000, 0x0000000c) [0x00000000, 0x0000000b)
 
     .section  .debug_info.dwo,"e",@progbits
     .long .Ldebug_info_dwo_end0-.Ldebug_info_dwo_start0 # Length of Unit
 .Ldebug_info_dwo_start0:
     .short  5                               # DWARF version number
     .byte 5                               # DWARF Unit Type (DW_UT_split_compile)
     .byte 8                               # Address Size (in bytes)
     .long 0                               # Offset Into Abbrev. Section

llvm/test/tools/llvm-dwp/X86/info-v5.s

 # this checks llvm-dwp handling of DWARFv5 Info section header.
 
 # RUN: llvm-mc --triple=x86_64-unknown-linux --filetype=obj --split-dwarf-file=%t.dwo -dwarf-version=5 %s -o %t.o
 
 # RUN: llvm-dwp %t.dwo -o %t.dwp
 # RUN: llvm-dwarfdump -v %t.dwp | FileCheck %s
 
 #CHECK-DAG: .debug_info.dwo contents:
 #CHECK: 0x00000000: Compile Unit: length = 0x00000050, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_compile, abbr_offset = 0x0000, addr_size = 0x08, DWO_id = [[DWOID:.*]] (next unit at 0x00000054)
 
 # CHECK-DAG: .debug_cu_index contents:
 # CHECK: version = 5, units = 1, slots = 2
-# CHECK: Index Signature          INFO                     ABBREV
-# CHECK: 1 [[DWOID]] [0x00000000, 0x00000054) [0x00000000, 0x0000002a)
+# CHECK: Index Signature          INFO                        ABBREV
+# CHECK: 1 [[DWOID]] [0x0000000000000000, 0x0000000000000054) [0x00000000, 0x0000002a)
 
   .section  .debug_info.dwo,"e",@progbits
   .long .Ldebug_info_dwo_end0-.Ldebug_info_dwo_start0 # Length of Unit
 .Ldebug_info_dwo_start0:
   .short  5                      # DWARF version number
   .byte 5                       # DWARF Unit Type
   .byte 8                       # Address Size (in bytes)
   .long 0                       # Offset Into Abbrev. Section

llvm/test/tools/llvm-dwp/X86/loclists.s

 # CHECK-NEXT: offsets: [
 # CHECK-NEXT: 0x00000004
 # CHECK-NEXT: ]
 # CHECK: DW_LLE_base_addressx   (0x0000000000000000)
 # CHECK-NEXT: DW_LLE_offset_pair     (0x0000000000000000, 0x0000000000000004): DW_OP_reg5 RDI
 # CHECK-NEXT: DW_LLE_offset_pair     (0x0000000000000004, 0x0000000000000008): DW_OP_reg3 RBX
 
 # CHECK-DAG: .debug_cu_index contents:
-# CHECK: Index Signature          INFO                     ABBREV                   LOCLISTS
-# CHECK:     1 {{.*}} [0x00000018, 0x0000002d) [0x00000000, 0x00000004) [0x00000000, 0x0000001d)
+# CHECK: Index Signature          INFO                         ABBREV                   LOCLISTS
+# CHECK:     1 {{.*}} [0x0000000000000018, 0x000000000000002d) [0x00000000, 0x00000004) [0x00000000, 0x0000001d)
 
 # CHECK-DAG: .debug_tu_index contents:
-# CHECK: Index Signature          INFO                     ABBREV                   LOCLISTS
-# CHECK:     2 {{.*}} [0x00000000, 0x00000018) [0x00000000, 0x00000004) [0x00000000, 0x0000001d)
+# CHECK: Index Signature          INFO                         ABBREV                   LOCLISTS
+# CHECK:     2 {{.*}} [0x0000000000000000, 0x0000000000000018) [0x00000000, 0x00000004) [0x00000000, 0x0000001d)
 
   .section  .debug_info.dwo,"e",@progbits
   .long .Ldebug_info_dwo_end0-.Ldebug_info_dwo_start0 # Length of Unit
 .Ldebug_info_dwo_start0:
   .short  5                               # DWARF version number
   .byte 6                               # DWARF Unit Type
   .byte 8                               # Address Size (in bytes)
   .long 0                               # Offset Into Abbrev. Section

llvm/test/tools/llvm-dwp/X86/merge.test

 CHECK-LABEL: Abbrev table for offset:
 CHECK: 0x0000[[CAOFF:.*]]
 CHECK-LABEL: Abbrev table for offset:
 CHECK: 0x0000[[AAOFF:.*]]
 CHECK-LABEL: Abbrev table for offset:
 CHECK: 0x0000[[BAOFF:.*]]
 
 CHECK: .debug_info.dwo contents:
-CHECK: [[COFF:0x[0-9a-f]*]]:
+CHECK: 0x[[#%.8x,COFF:]]:
 CHECK-LABEL: Compile Unit: length = {{.*}}, version = 0x0004, abbr_offset =
-CHECK:         0x[[CAOFF]], addr_size = 0x08 (next unit at [[AOFF:.*]])
+CHECK:         0x[[CAOFF]], addr_size = 0x08 (next unit at 0x[[#%.8x,AOFF:]])
 CHECK:   DW_AT_GNU_dwo_id {{.*}} ([[DWOC:.*]])
-CHECK: [[AOFF]]:
+CHECK: [[#AOFF]]:
 CHECK-LABEL: Compile Unit: length = {{.*}}, version = 0x0004, abbr_offset =
-CHECK:         0x[[AAOFF]], addr_size = 0x08 (next unit at [[BOFF:.*]])
+CHECK:         0x[[AAOFF]], addr_size = 0x08 (next unit at 0x[[#%.8x,BOFF:]])
 CHECK:   DW_AT_GNU_dwo_id {{.*}} ([[DWOA:.*]])
-CHECK: [[BOFF]]:
+CHECK: [[#BOFF]]:
 CHECK-LABEL: Compile Unit: length = {{.*}}, version = 0x0004, abbr_offset =
-CHECK:         0x[[BAOFF]], addr_size = 0x08 (next unit at [[XOFF:.*]])
+CHECK:         0x[[BAOFF]], addr_size = 0x08 (next unit at 0x[[#%.8x,XOFF:]])
 CHECK:   DW_AT_GNU_dwo_id {{.*}} ([[DWOB:.*]])
 
 CHECK-LABEL: .debug_cu_index
-CHECK:    Index  Signature INFO                 ABBREV                             LINE                     STR_OFFSETS
-CHECK-DAG:       [[DWOC]]  [[[COFF]], [[AOFF]]) [0x0000[[CAOFF]], 0x0000[[AAOFF]]) [0x00000000, 0x00000011) [0x00000000, 0x00000018)
-CHECK-DAG:       [[DWOA]]  [[[AOFF]], [[BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000011, 0x00000022) [0x00000018, 0x00000028)
-CHECK-DAG:       [[DWOB]]  [[[BOFF]], [[XOFF]]) [0x0000[[BAOFF]], 0x000000c3)      [0x00000022, 0x00000033) [0x00000028, 0x0000003c)
+CHECK:    Index  Signature INFO                                        ABBREV                             LINE                     STR_OFFSETS
+CHECK-DAG:       [[DWOC]]  [0x00000000[[#COFF]], 0x00000000[[#AOFF]]) [0x0000[[CAOFF]], 0x0000[[AAOFF]]) [0x00000000, 0x00000011) [0x00000000, 0x00000018)
+CHECK-DAG:       [[DWOA]]  [0x00000000[[#AOFF]], 0x00000000[[#BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000011, 0x00000022) [0x00000018, 0x00000028)
+CHECK-DAG:       [[DWOB]]  [0x00000000[[#BOFF]], 0x00000000[[#XOFF]]) [0x0000[[BAOFF]], 0x000000c3)      [0x00000022, 0x00000033) [0x00000028, 0x0000003c)

llvm/test/tools/llvm-dwp/X86/rnglists.s

 # This test checks if llvm-dwp outputs .debug_rnglists.
 
 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o \
 # RUN:         -split-dwarf-file=%t.dwo -dwarf-version=5
 # RUN: llvm-dwp %t.dwo -o %t.dwp
 # RUN: llvm-dwarfdump -debug-rnglists -debug-cu-index -debug-tu-index %t.dwp | FileCheck %s
 
 # CHECK-DAG: .debug_cu_index contents:
-# CHECK: Index Signature          INFO                     ABBREV                   RNGLISTS
-# CHECK:     1 {{.*}} [0x00000018, 0x0000002d) [0x00000000, 0x00000004) [0x00000000, 0x00000017)
+# CHECK: Index Signature          INFO                         ABBREV                   RNGLISTS
+# CHECK:     1 {{.*}} [0x0000000000000018, 0x000000000000002d) [0x00000000, 0x00000004) [0x00000000, 0x00000017)
 
 # CHECK-DAG: .debug_tu_index contents:
-# CHECK: Index Signature          INFO                     ABBREV                   RNGLISTS
-# CHECK:     2 {{.*}} [0x00000000, 0x00000018) [0x00000000, 0x00000004) [0x00000000, 0x00000017)
+# CHECK: Index Signature          INFO                         ABBREV                   RNGLISTS
+# CHECK:     2 {{.*}} [0x0000000000000000, 0x0000000000000018) [0x00000000, 0x00000004) [0x00000000, 0x00000017)
 
 # CHECK-DAG: .debug_rnglists.dwo contents:
 # range list header: length = 0x00000013, format = DWARF32, version = 0x0005, addr_size = 0x08, seg_size = 0x00, offset_entry_count = 0x00000001
 # CHECK: offsets: [
 # CHECK-NEXT: 0x00000004
 # CHECK-NEXT: ]
 # CHECK-NEXT: ranges:
 # CHECK-NEXT: [0x0000000000000004, 0x0000000000000008)

llvm/test/tools/llvm-dwp/X86/simple.test

 CHECK-LABEL: Abbrev table for offset:
 CHECK: 0x0000[[BAOFF:.*]]
 CHECK: DW_TAG_compile_unit
 CHECK: DW_TAG_structure_type
 CHECK: DW_TAG_subprogram
 CHECK: DW_TAG_formal_parameter
 
 CHECK: .debug_info.dwo contents:
-CHECK: [[AOFF:0x[0-9a-f]*]]:
+CHECK: 0x[[#%.8x,AOFF:]]:
 CHECK-LABEL: Compile Unit: length = {{.*}}, version = 0x0004, abbr_offset =
-CHECK:         0x[[AAOFF]], addr_size = 0x08 (next unit at [[BOFF:.*]])
+CHECK:         0x[[AAOFF]], addr_size = 0x08 (next unit at 0x[[#%.8x,BOFF:]])
 CHECK: DW_TAG_compile_unit
 CHECK:   DW_AT_name {{.*}} "a.cpp"
 CHECK:   DW_AT_GNU_dwo_id {{.*}} ([[DWOA:.*]])
 CHECK:   DW_TAG_variable
 CHECK:     DW_AT_name {{.*}} "a"
 CHECK:   DW_TAG_structure_type
 NOTYP:     DW_AT_name {{.*}} "foo"
 TYPES:     DW_AT_signature {{.*}} ([[FOOSIG:.*]])
 
-CHECK: [[BOFF]]:
+CHECK: 0x[[#BOFF]]:
 CHECK-LABEL: Compile Unit: length = {{.*}}, version = 0x0004, abbr_offset =
-CHECK:         0x[[BAOFF]], addr_size = 0x08 (next unit at [[XOFF:.*]])
+CHECK:         0x[[BAOFF]], addr_size = 0x08 (next unit at 0x[[#%.8x,XOFF:]])
 CHECK:   DW_AT_name {{.*}} "b.cpp"
 CHECK:   DW_AT_GNU_dwo_id {{.*}} ([[DWOB:.*]])
 CHECK:   DW_TAG_structure_type
 NOTYP:     DW_AT_name {{.*}} "bar"
 TYPES:     DW_AT_signature {{.*}} ([[BARSIG:.*]])
 CHECK:   DW_TAG_subprogram
 CHECK:     DW_AT_name {{.*}} "b"
 CHECK:     DW_TAG_formal_parameter
 
 NOTYP-NOT: .debug_types.dwo contents:
 TYPES-LABEL: .debug_types.dwo contents:
-TYPES: [[FOOUOFF:0x[0-9a-f]*]]:
+TYPES: 0x[[#%.8x,FOOUOFF:]]:
 TYPES-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
-TYPES:         0x[[AAOFF]], addr_size = 0x08, name = 'foo', type_signature = [[FOOSIG]], type_offset = 0x[[FOOOFF:.*]] (next unit at [[BARUOFF:.*]])
+TYPES:         0x[[AAOFF]], addr_size = 0x08, name = 'foo', type_signature = [[FOOSIG]], type_offset = 0x[[FOOOFF:.*]] (next unit at 0x[[#%.8x,BARUOFF:]])
 TYPES:             DW_TAG_type_unit
 TYPES: [[FOOOFF]]:   DW_TAG_structure_type
 TYPES:                 DW_AT_name {{.*}} "foo"
-TYPES: [[BARUOFF]]:
+TYPES: 0x[[#BARUOFF]]:
 TYPES-LABEL: Type Unit: length = 0x00000020, format = DWARF32, version = 0x0004, abbr_offset =
-TYPES:         0x[[BAOFF]], addr_size = 0x08, name = 'bar', type_signature = [[BARSIG]], type_offset = 0x001e (next unit at [[XUOFF:.*]])
+TYPES:         0x[[BAOFF]], addr_size = 0x08, name = 'bar', type_signature = [[BARSIG]], type_offset = 0x001e (next unit at 0x[[#%.8x,XUOFF:]])
 TYPES:             DW_TAG_type_unit
 TYPES: 0x00000042:   DW_TAG_structure_type
 TYPES:                 DW_AT_name {{.*}} "bar"
 
 CHECK-LABEL: .debug_cu_index contents:
-CHECK: Index Signature INFO                 ABBREV                             LINE                     STR_OFFSETS
-TYPES:     1 [[DWOA]]  [[[AOFF]], [[BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
-TYPES:     3 [[DWOB]]  [[[BOFF]], [[XOFF]]) [0x0000[[BAOFF]], 0x00000099)      [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
-NOTYP:     3 [[DWOA]]  [[[AOFF]], [[BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x00000011) [0x00000000, 0x00000010)
-NOTYP:     4 [[DWOB]]  [[[BOFF]], [[XOFF]]) [0x0000[[BAOFF]], 0x00000075)      [0x00000011, 0x00000022) [0x00000010, 0x00000024)
+CHECK: Index Signature INFO                                       ABBREV                             LINE                     STR_OFFSETS
+TYPES:     1 [[DWOA]]  [0x00000000[[#AOFF]], 0x00000000[[#BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
+TYPES:     3 [[DWOB]]  [0x00000000[[#BOFF]], 0x00000000[[#XOFF]]) [0x0000[[BAOFF]], 0x00000099)      [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
+NOTYP:     3 [[DWOA]]  [0x00000000[[#AOFF]], 0x00000000[[#BOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x00000011) [0x00000000, 0x00000010)
+NOTYP:     4 [[DWOB]]  [0x00000000[[#BOFF]], 0x00000000[[#XOFF]]) [0x0000[[BAOFF]], 0x00000075)      [0x00000011, 0x00000022) [0x00000010, 0x00000024)
 
 Ensure we do not create a debug_tu_index, even an empty or malformed one.
 NOTYPOBJ-NOT: .debug_tu_index
 
-TYPES: Index Signature  TYPES                      ABBREV                             LINE                     STR_OFFSETS
-TYPES:     1 [[FOOSIG]] [[[FOOUOFF]], [[BARUOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
-TYPES:     4 [[BARSIG]] [[[BARUOFF]], [[XUOFF]])   [0x0000[[BAOFF]], 0x00000099)      [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
+TYPES: Index Signature  TYPES                                          ABBREV                             LINE                     STR_OFFSETS
+TYPES:     1 [[FOOSIG]] [0x00000000[[#FOOUOFF]], 0x00000000[[#BARUOFF]]) [0x0000[[AAOFF]], 0x0000[[BAOFF]]) [0x00000000, 0x0000001a) [0x00000000, 0x00000010)
+TYPES:     4 [[BARSIG]] [0x00000000[[#BARUOFF]], 0x00000000[[#XUOFF]])   [0x0000[[BAOFF]], 0x00000099)      [0x0000001a, 0x00000034) [0x00000010, 0x00000024)
 
 CHECK-LABEL: .debug_str.dwo contents:
 CHECK: "clang version
 CHECK: 0x[[ACPP:.*]]: "a.cpp"
 CHECK-NOT: "clang version
 CHECK: 0x[[BCPP:.*]]: "b.cpp"
 
 CHECK-LABEL: .debug_str_offsets.dwo contents:
 CHECK: : 00000000
 CHECK: : [[ACPP]]
 CHECK: : 00000000
 CHECK: : [[BCPP]]

llvm/test/tools/llvm-dwp/X86/tu_units_v5.s

 # This test checks if llvm-dwp can correctly generate the tu index section (v5).
 
 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o \
 # RUN:         -split-dwarf-file=%t.dwo -dwarf-version=5
 # RUN: llvm-dwp %t.dwo -o %t.dwp
 # RUN: llvm-dwarfdump -debug-info -debug-tu-index %t.dwp | FileCheck %s
 
 ## Note: In order to check whether the type unit index is generated
 ## there is no need to add the missing DIEs for the structure type of the type unit.
 
 # CHECK-DAG: .debug_info.dwo contents:
 # CHECK: 0x00000000: Type Unit: length = 0x00000017, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_type, abbr_offset = 0x0000, addr_size = 0x08, name = '', type_signature = [[TUID1:.*]], type_offset = 0x0019 (next unit at 0x0000001b)
 # CHECK: 0x0000001b: Type Unit: length = 0x00000017, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_type, abbr_offset = 0x0000, addr_size = 0x08, name = '', type_signature = [[TUID2:.*]], type_offset = 0x0019 (next unit at 0x00000036)
 # CHECK-DAG: .debug_tu_index contents:
 # CHECK: version = 5, units = 2, slots = 4
-# CHECK: Index Signature          INFO                     ABBREV
-# CHECK:     1 [[TUID1]]          [0x00000000, 0x0000001b) [0x00000000, 0x00000010)
-# CHECK:     4 [[TUID2]]          [0x0000001b, 0x00000036) [0x00000000, 0x00000010)
+# CHECK: Index Signature          INFO                                     ABBREV
+# CHECK:     1 [[TUID1]]          [0x0000000000000000, 0x000000000000001b) [0x00000000, 0x00000010)
+# CHECK:     4 [[TUID2]]          [0x000000000000001b, 0x0000000000000036) [0x00000000, 0x00000010)
 
     .section  .debug_info.dwo,"e",@progbits
     .long .Ldebug_info_dwo_end0-.Ldebug_info_dwo_start0 # Length of Unit
 .Ldebug_info_dwo_start0:
     .short  5                               # DWARF version number
     .byte 6                               # DWARF Unit Type (DW_UT_split_type)
     .byte 8                               # Address Size (in bytes)
     .long 0                               # Offset Into Abbrev. Section

llvm/test/tools/llvm-dwp/X86/unknown-section-id.s

 ## Check that all known sections are preserved and no data for unknown section
 ## identifiers is copied.
 
 # CHECK:      .debug_cu_index contents:
 # CHECK-NEXT: version = 2, units = 1, slots = 2
 # CHECK:      Index Signature INFO ABBREV
 # CHECK-NOT:  Unknown
 # CHECK:      -----
-# CHECK-NEXT: 1 0x1100002222222222 [0x00000000, 0x00000014) [0x00000000, 0x00000009)
+# CHECK-NEXT: 1 0x1100002222222222 [0x0000000000000000, 0x0000000000000014) [0x00000000, 0x00000009)
 # CHECK-NOT:  [
 
 # CHECK:      .debug_tu_index contents:
 # CHECK-NEXT: version = 2, units = 1, slots = 2
 # CHECK:      Index Signature TYPES ABBREV
 # CHECK-NOT:  Unknown
 # CHECK:      -----
-# CHECK-NEXT: 2 0x1100003333333333 [0x00000000, 0x00000019) [0x00000009, 0x00000014)
+# CHECK-NEXT: 2 0x1100003333333333 [0x0000000000000000, 0x0000000000000019) [0x00000009, 0x00000014)
 # CHECK-NOT:  [
 
 .section .debug_abbrev.dwo, "e", @progbits
 .LCUAbbrevBegin:
     .uleb128 1                              # Abbreviation Code
     .uleb128 0x11                           # DW_TAG_compile_unit
     .byte 0                                 # DW_CHILDREN_no
     .uleb128 0x2131                         # DW_AT_GNU_dwo_id