[llvm-dwp] Add support for DWARFv5 type units ...

[kimanh]

Summary

This patch adds support for DWARFv5 type units: parsing from
the .debug_info section, and writing index to the type unit index.
Previously, the type units were part of the .debug_types section
which is no longer used in DWARFv5.

[kimanh]

Updated comment, and added extra output check to test.

[kimanh]

Update variable name (clang-tidy).

[dblaikie]

I think maybe combining the new index support with TU support might be complicating this patch a bit more than ideal - maybe pulling the new index support into a separate patch would be good (perhaps the new-in-v5 debug_macro section could be used to demonstrate that the v5 index is being used)

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

14–16

Could you fix the alignment so these fields line up with their headers?

56

Please add the newline at the end here

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

2

Might be worth a bit more detail somewhere in here that explains that the DWARF in this test is a bit bogus (two TUs with the same signature in the same input file - and TUs with invalid DIE offsets/no DIEs in the unit) but good enough for dwp.

Hmm, maybe it isn't good enough for dumping, though - I'd expect this still to produce some errors about missing DIEs in the dwarfdump?

16

Might be nice to include which unit type this is in the comment - improvements to llvm's verbose asm output to do this automatically would be great. (but you can add it by hand here too/instead)

[kimanh]

Splitting up CLs, addressing feedback.

[kimanh]

Some cleanup.

[kimanh]

Thanks a lot for the review!

I have split up the original CL into three (dependent) CLs now:

1. Making llvm-dwp aware of multiple debug info sections (as a preparation to further support DWARFv5 dwos and type units) https://reviews.llvm.org/D102312
2. Support reading and writing v5 index https://reviews.llvm.org/D102315
3. (this CL) add type unit support

I hope it's easier to review this way. The other CL for rnglists and loclists support (https://reviews.llvm.org/D101894) is dependent on this CL.

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

2

Yes you were right, that it would not be fine for dumping.

I have updated the test to actually use two separate files now, and added more information for dumping to at least not produce errors on not being able to parse the type unit.

16

I have added info on that manually now.

[dblaikie]

Looks alright, thanks!

[kimanh]

Rebase and upload to trigger premerge checks.

llvm/test/tools/llvm-dwp/Inputs/incompatible_versions/v4.s

+  .section  .debug_str.dwo,"eMS",@progbits,1
+.Linfo_string0:
+  .asciz  "main"                          # string offset=0
+  .section  .debug_info.dwo,"e",@progbits
+  .long .Ldebug_info_dwo_end1-.Ldebug_info_dwo_start1 # Length of Unit
+.Ldebug_info_dwo_start1:
+  .short  4                               # DWARF version number
+  .long 0                               # Offset Into Abbrev. Section
+  .byte 8                               # Address Size (in bytes)
+  .byte 9                               # Abbrev [9] 0xb:0x37 DW_TAG_compile_unit
+.Ldebug_info_dwo_end1:
+  .section  .debug_abbrev.dwo,"e",@progbits
+  .byte 9                               # Abbreviation Code
+  .byte 17                              # DW_TAG_compile_unit
+  .byte 1                               # DW_CHILDREN_yes
+  .byte 3                               # DW_AT_name
+  .ascii  "\202>"                         # DW_FORM_GNU_str_index
+  .ascii  "\261B"                         # DW_AT_GNU_dwo_id

llvm/test/tools/llvm-dwp/Inputs/incompatible_versions/v5.s

+  .section  .debug_info.dwo,"e",@progbits
+  .long .Ldebug_info_dwo_end1-.Ldebug_info_dwo_start1 # Length of Unit
+.Ldebug_info_dwo_start1:
+  .short  5                               # DWARF version number
+  .byte 5                               # DWARF Unit Type
+  .byte 8                               # Address Size (in bytes)
+  .long 0                               # Offset Into Abbrev. Section
+  .quad 4176978386676692168
+.Ldebug_info_dwo_end1:

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 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/incompatible_tu_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
 
 ## 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: incompatible tu_index versions, found 5 and expecting 2
 
 .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/test/tools/llvm-dwp/X86/incompatible_unit_version.test

