Don't expose a map in the DWARFContext interface

[• rafael]

Summary

Doing so is leaking an implementation detail.

I have an implementation that uses the lld infrastructure and doesn't use a map or object::SectionRef.

[dblaikie]

Worth using the extra storage like that? I guess a type-erased range is a bit much, but what about a callback-based API? ("forEachTypeSection(function_ref<void(DWARFSection&)>)")

[• rafael]

Use a callback instead.

[dblaikie]

Looks great!

[• espindola]

307846

include/llvm/DebugInfo/DWARF/DWARFContext.h

DILineInfoTable getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
   DIInliningInfo getInliningInfoForAddress(uint64_t Address,
       DILineInfoSpecifier Specifier = DILineInfoSpecifier()) override;
 
   virtual StringRef getFileName() const = 0;
   virtual bool isLittleEndian() const = 0;
   virtual uint8_t getAddressSize() const = 0;
   virtual const DWARFSection &getInfoSection() = 0;
-
-  using TypeSectionMap = MapVector<object::SectionRef, DWARFSection,
-                                   std::map<object::SectionRef, unsigned>>;
-
-  virtual const TypeSectionMap &getTypesSections() = 0;
+  virtual ArrayRef<const DWARFSection *> getTypesSections() = 0;
   virtual StringRef getAbbrevSection() = 0;
   virtual const DWARFSection &getLocSection() = 0;
   virtual StringRef getARangeSection() = 0;
   virtual StringRef getDebugFrameSection() = 0;
   virtual StringRef getEHFrameSection() = 0;
   virtual const DWARFSection &getLineSection() = 0;
   virtual StringRef getStringSection() = 0;
   virtual const DWARFSection& getRangeSection() = 0;
   virtual StringRef getMacinfoSection() = 0;
   virtual StringRef getPubNamesSection() = 0;
   virtual StringRef getPubTypesSection() = 0;
   virtual StringRef getGnuPubNamesSection() = 0;
   virtual StringRef getGnuPubTypesSection() = 0;
 
   /// DWARF v5
   /// @{
   virtual const DWARFSection &getStringOffsetSection() = 0;
   /// @}
 
   // Sections for DWARF5 split dwarf proposal.
   virtual const DWARFSection &getInfoDWOSection() = 0;
-  virtual const TypeSectionMap &getTypesDWOSections() = 0;
+  virtual ArrayRef<const DWARFSection *> getTypesDWOSections() = 0;
   virtual StringRef getAbbrevDWOSection() = 0;
   virtual const DWARFSection &getLineDWOSection() = 0;
   virtual const DWARFSection &getLocDWOSection() = 0;
   virtual StringRef getStringDWOSection() = 0;
   virtual const DWARFSection &getStringOffsetDWOSection() = 0;
   virtual const DWARFSection &getRangeDWOSection() = 0;
   virtual const DWARFSection &getAddrSection() = 0;
   virtual const DWARFSection& getAppleNamesSection() = 0;

 enum class ErrorPolicy { Halt, Continue };
 
 /// DWARFContextInMemory is the simplest possible implementation of a
 /// DWARFContext. It assumes all content is available in memory and stores
 /// pointers to it.
 class DWARFContextInMemory : public DWARFContext {
   virtual void anchor();
 
+  using TypeSectionMap = MapVector<object::SectionRef, DWARFSection,
+                                   std::map<object::SectionRef, unsigned>>;
+
   StringRef FileName;
   bool IsLittleEndian;
   uint8_t AddressSize;
   DWARFSection InfoSection;
   TypeSectionMap TypesSections;
+  std::vector<DWARFSection *> TypesSectionsPtrs;
   StringRef AbbrevSection;
   DWARFSection LocSection;
   StringRef ARangeSection;
   StringRef DebugFrameSection;
   StringRef EHFrameSection;
   DWARFSection LineSection;
   StringRef StringSection;
   DWARFSection RangeSection;
   StringRef MacinfoSection;
   StringRef PubNamesSection;
   StringRef PubTypesSection;
   StringRef GnuPubNamesSection;
   StringRef GnuPubTypesSection;
 
   /// DWARF v5
   /// @{
   DWARFSection StringOffsetSection;
   /// @}
 
   // Sections for DWARF5 split dwarf proposal.
   DWARFSection InfoDWOSection;
   TypeSectionMap TypesDWOSections;
+  std::vector<DWARFSection *> TypesDWOSectionsPtrs;
   StringRef AbbrevDWOSection;
   DWARFSection LineDWOSection;
   DWARFSection LocDWOSection;
   StringRef StringDWOSection;
   DWARFSection StringOffsetDWOSection;
   DWARFSection RangeDWOSection;
   DWARFSection AddrSection;
   DWARFSection AppleNamesSection;
public:
   DWARFContextInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
                        uint8_t AddrSize,
                        bool isLittleEndian = sys::IsLittleEndianHost);
 
   StringRef getFileName() const override { return FileName; }
   bool isLittleEndian() const override { return IsLittleEndian; }
   uint8_t getAddressSize() const override { return AddressSize; }
   const DWARFSection &getInfoSection() override { return InfoSection; }
