[llvm-dwp] Adding support for v5 index writing

[kimanh]

Summary

This patch adds general support for DWARFv5 index writing.
In particular, this means only allowing inputs with one version,
either DWARFv5 or DWARFv4.

This patch adds the .debug_macro section as an example,
but the DWARFv5 type support and loc and rangelists are still
missing (and upcoming).

[kimanh]

Hello Dave,

this is the second CL (out of 3): adding support for writing v5 index with the example of .debug_macro, ptal!

[dblaikie]

Looks OK - though honestly lots of this code (that I wrote) could use a bunch of refactoring, comments, smaller/more self-documenting functions, etc.

llvm/tools/llvm-dwp/llvm-dwp.cpp

704–705

A comment describing what this does would be handy

[kimanh]

Rebase to trigger premerge bots.

[kimanh]

Add missing comment for addressing review.

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)
+
+    .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
+    .quad 0
+    .byte 1                               # Abbrev [1] 0x14:0x5 DW_TAG_compile_unit
+    .long 0                               # DW_AT_macros
+.Ldebug_info_dwo_end0:
+    .section  .debug_macro.dwo,"e",@progbits
+    .short  5                               # Macro information version
+    .byte 0                               # Flags: 32 bit
+    .byte 3                               # DW_MACRO_start_file
+    .byte 0                               # Line Number
+    .byte 0                               # File Number
+    .byte 11                              # DW_MACRO_define_strx
+    .byte 1                               # Line Number
+    .byte 0                               # Macro String
+    .byte 4                               # DW_MACRO_end_file
+    .byte 0                               # End Of Macro List Mark
+    .section  .debug_abbrev.dwo,"e",@progbits
+    .byte 1                               # Abbreviation Code
+    .byte 17                              # DW_TAG_compile_unit
+    .byte 0                               # DW_CHILDREN_no
+    .byte 121                             # DW_AT_macros
+    .byte 23                              # DW_FORM_sec_offset
+    .byte 0                               # EOM(1)
+    .byte 0                               # EOM(2)
+    .byte 0                               # EOM(3)
+    .section  .debug_str.dwo,"eMS",@progbits,1
+    .asciz  "x 5"                           # string offset=0
+    .section  .debug_str_offsets.dwo,"e",@progbits
+    .long 8                            # Length of String Offsets Set
+    .short  5
+    .short  0
+  .long 0

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

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.dwp
 # RUN: not llvm-dwp %t.dwp -o %t 2>&1 | FileCheck %s
 
-# CHECK: error: unsupported cu_index version: 5 (only version 2 is supported)
+# CHECK: error: incompatible cu_index versions, found 2 and expecting 5
     .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 5                        # DWARF Unit type (DW_UT_split_compile)
     .byte 8                        # Address Size (in bytes)
     .long 0                        # Offset Into Abbrev. Section
     .quad -346972125991005518
+    .byte 0                               # Abbrev [9] 0xb:0x37 DW_TAG_compile_unit
 .Ldebug_info_dwo_end0:
     .section .debug_cu_index, "", @progbits
 ## Header:
-    .short 5                        # Version
+    .short 2                        # Version
     .space 2                        # Padding
     .long 2                         # Section count
     .long 1                         # Unit count
     .long 2                         # Slot count
 ## Hash Table of Signatures:
     .quad 0x1100001122222222
     .quad 0
 ## Parallel Table of Indexes:

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 = 2, units = 1, slots = 2
+# CHECK: version = 5, units = 1, slots = 2
 # CHECK: Index Signature          INFO                     ABBREV
 # CHECK: 1 [[DWOID]] [0x00000000, 0x00000054) [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

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

 # RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.dwp
 # RUN: not llvm-dwp %t.dwp -o %t 2>&1 | FileCheck %s
 
 ## Note: To reach the test point, we need a DWP file with a CU, a CU index
 ## of version 2 and a TU index of version 5. A valid TU is not required, but
 ## the .debug_types.dwo section should not be empty.
 
-# CHECK: error: unsupported tu_index version: 5 (only version 2 is supported)
+# CHECK: error: expected index version 2, but got: 5
 
 .section .debug_abbrev.dwo, "e", @progbits
 .LAbbrevBegin:
     .uleb128 1                      # Abbreviation Code
     .uleb128 17                     # DW_TAG_compile_unit
     .byte 1                         # DW_CHILDREN_no
     .uleb128 0x2131                 # DW_AT_GNU_dwo_id
     .uleb128 7                      # DW_FORM_data8