+# RUN: llvm-mc -triple x86_64-unknown-linux %p/../Inputs/incompatible_versions/v5.s -filetype=obj -o %t5.o \
+# RUN:         -split-dwarf-file=%t5.dwo -dwarf-version=5
+# RUN: llvm-mc -triple x86_64-unknown-linux %p/../Inputs/incompatible_versions/v4.s -filetype=obj -o %t4.o \
+# RUN:         -split-dwarf-file=%t4.dwo -dwarf-version=4
+# RUN: not llvm-dwp %t4.dwo %t5.dwo -o %t.dwp

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/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
+
+# CHECK-DAG: .debug_info.dwo contents:
+# CHECK: 0x00000000: Type Unit: length = 0x0000001c, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_type, abbr_offset = 0x0000, addr_size = 0x08, name = '', type_signature = [[TUID1:.*]], type_offset = 0x001f (next unit at 0x00000020)
+# CHECK: 0x00000020: Type Unit: length = 0x0000001c, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_type, abbr_offset = 0x0000, addr_size = 0x08, name = '', type_signature = [[TUID2:.*]], type_offset = 0x001f (next unit at 0x00000040)
+# CHECK_DAG: .debug_tu_index contents:
+# CHECK: version = 5, units = 2, slots = 4
+# CHECK: Index Signature          INFO                     ABBREV                   STR_OFFSETS
+# CHECK: 1 [[TUID1]] [0x00000000, 0x00000020) [0x00000000, 0x00000009) [0x00000000, 0x00000004)
+# CHECK: 4 [[TUID2]] [0x00000020, 0x00000040) [0x00000000, 0x00000009) [0x00000000, 0x00000004)
+
+  .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
+  .quad 5657452045627120676             # Type Signature
+  .long 31                              # Type DIE Offset
+  .byte 1                               # Abbrev [1] 0x18:0x1c DW_TAG_type_unit
+  .short  33                              # DW_AT_language
+  .long 0                               # DW_AT_stmt_list
+  .byte 0                               # End Of Children Mark
+.Ldebug_info_dwo_end0:
+  .long .Ldebug_info_dwo_end1-.Ldebug_info_dwo_start1 # Length of Unit
+.Ldebug_info_dwo_start1:
+  .short  5                               # DWARF version number
+  .byte 6                               # DWARF Unit Type
+  .byte 8                               # Address Size (in bytes)
+  .long 0                               # Offset Into Abbrev. Section
+  .quad -8528522068957683993            # Type Signature
+  .long 31                              # Type DIE Offset
+  .byte 1                               # Abbrev [1] 0x18:0x25 DW_TAG_type_unit
+  .short  33                              # DW_AT_language
+  .long 0                               # DW_AT_stmt_list
+  .byte 0                               # End Of Children Mark
+.Ldebug_info_dwo_end1:
+  .section  .debug_str_offsets.dwo,"e",@progbits
+  .long 0
+  .section  .debug_abbrev.dwo,"e",@progbits
+  .byte 1                               # Abbreviation Code
+  .byte 65                              # DW_TAG_type_unit
+  .byte 0                               # DW_CHILDREN_yes
+  .byte 19                              # DW_AT_language
+  .byte 5                               # DW_FORM_data2
+  .byte 16                              # DW_AT_stmt_list
+  .byte 23                              # DW_FORM_sec_offset
+  .byte 0                               # EOM(1)
+  .byte 0                               # EOM(2)
 No newline at end of file

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

+# This test checks if llvm-dwp can deduplicate tu units (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
+
+# CHECK_DAG: .debug_tu_index contents:
+# CHECK: version = 5, units = 1, slots = 2
+
+  .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
+  .quad 5657452045627120676             # Type Signature
+  .long 31                              # Type DIE Offset
+.Ldebug_info_dwo_end0:
+  .long .Ldebug_info_dwo_end1-.Ldebug_info_dwo_start1 # Length of Unit
+.Ldebug_info_dwo_start1:
+  .short  5                             # DWARF version number
+  .byte 6                               # DWARF Unit Type
+  .byte 8                               # Address Size (in bytes)
+  .long 0                               # Offset Into Abbrev. Section
+  .quad 5657452045627120676             # Type Signature
+  .long 31                              # Type DIE Offset
+.Ldebug_info_dwo_end1:

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

static uint64_t debugStrOffsetsHeaderSize(DataExtractor StrOffsetsData,
   uint64_t Length = StrOffsetsData.getU32(&Offset);
   if (Length == llvm::dwarf::DW_LENGTH_DWARF64)
     return 16; // unit length: 12 bytes, version: 2 bytes, padding: 2 bytes.
   return 8;    // unit length: 4 bytes, version: 2 bytes, padding: 2 bytes.
 }
 
 // Holds data for Skeleton and Split Compilation Unit Headers as defined in
 // Dwarf 5 specification, 7.5.1.2 and Dwarf 4 specification 7.5.1.1.
