[DWARFv5] Emit normal type units in .debug_info comdats.

[probinson]

Summary

This should make non-split type units fully conform to DWARF v5.

An artifact of the LLVM implementation means that the type-unit sections
will appear before the compile-unit section in the object file. So, readers
making assumptions about ordering will need to learn better.
(I'm looking at you, LLD.)

I was going to do split units at the same time, but that's going to be trickier,
because it looks like for v5, the split compile and type units should all coexist
in the same section. So, leaving split type-units for another day.

[dblaikie]

llvm/lib/MC/MCObjectFileInfo.cpp

822 ↗

(On Diff #173239)

Seems odd to have a function for "DwarfTypesSection" return the debug_info section. I'd tend towards having MCObjectFileInfo be more literal than this - getDwarfTypesSection(Hash) and getDwarfInfoSection(Hash), etc.

(a very casual/far-off motivation, is that it'd be great if, eventually, debug_info came to allowing various different entities in comdat'd sections - not just types - this is what some of us have thrown around as "bag of DWARF")

[probinson]

llvm/lib/MC/MCObjectFileInfo.cpp

822 ↗

(On Diff #173239)

Excellent point, that would be a better division of responsibility.

i've had some discussions with Sony linker people about different tactics for subdividing DWARF, using comdats or other ELF tricks. Cost/benefit tradeoffs have not been clear. But worth pursuing.

[dblaikie]

llvm/lib/MC/MCObjectFileInfo.cpp

822 ↗

(On Diff #173239)

Yeah, stuff Adrian, Eric, and I have thrown around goes in a few directions:

1. type units aren't super efficient (for GCC they were a 2x growth, roughly - for every byte that was removed from the CU, you got two bytes of TU - for Clang (only because it's a bit more conservative about which types to put in type units) it's about 1.5x) one major reason is that the CU can only reference the type itself - not all the other things, mostly the member function declarations would be great to reference ratehr than as it is today, where any member function definition in the CU references a declaration of that function in the stub type description in the CU, which is a lot of duplicate bytes.

-> So it'd be great if a type unit were enhanced to allow more than one entity to be referenced (have the TU header include a count N, then N x {hash, offset} pairs rather than the current header which has exactly one {hash, offset} pair)

2. Some data doesn't need to go in a separate unit - sometimes you know you're only emitting a type once, so would be cool to be able to emit it into the CU. But what about types that need to be in a type unit? I guess they could refer to the type by declaration - in which case there'd be no reason to refer back into the CU. But alternatively it could be done by having even the CU have a list of referencable entities... eh, maybe that's less useful.

But in any case, once you do (1) it's perhaps less important to refer to this thing as a type unit, but instead as a bag of referencable entities, whatever the producer wants to group up like that. (& yeah, might work welrl for inline function declarations, etc)

Aside: I actually might try to do the "types referenced from type units are referenced as declarations instead of using any signatures" because with modular debug info there's more chance you'll have types you know are only going in one place (even today we have some of those - with strong vtables you can know you won't put the type anywhere but there) so you'd want to avoid type unit overhead. But some type unit might want to refer to that type - obviously that type unit is going to be in multiple object files and only one of those object files has the first vtable-bound type, so the other copies of the type unit must be using declarations to refer to the vtable-bound type anyway, seems fine to do it in this case where the vtable-bound type is available anyway.

</ramble>

[probinson]

Make DwarfDebug responsible for picking which section to use.

[dblaikie]

Looks great!

llvm/trunk/include/llvm/MC/MCObjectFileInfo.h

public:
   MCSection *getTextSection() const { return TextSection; }
   MCSection *getDataSection() const { return DataSection; }
   MCSection *getBSSSection() const { return BSSSection; }
   MCSection *getReadOnlySection() const { return ReadOnlySection; }
   MCSection *getLSDASection() const { return LSDASection; }
   MCSection *getCompactUnwindSection() const { return CompactUnwindSection; }
   MCSection *getDwarfAbbrevSection() const { return DwarfAbbrevSection; }
   MCSection *getDwarfInfoSection() const { return DwarfInfoSection; }
+  MCSection *getDwarfInfoSection(uint64_t Hash) const {
+    return getDwarfComdatSection(".debug_info", Hash);
+  }
   MCSection *getDwarfLineSection() const { return DwarfLineSection; }
   MCSection *getDwarfLineStrSection() const { return DwarfLineStrSection; }
   MCSection *getDwarfFrameSection() const { return DwarfFrameSection; }
   MCSection *getDwarfPubNamesSection() const { return DwarfPubNamesSection; }
   MCSection *getDwarfPubTypesSection() const { return DwarfPubTypesSection; }
   MCSection *getDwarfGnuPubNamesSection() const {
     return DwarfGnuPubNamesSection;
   }
public:
   MCSection *getDwarfAccelObjCSection() const { return DwarfAccelObjCSection; }
   MCSection *getDwarfAccelNamespaceSection() const {
     return DwarfAccelNamespaceSection;
   }
   MCSection *getDwarfAccelTypesSection() const {
     return DwarfAccelTypesSection;
   }
   MCSection *getDwarfInfoDWOSection() const { return DwarfInfoDWOSection; }
-  MCSection *getDwarfTypesSection(uint64_t Hash) const;
+  MCSection *getDwarfTypesSection(uint64_t Hash) const {
+    return getDwarfComdatSection(".debug_types", Hash);
+  }
   MCSection *getDwarfTypesDWOSection() const { return DwarfTypesDWOSection; }
   MCSection *getDwarfAbbrevDWOSection() const { return DwarfAbbrevDWOSection; }
   MCSection *getDwarfStrDWOSection() const { return DwarfStrDWOSection; }
   MCSection *getDwarfLineDWOSection() const { return DwarfLineDWOSection; }
   MCSection *getDwarfLocDWOSection() const { return DwarfLocDWOSection; }
   MCSection *getDwarfStrOffDWOSection() const { return DwarfStrOffDWOSection; }
   MCSection *getDwarfStrOffSection() const { return DwarfStrOffSection; }
   MCSection *getDwarfAddrSection() const { return DwarfAddrSection; }
private:
   bool PositionIndependent;
   MCContext *Ctx;
   Triple TT;
 
   void initMachOMCObjectFileInfo(const Triple &T);
   void initELFMCObjectFileInfo(const Triple &T, bool Large);
   void initCOFFMCObjectFileInfo(const Triple &T);
   void initWasmMCObjectFileInfo(const Triple &T);
+  MCSection *getDwarfComdatSection(const char *Name, uint64_t Hash) const;
 
 public:
   const Triple &getTargetTriple() const { return TT; }
 };
 
 } // end namespace llvm
 
 #endif

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

void DwarfDebug::addDwarfTypeUnitType(DwarfCompileUnit &CU,
   NewTU.addUInt(UnitDie, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
                 CU.getLanguage());
 
   uint64_t Signature = makeTypeSignature(Identifier);
   NewTU.setTypeSignature(Signature);
   Ins.first->second = Signature;
 
   if (useSplitDwarf())
+    // FIXME: v5 split type units belong in .debug_info.dwo.
     NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesDWOSection());
   else {
-    NewTU.setSection(Asm->getObjFileLowering().getDwarfTypesSection(Signature));
+    MCSection *Section =
+        getDwarfVersion() <= 4
+            ? Asm->getObjFileLowering().getDwarfTypesSection(Signature)
+            : Asm->getObjFileLowering().getDwarfInfoSection(Signature);
+    NewTU.setSection(Section);
     // 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();

llvm/trunk/lib/MC/MCObjectFileInfo.cpp

case Triple::Wasm:
     initWasmMCObjectFileInfo(TT);
     break;
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot initialize MC for unknown object file format.");
     break;
   }
 }
 
-MCSection *MCObjectFileInfo::getDwarfTypesSection(uint64_t Hash) const {
+MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
+                                                   uint64_t Hash) const {
   switch (TT.getObjectFormat()) {
   case Triple::ELF:
-    return Ctx->getELFSection(".debug_types", ELF::SHT_PROGBITS, ELF::SHF_GROUP,
-                              0, utostr(Hash));
+    return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
+                              utostr(Hash));
   case Triple::MachO:
   case Triple::COFF:
   case Triple::Wasm:
   case Triple::UnknownObjectFormat:
-    report_fatal_error("Cannot get DWARF types section for this object file "
+    report_fatal_error("Cannot get DWARF comdat section for this object file "
                        "format: not implemented.");
     break;
   }
   llvm_unreachable("Unknown ObjectFormatType");
 }
 
 MCSection *
 MCObjectFileInfo::getStackSizesSection(const MCSection &TextSec) const {

llvm/trunk/test/CodeGen/X86/dwarf-headers.ll

 ; DWO-4: .debug_info.dwo contents:
 ; DWO-4: 0x00000000: Compile Unit: {{.*}} version = 0x0004 abbr_offset
 ; DWO-4: 0x0000000b: DW_TAG_compile_unit
 ;
 ; DWO-4: .debug_types.dwo contents:
 ; DWO-4: 0x00000000: Type Unit: {{.*}} version = 0x0004 abbr_offset
 ; DWO-4: 0x00000017: DW_TAG_type_unit
 
-; Verify the v5 non-split headers.
+; Verify the v5 non-split headers. Type units come first.
+; All .debug_info sections are reported in one go, but the offset resets for
+; each new section.
 ;
 ; SINGLE-5: .debug_info contents:
-; SINGLE-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_compile abbr_offset
-; SINGLE-5: 0x0000000c: DW_TAG_compile_unit
-;
-; FIXME: V5 wants type units in .debug_info not .debug_types.
-; SINGLE-5: .debug_types contents:
 ; SINGLE-5: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_type abbr_offset
 ; SINGLE-5: 0x00000018: DW_TAG_type_unit
+; SINGLE-5-NOT: contents:
+; SINGLE-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_compile abbr_offset
+; SINGLE-5: 0x0000000c: DW_TAG_compile_unit
 
 ; Verify the v5 split headers.
 ;
 ; O-5: .debug_info contents:
 ; O-5: 0x00000000: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_skeleton abbr_offset
 ; O-5-SAME:        DWO_id = 0xccd7e58ef8bf4aa6
 ; O-5: 0x00000014: DW_TAG_compile_unit
 ;

llvm/trunk/test/DebugInfo/X86/string-offsets-multiple-cus.ll

 ; c.cpp:
 ; enum E3 {g, h, i};
 ; E3 glob3;
 ;
 ; Check that all 3 compile units have the correct DW_AT_str_offsets_base attributes
 ; with the correct offsets. Check that strings referenced by compile units 2 and 3
 ; are displayed correctly.
 ;
-; CU 1
 ; BOTH:        .debug_info contents:
-; BOTH-NOT:    .contents:
-; BOTH:        DW_TAG_compile_unit
-; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF:[0-9a-f]+]])
-;
-; CU 2
-; BOTH-NOT:    contents:
-; BOTH:        DW_TAG_compile_unit
-; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
-; BOTH-NOT:    NULL
-; BOTH:        DW_TAG_variable
-; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_name [DW_FORM_strx1] ( indexed (00000009) string = "glob2")
-;
-; CU 3
-; BOTH-NOT:    contents:
-; BOTH:        DW_TAG_compile_unit
-; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
-; BOTH-NOT:    NULL
-; BOTH:        DW_TAG_variable
-; BOTH-NOT:    {{DW_TAG|NULL}}
-; BOTH:        DW_AT_name [DW_FORM_strx1] ( indexed (0000000f) string = "glob3")
 ;
 ; Verify that all 3 type units have the proper DW_AT_str_offsets_base attribute.