llvm/tools/llvm-dwp/llvm-dwp.cpp

parseInfoSectionUnitHeader(StringRef Info) {
   Header.HeaderSize = Offset;
   return Header;
 }
 
 static void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
                                    MCSection *StrOffsetSection,
                                    StringRef CurStrSection,
                                    StringRef CurStrOffsetSection,
-                                   const InfoSectionUnitHeader &Header) {
+                                   uint16_t Version) {
   // Could possibly produce an error or warning if one of these was non-null but
   // the other was null.
   if (CurStrSection.empty() || CurStrOffsetSection.empty())
     return;
 
   DenseMap<uint64_t, uint32_t> OffsetRemapping;
 
   DataExtractor Data(CurStrSection, true, 0);
   uint64_t LocalOffset = 0;
   uint64_t PrevOffset = 0;
   while (const char *s = Data.getCStr(&LocalOffset)) {
     OffsetRemapping[PrevOffset] =
         Strings.getOffset(s, LocalOffset - PrevOffset);
     PrevOffset = LocalOffset;
   }
 
   Data = DataExtractor(CurStrOffsetSection, true, 0);
 
   Out.SwitchSection(StrOffsetSection);
 
-  uint64_t HeaderSize = debugStrOffsetsHeaderSize(Data, Header.Version);
+  uint64_t HeaderSize = debugStrOffsetsHeaderSize(Data, Version);
   uint64_t Offset = 0;
   uint64_t Size = CurStrOffsetSection.size();
   // FIXME: This can be caused by bad input and should be handled as such.
   assert(HeaderSize <= Size && "StrOffsetSection size is less than its header");
   // Copy the header to the output.
   Out.emitBytes(Data.getBytes(&Offset, HeaderSize));
   while (Offset < Size) {
     auto OldOffset = Data.getU32(&Offset);

 };
 
 static bool isSupportedSectionKind(DWARFSectionKind Kind) {
   return Kind != DW_SECT_EXT_unknown;
 }
 
 // Convert an internal section identifier into the index to use with
 // UnitIndexEntry::Contributions.
-static unsigned getContributionIndex(DWARFSectionKind Kind) {
-  // Assuming the pre-standard DWP format.
-  assert(serializeSectionKind(Kind, 2) >= DW_SECT_INFO);
-  return serializeSectionKind(Kind, 2) - DW_SECT_INFO;
+static unsigned getContributionIndex(DWARFSectionKind Kind,
+                                     uint32_t IndexVersion) {
+  assert(serializeSectionKind(Kind, IndexVersion) >= DW_SECT_INFO);
+  return serializeSectionKind(Kind, IndexVersion) - DW_SECT_INFO;
 }
 
 // Convert a UnitIndexEntry::Contributions index to the corresponding on-disk
 // value of the section identifier.
 static unsigned getOnDiskSectionId(unsigned Index) {
   return Index + DW_SECT_INFO;
 }
 
for (const DWARFUnitIndex::Entry &E : TUIndex.getRows()) {
     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)];
+      auto &C =
+          Entry.Contributions[getContributionIndex(Kind, TUIndex.getVersion())];
       C.Offset += I->Offset;
       C.Length = I->Length;
       ++I;
     }
-    unsigned TypesIndex = getContributionIndex(DW_SECT_EXT_TYPES);
+    unsigned TypesIndex =
+        getContributionIndex(DW_SECT_EXT_TYPES, TUIndex.getVersion());
     auto &C = Entry.Contributions[TypesIndex];
     Out.emitBytes(Types.substr(
         C.Offset - TUEntry.Contributions[TypesIndex].Offset, C.Length));
     C.Offset = TypesOffset;
     TypesOffset += C.Length;
   }
 }
 
 static void addAllTypes(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)];
+      auto &C = Entry.Contributions[getContributionIndex(DW_SECT_EXT_TYPES, 2)];
       C.Offset = TypesOffset;
       auto PrevOffset = Offset;
       // Length of the unit, including the 4 byte length field.
       C.Length = Data.getU32(&Offset) + 4;
 
       Data.getU16(&Offset); // Version
       Data.getU32(&Offset); // Abbrev offset
       Data.getU8(&Offset);  // Address size