-struct CompileUnitHeader {
+struct InfoSectionUnitHeader {
   // unit_length field. Note that the type is uint64_t even in 32-bit dwarf.
   uint64_t Length = 0;
 
   // version field.
   uint16_t Version = 0;
 
   // unit_type field. Initialized only if Version >= 5.
   uint8_t UnitType = 0;
struct InfoSectionUnitHeader {
   dwarf::DwarfFormat Format = dwarf::DwarfFormat::DWARF32;
 
   // The size of the Header in bytes. This is derived while parsing the header,
   // and is stored as a convenience.
   uint8_t HeaderSize = 0;
 };
 
 // Parse and return the header of the compile unit.
-static Expected<CompileUnitHeader> parseCompileUnitHeader(StringRef Info) {
-  CompileUnitHeader Header;
-  Error Err = Error::success();
+static Expected<InfoSectionUnitHeader>
+parseInfoSectionUnitHeader(StringRef Info) {
+  InfoSectionUnitHeader Header;
   uint64_t Offset = 0;
+
+  Error Err = Error::success();
   DWARFDataExtractor InfoData(Info, true, 0);
   std::tie(Header.Length, Header.Format) =
       InfoData.getInitialLength(&Offset, &Err);
   if (Err)
     return make_error<DWPError>("cannot parse compile unit length: " +
                                 llvm::toString(std::move(Err)));
 
   if (!InfoData.isValidOffset(Offset + (Header.Length - 1))) {
return make_error<DWPError>(
         "compile unit length is too small: expected at least " +
         utostr(MinHeaderLength) + " got " + utostr(Header.Length) + ".");
   }
   if (Header.Version >= 5) {
     Header.UnitType = InfoData.getU8(&Offset);
     Header.AddrSize = InfoData.getU8(&Offset);
     Header.DebugAbbrevOffset = InfoData.getU32(&Offset);
     Header.Signature = InfoData.getU64(&Offset);
+    if (Header.UnitType == dwarf::DW_UT_split_type) {
+      // Type offset.
+      InfoData.getU32(&Offset);
+    }
   } else {
     // Note that, address_size and debug_abbrev_offset fields have switched
     // places between dwarf version 4 and 5.
     Header.DebugAbbrevOffset = InfoData.getU32(&Offset);
     Header.AddrSize = InfoData.getU8(&Offset);
   }
 
   Header.HeaderSize = Offset;
   return Header;
 }
 
 static void writeStringsAndOffsets(MCStreamer &Out, DWPStringPool &Strings,
                                    MCSection *StrOffsetSection,
                                    StringRef CurStrSection,
                                    StringRef CurStrOffsetSection,
-                                   const CompileUnitHeader &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);
getIndexedString(dwarf::Form Form, DataExtractor InfoData, uint64_t &InfoOffset,
   uint64_t StrOffsetsOffset = 4 * StrIndex;
   StrOffsetsOffset += debugStrOffsetsHeaderSize(StrOffsetsData, Version);
 
   uint64_t StrOffset = StrOffsetsData.getU32(&StrOffsetsOffset);
   DataExtractor StrData(Str, true, 0);
   return StrData.getCStr(&StrOffset);
 }
 
-static Expected<CompileUnitIdentifiers> getCUIdentifiers(StringRef Abbrev,
-                                                         StringRef Info,
-                                                         StringRef StrOffsets,
-                                                         StringRef Str) {
-  Expected<CompileUnitHeader> HeaderOrError = parseCompileUnitHeader(Info);
-  if (!HeaderOrError)
-    return HeaderOrError.takeError();
-  CompileUnitHeader &Header = *HeaderOrError;
+static Expected<CompileUnitIdentifiers>
+getCUIdentifiers(InfoSectionUnitHeader &Header, StringRef Abbrev,
+                 StringRef Info, StringRef StrOffsets, StringRef Str) {
+
   DataExtractor InfoData(Info, true, 0);
   uint64_t Offset = Header.HeaderSize;
   if (Header.Version >= 5 && Header.UnitType != dwarf::DW_UT_split_compile)
     return make_error<DWPError>(
         std::string("unit type DW_UT_split_compile type not found in "
                     "debug_info header. Unexpected unit type 0x" +
                     utostr(Header.UnitType) + " found"));
-
   CompileUnitIdentifiers ID;
 
   uint32_t AbbrCode = InfoData.getULEB128(&Offset);
   DataExtractor AbbrevData(Abbrev, true, 0);
   uint64_t AbbrevOffset = getCUAbbrev(Abbrev, AbbrCode);
   auto Tag = static_cast<dwarf::Tag>(AbbrevData.getULEB128(&AbbrevOffset));
   if (Tag != dwarf::DW_TAG_compile_unit)
     return make_error<DWPError>("top level DIE is not a compile unit");

 };
 
 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;
 }
 
 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);
 }
 
-static void addAllTypesFromDWP(
-    MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries,
-    const DWARFUnitIndex &TUIndex, MCSection *OutputTypes, StringRef Types,
-    const UnitIndexEntry &TUEntry, uint32_t &TypesOffset) {
+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)];
+      auto &C =
+          Entry.Contributions[getContributionIndex(Kind, TUIndex.getVersion())];
       C.Offset += I->Offset;
       C.Length = I->Length;
       ++I;
     }
