[DebugInfo] Fix emitting DWARF64 type units (10/19).

[ikudrin]

Summary

The patch fixes emitting the offset to the type DIE. All other fields are already fixed in previous patches.

[dblaikie]

Looks good.

General feedback: If you can include the original C source code and whatever compile command was needed to generate the IR in any tests (this includes other patches I've already approved, if possible - not vital, many of the tests have very small IR that's pretty easy to read, but it's a "nice to have") that'd be handy! Makes it easier to eyeball the dump output and understand what it's expecting.

[ikudrin]

In D87021#2253899, @dblaikie wrote:

General feedback: If you can include the original C source code and whatever compile command was needed to generate the IR in any tests (this includes other patches I've already approved, if possible - not vital, many of the tests have very small IR that's pretty easy to read, but it's a "nice to have") that'd be handy! Makes it easier to eyeball the dump output and understand what it's expecting.

The test sources were based on some simple code, but then they were cleared as much as I could. I guess they may be considered artificial. Do you think it will be beneficial to add the code like the following here?

struct Foo {int a;};
Foo foo;

[dblaikie]

In D87021#2254332, @ikudrin wrote:

In D87021#2253899, @dblaikie wrote:

General feedback: If you can include the original C source code and whatever compile command was needed to generate the IR in any tests (this includes other patches I've already approved, if possible - not vital, many of the tests have very small IR that's pretty easy to read, but it's a "nice to have") that'd be handy! Makes it easier to eyeball the dump output and understand what it's expecting.

The test sources were based on some simple code, but then they were cleared as much as I could.

You mean the IR was modified after compilation? Or that the original C source was simplified as much as possible?

Usually we don't simplify the IR - not worth it/doesn't make things especially more maintainable & more likely to introduce something that makes the IR quirky/not representative of the normal Clang generated IR.

I guess they may be considered artificial. Do you think it will be beneficial to add the code like the following here?

struct Foo {int a;};
Foo foo;

Yep! Nice and simple bits of stuff like that are great/handy to have!

[ikudrin]

In D87021#2267059, @dblaikie wrote:

The test sources were based on some simple code, but then they were cleared as much as I could.

You mean the IR was modified after compilation? Or that the original C source was simplified as much as possible?

I removed/adjusted some attributes here and there to make the tests smaller and to express mostly what I wanted to test in each particular case. In some cases, like the test for .debug_macro, the source was created fully manually, based on existing tests.

Usually we don't simplify the IR - not worth it/doesn't make things especially more maintainable & more likely to introduce something that makes the IR quirky/not representative of the normal Clang generated IR.

I'll see if I can update the tests in the series so that the IR is fully generated by clang.

[dblaikie]

In D87021#2267680, @ikudrin wrote:

In D87021#2267059, @dblaikie wrote:

The test sources were based on some simple code, but then they were cleared as much as I could.

You mean the IR was modified after compilation? Or that the original C source was simplified as much as possible?

I removed/adjusted some attributes here and there to make the tests smaller and to express mostly what I wanted to test in each particular case. In some cases, like the test for .debug_macro, the source was created fully manually, based on existing tests.

Usually we don't simplify the IR - not worth it/doesn't make things especially more maintainable & more likely to introduce something that makes the IR quirky/not representative of the normal Clang generated IR.

I'll see if I can update the tests in the series so that the IR is fully generated by clang.

Cool cool - use your best judgment, if the only pure Clang IR you can get is way more complicated than the hand-crafted/tweaked version (and the latter is simple enough in absolute, not just relative, terms to be fairly legible by itself) - the hand-crafted/tweaked version might be the better call. I imagine for macros this may be the case. Though I /thought/ I made it so a compile unit couldn't be emitted if it had no code/data in it - if that's the case, I'm not sure there's much simplification available in a macro test case compared to what clang would generate (& I'd use the simplest thing I can imagine to keep the CU live: "extern int i; int i;") - but if it can be done even without that, great!

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
 
   void setTypeSignature(uint64_t Signature) { TypeSignature = Signature; }
   void setType(const DIE *Ty) { this->Ty = Ty; }
 
   /// Emit the header for this unit, not including the initial length field.
   void emitHeader(bool UseOffsets) override;
   unsigned getHeaderSize() const override {
     return DwarfUnit::getHeaderSize() + sizeof(uint64_t) + // Type Signature
-           sizeof(uint32_t);                               // Type DIE Offset
+           Asm->getDwarfOffsetByteSize();                  // Type DIE Offset
   }
   void addGlobalName(StringRef Name, const DIE &Die,
                      const DIScope *Context) override;
   void addGlobalType(const DIType *Ty, const DIE &Die,
                      const DIScope *Context) override;
   DwarfCompileUnit &getCU() override { return CU; }
 };
 } // end llvm namespace
 #endif

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 void DwarfTypeUnit::emitHeader(bool UseOffsets) {
   DwarfUnit::emitCommonHeader(UseOffsets,
                               DD->useSplitDwarf() ? dwarf::DW_UT_split_type
                                                   : dwarf::DW_UT_type);
   Asm->OutStreamer->AddComment("Type Signature");
   Asm->OutStreamer->emitIntValue(TypeSignature, sizeof(TypeSignature));
   Asm->OutStreamer->AddComment("Type DIE Offset");
   // In a skeleton type unit there is no type DIE so emit a zero offset.
-  Asm->OutStreamer->emitIntValue(Ty ? Ty->getOffset() : 0,
-                                 sizeof(Ty->getOffset()));
+  Asm->emitDwarfLengthOrOffset(Ty ? Ty->getOffset() : 0);
 }
 
 DIE::value_iterator
 DwarfUnit::addSectionDelta(DIE &Die, dwarf::Attribute Attribute,
                            const MCSymbol *Hi, const MCSymbol *Lo) {
   return Die.addValue(DIEValueAllocator, Attribute,
                       DD->getDwarfSectionOffsetForm(),
                       new (DIEValueAllocator) DIEDelta(Hi, Lo));

llvm/test/DebugInfo/X86/debug-types-dwarf64.ll

+; This checks that .debug_types can be generated in the DWARF64 format.
+
+; RUN: llc -mtriple=x86_64 -dwarf-version=4 -dwarf64 -generate-type-units -filetype=obj %s -o %t
+; RUN: llvm-dwarfdump -debug-types -v %t | FileCheck %s
+
+; CHECK:      .debug_types contents:
+; CHECK-NEXT: Type Unit: {{.+}}, format = DWARF64, {{.+}}, type_offset = 0x[[OFF:.+]] (next unit at
+
+; CHECK:      0x00000027:     DW_TAG_type_unit
+
+; CHECK:      0x0000[[OFF]]:    DW_TAG_structure_type
+; CHECK-NEXT:                     DW_AT_calling_convention
+; CHECK-NEXT:                     DW_AT_name [DW_FORM_strp] ({{.+}} = "Foo")
+
+; CHECK:      0x{{.+}}:           DW_TAG_member
+; CHECK-NEXT:                       DW_AT_name [DW_FORM_strp] ({{.+}} = "bar")
+; CHECK-NEXT:                       DW_AT_type [DW_FORM_ref4] (cu + 0x[[BTOFF:.+]] => {0x0000[[BTOFF]]} "int")
+
+; CHECK:      0x{{.+}}:           NULL
+
+; CHECK:      0x0000[[BTOFF]]:  DW_TAG_base_type [4]  
+; CHECK-NEXT:                     DW_AT_name [DW_FORM_strp] ({{.+}} = "int")
+
+; CHECK:      0x{{.+}}:         NULL
+
+; IR generated and reduced from:
+; $ cat foo.cc
+; struct Foo { int bar; };
+; Foo foo;
+; $ clang -g -S -emit-llvm foo.cc -o foo.ll
+
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct.Foo = type { i32 }
+
+@foo = dso_local global %struct.Foo zeroinitializer, align 4, !dbg !0
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!10, !11, !12}
+!llvm.ident = !{!13}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", scope: !2, file: !3, line: 2, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 12.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "foo.cc", directory: "/tmp")
+!4 = !{}
+!5 = !{!0}
+!6 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo", file: !3, line: 1, size: 32, flags: DIFlagTypePassByValue, elements: !7, identifier: "_ZTS3Foo")
+!7 = !{!8}
+!8 = !DIDerivedType(tag: DW_TAG_member, name: "bar", scope: !6, file: !3, line: 1, baseType: !9, size: 32)
+!9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!10 = !{i32 7, !"Dwarf Version", i32 4}
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = !{i32 1, !"wchar_size", i32 4}
+!13 = !{!"clang version 12.0.0"}