[DebugInfo] Fix emitting .debug_names with -dwarf-sections-as-reference=Enable

[ikudrin]

Summary

If UseSectionsAsReferences == true, DwarfCompileUnit do not define a separate label at the beginning of the unit and getLabelBegin() cannot be used. To reference the CU, the section symbol and the offset in the debug info section should be used instead.

This fixes a crash in llvm/test/DebugInfo/Generic/2010-04-19-FramePtr.ll when NVPTX is set as a default target.

llvm/lib/CodeGen/AsmPrinter/AccelTable.cpp

public:
   void emit() const;
 
 #ifndef NDEBUG
   void print(raw_ostream &OS) const;
   void dump() const { print(dbgs()); }
 #endif
 };
 
+/// The struct represents a compile unit reference to be emitted by
+/// Dwarf5AccelTableWriter. It either contains LabelBegin of the CU and a zero
+/// offset or BeginSymbol of the debug info section and the offset in the
+/// section if a distinct label is not defined.
+struct CUReference {
+  MCSymbol *Label;
+  uint64_t Offset;
+};
+
 /// Class responsible for emitting a DWARF v5 Accelerator Table. The only
 /// public function is emit(), which performs the actual emission.
 ///
 /// The class is templated in its data type. This allows us to emit both dyamic
 /// and static data entries. A callback abstract the logic to provide a CU
 /// index for a given entry, which is different per data type, but identical
 /// for every entry in the same table.
 template <typename DataT>
class Dwarf5AccelTableWriter : public AccelTableWriter {
   };
   struct AttributeEncoding {
     dwarf::Index Index;
     dwarf::Form Form;
   };
 
   Header Header;
   DenseMap<uint32_t, SmallVector<AttributeEncoding, 2>> Abbreviations;