-    unsigned TypesIndex = getContributionIndex(DW_SECT_EXT_TYPES);
-    auto &C = Entry.Contributions[TypesIndex];
+    auto &C = Entry.Contributions[TypesContributionIndex];
     Out.emitBytes(Types.substr(
-        C.Offset - TUEntry.Contributions[TypesIndex].Offset, C.Length));
+        C.Offset - TUEntry.Contributions[TypesContributionIndex].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) {
+static void addAllTypesFromTypesSection(
+    MCStreamer &Out, MapVector<uint64_t, UnitIndexEntry> &TypeIndexEntries,
+    MCSection *OutputTypes, const std::vector<StringRef> &TypesSections,
   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);
 
handleCompressedSection(std::deque<SmallString<32>> &UncompressedSections,
   Contents = UncompressedSections.back();
   return Error::success();
 }
 
 static Error handleSection(
     const StringMap<std::pair<MCSection *, DWARFSectionKind>> &KnownSections,
     const MCSection *StrSection, const MCSection *StrOffsetSection,
     const MCSection *TypesSection, const MCSection *CUIndexSection,
-    const MCSection *TUIndexSection, const SectionRef &Section, MCStreamer &Out,
+    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, StringRef &InfoSection,
-    StringRef &AbbrevSection, StringRef &CurCUIndexSection,
-    StringRef &CurTUIndexSection) {
+    std::vector<StringRef> &CurTypesSection,
+    std::vector<StringRef> &CurInfoSection, StringRef &AbbrevSection,
+    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) {
-      CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
-      ContributionOffsets[Index] +=
-          (CurEntry.Contributions[Index].Length = Contents.size());
+    if (Kind != DW_SECT_EXT_TYPES && Kind != DW_SECT_INFO) {
+      SectionLength.push_back(std::make_pair(Kind, Contents.size()));
     }
 
-    switch (Kind) {
-    case DW_SECT_INFO:
-      InfoSection = Contents;
-      break;
-    case DW_SECT_ABBREV:
+    if (Kind == DW_SECT_ABBREV) {
       AbbrevSection = Contents;
-      break;
-    default:
-      break;
     }
   }
 
   MCSection *OutSection = SectionPair->second.first;
   if (OutSection == StrOffsetSection)
     CurStrOffsetSection = Contents;
   else if (OutSection == StrSection)
     CurStrSection = Contents;
   else if (OutSection == TypesSection)
     CurTypesSection.push_back(Contents);
   else if (OutSection == CUIndexSection)
     CurCUIndexSection = Contents;
   else if (OutSection == TUIndexSection)
     CurTUIndexSection = Contents;
+  else if (OutSection == InfoSection)
+    CurInfoSection.push_back(Contents);
   else {
     Out.SwitchSection(OutSection);
     Out.emitBytes(Contents);
   }
   return Error::success();
 }
 
 static Error

 
 static Error write(MCStreamer &Out, ArrayRef<std::string> Inputs) {
   const auto &MCOFI = *Out.getContext().getObjectFileInfo();
   MCSection *const StrSection = MCOFI.getDwarfStrDWOSection();
   MCSection *const StrOffsetSection = MCOFI.getDwarfStrOffDWOSection();
   MCSection *const TypesSection = MCOFI.getDwarfTypesDWOSection();
   MCSection *const CUIndexSection = MCOFI.getDwarfCUIndexSection();
   MCSection *const TUIndexSection = MCOFI.getDwarfTUIndexSection();
+  MCSection *const InfoSection = MCOFI.getDwarfInfoDWOSection();
   const StringMap<std::pair<MCSection *, DWARFSectionKind>> KnownSections = {
-      {"debug_info.dwo", {MCOFI.getDwarfInfoDWOSection(), DW_SECT_INFO}},
+      {"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_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) {
     auto ErrOrObj = object::ObjectFile::createObjectFile(Input);
     if (!ErrOrObj)
       return ErrOrObj.takeError();
 
     auto &Obj = *ErrOrObj->getBinary();
     Objects.push_back(std::move(*ErrOrObj));
 
     UnitIndexEntry CurEntry = {};
 
     StringRef CurStrSection;
     StringRef CurStrOffsetSection;
     std::vector<StringRef> CurTypesSection;
-    StringRef InfoSection;
+    std::vector<StringRef> CurInfoSection;
     StringRef AbbrevSection;
     StringRef CurCUIndexSection;
     StringRef CurTUIndexSection;
 
+    std::vector<std::pair<DWARFSectionKind, uint32_t>> SectionLength;
+
     for (const auto &Section : Obj.sections())
       if (auto Err = handleSection(
               KnownSections, StrSection, StrOffsetSection, TypesSection,
-              CUIndexSection, TUIndexSection, Section, Out,
+              CUIndexSection, TUIndexSection, InfoSection, Section, Out,
               UncompressedSections, ContributionOffsets, CurEntry,
-              CurStrSection, CurStrOffsetSection, CurTypesSection, InfoSection,
-              AbbrevSection, CurCUIndexSection, CurTUIndexSection))
+              CurStrSection, CurStrOffsetSection, CurTypesSection,
+              CurInfoSection, AbbrevSection, CurCUIndexSection,
+              CurTUIndexSection, SectionLength))
         return Err;
 
-    if (InfoSection.empty())
+    if (CurInfoSection.empty())
       continue;
 
-    Expected<CompileUnitHeader> CompileUnitHeaderOrErr =
-        parseCompileUnitHeader(InfoSection);
-    if (!CompileUnitHeaderOrErr)
-      return CompileUnitHeaderOrErr.takeError();
-    CompileUnitHeader &CompileUnitHeader = *CompileUnitHeaderOrErr;
+    Expected<InfoSectionUnitHeader> UnitHeaderOrErr =
+        parseInfoSectionUnitHeader(CurInfoSection.front());
+    if (!UnitHeaderOrErr)
+      return UnitHeaderOrErr.takeError();
+    InfoSectionUnitHeader &Header = *UnitHeaderOrErr;
+
+    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: " + utostr(Version) +
+          " and " + utostr(Header.Version));
+    }
+
+    // Add the contributions of each section to this unit entry, now that we
+    // know the IndexVersion to use.
+    for (auto Pair : SectionLength) {
+      auto Index = getContributionIndex(Pair.first, IndexVersion);
+      CurEntry.Contributions[Index].Offset = ContributionOffsets[Index];
+      ContributionOffsets[Index] +=
+          (CurEntry.Contributions[Index].Length = Pair.second);
+    }
 
     writeStringsAndOffsets(Out, Strings, StrOffsetSection, CurStrSection,
-                           CurStrOffsetSection, CompileUnitHeader);
+                           CurStrOffsetSection, Header.Version);
 