writeIndexTable(MCStreamer &Out, ArrayRef<unsigned> ContributionOffsets,
                 const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
                 uint32_t DWARFUnitIndex::Entry::SectionContribution::*Field) {
   for (const auto &E : IndexEntries)
     for (size_t i = 0; i != array_lengthof(E.second.Contributions); ++i)
       if (ContributionOffsets[i])
         Out.emitIntValue(E.second.Contributions[i].*Field, 4);
 }
 
-static void
-writeIndex(MCStreamer &Out, MCSection *Section,
+static void writeIndex(MCStreamer &Out, MCSection *Section,
                        ArrayRef<unsigned> ContributionOffsets,
-           const MapVector<uint64_t, UnitIndexEntry> &IndexEntries) {
+                       const MapVector<uint64_t, UnitIndexEntry> &IndexEntries,
+                       uint32_t IndexVersion) {
   if (IndexEntries.empty())
     return;
 
   unsigned Columns = 0;
   for (auto &C : ContributionOffsets)
     if (C)
       ++Columns;
 
while (Buckets[H]) {
              "Duplicate unit");
       H = (H + HP) & Mask;
     }
     Buckets[H] = i + 1;
     ++i;
   }
 
   Out.SwitchSection(Section);
-  Out.emitIntValue(2, 4);                   // Version
+  Out.emitIntValue(IndexVersion, 4);        // Version
   Out.emitIntValue(Columns, 4);             // Columns
   Out.emitIntValue(IndexEntries.size(), 4); // Num Units
   Out.emitIntValue(Buckets.size(), 4);      // Num Buckets
 
   // Write the signatures.
   for (const auto &I : Buckets)
     Out.emitIntValue(I ? IndexEntries.begin()[I - 1].first : 0, 8);
 
