[DEBUGINFO] Disable emission of the dwarf sections, but allow directives.

[ABataev]

Summary

Added an option that allows to emit only '.loc' and '.file' kind debug
directives, but disables emission of the DWARF sections. Required for
NVPTX target to support profiling. It requires '.loc' and '.file'
directives, but does not require any DWARF sections for the profiler.

[dblaikie]

Sorry, I'm a bit confused.

1. I'd expect /this/ behavior (line table directives, but no debug_info, etc) to be controlled via a DICompileUnit emission kind (a value between "NoDebug" and "LineTablesOnly" as Paul mentioned).

2. I'd expect the "no ', debug'" flag (which I don't see in this change? Is it missing? is it elsewhere?) to be controlled via an MCOption - because it must be global.

Now, arguably, if we have the global "no ', debug'" flag we maybe might as well use it to implement this behavior too since we don't have any other use for it? So maybe (2) invalidates (1).

[ABataev]

In D46021#1077023, @dblaikie wrote:

Sorry, I'm a bit confused.

1. I'd expect /this/ behavior (line table directives, but no debug_info, etc) to be controlled via a DICompileUnit emission kind (a value between "NoDebug" and "LineTablesOnly" as Paul mentioned).

2. I'd expect the "no ', debug'" flag (which I don't see in this change? Is it missing? is it elsewhere?) to be controlled via an MCOption - because it must be global.

Now, arguably, if we have the global "no ', debug'" flag we maybe might as well use it to implement this behavior too since we don't have any other use for it? So maybe (2) invalidates (1).

I thought, that it is not very useful to have an option that, actually, controls only single target and I decided instead to add the option that just disables emission of the DWARF sections. In this case we don't need the special debug info mode, we can use this option.

[ABataev]

Updated to latest version

[echristo]

In D46021#1077031, @ABataev wrote:

In D46021#1077023, @dblaikie wrote:

Sorry, I'm a bit confused.

1. I'd expect /this/ behavior (line table directives, but no debug_info, etc) to be controlled via a DICompileUnit emission kind (a value between "NoDebug" and "LineTablesOnly" as Paul mentioned).

2. I'd expect the "no ', debug'" flag (which I don't see in this change? Is it missing? is it elsewhere?) to be controlled via an MCOption - because it must be global.

Now, arguably, if we have the global "no ', debug'" flag we maybe might as well use it to implement this behavior too since we don't have any other use for it? So maybe (2) invalidates (1).

I thought, that it is not very useful to have an option that, actually, controls only single target and I decided instead to add the option that just disables emission of the DWARF sections. In this case we don't need the special debug info mode, we can use this option.

I agree with Dave here. We already have some existing functionality that handles, for example, "minimal line tables" and so extending it to be "location directives only" seems like the direction we should go.

[ABataev]

Reworked to control output by DICompileUnit emission kind.

[dblaikie]

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

2145

Could simplify this by dropping the "::const_iterator":

