[llvm-dwarfdump] - Refactor section name/uniqueness gathering.

[grimar]

Summary

As was requested in D36313 thread,

with this patch section names and uniqueness calculated once,
and not every time when a range is dumped.

[dblaikie]

include/llvm/DebugInfo/DWARF/DWARFSection.h

22 ↗

(On Diff #111166)

Maybe SectionName or SectionNameInfo?

lib/DebugInfo/DWARF/DWARFContext.cpp

1188–1191 ↗

(On Diff #111166)

Reckon it might be worth doing this lazily (inside getSectionNames)? So it's not computed if it's not needed?

I guess if we're already walking all the sections and getting their names, this is probably cheap enough to do unconditionally.

lib/DebugInfo/DWARF/DWARFDie.cpp

60–62 ↗

(On Diff #111166)

Similarly, probably call these SectionNames and getSectionNames (& similarly inside DWARFObject)

72 ↗

(On Diff #111166)

Can probably skip DumpOpts.Brief here, since Sections will be empty in that case?

76 ↗

(On Diff #111166)

does format not support StringRef? Or stream it out directly:

OS << " \"" << Name << '\"';

Save having to str().c_str() it.

[grimar]

• All comments addressed.

lib/DebugInfo/DWARF/DWARFContext.cpp

1188–1191 ↗

(On Diff #111166)

I tried both ways when wrote this patch. Non-lazy way was a bit shorter and does not have problem
with calling non-const methods for const object, that is why I posted it initially.
I changed to lazy one if you prefer it.

[dblaikie]

Nah, that's OK - just do it the non-lazy (original) way. Can muck with it if it ever turns out to be a real issue.

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

 // result is not used.
 class DWARFObject {
   DWARFSection Dummy;
 
 public:
   virtual ~DWARFObject() = default;
   virtual StringRef getFileName() const { llvm_unreachable("unimplemented"); }
   virtual const object::ObjectFile *getFile() const { return nullptr; }
+  virtual ArrayRef<SectionName> getSectionNames() const { return {}; }
   virtual bool isLittleEndian() const = 0;
   virtual uint8_t getAddressSize() const { llvm_unreachable("unimplemented"); }
   virtual const DWARFSection &getInfoSection() const { return Dummy; }
   virtual void
   forEachTypesSections(function_ref<void(const DWARFSection &)> F) const {}
   virtual StringRef getAbbrevSection() const { return ""; }
   virtual const DWARFSection &getLocSection() const { return Dummy; }
   virtual StringRef getARangeSection() const { return ""; }

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

 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 
 namespace llvm {
 
 struct DWARFSection {
   StringRef Data;
 };
 
+struct SectionName {
+  StringRef Name;
+  bool IsNameUnique;
+};
+
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFSECTION_H

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

 };
 } // namespace
 
 class DWARFObjInMemory final : public DWARFObject {
   bool IsLittleEndian;
   uint8_t AddressSize;
   StringRef FileName;
   const object::ObjectFile *Obj = nullptr;
+  std::vector<SectionName> SectionNames;
 
   using TypeSectionMap = MapVector<object::SectionRef, DWARFSectionMap,
                                    std::map<object::SectionRef, unsigned>>;
 
   TypeSectionMap TypesSections;
   TypeSectionMap TypesDWOSections;
 
   DWARFSectionMap InfoSection;
DWARFObjInMemory(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
     }
   }
   DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
                    function_ref<ErrorPolicy(Error)> HandleError)
       : IsLittleEndian(Obj.isLittleEndian()),
         AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
         Obj(&Obj) {
 
+    StringMap<unsigned> SectionAmountMap;
     for (const SectionRef &Section : Obj.sections()) {
       StringRef Name;
       Section.getName(Name);
+      ++SectionAmountMap[Name];
+      SectionNames.push_back({ Name, true });
+
       // Skip BSS and Virtual sections, they aren't interesting.
       if (Section.isBSS() || Section.isVirtual())
         continue;
 
       StringRef Data;
       section_iterator RelocatedSection = Section.getRelocatedSection();
       // Try to obtain an already relocated version of this section.
       // Else use the unrelocated section from the object file. We'll have to
for (const SectionRef &Section : Obj.sections()) {
           if (EP == ErrorPolicy::Halt)
             return;
           continue;
         }
         RelocAddrEntry Rel = {SymInfoOrErr->SectionIndex, Val};
         Map->insert({Reloc.getOffset(), Rel});
       }
     }
+
+    for (SectionName &S : SectionNames)
+      if (SectionAmountMap[S.Name] > 1)
+        S.IsNameUnique = false;
   }
 
   Optional<RelocAddrEntry> find(const DWARFSection &S,
                                 uint64_t Pos) const override {
     auto &Sec = static_cast<const DWARFSectionMap &>(S);
     RelocAddrMap::const_iterator AI = Sec.Relocs.find(Pos);
     if (AI == Sec.Relocs.end())
       return None;
     return AI->second;
   }
 
   const object::ObjectFile *getFile() const override { return Obj; }
 
+  ArrayRef<SectionName> getSectionNames() const override {
+    return SectionNames;
+  }
+
   bool isLittleEndian() const override { return IsLittleEndian; }
   StringRef getAbbrevDWOSection() const override { return AbbrevDWOSection; }
   const DWARFSection &getLineDWOSection() const override {
     return LineDWOSection;
   }
   const DWARFSection &getLocDWOSection() const override {
     return LocDWOSection;
   }

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

static void dumpApplePropertyAttribute(raw_ostream &OS, uint64_t Val) {
   } while (true);
   OS << ")";
 }
 
 static void dumpRanges(const DWARFObject &Obj, raw_ostream &OS,
                        const DWARFAddressRangesVector &Ranges,
                        unsigned AddressSize, unsigned Indent,
                        const DIDumpOptions &DumpOpts) {
-  StringMap<unsigned> SectionAmountMap;
-  std::vector<StringRef> SectionNames;
-  if (Obj.getFile() && !DumpOpts.Brief) {
-    for (const SectionRef &Section : Obj.getFile()->sections()) {
-      StringRef Name;
-      if (Section.getName(Name))
-        Name = "<error>";
-
-      ++SectionAmountMap[Name];
-      SectionNames.push_back(Name);
-    }
-  }
+  ArrayRef<SectionName> SectionNames;
+  if (!DumpOpts.Brief)
+    SectionNames = Obj.getSectionNames();
 
   for (size_t I = 0; I < Ranges.size(); ++I) {
     const DWARFAddressRange &R = Ranges[I];
 
     OS << '\n';
     OS.indent(Indent);
     OS << format("[0x%0*" PRIx64 " - 0x%0*" PRIx64 ")", AddressSize * 2,
                  R.LowPC, AddressSize * 2, R.HighPC);
 
     if (SectionNames.empty() || R.SectionIndex == -1ULL)
       continue;
 
-    StringRef Name = R.SectionIndex < SectionNames.size()
-                         ? SectionNames[R.SectionIndex]
-                         : "<error>";
-    OS << format(" \"%s\"", Name.str().c_str());
+    StringRef Name = SectionNames[R.SectionIndex].Name;
+    OS << " \"" << Name << '\"';
 
-    // Print section index if there is more than one section with this name.
-    if (SectionAmountMap[Name] > 1)
+    // Print section index if name is not unique.
+    if (!SectionNames[R.SectionIndex].IsNameUnique)
       OS << format(" [%u]", R.SectionIndex);
   }
 }
 
 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
                           uint32_t *OffsetPtr, dwarf::Attribute Attr,
                           dwarf::Form Form, unsigned Indent,
                           DIDumpOptions DumpOpts) {