DebugInfo: Move type units into the debug_types section with appropriate comdat grouping and type unit headers

This commit does not complete the type units feature - there are issues
around fission support (skeletal type units, pubtypes/pubnames) and
hashing of some types including those containing references to types in
other type units.

Originally committed as r197073 and reverted in r197079.
Recommitted as r197197 to reproduce the failure and reverted as r197199

Turns out there was unstable ordering in the type unit dumping code.
Fixed by using MapVector in DWARFContext to store the debug_types
comdat sections.

llvm-svn: 197210

include/llvm/MC/MCObjectFileInfo.h

@@ -262,6 +262,8 @@ public:
   const MCSection *getDwarfInfoDWOSection() const {
     return DwarfInfoDWOSection;
   }
+  const MCSection *getDwarfTypesSection(uint64_t Hash) const;
+  const MCSection *getDwarfTypesDWOSection(uint64_t Hash) const;
   const MCSection *getDwarfAbbrevDWOSection() const {
     return DwarfAbbrevDWOSection;
   }

include/llvm/MC/MCSectionELF.h

@@ -16,6 +16,7 @@
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCSection.h"
+#include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ELF.h"
 #include "llvm/Support/raw_ostream.h"
@@ -60,8 +61,13 @@ public:
 
   StringRef getSectionName() const { return SectionName; }
   virtual std::string getLabelBeginName() const {
-    return SectionName.str() + "_begin"; }
+    if (Group)
+      return (SectionName.str() + '_' + Group->getName() + "_begin").str();
+    return SectionName.str() + "_begin";
+  }
   virtual std::string getLabelEndName() const {
+    if (Group)
+      return (SectionName.str() + '_' + Group->getName() + "_end").str();
     return SectionName.str() + "_end";
   }
   unsigned getType() const { return Type; }

lib/CodeGen/AsmPrinter/DwarfDebug.cpp

@@ -3056,19 +3056,17 @@ void DwarfDebug::addDwarfTypeUnitType(uint16_t Language, DIE *RefDie,
     // referenced type, or possibly walk the precomputed hashes of related types
     // at the end.
     uint64_t Signature = DIEHash().computeTypeSignature(*Die);
+    NewTU->setTypeSignature(Signature);
+    NewTU->setType(Die);
 
     // Remove the References vector and add the type hash.
     I->second.first = Signature;
     I->second.second = NULL;
 
     NewTU->initSection(
-        useSplitDwarf() ? Asm->getObjFileLowering().getDwarfInfoDWOSection()
-                        : Asm->getObjFileLowering().getDwarfInfoSection(),
-        // FIXME: This is subtle (using the info section even when
-        // this CU is in the dwo section) and necessary for the
-        // current arange code - ideally it should iterate
-        // skeleton units, not full units, if it's going to reference skeletons
-        useSplitDwarf() ? NULL : DwarfInfoSectionSym);
+        useSplitDwarf()
+            ? Asm->getObjFileLowering().getDwarfTypesDWOSection(Signature)
+            : Asm->getObjFileLowering().getDwarfTypesSection(Signature));
   }
 
   // Populate all the signatures.

lib/CodeGen/AsmPrinter/DwarfUnit.cpp

@@ -1997,3 +1997,27 @@ void DwarfUnit::emitHeader(const MCSection *ASection,
   Asm->OutStreamer.AddComment("Address Size (in bytes)");
   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
 }