-  const TypeSectionMap &getTypesSections() override { return TypesSections; }
+  ArrayRef<const DWARFSection *> getTypesSections() override {
+    return TypesSectionsPtrs;
+  }
   StringRef getAbbrevSection() override { return AbbrevSection; }
   const DWARFSection &getLocSection() override { return LocSection; }
   StringRef getARangeSection() override { return ARangeSection; }
   StringRef getDebugFrameSection() override { return DebugFrameSection; }
   StringRef getEHFrameSection() override { return EHFrameSection; }
   const DWARFSection &getLineSection() override { return LineSection; }
   StringRef getStringSection() override { return StringSection; }
   const DWARFSection &getRangeSection() override { return RangeSection; }
public:
   // DWARF v5
   const DWARFSection &getStringOffsetSection() override {
     return StringOffsetSection;
   }
 
   // Sections for DWARF5 split dwarf proposal.
   const DWARFSection &getInfoDWOSection() override { return InfoDWOSection; }
 
-  const TypeSectionMap &getTypesDWOSections() override {
-    return TypesDWOSections;
+  ArrayRef<const DWARFSection *> getTypesDWOSections() override {
+    return TypesDWOSectionsPtrs;
   }
 
   StringRef getAbbrevDWOSection() override { return AbbrevDWOSection; }
   const DWARFSection &getLineDWOSection() override { return LineDWOSection; }
   const DWARFSection &getLocDWOSection() override { return LocDWOSection; }
   StringRef getStringDWOSection() override { return StringDWOSection; }
 
   const DWARFSection &getStringOffsetDWOSection() override {

lib/DebugInfo/DWARF/DWARFContext.cpp

 
 void DWARFContext::parseCompileUnits() {
   CUs.parse(*this, getInfoSection());
 }
 
 void DWARFContext::parseTypeUnits() {
   if (!TUs.empty())
     return;
-  for (const auto &I : getTypesSections()) {
+  for (const DWARFSection *S : getTypesSections()) {
     TUs.emplace_back();
-    TUs.back().parse(*this, I.second);
+    TUs.back().parse(*this, *S);
   }
 }
 
 void DWARFContext::parseDWOCompileUnits() {
   DWOCUs.parseDWO(*this, getInfoDWOSection());
 }
 
 void DWARFContext::parseDWOTypeUnits() {
   if (!DWOTUs.empty())
     return;
-  for (const auto &I : getTypesDWOSections()) {
+  for (const DWARFSection *S : getTypesDWOSections()) {
     DWOTUs.emplace_back();
-    DWOTUs.back().parseDWO(*this, I.second);
+    DWOTUs.back().parseDWO(*this, *S);
   }
 }
 
 DWARFCompileUnit *DWARFContext::getCompileUnitForOffset(uint32_t Offset) {
   parseCompileUnits();
   return CUs.getUnitForOffset(Offset);
 }
 
for (const RelocationRef &Reloc : Section.relocations()) {
         if (EP == ErrorPolicy::Halt)
           return;
         continue;
       }
       RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};
       Map->insert({Reloc.getOffset(), Rel});
     }
   }
+  for (auto &P : TypesSections)
+    TypesSectionsPtrs.push_back(&P.second);
+  for (auto &P : TypesDWOSections)
+    TypesDWOSectionsPtrs.push_back(&P.second);
 }
 
 DWARFContextInMemory::DWARFContextInMemory(
     const StringMap<std::unique_ptr<MemoryBuffer>> &Sections, uint8_t AddrSize,
     bool isLittleEndian)
     : IsLittleEndian(isLittleEndian), AddressSize(AddrSize) {
   for (const auto &SecIt : Sections) {
     if (StringRef *SectionData = mapSectionToMember(SecIt.first()))