[DWARF] Suppress split line tables more carefully.

[probinson]

Summary

If a given split type unit does not have source locations, don't have
it refer to the split line table.
If no split type unit refers to the split line table, don't emit the
line table at all.

This will save a little space on rare occasions, but also refactors
things a bit to improve which class is responsible for what.

Responding to review comments on r326395.

[dblaikie]

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

301–302 ↗

(On Diff #137444)

Presumably this could be improved to omit the stmt_list for non-split type units that don't use file names? Maybe a comment suggesting/mentioning that here or elsewhere might be nice.

llvm/test/CodeGen/X86/dwarf-split-line-1.ll

36–39 ↗

(On Diff #137444)

Guessing this is somewhat hand-crafted IR? You could drop the s1 member, probably, to simplify this further?

[probinson]

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

301–302 ↗

(On Diff #137444)

If you look at the code I removed from the DwarfTypeUnit ctor, it was adding stmt_list only for split type units. So I am doing the same here. I'm actually not sure where we add the stmt_list for a non-split unit.

llvm/test/CodeGen/X86/dwarf-split-line-1.ll

36–39 ↗

(On Diff #137444)

So the composite type would have no elements? I suppose that is legal.

[llvm-commits]

• msg-22155-3.txt162 BDownload

llvm/trunk/include/llvm/MC/MCDwarf.h

void setCompilationDir(StringRef CompilationDir) {
     Header.CompilationDir = CompilationDir;
   }
 
   unsigned getFile(StringRef Directory, StringRef FileName,
                    MD5::MD5Result *Checksum, Optional<StringRef> Source) {
     return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source));
   }
 
-  void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params) const;
+  void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
+            MCSection *Section) const;
 };
 
 class MCDwarfLineTable {
   MCDwarfLineTableHeader Header;
   MCLineSection MCLineSections;
 
 public:
   // This emits the Dwarf file and the line tables for all Compile Units.

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

class DwarfDebug : public DebugHandlerBase {
   bool HasSplitDwarf;
 
   /// Whether to generate the DWARF v5 string offsets table.
   /// It consists of a series of contributions, each preceded by a header.
   /// The pre-DWARF v5 string offsets table for split dwarf is, in contrast,
   /// a monolithic sequence of string offsets.
   bool UseSegmentedStringOffsetsTable;
 
-  /// Whether we have emitted any type units with split DWARF (and therefore
-  /// need to emit a line table to the .dwo file).
-  bool HasSplitTypeUnits = false;
-
   /// Separated Dwarf Variables
   /// In general these will all be for bits that are left in the
   /// original object file, rather than things that are meant
   /// to be in the .dwo sections.
 
   /// Holder for the skeleton information.
   DwarfFile SkeletonHolder;
 

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

 // abbreviations for the .debug_info.dwo section.
 void DwarfDebug::emitDebugAbbrevDWO() {
   assert(useSplitDwarf() && "No split dwarf?");
   InfoHolder.emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection());
 }
 
 void DwarfDebug::emitDebugLineDWO() {
   assert(useSplitDwarf() && "No split dwarf?");
-  if (!HasSplitTypeUnits)
-    return;
-  Asm->OutStreamer->SwitchSection(
+  SplitTypeUnitFileTable.Emit(
+      *Asm->OutStreamer, MCDwarfLineTableParams(),
       Asm->getObjFileLowering().getDwarfLineDWOSection());
-  SplitTypeUnitFileTable.Emit(*Asm->OutStreamer, MCDwarfLineTableParams());
 }
 
 void DwarfDebug::emitStringOffsetsTableHeaderDWO() {
   assert(useSplitDwarf() && "No split dwarf?");
   InfoHolder.emitStringOffsetsTableHeader(
       Asm->getObjFileLowering().getDwarfStrOffDWOSection());
 }
 
void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
 
   uint64_t Signature = makeTypeSignature(Identifier);
   NewTU.setTypeSignature(Signature);
   Ins.first->second = Signature;
 
   if (useSplitDwarf())
     NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
   else {
-    CU.applyStmtList(UnitDie);
     NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
+    // Non-split type units reuse the compile unit's line table.
+    CU.applyStmtList(UnitDie);
   }
 
   // Add DW_AT_str_offsets_base to the type unit DIE, but not for split type
   // units.
   if (useSegmentedStringOffsetsTable() && !useSplitDwarf())
     NewTU.addStringOffsetsStart();
 
   NewTU.setType(NewTU.createTypeDIE(CTy));
if (TopLevelType) {
     }
 
     // If the type wasn't dependent on fission addresses, finish adding the type
     // and all its dependent types.
     for (auto &TU : TypeUnitsToAdd) {
       InfoHolder.computeSizeAndOffsetsForUnit(TU.first.get());
       InfoHolder.emitUnit(TU.first.get(), useSplitDwarf());
     }
-    HasSplitTypeUnits = useSplitDwarf();
   }
   CU.addDIETypeSignature(RefDie, Signature);
 }
 
 // Accelerator table mutators - add each name along with its companion
 // DIE to the proper table while ensuring that the name that we're going
 // to reference is in the string table. We do this since the names we
 // add may not only be identical to the names in the DIE.

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