-; TYPEUNITS:      .debug_types contents:
 ; TYPEUNITS-NOT:  contents:
 ; TYPEUNITS:      DW_TAG_type_unit
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
-; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
+; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF:[0-9a-f]+]])
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumerator
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumerator
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
 ; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] ( indexed (00000005) string = "b")
 ; TYPEUNITS-NOT:  contents:
 ; TYPEUNITS:      DW_TAG_type_unit
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
 ; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumeration_type
 ; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] ( indexed (0000000d) string = "E2")
 ; TYPEUNITS-NOT:  contents:
 ; TYPEUNITS:      DW_TAG_type_unit
 ; TYPEUNITS-NOT:  {{DW_TAG|NULL}}
 ; TYPEUNITS:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
 ; TYPEUNITS-NOT:  NULL
 ; TYPEUNITS:      DW_TAG_enumeration_type
 ; TYPEUNITS:      DW_AT_name [DW_FORM_strx1] ( indexed (00000013) string = "E3")
+
+; CU 1
+; BOTH-NOT:    .contents:
+; BOTH:        DW_TAG_compile_unit
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; DEFAULT:     DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF:[0-9a-f]+]])
+; TYPEUNITS:   DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
+;
+; CU 2
+; BOTH-NOT:    contents:
+; BOTH:        DW_TAG_compile_unit
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
+; BOTH-NOT:    NULL
+; BOTH:        DW_TAG_variable
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_name [DW_FORM_strx1] ( indexed (00000009) string = "glob2")
+;
+; CU 3
+; BOTH-NOT:    contents:
+; BOTH:        DW_TAG_compile_unit
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x[[CU1_STROFF]])
+; BOTH-NOT:    NULL
+; BOTH:        DW_TAG_variable
+; BOTH-NOT:    {{DW_TAG|NULL}}
+; BOTH:        DW_AT_name [DW_FORM_strx1] ( indexed (0000000f) string = "glob3")
 ;
 ; Extract the offset of a string to verify that it is referenced in the string
 ; offsets section.
 ; BOTH:           .debug_str contents:
 ; BOTH-NOT:       contents:
 ; BOTH:           0x[[GLOB2OFF:[0-9a-f]+]]: "glob2"
 ;
 ; Check the .debug_str_offsets section header and make sure the referenced string