[DWARF5][Debuginfo] Not matching compilation unit type (DW_UT_skeleton) and root DIE (DW_TAG_compile_unit)

[avl]

Summary

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

cat split-dwarf.cpp

int main()
{
int a = 1;
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.

[aprantl]

Seems good to me. @dblaikie, do all the relevant non-llvm-tools that implement pre-standard fission know how to deal with DW_TAG_skeleton_unit?

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

57

//

[dblaikie]

In D70880#1765911, @aprantl wrote:

Seems good to me. @dblaikie, do all the relevant non-llvm-tools that implement pre-standard fission know how to deal with DW_TAG_skeleton_unit?

Oh, I think there's a bunch of tools/most things can't handle DWARFv5 split or non-split right now, so I'm mostly happy for us to just keep implementing the standard here & with the expectation that other people (or the same people when they have time/as they schedule things) will be implementing support on the consumer side.

@avl - are you planning to do the DW_TAG_split_compile/DW_TAG_split_type tags required by DWARFv5 too in separate patches?

llvm/lib/CodeGen/AsmPrinter/DwarfFile.h

106–109 ↗

(On Diff #231624)

Rather than adding this field - I think it'd be cleaner to pass the boolean (maybe use an enum class UnitKind { Skeleton, Full } to make it more readable) into the DwarfCompileUnit ctor directly. The two callers know statically which kind of unit they are constructing, so there would be no need for branching/conditionals/dynamic computation of the unit type by doing it that way.

(& probably add it as a default argument ("Full") to the end, then only the Skeleton unit construction gets the extra argument)

[aprantl]

Oh, I think there's a bunch of tools/most things can't handle DWARFv5 split or non-split right now, so I'm mostly happy for us to just keep implementing the standard here & with the expectation that other people (or the same people when they have time/as they schedule things) will be implementing support on the consumer side.

Sounds good!

[avl]

@avl - are you planning to do the DW_TAG_split_compile/DW_TAG_split_type tags required by DWARFv5 too in separate patches?

My understanding is that everything is already done here. There is no DW_TAG_split_compile/DW_TAG_split_type tags. There should be used DW_TAG_compile_unit+DW_UT_split_compile and DW_TAG_type_unit+DW_UT_split_type. It looks like these already are set correctly.

llvm/lib/CodeGen/AsmPrinter/DwarfFile.h

106–109 ↗

(On Diff #231624)

I did not clearly get the idea...

1. add a parameter of enum class UnitKind to DwarfCompileUnit ctor.

2. add a method like this into DwarfFile:

UnitKind DwarfFile::GetCompileUnitType(){
  if (Asm->getDwarfDebug()->getDwarfVersion() >= 5 && IsSkeleton)
    return UnitKind::Skeleton;

  return UnitKind::Full;
}

3. call GetCompileUnitType when creating DwarfCompileUnit.

is that correct?

[dblaikie]

In D70880#1767924, @avl wrote:

@avl - are you planning to do the DW_TAG_split_compile/DW_TAG_split_type tags required by DWARFv5 too in separate patches?

My understanding is that everything is already done here. There is no DW_TAG_split_compile/DW_TAG_split_type tags. There should be used DW_TAG_compile_unit+DW_UT_split_compile and DW_TAG_type_unit+DW_UT_split_type. It looks like these already are set correctly.

Ah, right you are - my mistake!

llvm/lib/CodeGen/AsmPrinter/DwarfFile.h

106–109 ↗

(On Diff #231624)

Not quite what I had in mind

1. - yep, add the extra (let's say defaulted) DwarfCompileUnit ctor parameter
2. pass the Skeleton UnitKind to the DwarfCompileUnit construction in DwarfDebug::constructSkeletonCU

& then in the implementation of (1) I guess something like:

DwarfUnit(Kind == UnitKind::Skeleton && Asm->getDwarfDebug()->getDwarfVersion() >= 5 ? dwarf::DW_TAG_skeleton_unit : dwarf::DW_TAG_compile_unit, Node, A, DW, DWU)

(or a utility function to pick between the two unit tags in the same way, if you like - but not sure it's worth it)

[avl]

addressed comments.

[dblaikie]

Looks good - thanks!

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

 // DIEUnit Implementation
 //===----------------------------------------------------------------------===//
 DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag)
     : Die(UnitTag), Section(nullptr), Offset(0), Length(0), Version(V),
       AddrSize(A)
 {
   Die.Owner = this;
   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
+          UnitTag == dwarf::DW_TAG_skeleton_unit ||
           UnitTag == dwarf::DW_TAG_type_unit ||
-          UnitTag == dwarf::DW_TAG_partial_unit) && "expected a unit TAG");
+          UnitTag == dwarf::DW_TAG_partial_unit) &&
+         "expected a unit TAG");
 }
 
 void DIEValue::EmitValue(const AsmPrinter *AP) const {
   switch (Ty) {
   case isNone:
     llvm_unreachable("Expected valid DIEValue");
 #define HANDLE_DIEVALUE(T)                                                     \
   case is##T:                                                                  \

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

 
 class AsmPrinter;
 class DwarfFile;
 class GlobalVariable;
 class MCExpr;
 class MCSymbol;
 class MDNode;
 
+enum class UnitKind { Skeleton, Full };
+
 class DwarfCompileUnit final : public DwarfUnit {
   /// A numeric ID unique among all CUs in the module
   unsigned UniqueID;
   bool HasRangeLists = false;
 
   /// The attribute index of DW_AT_stmt_list in the compile unit DIE, avoiding
   /// the need to search for it in applyStmtList.
   DIE::value_iterator StmtListValue;
if (isDwoUnit() && !DD->shareAcrossDWOCUs())
       return AbstractEntities;
     return DU->getAbstractEntities();
   }
 
   void finishNonUnitTypeDIE(DIE& D, const DICompositeType *CTy) override;
 
 public:
   DwarfCompileUnit(unsigned UID, const DICompileUnit *Node, AsmPrinter *A,
-                   DwarfDebug *DW, DwarfFile *DWU);
+                   DwarfDebug *DW, DwarfFile *DWU,
+                   UnitKind Kind = UnitKind::Full);
 
   bool hasRangeLists() const { return HasRangeLists; }
   unsigned getUniqueID() const { return UniqueID; }
 
   DwarfCompileUnit *getSkeleton() const {
     return Skeleton;
   }
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 #include <cstdint>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
 
 using namespace llvm;
 
+static dwarf::Tag GetCompileUnitType(UnitKind Kind, DwarfDebug *DW) {
+
+  //  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"
+  if (DW->getDwarfVersion() >= 5 && Kind == UnitKind::Skeleton)
+    return dwarf::DW_TAG_skeleton_unit;
+
+  return dwarf::DW_TAG_compile_unit;
+}
+
 DwarfCompileUnit::DwarfCompileUnit(unsigned UID, const DICompileUnit *Node,
                                    AsmPrinter *A, DwarfDebug *DW,
-                                   DwarfFile *DWU)
-    : DwarfUnit(dwarf::DW_TAG_compile_unit, Node, A, DW, DWU), UniqueID(UID) {
+                                   DwarfFile *DWU, UnitKind Kind)
+    : DwarfUnit(GetCompileUnitType(Kind, DW), Node, A, DW, DWU), UniqueID(UID) {
   insertDIE(Node, &getUnitDie());
   MacroLabelBegin = Asm->createTempSymbol("cu_macro_begin");
 }
 
 /// addLabelAddress - Add a dwarf label attribute data and value using
 /// DW_FORM_addr or DW_FORM_GNU_addr_index.
 void DwarfCompileUnit::addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                                        const MCSymbol *Label) {

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::initSkeletonUnit(const DwarfUnit &U, DIE &Die,
   addGnuPubAttributes(*NewU, Die);
 
   SkeletonHolder.addUnit(std::move(NewU));
 }
 
 DwarfCompileUnit &DwarfDebug::constructSkeletonCU(const DwarfCompileUnit &CU) {
 
   auto OwnedUnit = std::make_unique<DwarfCompileUnit>(
-      CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder);
+      CU.getUniqueID(), CU.getCUNode(), Asm, this, &SkeletonHolder,
+      UnitKind::Skeleton);
   DwarfCompileUnit &NewCU = *OwnedUnit;
   NewCU.setSection(Asm->getObjFileLowering().getDwarfInfoSection());
 
   NewCU.initStmtList();
 
   if (useSegmentedStringOffsetsTable())
     NewCU.addStringOffsetsStart();
 

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