private:
   const MCSymbol *getCrossSectionRelativeBaseAddress() const override;
 };
 
 class DwarfTypeUnit final : public DwarfUnit {
   uint64_t TypeSignature;
   const DIE *Ty;
   DwarfCompileUnit &CU;
   MCDwarfDwoLineTable *SplitLineTable;
+  bool UsedLineTable = false;
 
   unsigned getOrCreateSourceID(const DIFile *File) override;
   bool isDwoUnit() const override;
 
 public:
   DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A, DwarfDebug *DW,
                 DwarfFile *DWU, MCDwarfDwoLineTable *SplitLineTable = nullptr);
 

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

: DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
       CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
 }
 
 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
                              MCDwarfDwoLineTable *SplitLineTable)
     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
       SplitLineTable(SplitLineTable) {
-  if (SplitLineTable)
-    addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
 }
 
 DwarfUnit::~DwarfUnit() {
   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
     DIEBlocks[j]->~DIEBlock();
   for (unsigned j = 0, M = DIELocs.size(); j < M; ++j)
     DIELocs[j]->~DIELoc();
 }
MD5::MD5Result *DwarfUnit::getMD5AsBytes(const DIFile *File) {
   // An MD5 checksum is 16 bytes.
   std::string ChecksumString = fromHex(Checksum->Value);
   void *CKMem = Asm->OutStreamer->getContext().allocate(16, 1);
   memcpy(CKMem, ChecksumString.data(), 16);
   return reinterpret_cast<MD5::MD5Result *>(CKMem);
 }
 
 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
-  return SplitLineTable
-             ? SplitLineTable->getFile(File->getDirectory(),
-                                       File->getFilename(),
-                                       getMD5AsBytes(File),
-                                       File->getSource())
-             : getCU().getOrCreateSourceID(File);
+  if (!SplitLineTable)
+    return getCU().getOrCreateSourceID(File);
+  if (!UsedLineTable) {
+    UsedLineTable = true;
+    // This is a split type unit that needs a line table.
+    addSectionOffset(getUnitDie(), dwarf::DW_AT_stmt_list, 0);
+  }
+  return SplitLineTable->getFile(File->getDirectory(), File->getFilename(),
+                                 getMD5AsBytes(File), File->getSource());
 }
 
 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
   if (!DD->useSplitDwarf()) {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
     addLabel(Die, dwarf::DW_FORM_udata, Sym);
   } else {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_GNU_addr_index);

llvm/trunk/lib/MC/MCDwarf.cpp

void MCDwarfLineTable::Emit(MCObjectStreamer *MCOS,
   // Handle the rest of the Compile Units.
   for (const auto &CUIDTablePair : LineTables)
     CUIDTablePair.second.EmitCU(MCOS, Params, LineStr);
 
   if (LineStr)
     LineStr->emitSection(MCOS);
 }
 
