[AccelTable] Extract EmitterInfo

[JDevlieghere]

Summary

When emitting the DWARF accelerator tables from dsymutil, we don't have a DwarfDebug instance and we use a custom class to represent Dwarf compile units. This patch adds an interface AccelTableEmitterInfo to abstract these from the Dwarf5AccelTableEmitter, so we can have a custom implementation for this in dsymutil.

[aprantl]

llvm/include/llvm/CodeGen/AccelTable.h

290 ↗

(On Diff #154423)

Doxygen comment?

llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp

238 ↗

(On Diff #154423)

Doxygen comment for the class?

453 ↗

(On Diff #154423)

The LLVM coding guidelines discourage commented out code. Is this necessary here?

[JDevlieghere]

• Add doxygen comments
• Remove commented out code

[JDevlieghere]

llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp

453 ↗

(On Diff #154423)

Yup, this shouldn't have made it into the code review.

[aprantl]

llvm/include/llvm/CodeGen/AccelTable.h

292 ↗

(On Diff #154443)

What would you think about Writer instead of Emitter?

llvm/trunk/include/llvm/CodeGen/AccelTable.h

 class AccelTableData {
 public:
   virtual ~AccelTableData() = default;
 
   bool operator<(const AccelTableData &Other) const {
     return order() < Other.order();
   }
 
     // Subclasses should implement:
     // static uint32_t hash(StringRef Name);
 
 #ifndef NDEBUG
   virtual void print(raw_ostream &OS) const = 0;
 #endif
 protected:
   virtual uint64_t order() const = 0;
 };
 
void emitAppleAccelTable(AsmPrinter *Asm, AccelTable<DataT> &Contents,
   emitAppleAccelTableImpl(Asm, Contents, Prefix, SecBegin, DataT::Atoms);
 }
 
 void emitDWARF5AccelTable(AsmPrinter *Asm,
                           AccelTable<DWARF5AccelTableData> &Contents,
                           const DwarfDebug &DD,
                           ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs);
 
+/// Abstraction to allow different users (DwarfDebug and dsymutil) to emit
+/// Dwarf accelerator tables.
+class AccelTableWriterInfo {
+public:
+  virtual ~AccelTableWriterInfo() = default;
+  virtual MCSymbol* getLabelForCU(unsigned Idx) const = 0;
+  virtual unsigned getNumberOfCUs() const = 0;
+  virtual unsigned getUnqiueIDForUnitDie(const DIE* UnitDie) const = 0;
+};
+
+void emitDWARF5AccelTable(AsmPrinter *Asm,
+                          AccelTable<DWARF5AccelTableData> &Contents,
+                          const DwarfDebug &DD,
+                          ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs);
+
+void emitDWARF5AccelTable(
+    AsmPrinter *Asm, AccelTable<DWARF5AccelTableData> &Contents,
+    std::unique_ptr<AccelTableWriterInfo> WriterInfo);
+
 /// Accelerator table data implementation for simple Apple accelerator tables
 /// with just a DIE reference.
 class AppleAccelTableOffsetData : public AppleAccelTableData {
 public:
   AppleAccelTableOffsetData(const DIE *D) : Die(D) {}
 
   void emit(AsmPrinter *Asm) const override;
 

llvm/trunk/lib/CodeGen/AsmPrinter/AccelTable.cpp

class Dwarf5AccelTableWriter : public AccelTableWriter {
   };
   struct AttributeEncoding {
     dwarf::Index Index;
     dwarf::Form Form;
   };
 
   Header Header;
   DenseMap<uint32_t, SmallVector<AttributeEncoding, 2>> Abbreviations;
-  const DwarfDebug &DD;
-  ArrayRef<std::unique_ptr<DwarfCompileUnit>> CompUnits;
+  std::unique_ptr<AccelTableWriterInfo> WriterInfo;
   MCSymbol *ContributionStart = Asm->createTempSymbol("names_start");
   MCSymbol *ContributionEnd = Asm->createTempSymbol("names_end");
   MCSymbol *AbbrevStart = Asm->createTempSymbol("names_abbrev_start");
   MCSymbol *AbbrevEnd = Asm->createTempSymbol("names_abbrev_end");
   MCSymbol *EntryPool = Asm->createTempSymbol("names_entries");
 
   DenseSet<uint32_t> getUniqueTags() const;
 
   // Right now, we emit uniform attributes for all tags.
   SmallVector<AttributeEncoding, 2> getUniformAttributes() const;
 
   void emitCUList() const;
   void emitBuckets() const;
   void emitStringOffsets() const;
   void emitAbbrevs() const;
   void emitEntry(const DWARF5AccelTableData &Data) const;
   void emitData() const;
 
 public:
   Dwarf5AccelTableWriter(AsmPrinter *Asm, const AccelTableBase &Contents,
-                         const DwarfDebug &DD,
-                         ArrayRef<std::unique_ptr<DwarfCompileUnit>> CompUnits);
+                          std::unique_ptr<AccelTableWriterInfo> WriterInfo);
 
   void emit() const;
 };
+
+/// Default emitter info used by DwarfDebug.
+class DefaultAccelTableWriterInfo final : public AccelTableWriterInfo {
+private:
+  const DwarfDebug &DD;
+  ArrayRef<std::unique_ptr<DwarfCompileUnit>> CompUnits;
+
+public:
+  DefaultAccelTableWriterInfo(const DwarfDebug &DD, ArrayRef<std::unique_ptr<DwarfCompileUnit>> CompUnits);
+  MCSymbol *getLabelForCU(unsigned Idx) const override;
+  unsigned getNumberOfCUs() const override;
+  unsigned getUnqiueIDForUnitDie(const DIE *UnitDie) const override;
+};
 } // namespace
 
+DefaultAccelTableWriterInfo::DefaultAccelTableWriterInfo(
+    const DwarfDebug &DD, ArrayRef<std::unique_ptr<DwarfCompileUnit>> CompUnits)
+    : DD(DD), CompUnits(CompUnits) {}
+
+MCSymbol *DefaultAccelTableWriterInfo::getLabelForCU(unsigned Idx) const {
+  assert(Idx < CompUnits.size());
+  const auto &CU = CompUnits[Idx];
+  assert(Idx == CU->getUniqueID());
+  const DwarfCompileUnit *MainCU =
+      DD.useSplitDwarf() ? CU->getSkeleton() : CU.get();
+  return MainCU->getLabelBegin();
+}
+
+unsigned DefaultAccelTableWriterInfo::getNumberOfCUs() const {
+  return CompUnits.size();
+}
+
+unsigned
+DefaultAccelTableWriterInfo::getUnqiueIDForUnitDie(const DIE *UnitDie) const {
+  return DD.lookupCU(UnitDie)->getUniqueID();
+}
+
 void AccelTableWriter::emitHashes() const {
   uint64_t PrevHash = std::numeric_limits<uint64_t>::max();
   unsigned BucketIdx = 0;
   for (auto &Bucket : Contents.getBuckets()) {
     for (auto &Hash : Bucket) {
       uint32_t HashValue = Hash->HashValue;
       if (SkipIdenticalHashes && PrevHash == HashValue)
         continue;
for (auto &Bucket : Contents.getBuckets()) {
     }
   }
   return UniqueTags;
 }
 
 SmallVector<Dwarf5AccelTableWriter::AttributeEncoding, 2>
 Dwarf5AccelTableWriter::getUniformAttributes() const {
   SmallVector<AttributeEncoding, 2> UA;
-  if (CompUnits.size() > 1) {
-    size_t LargestCUIndex = CompUnits.size() - 1;
+  if (WriterInfo->getNumberOfCUs() > 1) {
+    size_t LargestCUIndex = WriterInfo->getNumberOfCUs() - 1;
     dwarf::Form Form = DIEInteger::BestForm(/*IsSigned*/ false, LargestCUIndex);
     UA.push_back({dwarf::DW_IDX_compile_unit, Form});
   }
   UA.push_back({dwarf::DW_IDX_die_offset, dwarf::DW_FORM_ref4});
   return UA;
 }
 
 void Dwarf5AccelTableWriter::emitCUList() const {
-  for (const auto &CU : enumerate(CompUnits)) {
-    assert(CU.index() == CU.value()->getUniqueID());
-    Asm->OutStreamer->AddComment("Compilation unit " + Twine(CU.index()));
-    const DwarfCompileUnit *MainCU =
-        DD.useSplitDwarf() ? CU.value()->getSkeleton() : CU.value().get();
-    Asm->emitDwarfSymbolReference(MainCU->getLabelBegin());
+  for (unsigned Idx = 0, CUs = WriterInfo->getNumberOfCUs(); Idx < CUs;
+       ++Idx) {
+    Asm->OutStreamer->AddComment("Compilation unit " + Twine(Idx));
+    Asm->emitDwarfSymbolReference(WriterInfo->getLabelForCU(Idx));
   }
 }
 
 void Dwarf5AccelTableWriter::emitBuckets() const {
   uint32_t Index = 1;
   for (const auto &Bucket : enumerate(Contents.getBuckets())) {
     Asm->OutStreamer->AddComment("Bucket " + Twine(Bucket.index()));
     Asm->emitInt32(Bucket.value().empty() ? 0 : Index);
assert(AbbrevIt != Abbreviations.end() &&
          "Why wasn't this abbrev generated?");
 
   Asm->EmitULEB128(AbbrevIt->first, "Abbreviation code");
   for (const auto &AttrEnc : AbbrevIt->second) {
     Asm->OutStreamer->AddComment(dwarf::IndexString(AttrEnc.Index));
     switch (AttrEnc.Index) {
     case dwarf::DW_IDX_compile_unit: {
       const DIE *CUDie = Entry.getDie().getUnitDie();
-      DIEInteger ID(DD.lookupCU(CUDie)->getUniqueID());
+      DIEInteger ID(WriterInfo->getUnqiueIDForUnitDie(CUDie));
       ID.EmitValue(Asm, AttrEnc.Form);
       break;
     }
     case dwarf::DW_IDX_die_offset:
       assert(AttrEnc.Form == dwarf::DW_FORM_ref4);
       Asm->emitInt32(Entry.getDie().getOffset());
       break;
     default:
for (auto *Hash : Bucket) {
         emitEntry(*static_cast<const DWARF5AccelTableData *>(Value));
       Asm->OutStreamer->AddComment("End of list: " + Hash->Name.getString());
       Asm->emitInt32(0);
     }
   }
 }
 
 Dwarf5AccelTableWriter::Dwarf5AccelTableWriter(
-    AsmPrinter *Asm, const AccelTableBase &Contents, const DwarfDebug &DD,
-    ArrayRef<std::unique_ptr<DwarfCompileUnit>> CompUnits)
+    AsmPrinter *Asm, const AccelTableBase &Contents,
+    std::unique_ptr<AccelTableWriterInfo> WriterInfo)
     : AccelTableWriter(Asm, Contents, false),
-      Header(CompUnits.size(), Contents.getBucketCount(),
+      Header(WriterInfo->getNumberOfCUs(), Contents.getBucketCount(),
              Contents.getUniqueNameCount()),
-      DD(DD), CompUnits(CompUnits) {
+      WriterInfo(std::move(WriterInfo)) {
   DenseSet<uint32_t> UniqueTags = getUniqueTags();
   SmallVector<AttributeEncoding, 2> UniformAttributes = getUniformAttributes();
 
   Abbreviations.reserve(UniqueTags.size());
   for (uint32_t Tag : UniqueTags)
     Abbreviations.try_emplace(Tag, UniformAttributes);
 }
 
void llvm::emitAppleAccelTableImpl(AsmPrinter *Asm, AccelTableBase &Contents,
                                    ArrayRef<AppleAccelTableData::Atom> Atoms) {
   Contents.finalize(Asm, Prefix);
   AppleAccelTableWriter(Asm, Contents, Atoms, SecBegin).emit();
 }
 
 void llvm::emitDWARF5AccelTable(
     AsmPrinter *Asm, AccelTable<DWARF5AccelTableData> &Contents,
     const DwarfDebug &DD, ArrayRef<std::unique_ptr<DwarfCompileUnit>> CUs) {
+  auto WriterInfo = llvm::make_unique<DefaultAccelTableWriterInfo>(DD, CUs);
+  emitDWARF5AccelTable(Asm, Contents, std::move(WriterInfo));
+}
+
+void llvm::emitDWARF5AccelTable(
+    AsmPrinter *Asm, AccelTable<DWARF5AccelTableData> &Contents,
+    std::unique_ptr<AccelTableWriterInfo> WriterInfo) {
   Contents.finalize(Asm, "names");
-  Dwarf5AccelTableWriter(Asm, Contents, DD, CUs).emit();
+  Dwarf5AccelTableWriter(Asm, Contents, std::move(WriterInfo)).emit();
 }
 
 void AppleAccelTableOffsetData::emit(AsmPrinter *Asm) const {
   Asm->emitInt32(Die->getDebugSectionOffset());
 }
 
 void AppleAccelTableTypeData::emit(AsmPrinter *Asm) const {
   Asm->emitInt32(Die->getDebugSectionOffset());