+    uint32_t &InfoSectionOffset =
+        ContributionOffsets[getContributionIndex(DW_SECT_INFO, IndexVersion)];
+    bool foundTypeUnits = false;
     if (CurCUIndexSection.empty()) {
-      Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
-          AbbrevSection, InfoSection, CurStrOffsetSection, CurStrSection);
+      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;
+
+          UnitOffset += C.Length;
+          // In DWARFv5 the debug info section may contain type units.
+          if (Header.Version >= 5 &&
+              Header.UnitType == dwarf::DW_UT_split_type) {
+            auto P = TypeIndexEntries.insert(
+                std::make_pair(Header.Signature.getValue(), Entry));
+            if (!P.second)
+              continue;
+            foundTypeUnits = true;
+          } else {
+            // Otherwise, this is assumed to be a compile unit.
+            Expected<CompileUnitIdentifiers> EID =
+                getCUIdentifiers(Header, AbbrevSection,
+                                 Info.substr(UnitOffset - C.Length, C.Length),
+                                 CurStrOffsetSection, CurStrSection);
             if (!EID)
               return createFileError(Input, EID.takeError());
             const auto &ID = *EID;
-      auto P = IndexEntries.insert(std::make_pair(ID.Signature, CurEntry));
+            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;
-      addAllTypes(Out, TypeIndexEntries, TypesSection, CurTypesSection,
-                  CurEntry,
-                  ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES)]);
+          }
+          Out.emitBytes(Info.substr(UnitOffset - C.Length, C.Length));
+          InfoSectionOffset += C.Length;
+        }
+      }
+
+      // Add types from the .debug_types section from DWARF < 5.
+      if (IndexVersion == 2) {
+        addAllTypesFromTypesSection(Out, TypeIndexEntries, TypesSection,
+                                    CurTypesSection, CurEntry,
+                                    ContributionOffsets[getContributionIndex(
+                                        DW_SECT_EXT_TYPES, IndexVersion)]);
+      }
       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();
