DebugInfo: Remove DWARFv5 TUs from CUs list by sorting the finalized list

[dblaikie]

Summary

Since DWARFv5 places TUs in debug_info, some of DWARFContext's APIs have
become a bit erroneous, including TUs in the CU list by accident.

Implementation: Once we finish parsing debug_info[.dwo], stable sort the list by whether they are a TU or CU (CUs first, then TUs).
Then, when querying for debug_info units, provide the whole range of both

Drawback: We have to then resort the units when dumping debug_info[.dwo] to print them in the order they are in the input file.

Trying to pick between this solution and D87935

One slight variation on this would be that we could avoid sorting after finalizing, if we kept an extra member to save the boundary point between CUs and TUs - or, always insert CUs at the start and TUs at the end.

[dblaikie]

Went with D87935 instead.

llvm/include/llvm/DebugInfo/DWARF/DWARFSection.h

 #define LLVM_DEBUGINFO_DWARF_DWARFSECTION_H
 
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
 struct DWARFSection {
   StringRef Data;
+  int Index;
 };
 
 struct SectionName {
   StringRef Name;
   bool IsNameUnique;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFSECTION_H

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

 /// Describe a collection of units. Intended to hold all units either from
 /// .debug_info and .debug_types, or from .debug_info.dwo and .debug_types.dwo.
 class DWARFUnitVector final : public SmallVector<std::unique_ptr<DWARFUnit>, 1> {
   std::function<std::unique_ptr<DWARFUnit>(uint64_t, DWARFSectionKind,
                                            const DWARFSection *,
                                            const DWARFUnitIndex::Entry *)>
       Parser;
   int NumInfoUnits = -1;
+  int NumCompileUnits = -1;
 
 public:
   using UnitVector = SmallVectorImpl<std::unique_ptr<DWARFUnit>>;
   using iterator = typename UnitVector::iterator;
   using iterator_range = llvm::iterator_range<typename UnitVector::iterator>;
 
   DWARFUnit *getUnitForOffset(uint64_t Offset) const;
   DWARFUnit *getUnitForIndexEntry(const DWARFUnitIndex::Entry &E);
public:
   DWARFUnit *addUnit(std::unique_ptr<DWARFUnit> Unit);
 
   /// Returns number of all units held by this instance.
   unsigned getNumUnits() const { return size(); }
   /// Returns number of units from all .debug_info[.dwo] sections.
   unsigned getNumInfoUnits() const {
     return NumInfoUnits == -1 ? size() : NumInfoUnits;
   }
+  unsigned getNumCompileUnits() const {
+    return NumCompileUnits == -1 ? size() : NumCompileUnits;
+  }
   /// Returns number of units from all .debug_types[.dwo] sections.
-  unsigned getNumTypesUnits() const { return size() - NumInfoUnits; }
+  unsigned getNumTypesUnits() const { return size() - NumCompileUnits; }
   /// Indicate that parsing .debug_info[.dwo] is done, and remaining units
   /// will be from .debug_types[.dwo].
-  void finishedInfoUnits() { NumInfoUnits = size(); }
+  void finishedInfoUnits();
 
 private:
   void addUnitsImpl(DWARFContext &Context, const DWARFObject &Obj,
                     const DWARFSection &Section, const DWARFDebugAbbrev *DA,
                     const DWARFSection *RS, const DWARFSection *LocSection,
                     StringRef SS, const DWARFSection &SOS,
                     const DWARFSection *AOS, const DWARFSection &LS, bool LE,
                     bool IsDWO, bool Lazy, DWARFSectionKind SectionKind);

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

void DWARFContext::dump(
   // Dump individual sections.
   if (shouldDump(Explicit, ".debug_abbrev", DIDT_ID_DebugAbbrev,
                  DObj->getAbbrevSection()))
     getDebugAbbrev()->dump(OS);
   if (shouldDump(ExplicitDWO, ".debug_abbrev.dwo", DIDT_ID_DebugAbbrev,
                  DObj->getAbbrevDWOSection()))
     getDebugAbbrevDWO()->dump(OS);
 
-  auto dumpDebugInfo = [&](const char *Name, unit_iterator_range Units) {
+  auto dumpDebugInfo = [&](const char *Name,
+                           unit_iterator_range UnsortedUnits) {
     OS << '\n' << Name << " contents:\n";
+    SmallVector<DWARFUnit *, 1> Units;
+    Units.reserve(llvm::size(UnsortedUnits));
+    for (const auto &U : UnsortedUnits)
+      Units.push_back(U.get());
+    llvm::stable_sort(Units, [](const DWARFUnit *LHS, const DWARFUnit *RHS) {
+      return std::make_tuple(LHS->getInfoSection().Index, LHS->getOffset()) <
+             std::make_tuple(RHS->getInfoSection().Index, RHS->getOffset());
+    });
     if (auto DumpOffset = DumpOffsets[DIDT_ID_DebugInfo])
       for (const auto &U : Units)
         U->getDIEForOffset(DumpOffset.getValue())
             .dump(OS, 0, DumpOpts.noImplicitRecursion());
     else
       for (const auto &U : Units)
         U->dump(OS, DumpOpts);
   };
for (const SectionRef &Section : Obj.sections()) {
                          .Case("debug_info.dwo", &InfoDWOSections)
                          .Case("debug_types", &TypesSections)
                          .Case("debug_types.dwo", &TypesDWOSections)
                          .Default(nullptr)) {
         // Find debug_info and debug_types data by section rather than name as
         // there are multiple, comdat grouped, of these sections.
         DWARFSectionMap &S = (*Sections)[Section];
         S.Data = Data;
+        S.Index = Section.getIndex();
       }
 
       if (RelocatedSection == Obj.section_end())
         continue;
 
       StringRef RelSecName;
       if (auto NameOrErr = RelocatedSection->getName())
         RelSecName = *NameOrErr;

llvm/lib/DebugInfo/DWARF/DWARFUnit.cpp

if (!U)
     U = nullptr;
 
   auto *NewCU = U.get();
   this->insert(CU, std::move(U));
   ++NumInfoUnits;
   return NewCU;
 }
 
+void DWARFUnitVector::finishedInfoUnits() {
+  NumInfoUnits = size();
+  llvm::stable_sort(*this, [](const std::unique_ptr<DWARFUnit> &LHS,
+                              const std::unique_ptr<DWARFUnit> &RHS) {
+    bool LTU = LHS->isTypeUnit();
+    bool RTU = RHS->isTypeUnit();
+    if (LTU == RTU)
+      return false;
+    if (!LTU && RTU)
+      return true;
+    return false;
+  });
+  auto I = llvm::find_if(*this, [](const std::unique_ptr<DWARFUnit> &U) {
+    return U->isTypeUnit();
+  });
+  NumCompileUnits = I - begin();
+}
 DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFSection &Section,
                      const DWARFUnitHeader &Header, const DWARFDebugAbbrev *DA,
                      const DWARFSection *RS, const DWARFSection *LocSection,
                      StringRef SS, const DWARFSection &SOS,
                      const DWARFSection *AOS, const DWARFSection &LS, bool LE,
                      bool IsDWO, const DWARFUnitVector &UnitVector)
     : Context(DC), InfoSection(Section), Header(Header), Abbrev(DA),
       RangeSection(RS), LineSection(LS), StringSection(SS),