+
+void DwarfTypeUnit::emitHeader(const MCSection *ASection,
+                               const MCSymbol *ASectionSym) const {
+  DwarfUnit::emitHeader(ASection, ASectionSym);
+  Asm->OutStreamer.AddComment("Type Signature");
+  Asm->OutStreamer.EmitIntValue(TypeSignature, sizeof(TypeSignature));
+  Asm->OutStreamer.AddComment("Type DIE Offset");
+  Asm->OutStreamer.EmitIntValue(Ty->getOffset(), sizeof(Ty->getOffset()));
+}
+
+void DwarfTypeUnit::initSection(const MCSection *Section) {
+  assert(!this->Section);
+  this->Section = Section;
+  // Since each type unit is contained in its own COMDAT section, the begin
+  // label and the section label are the same. Using the begin label emission in
+  // DwarfDebug to emit the section label as well is slightly subtle/sneaky, but
+  // the only other alternative of lazily constructing start-of-section labels
+  // and storing a mapping in DwarfDebug (or AsmPrinter).
+  this->SectionSym = this->LabelBegin =
+      Asm->GetTempSymbol(Section->getLabelBeginName(), getUniqueID());
+  this->LabelEnd =
+      Asm->GetTempSymbol(Section->getLabelEndName(), getUniqueID());
+  this->LabelRange = Asm->GetTempSymbol("gnu_ranges", getUniqueID());
+}

lib/CodeGen/AsmPrinter/DwarfUnit.h

@@ -413,14 +413,15 @@ public:
 
   /// Compute the size of a header for this unit, not including the initial
   /// length field.
-  unsigned getHeaderSize() const {
+  virtual unsigned getHeaderSize() const {
     return sizeof(int16_t) + // DWARF version number
            sizeof(int32_t) + // Offset Into Abbrev. Section
            sizeof(int8_t);   // Pointer Size (in bytes)
   }
 
   /// Emit the header for this unit, not including the initial length field.
-  void emitHeader(const MCSection *ASection, const MCSymbol *ASectionSym) const;
+  virtual void emitHeader(const MCSection *ASection,
+                          const MCSymbol *ASectionSym) const;
 
 protected:
   /// getOrCreateStaticMemberDIE - Create new static data member DIE.
@@ -513,12 +514,25 @@ public:
 class DwarfTypeUnit : public DwarfUnit {
 private:
   uint16_t Language;
+  uint64_t TypeSignature;
+  const DIE *Ty;
 
 public:
   DwarfTypeUnit(unsigned UID, DIE *D, uint16_t Language, AsmPrinter *A,
                 DwarfDebug *DW, DwarfFile *DWU);
 
+  void setTypeSignature(uint64_t Signature) { TypeSignature = Signature; }
+  void setType(const DIE *Ty) { this->Ty = Ty; }
+
   uint16_t getLanguage() const LLVM_OVERRIDE { return Language; }
+  /// Emit the header for this unit, not including the initial length field.
+  void emitHeader(const MCSection *ASection, const MCSymbol *ASectionSym) const
+      LLVM_OVERRIDE;
+  unsigned getHeaderSize() const LLVM_OVERRIDE {
+    return DwarfUnit::getHeaderSize() + sizeof(uint64_t) + // Type Signature
+           sizeof(uint32_t);                               // Type DIE Offset
+  }
+  void initSection(const MCSection *Section);
 };
 } // end llvm namespace
 #endif

lib/DebugInfo/DWARFContext.cpp

@@ -297,10 +297,8 @@ void DWARFContext::parseCompileUnits() {
 }
 
 void DWARFContext::parseTypeUnits() {
-  const std::map<object::SectionRef, Section> &Sections = getTypesSections();
-  for (std::map<object::SectionRef, Section>::const_iterator
-           I = Sections.begin(),
-           E = Sections.end();
+  const TypeSectionMap &Sections = getTypesSections();
+  for (TypeSectionMap::const_iterator I = Sections.begin(), E = Sections.end();
        I != E; ++I) {
     uint32_t offset = 0;
     const DataExtractor &DIData =

lib/DebugInfo/DWARFContext.h

@@ -19,6 +19,7 @@
 #include "DWARFTypeUnit.h"
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/MapVector.h"
 #include "llvm/DebugInfo/DIContext.h"
 
 namespace llvm {
@@ -138,7 +139,9 @@ public:
   virtual bool isLittleEndian() const = 0;
   virtual uint8_t getAddressSize() const = 0;
   virtual const Section &getInfoSection() = 0;
-  virtual const std::map<object::SectionRef, Section> &getTypesSections() = 0;
+  typedef MapVector<object::SectionRef, Section,
+                    std::map<object::SectionRef, unsigned> > TypeSectionMap;
+  virtual const TypeSectionMap &getTypesSections() = 0;
   virtual StringRef getAbbrevSection() = 0;
   virtual const Section &getLocSection() = 0;
   virtual StringRef getARangeSection() = 0;
@@ -179,7 +182,7 @@ class DWARFContextInMemory : public DWARFContext {
   bool IsLittleEndian;
   uint8_t AddressSize;
   Section InfoSection;
-  std::map<object::SectionRef, Section> TypesSections;
+  TypeSectionMap TypesSections;
   StringRef AbbrevSection;
   Section LocSection;
   StringRef ARangeSection;
@@ -208,9 +211,7 @@ public:
   virtual bool isLittleEndian() const { return IsLittleEndian; }
   virtual uint8_t getAddressSize() const { return AddressSize; }
   virtual const Section &getInfoSection() { return InfoSection; }
-  virtual const std::map<object::SectionRef, Section> &getTypesSections() {
-    return TypesSections;
-  }
+  virtual const TypeSectionMap &getTypesSections() { return TypesSections; }
   virtual StringRef getAbbrevSection() { return AbbrevSection; }
   virtual const Section &getLocSection() { return LocSection; }
   virtual StringRef getARangeSection() { return ARangeSection; }

lib/MC/MCObjectFileInfo.cpp

@@ -9,6 +9,7 @@
 
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
@@ -718,6 +719,17 @@ void MCObjectFileInfo::InitMCObjectFileInfo(StringRef TT, Reloc::Model relocm,
   }
 }
 
+const MCSection *MCObjectFileInfo::getDwarfTypesSection(uint64_t Hash) const {
+  return Ctx->getELFSection(".debug_types", ELF::SHT_PROGBITS, ELF::SHF_GROUP,
+                            SectionKind::getMetadata(), 0, utostr(Hash));
+}
+
+const MCSection *
+MCObjectFileInfo::getDwarfTypesDWOSection(uint64_t Hash) const {
+  return Ctx->getELFSection(".debug_types.dwo", ELF::SHT_GROUP, 0,
+                            SectionKind::getMetadata(), 0, utostr(Hash));
+}
+
 void MCObjectFileInfo::InitEHFrameSection() {
   if (Env == IsMachO)
     EHFrameSection =

test/DebugInfo/X86/c-type-units.ll

@@ -1,6 +1,6 @@
 ; REQUIRES: object-emission
 
-; RUN: llc -o - %s -filetype=obj -O0 -generate-type-units -mtriple=x86_64-unknown-linux-gnu | llvm-dwarfdump -debug-dump=info - | FileCheck %s
+; RUN: llc -o - %s -filetype=obj -O0 -generate-dwarf-pub-sections=Disable -generate-type-units -mtriple=x86_64-unknown-linux-gnu | llvm-dwarfdump -debug-dump=types - | FileCheck %s
 
 ; struct foo {
 ; } f;

test/DebugInfo/X86/generate-odr-hash.ll

@@ -45,13 +45,19 @@
 
 ; CHECK-LABEL: .debug_info contents:
 ; CHECK: Compile Unit: length = [[CU_SIZE:[0-9a-f]+]]
+
+; CHECK-LABEL: .debug_types contents:
+
 ; Check that we generate a hash for bar and the value.
-; CHECK-LABEL: DW_AT_GNU_odr_signature [DW_FORM_data8] (0x200520c0d5b90eff)
+; CHECK-LABEL: type_signature = 0x6a7ee3d400662e88
+; CHECK: DW_AT_GNU_odr_signature [DW_FORM_data8] (0x200520c0d5b90eff)
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NEXT: debug_str{{.*}}"bar"
 
+
 ; Check that we generate a hash for fluffy and the value.
-; CHECK-LABEL: DW_AT_GNU_odr_signature [DW_FORM_data8]   (0x9a0124d5a0c21c52)
+; CHECK-LABEL: type_signature = 0x139b2e1ea94afec7
+; CHECK: DW_AT_GNU_odr_signature [DW_FORM_data8]   (0x9a0124d5a0c21c52)
 ; CHECK: DW_TAG_namespace
 ; CHECK-NEXT: debug_str{{.*}}"echidna"
 ; CHECK: DW_TAG_namespace
@@ -61,10 +67,11 @@
 ; CHECK: DW_TAG_class_type
 ; CHECK-NEXT: debug_str{{.*}}"fluffy"
 
-; We emit no hash for walrus since the type is contained in an anonymous
 ; namespace and won't violate any ODR-ness.
+; CHECK-LABEL: type_signature = 0xc0d031d6449dbca7
 ; CHECK: DW_TAG_type_unit
 ; CHECK-NOT: NULL
+; We emit no hash for walrus since the type is contained in an anonymous
 ; CHECK-NOT: DW_AT_GNU_odr_signature
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NEXT: debug_str{{.*}}"walrus"
@@ -73,17 +80,20 @@
 ; CHECK-NEXT: DW_AT_decl_line
 ; CHECK: DW_TAG_subprogram
 
-
 ; Check that we generate a hash for wombat and the value, but not for the
 ; anonymous type contained within.
-; CHECK-LABEL: DW_AT_GNU_odr_signature [DW_FORM_data8] (0x685bcc220141e9d7)
+; CHECK-LABEL: type_signature = 0x73776f130648b986
+; CHECK: DW_AT_GNU_odr_signature [DW_FORM_data8] (0x685bcc220141e9d7)
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NEXT: debug_str{{.*}}"wombat"
+
+; CHECK-LABEL: type_signature = 0xbf6fc40e82583d7c
 ; CHECK: DW_TAG_type_unit
+; CHECK-NOT: NULL
+; Check that we generate no ODR hash for the anonymous type nested inside 'wombat'
+; CHECK-NOT: DW_AT_GNU_odr_signature
 ; CHECK: DW_TAG_structure_type
-; The signature for the outer 'wombat' type - this can be FileChecked once the
-; type units are moved to their own section with the full type unit header
-; including the signature
+; The signature for the outer 'wombat' type
 ; CHECK: DW_AT_signature [DW_FORM_ref_sig8] (0x73776f130648b986)
 ; CHECK: DW_TAG_structure_type
 ; CHECK-NOT: DW_AT_name
@@ -98,20 +108,20 @@
 ; CHECK-NEXT: unit_size = [[CU_SIZE]]
 ; CHECK-NEXT: Offset Name
 ; Type unit for 'bar'
-; CHECK-NEXT: unit_size = 0x0000001f
+; CHECK-NEXT: unit_size = 0x0000002b
 ; CHECK-NEXT: Offset Name
 ; CHECK-NEXT: "bar"
-; CHECK-NEXT: unit_size = 0x00000059
+; CHECK-NEXT: unit_size = 0x00000065
 ; CHECK-NEXT: Offset Name
 ; CHECK-NEXT: "int"
 ; CHECK-NEXT: "echidna::capybara::mongoose::fluffy"
-; CHECK-NEXT: unit_size = 0x0000002f
+; CHECK-NEXT: unit_size = 0x0000003b
 ; CHECK-NEXT: Offset Name
 ; CHECK-NEXT: "walrus"
-; CHECK-NEXT: unit_size = 0x00000036
+; CHECK-NEXT: unit_size = 0x00000042
 ; CHECK-NEXT: Offset Name
 ; CHECK-NEXT: "wombat"
-; CHECK-NEXT: unit_size = 0x0000003f
+; CHECK-NEXT: unit_size = 0x0000004b
 ; CHECK-NEXT: Offset Name
 ; CHECK-NEXT: "int"