[](const decltype(CUMap)::value_type &Pair) {

test/DebugInfo/Generic/directives-only.ll

5

Is the integrated assembler tested here? Doesn't immediately look like it to me.

[ABataev]

test/DebugInfo/Generic/directives-only.ll

5

Wrong comment, will remove it.

[ABataev]

Address David's comments

[dblaikie]

• Naming of "DebugDirectivesOnly" could maybe be improved but I can't think of anything better - can be changed later if someone comes up with a better name in post-commit review
• Probably add a helper function to DwarfCompileUnit to test if the CUNode specifies DebugDirectivesOnly ("bool DwarfCompileUnit::hasDebugDirectivesOnly()" for example) & use that everywhere, since this test is done in enough places and is a bit verbose as-is.

[tra]

Is there a way to control this from clang command line?

[ABataev]

In D46021#1200884, @tra wrote:

Is there a way to control this from clang command line?

Not yet, need to commit at least one more patch and then will start work on the clang patch for this feature.

include/llvm/IR/DebugInfoMetadata.h

class DICompileUnit : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
 public:
   enum DebugEmissionKind : unsigned {
     NoDebug = 0,
     FullDebug,
     LineTablesOnly,
-    LastEmissionKind = LineTablesOnly
+    DebugDirectivesOnly,
+    LastEmissionKind = DebugDirectivesOnly
   };
 
   static Optional<DebugEmissionKind> getEmissionKind(StringRef Str);
   static const char *emissionKindString(DebugEmissionKind EK);
 
 private:
   unsigned SourceLanguage;
   bool IsOptimized;

lib/AsmParser/LLLexer.cpp

#undef DWKEYWORD
   }
 
   if (Keyword.startswith("CSK_")) {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::ChecksumKind;
   }
 
   if (Keyword == "NoDebug" || Keyword == "FullDebug" ||
-      Keyword == "LineTablesOnly") {
+      Keyword == "LineTablesOnly" || Keyword == "DebugDirectivesOnly") {
     StrVal.assign(Keyword.begin(), Keyword.end());
     return lltok::EmissionKind;
   }
 
   // Check for [us]0x[0-9A-Fa-f]+ which are Hexadecimal constant generated by
   // the CFE to avoid forcing it to deal with 64-bit numbers.
   if ((TokStart[0] == 'u' || TokStart[0] == 's') &&
       TokStart[1] == '0' && TokStart[2] == 'x' &&

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (CURanges.empty() || !SameAsPrevCU ||
     CURanges.push_back(Range);
     return;
   }
 
   CURanges.back().setEnd(Range.getEnd());
 }
 
 void DwarfCompileUnit::initStmtList() {
+  if (CUNode->getEmissionKind() == DICompileUnit::DebugDirectivesOnly)
+    return;
+
   // Define start line table label for each Compile Unit.
   MCSymbol *LineTableStartSym;
   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
   if (DD->useSectionsAsReferences()) {
     LineTableStartSym = TLOF.getDwarfLineSection()->getBeginSymbol();
   } else {
     LineTableStartSym =
         Asm->OutStreamer->getDwarfLineTableSymbol(getUniqueID());

 
 bool DwarfCompileUnit::hasDwarfPubSections() const {
   // Opting in to GNU Pubnames/types overrides the default to ensure these are
   // generated for things like Gold's gdb_index generation.
   if (CUNode->getGnuPubnames())
     return true;
 
   return DD->tuneForGDB() && DD->usePubSections() &&
-         !includeMinimalInlineScopes();
+         !includeMinimalInlineScopes() &&
+         CUNode->getEmissionKind() != DICompileUnit::DebugDirectivesOnly;
 }
 
 /// addGlobalName - Add a new global name to the compile unit.
 void DwarfCompileUnit::addGlobalName(StringRef Name, const DIE &Die,
                                      const DIScope *Context) {
   if (!hasDwarfPubSections())
     return;
   std::string FullName = getParentContextString(Context) + Name.str();

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::finalizeModuleInfo() {
   StringRef DWOName;
   if (CUMap.size() > 1)
     DWOName = Asm->TM.Options.MCOptions.SplitDwarfFile;
 
   // Handle anything that needs to be done on a per-unit basis after
   // all other generation.
   for (const auto &P : CUMap) {
     auto &TheCU = *P.second;
+    if (TheCU.getCUNode()->getEmissionKind() ==
+        DICompileUnit::DebugDirectivesOnly)
+      continue;
     // Emit DW_AT_containing_type attribute to connect types with their
     // vtable holding type.
     TheCU.constructContainingTypeDIEs();
 
     // Add CU specific attributes if we need to add any.
     // If we're splitting the dwarf out now that we've got the entire
     // CU then add the dwo id to it.
     auto *SkCU = TheCU.getSkeleton();
assert(CurFn == MF &&
       "endFunction should be called with the same function as beginFunction");
 
   // Set DwarfDwarfCompileUnitID in MCContext to default value.
   Asm->OutStreamer->getContext().setDwarfCompileUnitID(0);
 
   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
   assert(!FnScope || SP == FnScope->getScopeNode());
   DwarfCompileUnit &TheCU = *CUMap.lookup(SP->getUnit());
+  if (TheCU.getCUNode()->getEmissionKind() ==
+      DICompileUnit::DebugDirectivesOnly) {
+    PrevLabel = nullptr;
+    CurFn = nullptr;
+    return;
+  }
 
   DenseSet<InlinedVariable> ProcessedVars;
   collectVariableInfo(TheCU, SP, ProcessedVars);
 
   // Add the range of this function to the list of ranges for the CU.
   TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
 
   // Under -gmlt, skip building the subprogram if there are no inlined
void DwarfDebug::emitDebugRanges() {
 
   auto NoRangesPresent = [this]() {
     return llvm::all_of(
         CUMap, [](const decltype(CUMap)::const_iterator::value_type &Pair) {
           return Pair.second->getRangeLists().empty();
         });
   };
 
+  if (llvm::all_of(CUMap, [](const decltype(CUMap)::value_type &Pair) {
+        return Pair.second->getCUNode()->getEmissionKind() ==
+               DICompileUnit::DebugDirectivesOnly;
+      })) {
+    assert(NoRangesPresent() && "No debug ranges expected.");
+    return;
+  }
+
   if (!useRangesSection()) {
     assert(NoRangesPresent() && "No debug ranges expected.");
     return;
   }
 
   if (NoRangesPresent())
     return;
 
   // Start the dwarf ranges section.
   MCSymbol *TableEnd = nullptr;
   if (getDwarfVersion() >= 5) {
     Asm->OutStreamer->SwitchSection(
         Asm->getObjFileLowering().getDwarfRnglistsSection());
     TableEnd = emitRnglistsTableHeader(Asm, useSplitDwarf() ? SkeletonHolder
                                                             : InfoHolder);
   } else
     Asm->OutStreamer->SwitchSection(
         Asm->getObjFileLowering().getDwarfRangesSection());
 
   // Grab the specific ranges for the compile units in the module.
   for (const auto &I : CUMap) {
     DwarfCompileUnit *TheCU = I.second;
+    if (TheCU->getCUNode()->getEmissionKind() ==
+        DICompileUnit::DebugDirectivesOnly)
+      continue;
 
     if (auto *Skel = TheCU->getSkeleton())
       TheCU = Skel;
 
     // Iterate over the misc ranges for the compile units in the module.
     for (const RangeSpanList &List : TheCU->getRangeLists())
       emitRangeList(Asm, TheCU, List);
   }
void DwarfDebug::emitMacroFile(DIMacroFile &F, DwarfCompileUnit &U) {
   Asm->EmitULEB128(dwarf::DW_MACINFO_end_file);
 }
 
 /// Emit macros into a debug macinfo section.
 void DwarfDebug::emitDebugMacinfo() {
   if (CUMap.empty())
     return;
 
+  if (llvm::all_of(CUMap,
+                   [](const decltype(CUMap)::const_iterator::value_type &Pair) {
+                     return Pair.second->getCUNode()->getEmissionKind() ==
+                            DICompileUnit::DebugDirectivesOnly;
+                   }))
+    return;
+
   // Start the dwarf macinfo section.
   Asm->OutStreamer->SwitchSection(
       Asm->getObjFileLowering().getDwarfMacinfoSection());
 
   for (const auto &P : CUMap) {
     auto &TheCU = *P.second;
+    if (TheCU.getCUNode()->getEmissionKind() ==
+        DICompileUnit::DebugDirectivesOnly)
+      continue;
     auto *SkCU = TheCU.getSkeleton();
     DwarfCompileUnit &U = SkCU ? *SkCU : TheCU;
     auto *CUNode = cast<DICompileUnit>(P.first);
     DIMacroNodeArray Macros = CUNode->getMacros();
     if (!Macros.empty()) {
       Asm->OutStreamer->EmitLabel(U.getMacroLabelBegin());
       handleMacroNodes(Macros, U);
     }

lib/CodeGen/AsmPrinter/DwarfFile.cpp

 // Emit the various dwarf units to the unit section USection with
 // the abbreviations going into ASection.
 void DwarfFile::emitUnits(bool UseOffsets) {
   for (const auto &TheU : CUs)
     emitUnit(TheU.get(), UseOffsets);
 }
 
 void DwarfFile::emitUnit(DwarfUnit *TheU, bool UseOffsets) {
+  if (TheU->getCUNode()->getEmissionKind() ==
+      DICompileUnit::DebugDirectivesOnly)
+    return;
+
   DIE &Die = TheU->getUnitDie();
   MCSection *USection = TheU->getSection();
   Asm->OutStreamer->SwitchSection(USection);
 
   TheU->emitHeader(UseOffsets);
 
   Asm->emitDwarfDIE(Die);
 }
 
 // Compute the size and offset for each DIE.
 void DwarfFile::computeSizeAndOffsets() {
   // Offset from the first CU in the debug info section is 0 initially.
   unsigned SecOffset = 0;
 
   // Iterate over each compile unit and set the size and offsets for each
   // DIE within each compile unit. All offsets are CU relative.
   for (const auto &TheU : CUs) {
+    if (TheU->getCUNode()->getEmissionKind() ==
+        DICompileUnit::DebugDirectivesOnly)
+      continue;
+
     TheU->setDebugSectionOffset(SecOffset);
     SecOffset += computeSizeAndOffsetsForUnit(TheU.get());
   }
 }
 
 unsigned DwarfFile::computeSizeAndOffsetsForUnit(DwarfUnit *TheU) {
   // CU-relative offset is reset to 0 here.
   unsigned Offset = sizeof(int32_t) +      // Length of Unit Info

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 
 void DwarfUnit::addSInt(DIELoc &Die, Optional<dwarf::Form> Form,
                         int64_t Integer) {
   addSInt(Die, (dwarf::Attribute)0, Form, Integer);
 }
 
 void DwarfUnit::addString(DIE &Die, dwarf::Attribute Attribute,
                           StringRef String) {
+  if (CUNode->getEmissionKind() == DICompileUnit::DebugDirectivesOnly)
+    return;
+
   if (DD->useInlineStrings()) {
     Die.addValue(DIEValueAllocator, Attribute, dwarf::DW_FORM_string,
                  new (DIEValueAllocator)
                      DIEInlineString(String, DIEValueAllocator));
     return;
   }
   auto StringPoolEntry = DU->getStringPool().getEntry(*Asm, String);
   dwarf::Form IxForm =

lib/IR/DebugInfoMetadata.cpp

 }
 
 Optional<DICompileUnit::DebugEmissionKind>
 DICompileUnit::getEmissionKind(StringRef Str) {
   return StringSwitch<Optional<DebugEmissionKind>>(Str)
       .Case("NoDebug", NoDebug)
       .Case("FullDebug", FullDebug)
       .Case("LineTablesOnly", LineTablesOnly)
+      .Case("DebugDirectivesOnly", DebugDirectivesOnly)
       .Default(None);
 }
 
 const char *DICompileUnit::emissionKindString(DebugEmissionKind EK) {
   switch (EK) {
   case NoDebug:        return "NoDebug";
   case FullDebug:      return "FullDebug";
   case LineTablesOnly: return "LineTablesOnly";
+  case DebugDirectivesOnly: return "DebugDirectviesOnly";
   }
   return nullptr;
 }
 
 DISubprogram *DILocalScope::getSubprogram() const {
   if (auto *Block = dyn_cast<DILexicalBlockBase>(this))
     return Block->getScope()->getSubprogram();
   return const_cast<DISubprogram *>(cast<DISubprogram>(this));

test/DebugInfo/Generic/directives-only.ll

+; RUN: llc -filetype=asm -asm-verbose=0 -O0 < %s | FileCheck %s
+
+; Generated with clang from multiline.c:
+; void f1();
+; void f2() {
+;   f1(); f1(); f1();
+;   f1(); f1(); f1();
+; }
+
+
+; CHECK: .file 1 "/tmp/dbginfo{{.*}}multiline.c"
+; CHECK: .loc 1 2 0
+; CHECK: .loc 1 3 3
+; CHECK: .loc 1 3 9
+; CHECK: .loc 1 3 15
+; CHECK: .loc 1 4 3
+; CHECK: .loc 1 4 9
+; CHECK: .loc 1 4 15
+; CHECK: .loc 1 5 1
+
+; CHECK-NOT: .section .{{debug.*}}
+
+; Function Attrs: nounwind uwtable
+define void @f2() #0 !dbg !4 {
+entry:
+  call void (...) @f1(), !dbg !11
+  call void (...) @f1(), !dbg !12
+  call void (...) @f1(), !dbg !13
+  call void (...) @f1(), !dbg !14
+  call void (...) @f1(), !dbg !15
+  call void (...) @f1(), !dbg !16
+  ret void, !dbg !17
+}
+
+declare void @f1(...) #1
+
+attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.6.0 (trunk 225000) (llvm/trunk 224999)", isOptimized: false, emissionKind: DebugDirectivesOnly, file: !1)
+!1 = !DIFile(filename: "multiline.c", directory: "/tmp/dbginfo")
+!4 = distinct !DISubprogram(name: "f2", line: 2, isLocal: false, isDefinition: true, isOptimized: false, unit: !0, scopeLine: 2, file: !1, scope: !5, type: !6)
+!5 = !DIFile(filename: "multiline.c", directory: "/tmp/dbginfo")
+!6 = !DISubroutineType(types: !7)
+!7 = !{null}
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 3.6.0 (trunk 225000) (llvm/trunk 224999)"}
+!11 = !DILocation(line: 3, column: 3, scope: !4)
+!12 = !DILocation(line: 3, column: 9, scope: !4)
+!13 = !DILocation(line: 3, column: 15, scope: !4)
+!14 = !DILocation(line: 4, column: 3, scope: !4)
+!15 = !DILocation(line: 4, column: 9, scope: !4)
+!16 = !DILocation(line: 4, column: 15, scope: !4)
+!17 = !DILocation(line: 5, column: 1, scope: !4)