[DWARF5][Debuginfo] Compilation unit type (DW_UT_skeleton) and root DIE (DW_TAG_compile_unit) do not match.

[avl]

Summary

That patch fixes "incompatible compilation unit type (DW_UT_skeleton) and root DIE (DW_TAG_compile_unit)" error.

cat split-dwarf.cpp
#include <iostream>

int main()
{

int a = 1;
std::cout << "Split DWARF test" << std::endl;
 
return 0;

}

clang++ -O -g -gsplit-dwarf -gdwarf-5 split-dwarf.cpp; llvm-dwarfdump --verify ./a.out | grep skeleton

error: Compilation unit type (DW_UT_skeleton) and root DIE (DW_TAG_compile_unit) do not match.

According to "3.1.2 Skeleton Compilation Unit Entries" part of "DWARF Debugging Information Format Version 5"
: "When generating a split DWARF object file (see Section 7.3.2 on page 187), the
compilation unit in the .debug_info section is a "skeleton" compilation unit with
the tag DW_TAG_skeleton_unit".

The fix is to change DW_TAG_compile_unit into DW_TAG_skeleton_unit tag when skeleton file is generated.

[avl]

resubmitted this review - D70880

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   //===------------------------------------------------------------------===//
   // Dwarf Lowering Routines
   //===------------------------------------------------------------------===//
 
   /// Emit frame instruction to describe the layout of the frame.
   void emitCFIInstruction(const MCCFIInstruction &Inst) const;
 
   /// Emit Dwarf abbreviation table.
-  template <typename T> void emitDwarfAbbrevs(const T &Abbrevs) const {
+  template <typename T>
+  void emitDwarfAbbrevs(const T &Abbrevs, bool EmitForSkeleton) const {
     // For each abbreviation.
     for (const auto &Abbrev : Abbrevs)
-      emitDwarfAbbrev(*Abbrev);
+      emitDwarfAbbrev(*Abbrev, EmitForSkeleton);
 
     // Mark end of abbreviations.
     EmitULEB128(0, "EOM(3)");
   }
 
-  void emitDwarfAbbrev(const DIEAbbrev &Abbrev) const;
+  void emitDwarfAbbrev(const DIEAbbrev &Abbrev, bool EmitForSkeleton) const;
 
   /// Recursively emit Dwarf DIE tree.
   void emitDwarfDIE(const DIE &Die) const;
 
   //===------------------------------------------------------------------===//
   // Inline Asm Support
   //===------------------------------------------------------------------===//
 

llvm/include/llvm/CodeGen/DIE.h

public:
   void AddImplicitConstAttribute(dwarf::Attribute Attribute, int64_t Value) {
     Data.push_back(DIEAbbrevData(Attribute, Value));
   }
 
   /// Used to gather unique data for the abbreviation folding set.
   void Profile(FoldingSetNodeID &ID) const;
 
   /// Print the abbreviation using the specified asm printer.
-  void Emit(const AsmPrinter *AP) const;
+  void Emit(const AsmPrinter *AP, bool EmitForSkeleton) const;
 
   void print(raw_ostream &O) const;
   void dump() const;
 };
 
 //===--------------------------------------------------------------------===//
 /// Helps unique DIEAbbrev objects and assigns abbreviation numbers.
 ///
public:
   /// the generated abbreviation.
   ///
   /// \param Die the debug info entry to generate the abbreviation for.
   /// \returns A reference to the uniqued abbreviation declaration that is
   /// owned by this class.
   DIEAbbrev &uniqueAbbreviation(DIE &Die);
 
   /// Print all abbreviations using the specified asm printer.
-  void Emit(const AsmPrinter *AP, MCSection *Section) const;
+  void Emit(const AsmPrinter *AP, MCSection *Section,
+            bool EmitForSkeleton) const;
 };
 
 //===--------------------------------------------------------------------===//
 /// An integer value DIE.
 ///
 class DIEInteger {
   uint64_t Integer;
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

if (Die.hasChildren()) {
     for (auto &Child : Die.children())
       emitDwarfDIE(Child);
 
     OutStreamer->AddComment("End Of Children Mark");
     emitInt8(0);
   }
 }
 