static Error handleSection(
     const MCSection *TypesSection, const MCSection *CUIndexSection,
     const MCSection *TUIndexSection, const MCSection *InfoSection,
     const SectionRef &Section, MCStreamer &Out,
     std::deque<SmallString<32>> &UncompressedSections,
     uint32_t (&ContributionOffsets)[8], UnitIndexEntry &CurEntry,
     StringRef &CurStrSection, StringRef &CurStrOffsetSection,
     std::vector<StringRef> &CurTypesSection,
     std::vector<StringRef> &CurInfoSection, StringRef &AbbrevSection,
-    StringRef &CurCUIndexSection, StringRef &CurTUIndexSection) {
+    StringRef &CurCUIndexSection, StringRef &CurTUIndexSection,
+    std::vector<std::pair<DWARFSectionKind, uint32_t>> &SectionLength) {
   if (Section.isBSS())
     return Error::success();
 
   if (Section.isVirtual())
     return Error::success();
 
   Expected<StringRef> NameOrErr = Section.getName();
   if (!NameOrErr)
static Error handleSection(
 
   Name = Name.substr(Name.find_first_not_of("._"));
 
   auto SectionPair = KnownSections.find(Name);
   if (SectionPair == KnownSections.end())
     return Error::success();
 
   if (DWARFSectionKind Kind = SectionPair->second.second) {
-    auto Index = getContributionIndex(Kind);
     if (Kind != DW_SECT_EXT_TYPES && Kind != DW_SECT_INFO) {
-      CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
-      ContributionOffsets[Index] +=
-          (CurEntry.Contributions[Index].Length = Contents.size());
+      SectionLength.push_back(std::make_pair(Kind, Contents.size()));
     }
 
     if (Kind == DW_SECT_ABBREV) {
       AbbrevSection = Contents;
     }
   }
 
   MCSection *OutSection = SectionPair->second.first;
static Error write(MCStreamer &Out, ArrayRef<std::string> Inputs) {
   MCSection *const InfoSection = MCOFI.getDwarfInfoDWOSection();
   const StringMap<std::pair<MCSection *, DWARFSectionKind>> KnownSections = {
       {"debug_info.dwo", {InfoSection, DW_SECT_INFO}},
       {"debug_types.dwo", {MCOFI.getDwarfTypesDWOSection(), DW_SECT_EXT_TYPES}},
       {"debug_str_offsets.dwo", {StrOffsetSection, DW_SECT_STR_OFFSETS}},
       {"debug_str.dwo", {StrSection, static_cast<DWARFSectionKind>(0)}},
       {"debug_loc.dwo", {MCOFI.getDwarfLocDWOSection(), DW_SECT_EXT_LOC}},
       {"debug_line.dwo", {MCOFI.getDwarfLineDWOSection(), DW_SECT_LINE}},
+      {"debug_macro.dwo", {MCOFI.getDwarfMacroDWOSection(), DW_SECT_MACRO}},
       {"debug_abbrev.dwo", {MCOFI.getDwarfAbbrevDWOSection(), DW_SECT_ABBREV}},
       {"debug_cu_index", {CUIndexSection, static_cast<DWARFSectionKind>(0)}},
       {"debug_tu_index", {TUIndexSection, static_cast<DWARFSectionKind>(0)}}};
 
   MapVector<uint64_t, UnitIndexEntry> IndexEntries;
   MapVector<uint64_t, UnitIndexEntry> TypeIndexEntries;
 
   uint32_t ContributionOffsets[8] = {};
+  uint16_t Version = 0;
+  uint32_t IndexVersion = 0;
 
   DWPStringPool Strings(Out, StrSection);
 
   SmallVector<OwningBinary<object::ObjectFile>, 128> Objects;
   Objects.reserve(Inputs.size());
 
   std::deque<SmallString<32>> UncompressedSections;
 
for (const auto &Input : Inputs) {
     StringRef CurStrSection;
     StringRef CurStrOffsetSection;
     std::vector<StringRef> CurTypesSection;
     std::vector<StringRef> CurInfoSection;
     StringRef AbbrevSection;
     StringRef CurCUIndexSection;
     StringRef CurTUIndexSection;
 
+    // This maps each section contained in this file to its length.
+    // This information is later on used to calculate the contributions,
+    // i.e. offset and length, of each compile/type unit to a section.
+    std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength;
+
     for (const auto &Section : Obj.sections())
       if (auto Err = handleSection(
               KnownSections, StrSection, StrOffsetSection, TypesSection,
               CUIndexSection, TUIndexSection, InfoSection, Section, Out,
               UncompressedSections, ContributionOffsets, CurEntry,
               CurStrSection, CurStrOffsetSection, CurTypesSection,
               CurInfoSection, AbbrevSection, CurCUIndexSection,
-              CurTUIndexSection))
+              CurTUIndexSection, SectionLength))
         return Err;
 
     if (CurInfoSection.empty())
       continue;
 
     Expected<InfoSectionUnitHeader> HeaderOrErr =
         parseInfoSectionUnitHeader(CurInfoSection.front());
     if (!HeaderOrErr)
       return HeaderOrErr.takeError();
     InfoSectionUnitHeader &Header = *HeaderOrErr;
 
+    if (Version == 0) {
+      Version = Header.Version;
+      IndexVersion = Version < 5 ? 2 : 5;
+    } else if (Version != Header.Version) {
+      return make_error<DWPError>("incompatible DWARF compile unit versions.");
+    }
+
     writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
-                           CurStrOffsetSection, Header);
+                           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);
+    }
 
     uint32_t &InfoSectionOffset =
-        ContributionOffsets[getContributionIndex(DW_SECT_INFO)];
+        ContributionOffsets[getContributionIndex(DW_SECT_INFO, IndexVersion)];
     if (CurCUIndexSection.empty()) {
       bool FoundCUUnit = false;
       Out.SwitchSection(InfoSection);
       for (StringRef Info : CurInfoSection) {
         if (FoundCUUnit)
           break;
         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)];
+          auto &C = Entry.Contributions[getContributionIndex(DW_SECT_INFO,
+                                                             IndexVersion)];
           C.Offset = InfoSectionOffset;
           C.Length = Header.Length + 4;
 
           if (Header.Version < 5 ||
               Header.UnitType == dwarf::DW_UT_split_compile) {
             Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
                 Header, AbbrevSection, Info.substr(UnitOffset, C.Length),
                 CurStrOffsetSection, CurStrSection);
if (CurCUIndexSection.empty()) {
           }
           UnitOffset += Header.Length + 4;
         }
       }
 
       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.