+
+    Out.SwitchSection(InfoSection);
     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));
 
     for (const DWARFUnitIndex::Entry &E : CUIndex.getRows()) {
       auto *I = E.getContributions();
       if (!I)
         continue;
       auto P = IndexEntries.insert(std::make_pair(E.getSignature(), CurEntry));
+      Expected<InfoSectionUnitHeader> HeaderOrError =
+          parseInfoSectionUnitHeader(DwpSingleInfoSection);
+      if (!HeaderOrError)
+        return HeaderOrError.takeError();
+      InfoSectionUnitHeader &Header = *HeaderOrError;
+
       Expected<CompileUnitIdentifiers> EID = getCUIdentifiers(
-          getSubsection(AbbrevSection, E, DW_SECT_ABBREV),
-          getSubsection(InfoSection, E, DW_SECT_INFO),
+          Header, getSubsection(AbbrevSection, E, DW_SECT_ABBREV),
+          getSubsection(DwpSingleInfoSection, E, DW_SECT_INFO),
           getSubsection(CurStrOffsetSection, E, DW_SECT_STR_OFFSETS),
           CurStrSection);
       if (!EID)
         return createFileError(Input, EID.takeError());
       const auto &ID = *EID;
       if (!P.second)
         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, IndexVersion);
+      auto &C = NewEntry.Contributions[Index];
+      Out.emitBytes(DwpSingleInfoSection.substr(
+          C.Offset - CurEntry.Contributions[Index].Offset, C.Length));
+      C.Offset = InfoSectionOffset;
+      InfoSectionOffset += C.Length;
+    }
+
+    foundTypeUnits |= !CurTypesSection.empty();
+    if (foundTypeUnits) {
+      llvm::DWARFSectionKind TUSectionKind;
+      MCSection *OutSection;
+      StringRef TypeInputSection;
+      // Write type units into debug info section for DWARFv5.
+      if (Version >= 5) {
+        TUSectionKind = DW_SECT_INFO;
+        OutSection = InfoSection;
+        TypeInputSection = DwpSingleInfoSection;
+      } else {
+        // Write type units into debug types section for DWARF < 5.
+        if (CurTypesSection.size() != 1)
+          return make_error<DWPError>(
+              "multiple type unit sections in .dwp file");
+
+        TUSectionKind = DW_SECT_EXT_TYPES;
+        OutSection = TypesSection;
+        TypeInputSection = CurTypesSection.front();
       }
 
-    if (!CurTypesSection.empty()) {
-      if (CurTypesSection.size() != 1)
-        return make_error<DWPError>("multiple type unit sections in .dwp file");
-      DWARFUnitIndex TUIndex(DW_SECT_EXT_TYPES);
+      DWARFUnitIndex TUIndex(TUSectionKind);
       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)");
+      if (TUIndex.getVersion() != IndexVersion)
+        return make_error<DWPError>("incompatible tu_index versions, found " +
+                                    utostr(TUIndex.getVersion()) +
+                                    " and expecting " + utostr(IndexVersion));
 
-      addAllTypesFromDWP(
-          Out, TypeIndexEntries, TUIndex, TypesSection, CurTypesSection.front(),
-          CurEntry,
-          ContributionOffsets[getContributionIndex(DW_SECT_EXT_TYPES)]);
+      unsigned TypesContributionIndex =
+          getContributionIndex(TUSectionKind, IndexVersion);
+      addAllTypesFromDWP(Out, TypeIndexEntries, TUIndex, OutSection,
+                         TypeInputSection, CurEntry,
+                         ContributionOffsets[TypesContributionIndex],
+                         TypesContributionIndex);
     }
   }
 
+  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 a bout 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;