-void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev) const {
+void AsmPrinter::emitDwarfAbbrev(const DIEAbbrev &Abbrev,
+                                 bool EmitForSkeleton) const {
   // Emit the abbreviations code (base 1 index.)
   EmitULEB128(Abbrev.getNumber(), "Abbreviation Code");
 
   // Emit the abbreviations data.
-  Abbrev.Emit(this);
+  Abbrev.Emit(this, EmitForSkeleton);
 }

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

void DIEAbbrev::Profile(FoldingSetNodeID &ID) const {
 
   // For each attribute description.
   for (unsigned i = 0, N = Data.size(); i < N; ++i)
     Data[i].Profile(ID);
 }
 
 /// Emit - Print the abbreviation using the specified asm printer.
 ///
-void DIEAbbrev::Emit(const AsmPrinter *AP) const {
+void DIEAbbrev::Emit(const AsmPrinter *AP, bool EmitForSkeleton) const {
   // Emit its Dwarf tag type.
+  if (EmitForSkeleton &&
+      (AP->getDwarfDebug() && AP->getDwarfDebug()->getDwarfVersion() >= 5) &&
+      Tag == dwarf::DW_TAG_compile_unit)
+    /*  According to DWARF Debugging Information Format Version 5,
+     *  3.1.2 Skeleton Compilation Unit Entries:
+     *  "When generating a split DWARF object file (see Section 7.3.2
+     *  on page 187), the compilation unit in the .debug_info section
+     *  is a "skeleton" compilation unit with the tag DW_TAG_skeleton_unit"
+     */
+    AP->EmitULEB128(dwarf::DW_TAG_skeleton_unit,
+                    dwarf::TagString(dwarf::DW_TAG_skeleton_unit).data());
+  else
     AP->EmitULEB128(Tag, dwarf::TagString(Tag).data());
 
   // Emit whether it has children DIEs.
   AP->EmitULEB128((unsigned)Children, dwarf::ChildrenString(Children).data());
 
   // For each attribute description.
   for (unsigned i = 0, N = Data.size(); i < N; ++i) {
     const DIEAbbrevData &AttrData = Data[i];
 
DIEAbbrev &DIEAbbrevSet::uniqueAbbreviation(DIE &Die) {
   New->setNumber(Abbreviations.size());
   Die.setAbbrevNumber(Abbreviations.size());
 
   // Store it for lookup.
   AbbreviationsSet.InsertNode(New, InsertPos);
   return *New;
 }
 
-void DIEAbbrevSet::Emit(const AsmPrinter *AP, MCSection *Section) const {
+void DIEAbbrevSet::Emit(const AsmPrinter *AP, MCSection *Section,
+                        bool EmitForSkeleton) const {
   if (!Abbreviations.empty()) {
     // Start the debug abbrev section.
     AP->OutStreamer->SwitchSection(Section);
-    AP->emitDwarfAbbrevs(Abbreviations);
+    AP->emitDwarfAbbrevs(Abbreviations, EmitForSkeleton);
   }
 }
 
 //===----------------------------------------------------------------------===//
 // DIE Implementation
 //===----------------------------------------------------------------------===//
 
 DIE *DIE::getParent() const {

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

static AccelTableKind computeAccelTableKind(unsigned DwarfVersion,
   if (Tuning == DebuggerKind::LLDB)
     return TT.isOSBinFormatMachO() ? AccelTableKind::Apple
                                    : AccelTableKind::Dwarf;
   return AccelTableKind::None;
 }
 
 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
     : DebugHandlerBase(A), DebugLocs(A->OutStreamer->isVerboseAsm()),
-      InfoHolder(A, "info_string", DIEValueAllocator),
-      SkeletonHolder(A, "skel_string", DIEValueAllocator),
+      InfoHolder(A, "info_string", DIEValueAllocator, false),
+      SkeletonHolder(A, "skel_string", DIEValueAllocator, true),
       IsDarwin(A->TM.getTargetTriple().isOSDarwin()) {
   const Triple &TT = Asm->TM.getTargetTriple();
 
   // Make sure we know our "debugger tuning".  The target option takes
   // precedence; fall back to triple-based defaults.
   if (Asm->TM.Options.DebuggerTuning != DebuggerKind::Default)
     DebuggerTuning = Asm->TM.Options.DebuggerTuning;
   else if (IsDarwin)

llvm/lib/CodeGen/AsmPrinter/DwarfFile.h

class DwarfFile {
   DenseMap<const MDNode *, DIE *> AbstractSPDies;
   DenseMap<const DINode *, std::unique_ptr<DbgEntity>> AbstractEntities;
 
   /// Maps MDNodes for type system with the corresponding DIEs. These DIEs can
   /// be shared across CUs, that is why we keep the map here instead
   /// of in DwarfCompileUnit.
   DenseMap<const MDNode *, DIE *> DITypeNodeToDieMap;
 
+  /// That value indicates whether we are generating file
+  /// containing skeleton compilation units.
+  bool IsSkeleton = false;
+
 public:
-  DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA);
+  DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA,
+            bool isSkeleton);
 
   const SmallVectorImpl<std::unique_ptr<DwarfCompileUnit>> &getUnits() {
     return CUs;
   }
 
   std::pair<uint32_t, RangeSpanList *> addRange(const DwarfCompileUnit &CU,
                                                 SmallVector<RangeSpan, 2> R);
 

llvm/lib/CodeGen/AsmPrinter/DwarfFile.cpp

 #include "llvm/CodeGen/DIE.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/MC/MCStreamer.h"
 #include <algorithm>
 #include <cstdint>
 
 using namespace llvm;
 
-DwarfFile::DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA)
-    : Asm(AP), Abbrevs(AbbrevAllocator), StrPool(DA, *Asm, Pref) {}
+DwarfFile::DwarfFile(AsmPrinter *AP, StringRef Pref, BumpPtrAllocator &DA,
+                     bool isSkeleton)
+    : Asm(AP), Abbrevs(AbbrevAllocator), StrPool(DA, *Asm, Pref),
+      IsSkeleton(isSkeleton) {}
 
 void DwarfFile::addUnit(std::unique_ptr<DwarfCompileUnit> U) {
   CUs.push_back(std::move(U));
 }
 
 // Emit the various dwarf units to the unit section USection with
 // the abbreviations going into ASection.
 void DwarfFile::emitUnits(bool UseOffsets) {

 }
 
 // Compute the size and offset of a DIE. The offset is relative to start of the
 // CU. It returns the offset after laying out the DIE.
 unsigned DwarfFile::computeSizeAndOffset(DIE &Die, unsigned Offset) {
   return Die.computeOffsetsAndAbbrevs(Asm, Abbrevs, Offset);
 }
 
-void DwarfFile::emitAbbrevs(MCSection *Section) { Abbrevs.Emit(Asm, Section); }
+void DwarfFile::emitAbbrevs(MCSection *Section) {
+  Abbrevs.Emit(Asm, Section, IsSkeleton);
+}
 
 // Emit strings into a string section.
 void DwarfFile::emitStrings(MCSection *StrSection, MCSection *OffsetSection,
                             bool UseRelativeOffsets) {
   StrPool.emit(*Asm, StrSection, OffsetSection, UseRelativeOffsets);
 }
 
 bool DwarfFile::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {

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

 ; 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
+; O-5: 0x00000014: DW_TAG_skeleton_unit 
 ;
 ; DWO-5: .debug_info.dwo contents:
 ; DWO-5: 0x00000000: Type Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_type abbr_offset
 ; DWO-5: 0x00000018: DW_TAG_type_unit
 ; DWO-5: 0x00000033: Compile Unit: {{.*}} version = 0x0005 unit_type = DW_UT_split_compile abbr_offset
 ; DWO-5-SAME:        DWO_id = 0xccd7e58ef8bf4aa6
 ; DWO-5: 0x00000047: DW_TAG_compile_unit
 

llvm/test/DebugInfo/X86/debug_addr.ll

 ; DWARF4-NEXT: Addrs: [
 ; DWARF4-NEXT: 0x00000000
 ; DWARF4-NEXT: 0x00000010
 ; DWARF4-NEXT: ]
 
 ; DWARF5: .debug_info contents:
 ; DWARF5: Compile Unit:{{.*}}version = 0x0005
 ; DWARF5-NOT: Compile Unit
-; DWARF5: DW_TAG_compile_unit
+; DWARF5: DW_TAG_skeleton_unit
 ; DWARF5-NOT: DW_TAG_{{.*}}
 ; DWARF5: DW_AT_GNU_dwo_name{{.*}}test.dwo
 ; DWARF5: DW_AT_addr_base{{.*}}0x00000008
 ; DWARF5: DW_AT_low_pc [DW_FORM_addrx] (indexed (00000000) address = 0x0000000000000000 ".text")
 ; DWARF5: .debug_addr contents:
 ; DWARF5-NEXT: 0x00000000: Addr Section: length = 0x0000000c, version = 0x0005, addr_size = 0x04, seg_size = 0x00
 ; DWARF5-NEXT: Addrs: [
 ; DWARF5-NEXT: 0x00000000

llvm/test/DebugInfo/X86/string-offsets-table-order.ll

 ; REQUIRES: object-emission
 ; RUN: llc -mtriple=x86_64-unknown-linux-gnu -split-dwarf-file=foo.dwo -filetype=obj < %s \
 ; RUN:   | llvm-dwarfdump -v - | FileCheck %s
 
 ; This triggers a situation where the order of entries in the .debug_str and
 ; .debug_str_offsets sections does not match and makes sure that all entries are
 ; still wired up correctly.
 
 ; Produced with "clang -S -emit-llvm -gdwarf-5" from source "int X;", copied
 ; three times and modified by hand. The modifications consisted of modifying the
 ; compilation directory and the variable names to trigger the insertion of names
 ; in different order.
 
 ; CHECK: .debug_info contents:
-; CHECK:   DW_TAG_compile_unit
+; CHECK:   DW_TAG_skeleton_unit
 ; CHECK:     DW_AT_comp_dir [DW_FORM_strx1] (indexed (00000000) string = "X3")
-; CHECK:   DW_TAG_compile_unit
+; CHECK:   DW_TAG_skeleton_unit
 ; CHECK:     DW_AT_comp_dir [DW_FORM_strx1] (indexed (00000001) string = "X2")
-; CHECK:   DW_TAG_compile_unit
+; CHECK:   DW_TAG_skeleton_unit
 ; CHECK:     DW_AT_comp_dir [DW_FORM_strx1] (indexed (00000002) string = "X1")
 ; CHECK: .debug_info.dwo contents:
 
 ; CHECK: .debug_str contents:
 ; CHECK: 0x[[X3:[0-9a-f]*]]: "X3"
 ; CHECK: 0x[[X1:[0-9a-f]*]]: "X1"
 ; CHECK: 0x[[X2:[0-9a-f]*]]: "X2"
 

llvm/test/DebugInfo/X86/string-offsets-table.ll

 ; MONOLITHIC-NEXT:     0x00000014: [[STRING4]]
 
 ; For split dwarf, verify that the skeleton unit has the DW_AT_str_offsets_base
 ; attribute and that it has the right value.
 ;
 ; SPLIT:      .debug_info contents:
 ; SPLIT-NEXT: 0x00000000: Compile Unit:{{.*}}DW_UT_skeleton
 ; SPLIT-NOT:  contents:
-; SPLIT:      DW_TAG_compile_unit
+; SPLIT:      DW_TAG_skeleton_unit
 ; SPLIT-NOT:  {{DW_TAG|contents:}}
 ; SPLIT:      DW_AT_str_offsets_base [DW_FORM_sec_offset] (0x00000008)
 ; SPLIT:      DW_AT_comp_dir [DW_FORM_strx1] (indexed (00000000) string = "/home/test")
 ; SPLIT:      DW_AT_GNU_dwo_name [DW_FORM_strx1] (indexed (00000001) string = "foo.dwo")
 
 ; Check for the split CU in .debug_info.dwo.
 ; SPLIT:      .debug_info.dwo contents:
 ; SPLIT-NEXT: 0x00000000: Compile Unit:{{.*}}DW_UT_split_compile

llvm/tools/dsymutil/DwarfStreamer.cpp

 
 /// Emit the \p Abbrevs array as the shared abbreviation table
 /// for the linked Dwarf file.
 void DwarfStreamer::emitAbbrevs(
     const std::vector<std::unique_ptr<DIEAbbrev>> &Abbrevs,
     unsigned DwarfVersion) {
   MS->SwitchSection(MOFI->getDwarfAbbrevSection());
   MC->setDwarfVersion(DwarfVersion);
-  Asm->emitDwarfAbbrevs(Abbrevs);
+  Asm->emitDwarfAbbrevs(Abbrevs, false);
 }
 
 /// Recursively emit the DIE tree rooted at \p Die.
 void DwarfStreamer::emitDIE(DIE &Die) {
   MS->SwitchSection(MOFI->getDwarfInfoSection());
   Asm->emitDwarfDIE(Die);
 }
 

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.cpp

for (auto &CU : CompileUnits) {
     CU->setOffset(SecOffset);
     // The DIEs contain compile unit relative offsets.
     unsigned CUOffset = 11;
     CUOffset = CU->getUnitDIE().computeSizeAndOffsets(CUOffset);
     // Update our absolute .debug_info offset.
     SecOffset += CUOffset;
     CU->setLength(CUOffset - 4);
   }
-  Abbreviations.Emit(Asm.get(), TLOF->getDwarfAbbrevSection());
+  Abbreviations.Emit(Asm.get(), TLOF->getDwarfAbbrevSection(), false);
 
   StringPool->emitStringOffsetsTableHeader(*Asm, TLOF->getDwarfStrOffSection(),
                                            StringOffsetsStartSym);
   StringPool->emit(*Asm, TLOF->getDwarfStrSection(),
                    TLOF->getDwarfStrOffSection());
 
   MS->SwitchSection(TLOF->getDwarfInfoSection());
   for (auto &CU : CompileUnits) {