-      addAllTypes(Out, TypeIndexEntries, TypesSection, CurTypesSection,
-                  CurEntry,
-                  ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES)]);
-
+        addAllTypes(
+            Out, TypeIndexEntries, TypesSection, CurTypesSection, CurEntry,
+            ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)]);
+      }
       continue;
     }
 
     if (CurInfoSection.size() != 1)
       return make_error<DWPError>("expected exactly one occurrence of a debug "
                                   "info section in a .dwp file");
     StringRef DwpSingleInfoSection = CurInfoSection.front();
 
     DWARFUnitIndex CUIndex(DW_SECT_INFO);
     DataExtractor CUIndexData(CurCUIndexSection, Obj.isLittleEndian(), 0);
     if (!CUIndex.parse(CUIndexData))
       return make_error<DWPError>("failed to parse cu_index");
-    if (CUIndex.getVersion() != 2)
-      return make_error<DWPError>(
-          "unsupported cu_index version: " + utostr(CUIndex.getVersion()) +
-          " (only version 2 is supported)");
+    if (CUIndex.getVersion() != IndexVersion)
+      return make_error<DWPError>("incompatible cu_index versions, found " +
+                                  utostr(CUIndex.getVersion()) +
+                                  " and expecting " + utostr(IndexVersion));
 
     Out.SwitchSection(InfoSection);
     for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
       auto *I = E.getContributions();
       if (!I)
         continue;
       auto P = IndexEntries.insert(std::make_pair(E.getSignature(), CurEntry));
       StringRef CUInfoSection =
for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
         return buildDuplicateError(*P.first, ID, Input);
       auto &NewEntry = P.first->second;
       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)];
+        auto &C =
+            NewEntry.Contributions[getContributionIndex(Kind, IndexVersion)];
         C.Offset += I->Offset;
         C.Length = I->Length;
         ++I;
       }
-      unsigned Index = getContributionIndex(DW_SECT_INFO);
+      unsigned Index = getContributionIndex(DW_SECT_INFO, IndexVersion);
       auto &C = NewEntry.Contributions[Index];
       Out.emitBytes(CUInfoSection);
       C.Offset = InfoSectionOffset;
       InfoSectionOffset += C.Length;
     }
 
     if (!CurTypesSection.empty()) {
       if (CurTypesSection.size() != 1)
         return make_error<DWPError>("multiple type unit sections in .dwp file");
       DWARFUnitIndex TUIndex(DW_SECT_EXT_TYPES);
       DataExtractor TUIndexData(CurTUIndexSection, Obj.isLittleEndian(), 0);
       if (!TUIndex.parse(TUIndexData))
         return make_error<DWPError>("failed to parse tu_index");
       if (TUIndex.getVersion() != 2)
-        return make_error<DWPError>(
-            "unsupported tu_index version: " + utostr(TUIndex.getVersion()) +
-            " (only version 2 is supported)");
+        return make_error<DWPError>("expected index version 2, but got: " +
+                                    utostr(TUIndex.getVersion()));
 
       addAllTypesFromDWP(
           Out, TypeIndexEntries, TUIndex, TypesSection, CurTypesSection.front(),
           CurEntry,
-          ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES)]);
+          ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)]);
     }
   }
 
+  if (Version < 5) {
     // Lie about there being no info contributions so the TU index only includes
-  // the type unit contribution
+    // the type unit contribution for DWARF < 5. In DWARFv5 the TU index has a
+    // contribution to the info section, so we do not want to lie about it.
     ContributionOffsets[0] = 0;
+  }
   writeIndex(Out, MCOFI.getDwarfTUIndexSection(), ContributionOffsets,
-             TypeIndexEntries);
+             TypeIndexEntries, IndexVersion);
 
-  // Lie about the type contribution
-  ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES)] = 0;
+  if (Version < 5) {
+    // Lie about the type contribution for DWARF < 5. In DWARFv5 the type
+    // section does not exist, so no need to do anything about this.
+    ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES, 2)] = 0;
     // Unlie about the info contribution
     ContributionOffsets[0] = 1;
+  }
 
   writeIndex(Out, MCOFI.getDwarfCUIndexSection(), ContributionOffsets,
-             IndexEntries);
+             IndexEntries, IndexVersion);
 
   return Error::success();
 }
 
 static int error(const Twine &Error, const Twine &Context) {
   errs() << Twine("while processing ") + Context + ":\n";
   errs() << Twine("error: ") + Error + "\n";
   return 1;