[DEBUGINFO] Add flag for DWARF2 to use sections as references.

[ABataev]

Summary

Some targets does not support labels inside debug sections, but support
references in form section+offset. Patch adds initial support
for this. Also, this patch disables emission of all additional debug
sections that may have labels inside of it (like pub sections and
string tables).

[echristo]

Some inline comments.

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

320 ↗

(On Diff #136521)

Why?

751 ↗

(On Diff #136521)

Can you explain why this one is necessary?

1579–1583 ↗

(On Diff #136521)

Let's refactor this into a "DwarfEmitOffset" function and use it in all of the places we want to emit a label plus an offset, then this becomes a two line patch.

[ABataev]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

320 ↗

(On Diff #136521)

Removed

751 ↗

(On Diff #136521)

It was fixed already in another patch

1579–1583 ↗

(On Diff #136521)

Ok, will do

[ABataev]

Updated to the latest version + fixes.

[echristo]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

1579–1583 ↗

(On Diff #136521)

Feels like you should be able to refactor the if conditional into the function as well and generally just use it everywhere?

Also means you can probably split it into two patches:

1. Add EmitDwarfOffset
2. Add support for useSectionsAsReferences

Thoughts?

[ABataev]

Update after review

[echristo]

Works for me. Might want to make sure that any other uses are updated as well.

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

if (CURanges.empty() || !SameAsPrevCU ||
     return;
   }
 
   CURanges.back().setEnd(Range.getEnd());
 }
 
 void DwarfCompileUnit::initStmtList() {
   // Define start line table label for each Compile Unit.
-  MCSymbol *LineTableStartSym =
+  MCSymbol *LineTableStartSym;
+  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
+  if (DD->useSectionsAsReferences()) {
+    LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
+  } else {
+    LineTableStartSym =
         Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());
+  }
 
   // DW_AT_stmt_list is a offset of line number information for this
   // compile unit in debug_line section. For split dwarf this is
   // left in the skeleton CU and so not included.
   // The line table entries are not always emitted in assembly, so it
   // is not okay to use line_table_start here.
-  const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   StmtListValue =
       addSectionLabel(getUnitDie(), dwarf::DW_AT_stmt_list, LineTableStartSym,
                       TLOF.getDwarfLineSection()->getBeginSymbol());
 }
 
 void DwarfCompileUnit::applyStmtList(DIE &D) {
   D.addValue(DIEValueAllocator, *StmtListValue);
 }
void DwarfCompileUnit::createAbstractVariable(const DILocalVariable *Var,
   assert(Scope && Scope->isAbstractScope());
   auto AbsDbgVariable = llvm::make_unique<DbgVariable>(Var, /* IA */ nullptr);
   DU->addScopeVariable(Scope, AbsDbgVariable.get());
   getAbstractVariables()[Var] = std::move(AbsDbgVariable);
 }
 
 void DwarfCompileUnit::emitHeader(bool UseOffsets) {
   // Don't bother labeling the .dwo unit, as its offset isn't used.
-  if (!Skeleton) {
+  if (!Skeleton && !DD->useSectionsAsReferences()) {
     LabelBegin = Asm->createTempSymbol("cu_begin");
     Asm->OutStreamer->EmitLabel(LabelBegin);
   }
 
   dwarf::UnitType UT = Skeleton ? dwarf::DW_UT_split_compile
                                 : DD->useSplitDwarf() ? dwarf::DW_UT_skeleton
                                                       : dwarf::DW_UT_compile;
   DwarfUnit::emitCommonHeader(UseOffsets, UT);

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.h

class DwarfDebug : public DebugHandlerBase {
   bool UseInlineStrings = false;
 
   /// Whether to emit DWARF pub sections or not.
   bool UsePubSections = true;
 
   /// Allow emission of .debug_ranges section.
   bool UseRangesSection = true;
 
+  /// True if the sections itself must be used as references and don't create
+  /// temp symbols inside DWARF sections.
+  bool UseSectionsAsReferences = false;
+
   /// DWARF5 Experimental Options
   /// @{
   bool HasDwarfAccelTables;
   bool HasAppleExtensionAttributes;
   bool HasSplitDwarf;
 
   /// Whether to generate the DWARF v5 string offsets table.
   /// It consists of a series of contributions, each preceded by a header.
class DwarfDebug : public DebugHandlerBase {
   /// function that describe the same variable.
   void buildLocationList(SmallVectorImpl<DebugLocEntry> &DebugLoc,
                          const DbgValueHistoryMap::InstrRanges &Ranges);
 
   /// Collect variable information from the side table maintained by MF.
   void collectVariableInfoFromMFTable(DwarfCompileUnit &TheCU,
                                       DenseSet<InlinedVariable> &P);
 
+  /// Emit the reference to the section.
+  void emitSectionReference(const DwarfCompileUnit &CU);
+
 protected:
   /// Gather pre-function debug information.
   void beginFunctionImpl(const MachineFunction *MF) override;
 
   /// Gather and emit post-function debug information.
   void endFunctionImpl(const MachineFunction *MF) override;
 
   void skippedNonDebugFunction() override;
public:
   bool useInlineStrings() const { return UseInlineStrings; }
 
   /// Returns whether GNU oub sections should be emitted.
   bool usePubSections() const { return UsePubSections; }
 
   /// Returns whether ranges section should be emitted.
   bool useRangesSection() const { return UseRangesSection; }
 
+  /// Returns whether to use sections as labels rather than temp symbols.
+  bool useSectionsAsReferences() const {
+    return UseSectionsAsReferences;
+  }
+
   // Experimental DWARF5 features.
 
   /// Returns whether or not to emit tables that dwarf consumers can
   /// use to accelerate lookup.
   bool useDwarfAccelTables() const { return HasDwarfAccelTables; }
 
   bool useAppleExtensionAttributes() const {
     return HasAppleExtensionAttributes;

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

NoDwarfPubSections("no-dwarf-pub-sections", cl::Hidden,
                        cl::desc("Disable emission of DWARF pub sections."),
                        cl::init(false));
 
 static cl::opt<bool>
     NoDwarfRangesSection("no-dwarf-ranges-section", cl::Hidden,
                          cl::desc("Disable emission .debug_ranges section."),
                          cl::init(false));
 
+static cl::opt<DefaultOnOff> DwarfSectionsAsReferences(
+    "dwarf-sections-as-references", cl::Hidden,
+    cl::desc("Use sections+offset as references rather than labels."),
+    cl::values(clEnumVal(Default, "Default for platform"),
+               clEnumVal(Enable, "Enabled"), clEnumVal(Disable, "Disabled")),
+    cl::init(Default));
+
 enum LinkageNameOption {
   DefaultLinkageNames,
   AllLinkageNames,
   AbstractLinkageNames
 };
 
 static cl::opt<LinkageNameOption>
     DwarfLinkageNames("dwarf-linkage-names", cl::Hidden,
DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
   unsigned DwarfVersion = DwarfVersionNumber ? DwarfVersionNumber
                                     : MMI->getModule()->getDwarfVersion();
   // Use dwarf 4 by default if nothing is requested.
   DwarfVersion = DwarfVersion ? DwarfVersion : dwarf::DWARF_VERSION;
 
   UsePubSections = !NoDwarfPubSections;
   UseRangesSection = !NoDwarfRangesSection;
 
+  // Use sections as references.
+  UseSectionsAsReferences = DwarfSectionsAsReferences == Enable;
+
   // Work around a GDB bug. GDB doesn't support the standard opcode;
   // SCE doesn't support GNU's; LLDB prefers the standard opcode, which
   // is defined as of DWARF 3.
   // See GDB bug 11616 - DW_OP_form_tls_address is unimplemented
   // https://sourceware.org/bugzilla/show_bug.cgi?id=11616
   UseGNUTLSOpcode = tuneForGDB() || DwarfVersion < 3;
 
   // GDB does not fully support the DWARF 4 representation for bitfields.
for (const auto &NU : CUMap) {
 
     Asm->OutStreamer->SwitchSection(
         GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
                  : Asm->getObjFileLowering().getDwarfPubTypesSection());
     emitDebugPubSection(GnuStyle, "Types", TheU, TheU->getGlobalTypes());
   }
 }
 
+void DwarfDebug::emitSectionReference(const DwarfCompileUnit &CU) {
+  if (useSectionsAsReferences())
+    Asm->EmitDwarfOffset(CU.getSection()->getBeginSymbol(),
+                         CU.getDebugSectionOffset());
+  else
+    Asm->emitDwarfSymbolReference(CU.getLabelBegin());
+}
+
 void DwarfDebug::emitDebugPubSection(bool GnuStyle, StringRef Name,
                                      DwarfCompileUnit *TheU,
                                      const StringMap<const DIE *> &Globals) {
   if (auto *Skeleton = TheU->getSkeleton())
     TheU = Skeleton;
 
   // Emit the header.
   Asm->OutStreamer->AddComment("Length of Public " + Name + " Info");
   MCSymbol *BeginLabel = Asm->createTempSymbol("pub" + Name + "_begin");
   MCSymbol *EndLabel = Asm->createTempSymbol("pub" + Name + "_end");
   Asm->EmitLabelDifference(EndLabel, BeginLabel, 4);
 
   Asm->OutStreamer->EmitLabel(BeginLabel);
 
   Asm->OutStreamer->AddComment("DWARF Version");
   Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
 
   Asm->OutStreamer->AddComment("Offset of Compilation Unit Info");
-  Asm->emitDwarfSymbolReference(TheU->getLabelBegin());
+  emitSectionReference(*TheU);
 
   Asm->OutStreamer->AddComment("Compilation Unit Length");
   Asm->EmitInt32(TheU->getLength());
 
   // Emit the pubnames for this compilation unit.
   for (const auto &GI : Globals) {
     const char *Name = GI.getKeyData();
     const DIE *Entity = GI.second;
for (DwarfCompileUnit *CU : CUs) {
     ContentSize += (List.size() + 1) * TupleSize;
 
     // For each compile unit, write the list of spans it covers.
     Asm->OutStreamer->AddComment("Length of ARange Set");
     Asm->EmitInt32(ContentSize);
     Asm->OutStreamer->AddComment("DWARF Arange version number");
     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
     Asm->OutStreamer->AddComment("Offset Into Debug Info Section");
-    Asm->emitDwarfSymbolReference(CU->getLabelBegin());
+    emitSectionReference(*CU);
     Asm->OutStreamer->AddComment("Address Size (in bytes)");
     Asm->EmitInt8(PtrSize);
     Asm->OutStreamer->AddComment("Segment Size (in bytes)");
     Asm->EmitInt8(0);
 
     Asm->OutStreamer->emitFill(Padding, 0xff);
 
     for (const ArangeSpan &Span : List) {

llvm/trunk/test/DebugInfo/X86/sections_as_references.ll

+; RUN: llc -filetype=asm -O0 -mtriple=x86_64-linux-gnu < %s -dwarf-sections-as-references=Enable -dwarf-inlined-strings=Enable -no-dwarf-pub-sections -no-dwarf-ranges-section -dwarf-version 2 -debugger-tune=gdb | FileCheck %s
+
+; CHECK:      .file
+
+; CHECK-NOT:  .L
+
+; CHECK:      .section .debug_abbrev
+; CHECK-NOT:  DW_FORM_str{{p|x}}
+; CHECK-NOT: .L
+
+; CHECK:      .section .debug_info
+; CHECK-NOT:  .L
+; CHECK:      .short 2             # DWARF version number
+; CHECK-NOT:  .L
+; CHECK:      .long .debug_abbrev  # Offset Into Abbrev. Section
+; CHECK-NOT:  .L
+; CHECK:      .long .debug_line    # DW_AT_stmt_list
+; CHECK-NOT:  .L
+; CHECK:      .long .debug_abbrev  # Offset Into Abbrev. Section
+; CHECK-NOT:  .L
+; CHECK:      .long .debug_line    # DW_AT_stmt_list
+; CHECK-NOT:  .L
+; CHECK:      .quad .debug_info+{{[0-9]+}} # DW_AT_type
+; CHECK-NOT:  .L
+; CHECK:      .byte 0              # End Of Children Mark
+; CHECK-NOT:  .L
+
+source_filename = "test/DebugInfo/X86/sections_as_references.ll"
+
+%struct.foo = type { i8 }
+
+@f = global %struct.foo zeroinitializer, align 1, !dbg !0
+@g = global %struct.foo zeroinitializer, align 1, !dbg !6
+
+!llvm.dbg.cu = !{!9, !12}
+!llvm.module.flags = !{!14, !15}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = !DIGlobalVariable(name: "f", scope: null, file: !2, line: 2, type: !3, isLocal: false, isDefinition: true)
+!2 = !DIFile(filename: "tu1.cpp", directory: "/dir")
+!3 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", file: !4, line: 1, size: 8, align: 8, elements: !5, identifier: "_ZTS3foo")
+!4 = !DIFile(filename: "./hdr.h", directory: "/dir")
+!5 = !{}
+!6 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression())
+!7 = !DIGlobalVariable(name: "g", scope: null, file: !8, line: 2, type: !3, isLocal: false, isDefinition: true)
+!8 = !DIFile(filename: "tu2.cpp", directory: "/dir")
+!9 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !2, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !10, globals: !11, imports: !5)
+!10 = !{!3}
+!11 = !{!0}
+!12 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !8, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !10, globals: !13, imports: !5)
+!13 = !{!6}
+!14 = !{i32 2, !"Dwarf Version", i32 2}
+!15 = !{i32 1, !"Debug Info Version", i32 3}
+