-void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS,
-                               MCDwarfLineTableParams Params) const {
+void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
+                               MCSection *Section) const {
+  if (Header.MCDwarfFiles.empty())
+    return;
   Optional<MCDwarfLineStr> NoLineStr(None);
+  MCOS.SwitchSection(Section);
   MCOS.EmitLabel(Header.Emit(&MCOS, Params, None, NoLineStr).second);
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              Optional<MCDwarfLineStr> &LineStr) const {
   static const char StandardOpcodeLengths[] = {
       0, // length of DW_LNS_copy

llvm/trunk/test/CodeGen/X86/dwarf-split-line-1.ll

+; Verify that split type units with no source locations don't have a
+; DW_AT_stmt_list attribute, and the .debug_line.dwo section is suppressed.
+
+; RUN: llc -split-dwarf-file=foo.dwo -dwarf-version=5 -generate-type-units \
+; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
+; RUN:     | llvm-dwarfdump -v - | FileCheck %s
+
+; FIXME: V5 wants type units in .debug_info.dwo not .debug_types.dwo.
+; CHECK-NOT: .debug_line.dwo
+; CHECK: .debug_types.dwo contents:
+; CHECK: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_type abbr_offset
+; CHECK: 0x00000018: DW_TAG_type_unit
+; CHECK-NOT: DW_AT_stmt_list
+; CHECK-NOT: DW_AT_decl_file
+; CHECK-NOT: .debug_line.dwo
+
+; ModuleID = 't.cpp'
+source_filename = "t.cpp"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.S = type { i32 }
+
+@s = global %struct.S zeroinitializer, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 5, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 295942)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "t.cpp", directory: "/home/probinson/projects/scratch")
+!4 = !{}
+!5 = !{!0}
+!6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", size: 32, elements: !7, identifier: "_ZTS1S")
+!7 = !{}
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 5.0.0 (trunk 295942)"}

llvm/trunk/test/CodeGen/X86/dwarf-split-line-2.ll

+; Verify that if we have two split type units, one with source locations and
+; one without, the one without locations doesn't have a DW_AT_stmt_list
+; attribute, but the other one does and the .debug_line.dwo section is present.
+
+; RUN: llc -split-dwarf-file=foo.dwo -dwarf-version=5 -generate-type-units \
+; RUN:     -filetype=obj -O0 -mtriple=x86_64-unknown-linux-gnu < %s \
+; RUN:     | llvm-dwarfdump -v - | FileCheck %s
+
+; Currently the no-source-location type comes out first.
+; FIXME: V5 wants type units in .debug_info.dwo not .debug_types.dwo.
+; CHECK: .debug_types.dwo contents:
+; CHECK: 0x00000000: Type Unit: {{.*}} name = 'S'
+; CHECK-SAME: (next unit at [[TU2:0x[0-9a-f]+]])
+; CHECK: DW_TAG_type_unit
+; CHECK-NOT: DW_AT_stmt_list
+; CHECK-NOT: DW_AT_decl_file
+; CHECK: [[TU2]]: Type Unit: {{.*}} name = 'T'
+; CHECK: DW_TAG_type_unit
+; CHECK: DW_AT_stmt_list
+; CHECK: DW_AT_decl_file
+
+; CHECK: .debug_line.dwo
+; CHECK-NOT: standard_opcode_lengths
+; CHECK: file_names[ 0]:
+; CHECK-NEXT: name: "t.cpp"
+; CHECK-NEXT: dir_index: 0
+
+; ModuleID = 't.cpp'
+source_filename = "t.cpp"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.S = type { i32 }
+%struct.T = type { i32 }
+
+@s = global %struct.S zeroinitializer, align 4, !dbg !0
+@t = global %struct.T zeroinitializer, align 4, !dbg !14
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 5, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 5.0.0 (trunk 295942)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "t.cpp", directory: "/home/probinson/projects/scratch")
+!4 = !{}
+!5 = !{!0,!14}
+!6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", size: 32, elements: !7, identifier: "_ZTS1S")
+!7 = !{}
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{!"clang version 5.0.0 (trunk 295942)"}
+!11 = distinct !DIGlobalVariable(name: "t", scope: !2, file: !3, line: 10, type: !12, isLocal: false, isDefinition: true)
+!12 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "T", file: !3, line: 8, size: 32, elements: !13, identifier: "_ZTS1S")
+!13 = !{}
+!14 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression())