[DebugInfo/DWARF] [2/4] De-segregate type units and compile units. NFC

[probinson]

Summary

This is Patch 2 of 4 NFC refactorings to handle type units and compile
units more consistently and with less concern about the object-file
section that they came from.

Patch 1 replaces the templated DWARFUnitSection with a non-templated
version. That is, instead of being a SmallVector of pointers to a
specific unit kind, it is now a SmallVector of pointers to the base
class for both type and compile units. Virtual methods are magic.

Patch 2 takes the existing std::deque<DWARFUnitSection> for type units
and makes it a simple DWARFUnitSection, simplifying the handling of
type units and making it more consistent with compile units.

Patch 3 simply renames DWARFUnitSection to DWARFUnitVector, as the
object-file section of a unit is nearly irrelevant now.

Patch 4 combines separate DWARFUnitVectors for compile and type units
into a single DWARFUnitVector that contains both. For now the
implementation distinguishes compile units from type units by putting
all compile units at the front of the vector, reflecting the DWARF v4
distinction between .debug_info and .debug_types sections. A future
patch will change this to allow the free mixing of unit kinds, as is
specified by DWARF v5.

[aprantl]

SGTM.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

838 ↗

(On Diff #157070)

Where did the emplace_back go?

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

59 ↗

(On Diff #157070)

why is this no longer necessary?

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

838 ↗

(On Diff #157070)

It's gone, because DWOTUs is no longer a deque of DWARFUnitSection, it is simply a single DWARFUnitSection.

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

59 ↗

(On Diff #157070)

More than unnecessary, it gets in the way. The parse method is called once per object-file section, and a single DWARFUnitSection now contains info from multiple sections. So, we have to be able to call it multiple times.
It's the caller's responsibility to avoid re-parsing now. Hmm which ought to be documented in a comment.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

59 ↗

(On Diff #157070)

More than a comment - I reckon these functions need a different name to call them out as being different from the other DWARF parsing objects semantics (construct -> parse -> use, this one is: construct -> {parse, use}*). As discussed on the llvm-dev thread, maybe something like "addSectionContents" or the like.

[probinson]

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

59 ↗

(On Diff #157070)

Right, thanks for the reminder, will do.

[probinson]

Rebase. Renamed 'parse' methods to start with 'addUnits' to reflect their cumulative nature.

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

 /// object parsing, or should return Continue otherwise.
 enum class ErrorPolicy { Halt, Continue };
 
 /// DWARFContext
 /// This data structure is the top level entity that deals with dwarf debug
 /// information parsing. The actual data is supplied through DWARFObj.
 class DWARFContext : public DIContext {
   DWARFUnitSection CUs;
-  std::deque<DWARFUnitSection> TUs;
+  DWARFUnitSection TUs;
   std::unique_ptr<DWARFUnitIndex> CUIndex;
   std::unique_ptr<DWARFGdbIndex> GdbIndex;
   std::unique_ptr<DWARFUnitIndex> TUIndex;
   std::unique_ptr<DWARFDebugAbbrev> Abbrev;
   std::unique_ptr<DWARFDebugLoc> Loc;
   std::unique_ptr<DWARFDebugAranges> Aranges;
   std::unique_ptr<DWARFDebugLine> Line;
   std::unique_ptr<DWARFDebugFrame> DebugFrame;
   std::unique_ptr<DWARFDebugFrame> EHFrame;
   std::unique_ptr<DWARFDebugMacro> Macro;
   std::unique_ptr<DWARFDebugNames> Names;
   std::unique_ptr<AppleAcceleratorTable> AppleNames;
   std::unique_ptr<AppleAcceleratorTable> AppleTypes;
   std::unique_ptr<AppleAcceleratorTable> AppleNamespaces;
   std::unique_ptr<AppleAcceleratorTable> AppleObjC;
 
   DWARFUnitSection DWOCUs;
-  std::deque<DWARFUnitSection> DWOTUs;
+  DWARFUnitSection DWOTUs;
   std::unique_ptr<DWARFDebugAbbrev> AbbrevDWO;
   std::unique_ptr<DWARFDebugLocDWO> LocDWO;
 
   /// The maximum DWARF version of all units.
   unsigned MaxVersion = 0;
 
   struct DWOFile {
     object::OwningBinary<object::ObjectFile> File;
void dump(raw_ostream &OS, DIDumpOptions DumpOpts) override {
     std::array<Optional<uint64_t>, DIDT_ID_Count> DumpOffsets;
     dump(OS, DumpOpts, DumpOffsets);
   }
 
   bool verify(raw_ostream &OS, DIDumpOptions DumpOpts = {}) override;
 
   using cu_iterator_range = DWARFUnitSection::iterator_range;
   using tu_iterator_range = DWARFUnitSection::iterator_range;
-  using tu_section_iterator_range = iterator_range<decltype(TUs)::iterator>;
 
   /// Get compile units in this context.
   cu_iterator_range compile_units() {
     parseCompileUnits();
     return cu_iterator_range(CUs.begin(), CUs.end());
   }
 
   /// Get type units in this context.
-  tu_section_iterator_range type_unit_sections() {
+  tu_iterator_range type_units() {
     parseTypeUnits();
-    return tu_section_iterator_range(TUs.begin(), TUs.end());
+    return tu_iterator_range(TUs.begin(), TUs.end());
   }
 
   /// Get compile units in the DWO context.
   cu_iterator_range dwo_compile_units() {
     parseDWOCompileUnits();
     return cu_iterator_range(DWOCUs.begin(), DWOCUs.end());
   }
 
   /// Get type units in the DWO context.
-  tu_section_iterator_range dwo_type_unit_sections() {
+  tu_iterator_range dwo_type_units() {
     parseDWOTypeUnits();
-    return tu_section_iterator_range(DWOTUs.begin(), DWOTUs.end());
+    return tu_iterator_range(DWOTUs.begin(), DWOTUs.end());
   }
 
   /// Get the number of compile units in this context.
   unsigned getNumCompileUnits() {
     parseCompileUnits();
     return CUs.size();
   }
 

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

Expected<const LineTable *> getOrParseLineTable(
       DWARFDataExtractor &DebugLineData, uint32_t Offset,
       const DWARFContext &Ctx, const DWARFUnit *U,
       std::function<void(Error)> RecoverableErrorCallback = warn);
 
   /// Helper to allow for parsing of an entire .debug_line section in sequence.
   class SectionParser {
   public:
     using cu_range = DWARFUnitSection::iterator_range;
-    using tu_range = iterator_range<std::deque<DWARFUnitSection>::iterator>;
+    using tu_range = DWARFUnitSection::iterator_range;
     using LineToUnitMap = std::map<uint64_t, DWARFUnit *>;
 
     SectionParser(DWARFDataExtractor &Data, const DWARFContext &C, cu_range CUs,
                   tu_range TUs);
 
     /// Get the next line table from the section. Report any issues via the
     /// callbacks.
     ///

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

public:
   uint32_t getNextUnitOffset() const { return Offset + Length + 4; }
 };
 
 const DWARFUnitIndex &getDWARFUnitIndex(DWARFContext &Context,
                                         DWARFSectionKind Kind);
 
 /// Describes one section's Units.
 class DWARFUnitSection final : public SmallVector<std::unique_ptr<DWARFUnit>, 1> {
-  bool Parsed = false;
-  std::function<std::unique_ptr<DWARFUnit>(uint32_t)> Parser;
+  std::function<std::unique_ptr<DWARFUnit>(uint32_t, const DWARFSection *)>
+      Parser;
 
 public:
   using UnitVector = SmallVectorImpl<std::unique_ptr<DWARFUnit>>;
   using iterator = typename UnitVector::iterator;
   using iterator_range = llvm::iterator_range<typename UnitVector::iterator>;
 
   DWARFUnit *getUnitForOffset(uint32_t Offset) const;
   DWARFUnit *getUnitForIndexEntry(const DWARFUnitIndex::Entry &E);
-  void parse(DWARFContext &C, const DWARFSection &Section,
+  void addUnitsForSection(DWARFContext &C, const DWARFSection &Section,
                           DWARFSectionKind SectionKind);
-  void parseDWO(DWARFContext &C, const DWARFSection &DWOSection,
+  void addUnitsForDWOSection(DWARFContext &C, const DWARFSection &DWOSection,
                              DWARFSectionKind SectionKind, bool Lazy = false);
+
 private:
-  void parseImpl(DWARFContext &Context, const DWARFObject &Obj,
+  void addUnitsImpl(DWARFContext &Context, const DWARFObject &Obj,
                     const DWARFSection &Section, const DWARFDebugAbbrev *DA,
-                 const DWARFSection *RS, StringRef SS, const DWARFSection &SOS,
-                 const DWARFSection *AOS, const DWARFSection &LS, bool LE,
-                 bool IsDWO, bool Lazy, DWARFSectionKind SectionKind);
+                    const DWARFSection *RS, StringRef SS,
+                    const DWARFSection &SOS, const DWARFSection *AOS,
+                    const DWARFSection &LS, bool LE, bool IsDWO, bool Lazy,
+                    DWARFSectionKind SectionKind);
 };
 
 /// Represents base address of the CU.
 struct BaseAddress {
   uint64_t Address;
   uint64_t SectionIndex;
 };
 

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

 
 using ContributionCollection =
     std::vector<Optional<StrOffsetsContributionDescriptor>>;
 
 // Collect all the contributions to the string offsets table from all units,
 // sort them by their starting offsets and remove duplicates.
 static ContributionCollection
 collectContributionData(DWARFContext::cu_iterator_range CUs,
-                        DWARFContext::tu_section_iterator_range TUSs) {
+                        DWARFContext::tu_iterator_range TUs) {
   ContributionCollection Contributions;
   for (const auto &CU : CUs)
     Contributions.push_back(CU->getStringOffsetsTableContribution());
-  for (const auto &TUS : TUSs)
-    for (const auto &TU : TUS)
-      Contributions.push_back(TU->getStringOffsetsTableContribution());
-
+  for (const auto &TU : TUs)
   // Sort the contributions so that any invalid ones are placed at
   // the start of the contributions vector. This way they are reported
   // first.
   llvm::sort(Contributions.begin(), Contributions.end(),
              [](const Optional<StrOffsetsContributionDescriptor> &L,
                 const Optional<StrOffsetsContributionDescriptor> &R) {
                if (L && R) return L->Base < R->Base;
                return R.hasValue();
Contributions.erase(
                   }),
       Contributions.end());
   return Contributions;
 }
 
 static void dumpDWARFv5StringOffsetsSection(
     raw_ostream &OS, StringRef SectionName, const DWARFObject &Obj,
     const DWARFSection &StringOffsetsSection, StringRef StringSection,
-    DWARFContext::cu_iterator_range CUs,
-    DWARFContext::tu_section_iterator_range TUSs, bool LittleEndian) {
-  auto Contributions = collectContributionData(CUs, TUSs);
+    DWARFContext::cu_iterator_range CUs, DWARFContext::tu_iterator_range TUs,
+    bool LittleEndian) {
+  auto Contributions = collectContributionData(CUs, TUs);
   DWARFDataExtractor StrOffsetExt(Obj, StringOffsetsSection, LittleEndian, 0);
   DataExtractor StrData(StringSection, LittleEndian, 0);
   uint64_t SectionSize = StringOffsetsSection.Data.size();
   uint32_t Offset = 0;
   for (auto &Contribution : Contributions) {
     // Report an ill-formed contribution.
     if (!Contribution) {
       OS << "error: invalid contribution to string offsets table in section ."

 }
 
 // Dump a DWARF string offsets section. This may be a DWARF v5 formatted
 // string offsets section, where each compile or type unit contributes a
 // number of entries (string offsets), with each contribution preceded by
 // a header containing size and version number. Alternatively, it may be a
 // monolithic series of string offsets, as generated by the pre-DWARF v5
 // implementation of split DWARF.
-static void dumpStringOffsetsSection(
-    raw_ostream &OS, StringRef SectionName, const DWARFObject &Obj,
-    const DWARFSection &StringOffsetsSection, StringRef StringSection,
+static void dumpStringOffsetsSection(raw_ostream &OS, StringRef SectionName,
+                                     const DWARFObject &Obj,
+                                     const DWARFSection &StringOffsetsSection,
+                                     StringRef StringSection,
                                      DWARFContext::cu_iterator_range CUs,
-    DWARFContext::tu_section_iterator_range TUSs, bool LittleEndian,
-    unsigned MaxVersion) {
+                                     DWARFContext::tu_iterator_range TUs,
+                                     bool LittleEndian, unsigned MaxVersion) {
   // If we have at least one (compile or type) unit with DWARF v5 or greater,
   // we assume that the section is formatted like a DWARF v5 string offsets
   // section.
   if (MaxVersion >= 5)
     dumpDWARFv5StringOffsetsSection(OS, SectionName, Obj, StringOffsetsSection,
-                                    StringSection, CUs, TUSs, LittleEndian);
+                                    StringSection, CUs, TUs, LittleEndian);
   else {
     DataExtractor strOffsetExt(StringOffsetsSection.Data, LittleEndian, 0);
     uint32_t offset = 0;
     uint64_t size = StringOffsetsSection.Data.size();
     // Ensure that size is a multiple of the size of an entry.
     if (size & ((uint64_t)(sizeof(uint32_t) - 1))) {
       OS << "error: size of ." << SectionName << " is not a multiple of "
          << sizeof(uint32_t) << ".\n";
if (shouldDump(IsExplicit, Name, DIDT_ID_DebugInfo, Section.Data)) {
           CU->dump(OS, DumpOpts);
     }
   };
   dumpDebugInfo(Explicit, ".debug_info", DObj->getInfoSection(),
                 compile_units());
   dumpDebugInfo(ExplicitDWO, ".debug_info.dwo", DObj->getInfoDWOSection(),
                 dwo_compile_units());
 
-  auto dumpDebugType = [&](const char *Name,
-                           tu_section_iterator_range TUSections) {
+  auto dumpDebugType = [&](const char *Name, tu_iterator_range TUs) {
     OS << '\n' << Name << " contents:\n";
     DumpOffset = DumpOffsets[DIDT_ID_DebugTypes];
-    for (const auto &TUS : TUSections)
-      for (const auto &TU : TUS)
-        if (DumpOffset)
-          TU->getDIEForOffset(*DumpOffset)
-              .dump(OS, 0, DumpOpts.noImplicitRecursion());
-        else
-          TU->dump(OS, DumpOpts);
+    for (const auto &TU : TUs)
   };
   if ((DumpType & DIDT_DebugTypes)) {
     if (Explicit || getNumTypeUnits())
-      dumpDebugType(".debug_types", type_unit_sections());
+      dumpDebugType(".debug_types", type_units());
     if (ExplicitDWO || getNumDWOTypeUnits())
-      dumpDebugType(".debug_types.dwo", dwo_type_unit_sections());
+      dumpDebugType(".debug_types.dwo", dwo_type_units());
   }
 
   if (shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                  DObj->getLocSection().Data)) {
     getDebugLoc()->dump(OS, getRegisterInfo(), DumpOffset);
   }
   if (shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                  DObj->getLocDWOSection().Data)) {
auto DumpLineSection = [&](DWARFDebugLine::SectionParser Parser,
     }
   };
 
   if (shouldDump(Explicit, ".debug_line", DIDT_ID_DebugLine,
                  DObj->getLineSection().Data)) {
     DWARFDataExtractor LineData(*DObj, DObj->getLineSection(), isLittleEndian(),
                                 0);
     DWARFDebugLine::SectionParser Parser(LineData, *this, compile_units(),
-                                         type_unit_sections());
+                                         type_units());
     DumpLineSection(Parser, DumpOpts);
   }
 
   if (shouldDump(ExplicitDWO, ".debug_line.dwo", DIDT_ID_DebugLine,
                  DObj->getLineDWOSection().Data)) {
     DWARFDataExtractor LineData(*DObj, DObj->getLineDWOSection(),
                                 isLittleEndian(), 0);
     DWARFDebugLine::SectionParser Parser(LineData, *this, dwo_compile_units(),
-                                         dwo_type_unit_sections());
+                                         dwo_type_units());
     DumpLineSection(Parser, DumpOpts);
   }
 
   if (shouldDump(Explicit, ".debug_cu_index", DIDT_ID_DebugCUIndex,
                  DObj->getCUIndexSection())) {
     getCUIndex().dump(OS);
   }
 
void DWARFContext::dump(
   if (shouldDump(Explicit, ".debug_gnu_pubtypes", DIDT_ID_DebugGnuPubtypes,
                  DObj->getGnuPubTypesSection()))
     DWARFDebugPubTable(DObj->getGnuPubTypesSection(), isLittleEndian(),
                        true /* GnuStyle */)
         .dump(OS);
 
   if (shouldDump(Explicit, ".debug_str_offsets", DIDT_ID_DebugStrOffsets,
                  DObj->getStringOffsetSection().Data))
-    dumpStringOffsetsSection(
-        OS, "debug_str_offsets", *DObj, DObj->getStringOffsetSection(),
-        DObj->getStringSection(), compile_units(), type_unit_sections(),
-        isLittleEndian(), getMaxVersion());
+    dumpStringOffsetsSection(OS, "debug_str_offsets", *DObj,
+                             DObj->getStringOffsetSection(),
+                             DObj->getStringSection(), compile_units(),
+                             type_units(), isLittleEndian(), getMaxVersion());
   if (shouldDump(ExplicitDWO, ".debug_str_offsets.dwo", DIDT_ID_DebugStrOffsets,
                  DObj->getStringOffsetDWOSection().Data))
     dumpStringOffsetsSection(
         OS, "debug_str_offsets.dwo", *DObj, DObj->getStringOffsetDWOSection(),
-        DObj->getStringDWOSection(), dwo_compile_units(),
-        dwo_type_unit_sections(), isLittleEndian(), getMaxVersion());
+        DObj->getStringDWOSection(), dwo_compile_units(), dwo_type_units(),
+        isLittleEndian(), getMaxVersion());
 
   if (shouldDump(Explicit, ".gnu_index", DIDT_ID_GdbIndex,
                  DObj->getGdbIndexSection())) {
     getGdbIndex().dump(OS);
   }
 
   if (shouldDump(Explicit, ".apple_names", DIDT_ID_AppleNames,
                  DObj->getAppleNamesSection().Data))
if (shouldDump(Explicit, ".apple_objc", DIDT_ID_AppleObjC,
                  DObj->getAppleObjCSection().Data))
     getAppleObjC().dump(OS);
   if (shouldDump(Explicit, ".debug_names", DIDT_ID_DebugNames,
                  DObj->getDebugNamesSection().Data))
     getDebugNames().dump(OS);
 }
 
 DWARFCompileUnit *DWARFContext::getDWOCompileUnitForHash(uint64_t Hash) {
-  DWOCUs.parseDWO(*this, DObj->getInfoDWOSection(), DW_SECT_INFO, true);
+  if (DWOCUs.empty())
+    DWOCUs.addUnitsForDWOSection(*this, DObj->getInfoDWOSection(), DW_SECT_INFO,
+                                 true);
 
   if (const auto &CUI = getCUIndex()) {
     if (const auto *R = CUI.getFromHash(Hash))
       return dyn_cast_or_null<DWARFCompileUnit>(DWOCUs.getUnitForIndexEntry(*R));
     return nullptr;
   }
 
   // If there's no index, just search through the CUs in the DWO - there's
Expected<const DWARFDebugLine::LineTable *> DWARFContext::getLineTableForUnit(
   // We have to parse it first.
   DWARFDataExtractor lineData(*DObj, U->getLineSection(), isLittleEndian(),
                               U->getAddressByteSize());
   return Line->getOrParseLineTable(lineData, stmtOffset, *this, U,
                                    RecoverableErrorCallback);
 }
 
 void DWARFContext::parseCompileUnits() {
-  CUs.parse(*this, DObj->getInfoSection(), DW_SECT_INFO);
+  if (!CUs.empty())
+    return;
+  CUs.addUnitsForSection(*this, DObj->getInfoSection(), DW_SECT_INFO);
 }
 
 void DWARFContext::parseTypeUnits() {
   if (!TUs.empty())
     return;
   DObj->forEachTypesSections([&](const DWARFSection &S) {
-    TUs.emplace_back();
-    TUs.back().parse(*this, S, DW_SECT_TYPES);
+    TUs.addUnitsForSection(*this, S, DW_SECT_TYPES);
   });
 }
 
 void DWARFContext::parseDWOCompileUnits() {
-  DWOCUs.parseDWO(*this, DObj->getInfoDWOSection(), DW_SECT_INFO);
+  if (!DWOCUs.empty())
+    return;
+  DWOCUs.addUnitsForDWOSection(*this, DObj->getInfoDWOSection(), DW_SECT_INFO);
 }
 
 void DWARFContext::parseDWOTypeUnits() {
   if (!DWOTUs.empty())
     return;
   DObj->forEachTypesDWOSections([&](const DWARFSection &S) {
-    DWOTUs.emplace_back();
-    DWOTUs.back().parseDWO(*this, S, DW_SECT_TYPES);
+    DWOTUs.addUnitsForDWOSection(*this, S, DW_SECT_TYPES);
   });
 }
 
 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
   parseCompileUnits();
   return dyn_cast_or_null<DWARFCompileUnit>(CUs.getUnitForOffset(Offset));
 }
 

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

 }
 
 // We want to supply the Unit associated with a .debug_line[.dwo] table when
 // we dump it, if possible, but still dump the table even if there isn't a Unit.
 // Therefore, collect up handles on all the Units that point into the
 // line-table section.
 static DWARFDebugLine::SectionParser::LineToUnitMap
 buildLineToUnitMap(DWARFDebugLine::SectionParser::cu_range CUs,
-                   DWARFDebugLine::SectionParser::tu_range TUSections) {
+                   DWARFDebugLine::SectionParser::tu_range TUs) {
   DWARFDebugLine::SectionParser::LineToUnitMap LineToUnit;
   for (const auto &CU : CUs)
     if (auto CUDIE = CU->getUnitDIE())
       if (auto StmtOffset = toSectionOffset(CUDIE.find(DW_AT_stmt_list)))
         LineToUnit.insert(std::make_pair(*StmtOffset, &*CU));
-  for (const auto &TUS : TUSections)
-    for (const auto &TU : TUS)
-      if (auto TUDIE = TU->getUnitDIE())
-        if (auto StmtOffset = toSectionOffset(TUDIE.find(DW_AT_stmt_list)))
-          LineToUnit.insert(std::make_pair(*StmtOffset, &*TU));
+  for (const auto &TU : TUs)
   return LineToUnit;
 }
 
 DWARFDebugLine::SectionParser::SectionParser(DWARFDataExtractor &Data,
                                              const DWARFContext &C,
                                              cu_range CUs, tu_range TUs)
     : DebugLineData(Data), Context(C) {
   LineToUnit = buildLineToUnitMap(CUs, TUs);

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

 #include <cstdint>
 #include <cstdio>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
-void DWARFUnitSection::parse(DWARFContext &C, const DWARFSection &Section,
+void DWARFUnitSection::addUnitsForSection(DWARFContext &C,
+                                          const DWARFSection &Section,
                                           DWARFSectionKind SectionKind) {
   const DWARFObject &D = C.getDWARFObj();
-  parseImpl(C, D, Section, C.getDebugAbbrev(), &D.getRangeSection(),
+  addUnitsImpl(C, D, Section, C.getDebugAbbrev(), &D.getRangeSection(),
                D.getStringSection(), D.getStringOffsetSection(),
-            &D.getAddrSection(), D.getLineSection(), D.isLittleEndian(), false,
-            false, SectionKind);
+               &D.getAddrSection(), D.getLineSection(), D.isLittleEndian(),
+               false, false, SectionKind);
 }
 
-void DWARFUnitSection::parseDWO(DWARFContext &C,
+void DWARFUnitSection::addUnitsForDWOSection(DWARFContext &C,
                                              const DWARFSection &DWOSection,
-                                DWARFSectionKind SectionKind, bool Lazy) {
+                                             DWARFSectionKind SectionKind,
+                                             bool Lazy) {
   const DWARFObject &D = C.getDWARFObj();
-  parseImpl(C, D, DWOSection, C.getDebugAbbrevDWO(), &D.getRangeDWOSection(),
+  addUnitsImpl(C, D, DWOSection, C.getDebugAbbrevDWO(), &D.getRangeDWOSection(),
                D.getStringDWOSection(), D.getStringOffsetDWOSection(),
                &D.getAddrSection(), D.getLineDWOSection(), C.isLittleEndian(),
                true, Lazy, SectionKind);
 }
 
-void DWARFUnitSection::parseImpl(DWARFContext &Context, const DWARFObject &Obj,
-               const DWARFSection &Section, const DWARFDebugAbbrev *DA,
-               const DWARFSection *RS, StringRef SS, const DWARFSection &SOS,
-               const DWARFSection *AOS, const DWARFSection &LS, bool LE,
-               bool IsDWO, bool Lazy, DWARFSectionKind SectionKind) {
-  if (Parsed)
-    return;
+void DWARFUnitSection::addUnitsImpl(
+    DWARFContext &Context, const DWARFObject &Obj, const DWARFSection &Section,
+    const DWARFDebugAbbrev *DA, const DWARFSection *RS, StringRef SS,
+    const DWARFSection &SOS, const DWARFSection *AOS, const DWARFSection &LS,
+    bool LE, bool IsDWO, bool Lazy, DWARFSectionKind SectionKind) {
   DWARFDataExtractor Data(Obj, Section, LE, 0);
   // Lazy initialization of Parser, now that we have all section info.
   if (!Parser) {
     const DWARFUnitIndex *Index = nullptr;
     if (IsDWO)
       Index = &getDWARFUnitIndex(Context, SectionKind);
-    Parser = [=, &Context, &Section, &SOS,
-      &LS](uint32_t Offset) -> std::unique_ptr<DWARFUnit> {
+    Parser = [=, &Context, &Obj, &Section, &SOS, &LS](
+                 uint32_t Offset,
+                 const DWARFSection *CurSection) -> std::unique_ptr<DWARFUnit> {
+      const DWARFSection &InfoSection = CurSection ? *CurSection : Section;
+      DWARFDataExtractor Data(Obj, InfoSection, LE, 0);
       if (!Data.isValidOffset(Offset))
         return nullptr;
       DWARFUnitHeader Header;
       if (!Header.extract(Context, Data, &Offset, SectionKind, Index))
         return nullptr;
       std::unique_ptr<DWARFUnit> U;
       if (Header.isTypeUnit())
-        U = llvm::make_unique<DWARFTypeUnit>(
-          Context, Section, Header, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
+        U = llvm::make_unique<DWARFTypeUnit>(Context, InfoSection, Header, DA,
+                                             RS, SS, SOS, AOS, LS, LE, IsDWO,
                                              *this);
       else
-        U = llvm::make_unique<DWARFCompileUnit>(
-          Context, Section, Header, DA, RS, SS, SOS, AOS, LS, LE, IsDWO,
-          *this);
+        U = llvm::make_unique<DWARFCompileUnit>(Context, InfoSection, Header,
+                                                DA, RS, SS, SOS, AOS, LS, LE,
+                                                IsDWO, *this);
       return U;
     };
   }
   if (Lazy)
     return;
   auto I = this->begin();
   uint32_t Offset = 0;
   while (Data.isValidOffset(Offset)) {
     if (I != this->end() && (*I)->getOffset() == Offset) {
       ++I;
       continue;
     }
-    auto U = Parser(Offset);
+    auto U = Parser(Offset, &Section);
     if (!U)
       break;
     Offset = U->getNextUnitOffset();
     I = std::next(this->insert(I, std::move(U)));
   }
-  Parsed = true;
 }
 
 DWARFUnit *DWARFUnitSection::getUnitForOffset(uint32_t Offset) const {
   auto *CU = std::upper_bound(
     this->begin(), this->end(), Offset,
     [](uint32_t LHS, const std::unique_ptr<DWARFUnit> &RHS) {
     return LHS < RHS->getNextUnitOffset();
   });
auto *CU = std::upper_bound(
     return LHS < RHS->getNextUnitOffset();
   });
   if (CU != this->end() && (*CU)->getOffset() <= Offset)
     return CU->get();
 
   if (!Parser)
     return nullptr;
 
-  auto U = Parser(Offset);
+  auto U = Parser(Offset, nullptr);
   if (!U)
     U = nullptr;
 
   auto *NewCU = U.get();
   this->insert(CU, std::move(U));
   return NewCU;
 }
 

llvm/trunk/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

struct CommonFixture {
   DWARFDataExtractor LineData;
   DWARFDebugLine Line;
   Error Recoverable;
   std::function<void(Error)> RecordRecoverable;
   Error Unrecoverable;
   std::function<void(Error)> RecordUnrecoverable;
 
   SmallVector<std::unique_ptr<DWARFUnit>, 2> CUs;
-  std::deque<DWARFUnitSection> TUs;
+  SmallVector<std::unique_ptr<DWARFUnit>, 2> TUs;
 };
 
 // Fixtures must derive from "Test", but parameterised fixtures from
 // "TestWithParam". It does not seem possible to inherit from both, so we share
 // the common state in a separate class, inherited by the two fixture classes.
 struct DebugLineBasicFixture : public Test, public CommonFixture {};
 
 struct DebugLineParameterisedFixture