-  ArrayRef<MCSymbol *> CompUnits;
+  ArrayRef<CUReference> CompUnits;
   llvm::function_ref<unsigned(const DataT &)> getCUIndexForEntry;
   MCSymbol *ContributionEnd = nullptr;
   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 DataT &Entry) const;
   void emitData() const;
 
 public:
   Dwarf5AccelTableWriter(
       AsmPrinter *Asm, const AccelTableBase &Contents,
-      ArrayRef<MCSymbol *> CompUnits,
+      ArrayRef<CUReference> CompUnits,
       llvm::function_ref<unsigned(const DataT &)> GetCUIndexForEntry);
 
   void emit();
 };
 } // namespace
 
 void AccelTableWriter::emitHashes() const {
   uint64_t PrevHash = std::numeric_limits<uint64_t>::max();
Dwarf5AccelTableWriter<DataT>::getUniformAttributes() const {
   UA.push_back({dwarf::DW_IDX_die_offset, dwarf::DW_FORM_ref4});
   return UA;
 }
 
 template <typename DataT>
 void Dwarf5AccelTableWriter<DataT>::emitCUList() const {
   for (const auto &CU : enumerate(CompUnits)) {
     Asm->OutStreamer->AddComment("Compilation unit " + Twine(CU.index()));
-    Asm->emitDwarfSymbolReference(CU.value());
+    if (CU.value().Offset)
+      Asm->emitDwarfOffset(CU.value().Label, CU.value().Offset);
+    else
+      Asm->emitDwarfSymbolReference(CU.value().Label);
   }
 }
 
 template <typename DataT>
 void Dwarf5AccelTableWriter<DataT>::emitBuckets() const {
   uint32_t Index = 1;
   for (const auto &Bucket : enumerate(Contents.getBuckets())) {
     Asm->OutStreamer->AddComment("Bucket " + Twine(Bucket.index()));
for (auto *Hash : Bucket) {
       Asm->emitInt8(0);
     }
   }
 }
 
 template <typename DataT>
 Dwarf5AccelTableWriter<DataT>::Dwarf5AccelTableWriter(
     AsmPrinter *Asm, const AccelTableBase &Contents,
-    ArrayRef<MCSymbol *> CompUnits,
+    ArrayRef<CUReference> CompUnits,
     llvm::function_ref<unsigned(const DataT &)> getCUIndexForEntry)
     : AccelTableWriter(Asm, Contents, false),
       Header(CompUnits.size(), Contents.getBucketCount(),
              Contents.getUniqueNameCount()),
       CompUnits(CompUnits), getCUIndexForEntry(std::move(getCUIndexForEntry)) {
   DenseSet<uint32_t> UniqueTags = getUniqueTags();
   SmallVector<AttributeEncoding, 2> UniformAttributes = getUniformAttributes();
 
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) {
-  std::vector<MCSymbol *> CompUnits;
+  std::vector<CUReference> CompUnits;
   SmallVector<unsigned, 1> CUIndex(CUs.size());
   int Count = 0;
   for (const auto &CU : enumerate(CUs)) {
     if (CU.value()->getCUNode()->getNameTableKind() !=
         DICompileUnit::DebugNameTableKind::Default)
       continue;
     CUIndex[CU.index()] = Count++;
     assert(CU.index() == CU.value()->getUniqueID());
     const DwarfCompileUnit *MainCU =
         DD.useSplitDwarf() ? CU.value()->getSkeleton() : CU.value().get();
-    CompUnits.push_back(MainCU->getLabelBegin());
+    if (DD.useSectionsAsReferences())
+      CompUnits.push_back({MainCU->getSection()->getBeginSymbol(),
+                           MainCU->getDebugSectionOffset()});
+    else
+      CompUnits.push_back({MainCU->getLabelBegin(), 0});
   }
 
   if (CompUnits.empty())
     return;
 
   Asm->OutStreamer->SwitchSection(
       Asm->getObjFileLowering().getDwarfDebugNamesSection());
 
   Contents.finalize(Asm, "names");
   Dwarf5AccelTableWriter<DWARF5AccelTableData>(
       Asm, Contents, CompUnits,
       [&](const DWARF5AccelTableData &Entry) {
         const DIE *CUDie = Entry.getDie().getUnitDie();
         return CUIndex[DD.lookupCU(CUDie)->getUniqueID()];
       })
       .emit();
 }
 
 void llvm::emitDWARF5AccelTable(
     AsmPrinter *Asm, AccelTable<DWARF5AccelTableStaticData> &Contents,
     ArrayRef<MCSymbol *> CUs,
     llvm::function_ref<unsigned(const DWARF5AccelTableStaticData &)>
         getCUIndexForEntry) {
   Contents.finalize(Asm, "names");
-  Dwarf5AccelTableWriter<DWARF5AccelTableStaticData>(Asm, Contents, CUs,
+  std::vector<CUReference> CompUnits;
+  CompUnits.reserve(CUs.size());
+  for (auto *Label : CUs)
+    CompUnits.push_back({Label, 0});
+  Dwarf5AccelTableWriter<DWARF5AccelTableStaticData>(Asm, Contents, CompUnits,
                                                      getCUIndexForEntry)
       .emit();
 }
 
 void AppleAccelTableOffsetData::emit(AsmPrinter *Asm) const {
   assert(Die.getDebugSectionOffset() <= UINT32_MAX &&
          "The section offset exceeds the limit.");
   Asm->emitInt32(Die.getDebugSectionOffset());

llvm/test/DebugInfo/X86/sections-as-references-dwarf5-accel-tables.ll

+; Test that DWARFv5 accelerator tables can be emitted when
+; -dwarf-sections-as-references=Enable is specified.
+
+; RUN: llc -filetype=asm -mtriple=x86_64-linux-gnu -accel-tables=Dwarf \
+; RUN:   -dwarf-sections-as-references=Enable < %s | FileCheck %s
+
+; CHECK:      .section .debug_names,
+; CHECK-NOT:  .section
+; CHECK:      .long .debug_info        # Compilation unit 0
+; CHECK-NEXT: .long .debug_info+[[#]]  # Compilation unit 1
+
+%struct.foo = type { i8 }
+
+@f = global %struct.foo zeroinitializer, align 1, !dbg !0
+
+!llvm.dbg.cu = !{!6, !7}
+!llvm.module.flags = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = !DIGlobalVariable(name: "f", scope: null, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true)
+!2 = !DIFile(filename: "tu.h", directory: "/dir")
+!3 = !DIFile(filename: "tu.cpp", directory: "/dir")
+!4 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", file: !2, line: 1, size: 8, align: 8, elements: !5, identifier: "_ZTS3foo")
+!5 = !{}
+!6 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !8, imports: !5)
+!7 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, globals: !9, imports: !5)
+!8 = !{!4}
+!9 = !{!0}
+!10 = !{i32 1, !"Debug Info Version", i32 3}