[DWARF] Support new TAG DW_TAG_LLVM_annotation

[yonghong-song]

Summary

A new LLVM specific TAG DW_TAG_LLVM_annotation is added.
The name is suggested by Paul Robinson ([1]).
Currently, this tag is used to output attribute((btf_tag("string")))
annotations in dwarf. The following is an example for a global
variable with two btf_tag attributes:

0x0000002a:   DW_TAG_variable
                DW_AT_name      ("g1")
                DW_AT_type      (0x00000052 "int")
                DW_AT_external  (true)
                DW_AT_decl_file ("/tmp/home/yhs/work/tests/llvm/btf_tag/t.c")
                DW_AT_decl_line (8) 
                DW_AT_location  (DW_OP_addr 0x0)

0x0000003f:     DW_TAG_LLVM_annotation
                  DW_AT_name    ("btf_tag")
                  DW_AT_const_value     ("tag1")

0x00000048:     DW_TAG_LLVM_annotation
                  DW_AT_name    ("btf_tag")
                  DW_AT_const_value     ("tag2")

0x00000051:     NULL

In the future, DW_TAG_LLVM_annotation may encode other type
of non-string const value.

[1] https://lists.llvm.org/pipermail/llvm-dev/2021-June/151250.html

[anakryiko]

llvm/test/DebugInfo/attr-btf_tag.ll

14

looking at CHECK tests below, seems like tag1 and tag2 are associated with the arg parameter, right? A bit surprised with syntax, I was expecting something like struct t1 *arg __tag1 __tag2, would such variant also work?

[yonghong-song]

llvm/test/DebugInfo/attr-btf_tag.ll

14

struct t1 *arg __tag1 __tag2 will have the same effect as struct t1 __tag1 __tag2 *arg. But I will change example to have the syntax as you suggested.

[yonghong-song]

• rebase based on latest llvm-project and update commit message

[yonghong-song]

@dblaikie @probinson Could you help take a look at the patch? Currently I chose the new tag definition as HANDLE_DW_TAG(0x6000, LLVM_annotation, 0, LLVM, DW_KIND_NONE) which might not be the best choice. Please let me know if you have other suggestions.

[dblaikie]

Looks generally OK to me. (not 100% sure that DW_TAG extension space is unused, but I think we've generally got most of the extensions in llvm-dwarfdump, so it probably is unused - and worst-case we can change it if needed)

[probinson]

In D106621#2973954, @dblaikie wrote:

Looks generally OK to me. (not 100% sure that DW_TAG extension space is unused, but I think we've generally got most of the extensions in llvm-dwarfdump, so it probably is unused - and worst-case we can change it if needed)

@aprantl updated Dwarf.def with everything that David Anderson (libdwarf) was aware of, early this year. If we're adding a new vendor TAG that will actually reach object files (as opposed to internal-only things like DW_OP_LLVM_convert) then we should communicate that back to David.

llvm/include/llvm/BinaryFormat/Dwarf.def

 
 // DSP-C/Starcore __circ, _rev
 HANDLE_DW_TAG(0x5101, ALTIUM_circ_type, 0, ALTIUM, DW_KIND_NONE)
 HANDLE_DW_TAG(0x5102, ALTIUM_mwa_circ_type, 0, ALTIUM, DW_KIND_NONE)
 HANDLE_DW_TAG(0x5103, ALTIUM_rev_carry_type, 0, ALTIUM, DW_KIND_NONE)
 // M16 __rom qualifier
 HANDLE_DW_TAG(0x5111, ALTIUM_rom, 0, ALTIUM, DW_KIND_NONE)
 
+// LLVM
+HANDLE_DW_TAG(0x6000, LLVM_annotation, 0, LLVM, DW_KIND_NONE)
+
 // Green Hills.
 HANDLE_DW_TAG(0x8004, GHS_namespace, 0, GHS, DW_KIND_NONE)
 HANDLE_DW_TAG(0x8005, GHS_using_namespace, 0, GHS, DW_KIND_NONE)
 HANDLE_DW_TAG(0x8006, GHS_using_declaration, 0, GHS, DW_KIND_NONE)
 HANDLE_DW_TAG(0x8007, GHS_template_templ_param, 0, GHS, DW_KIND_NONE)
 
 // Unified Parallel C.
 HANDLE_DW_TAG(0x8765, UPC_shared_type, 0, UPC, DW_KIND_NONE)

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

if (auto *SDMDecl = GV->getStaticDataMemberDeclaration()) {
     addSourceLine(*VariableDIE, GV);
   }
 
   if (!GV->isDefinition())
     addFlag(*VariableDIE, dwarf::DW_AT_declaration);
   else
     addGlobalName(GV->getName(), *VariableDIE, DeclContext);
 
+  if (GV->getAnnotations())
+    addAnnotation(*VariableDIE, GV->getAnnotations());
+
   if (uint32_t AlignInBytes = GV->getAlignInBytes())
     addUInt(*VariableDIE, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
             AlignInBytes);
 
   if (MDTuple *TP = GV->getTemplateParams())
     addTemplateParams(*VariableDIE, DINodeArray(TP));
 
   // Add location.

 }
 
 void DwarfCompileUnit::applyVariableAttributes(const DbgVariable &Var,
                                                DIE &VariableDie) {
   StringRef Name = Var.getName();
   if (!Name.empty())
     addString(VariableDie, dwarf::DW_AT_name, Name);
   const auto *DIVar = Var.getVariable();
-  if (DIVar)
+  if (DIVar) {
     if (uint32_t AlignInBytes = DIVar->getAlignInBytes())
       addUInt(VariableDie, dwarf::DW_AT_alignment, dwarf::DW_FORM_udata,
               AlignInBytes);
+    if (DIVar->getAnnotations())
+      addAnnotation(VariableDie, DIVar->getAnnotations());
+  }
 
   addSourceLine(VariableDie, DIVar);
   addType(VariableDie, Var.getType());
   if (Var.isArtificial())
     addFlag(VariableDie, dwarf::DW_AT_artificial);
 }
 
 void DwarfCompileUnit::applyLabelAttributes(const DbgLabel &Label,

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
   /// addSectionDelta - Add a label delta attribute data and value.
   void addSectionDelta(DIE &Die, dwarf::Attribute Attribute, const MCSymbol *Hi,
                        const MCSymbol *Lo);
 
   /// Add a Dwarf section label attribute data and value.
   void addSectionLabel(DIE &Die, dwarf::Attribute Attribute,
                        const MCSymbol *Label, const MCSymbol *Sec);
 
+  /// Add DW_TAG_LLVM_annotation.
+  void addAnnotation(DIE &Buffer, DINodeArray Annotations);
+
   /// Get context owner's DIE.
   DIE *createTypeDIE(const DICompositeType *Ty);
 
 protected:
   ~DwarfUnit();
 
   /// Create new static data member DIE.
   DIE *getOrCreateStaticMemberDIE(const DIDerivedType *DT);

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
 
   if (CTy->isLValueReference())
     addFlag(Buffer, dwarf::DW_AT_reference);
 
   if (CTy->isRValueReference())
     addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
 }
 
+void DwarfUnit::addAnnotation(DIE &Buffer, DINodeArray Annotations) {
+  for (const Metadata *Annotation: Annotations->operands()) {
+    const MDNode *MD = cast<MDNode>(Annotation);
+    const MDString *Name = cast<MDString>(MD->getOperand(0));
+    const MDString *Value = cast<MDString>(MD->getOperand(1));
+
+    DIE &AnnotationDie = createAndAddDIE(dwarf::DW_TAG_LLVM_annotation, Buffer);
+    addString(AnnotationDie, dwarf::DW_AT_name, Name->getString());
+    addString(AnnotationDie, dwarf::DW_AT_const_value, Value->getString());
+  }
+}
+
 void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
   // Add name if not anonymous or intermediate type.
   StringRef Name = CTy->getName();
 
   uint64_t Size = CTy->getSizeInBits() >> 3;
   uint16_t Tag = Buffer.getTag();
 
   switch (Tag) {
void DwarfUnit::constructTypeDIE(DIE &Buffer, const DICompositeType *CTy) {
   default:
     break;
   }
 
   // Add name if not anonymous or intermediate type.
   if (!Name.empty())
     addString(Buffer, dwarf::DW_AT_name, Name);
 
+  if (CTy->getAnnotations())
+    addAnnotation(Buffer, CTy->getAnnotations());
+
   if (Tag == dwarf::DW_TAG_enumeration_type ||
       Tag == dwarf::DW_TAG_class_type || Tag == dwarf::DW_TAG_structure_type ||
       Tag == dwarf::DW_TAG_union_type) {
     // Add size if non-zero (derived types might be zero-sized.)
     // Ignore the size if it's a non-enum forward decl.
     // TODO: Do we care about size for enum forward declarations?
     if (Size &&
         (!CTy->isForwardDecl() || Tag == dwarf::DW_TAG_enumeration_type))
void DwarfUnit::applySubprogramAttributes(const DISubprogram *SP, DIE &SPDie,
   if (!SkipSPSourceLocation)
     if (applySubprogramDefinitionAttributes(SP, SPDie, SkipSPAttributes))
       return;
 
   // Constructors and operators for anonymous aggregates do not have names.
   if (!SP->getName().empty())
     addString(SPDie, dwarf::DW_AT_name, SP->getName());
 
+  if (SP->getAnnotations())
+    addAnnotation(SPDie, SP->getAnnotations());
+
   if (!SkipSPSourceLocation)
     addSourceLine(SPDie, SP);
 
   // Skip the rest of the attributes under -gmlt to save space.
   if (SkipSPAttributes)
     return;
 
   // Add the prototype if we have a prototype and we have a C like

 }
 
 DIE &DwarfUnit::constructMemberDIE(DIE &Buffer, const DIDerivedType *DT) {
   DIE &MemberDie = createAndAddDIE(DT->getTag(), Buffer);
   StringRef Name = DT->getName();
   if (!Name.empty())
     addString(MemberDie, dwarf::DW_AT_name, Name);
 
+  if (DT->getAnnotations())
+    addAnnotation(MemberDie, DT->getAnnotations());
+
   if (DIType *Resolved = DT->getBaseType())
     addType(MemberDie, Resolved);
 
   addSourceLine(MemberDie, DT);
 
   if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
 
     // For C++, virtual base classes are not at fixed offset. Use following

llvm/test/DebugInfo/attr-btf_tag.ll

+; REQUIRES: x86-registered-target
+; RUN: llc -filetype=obj -o %t %s
+; RUN: llvm-dwarfdump -debug-info %t | FileCheck %s
+; Source:
+;   #define __tag1 __attribute__((btf_tag("tag1")))
+;   #define __tag2 __attribute__((btf_tag("tag2")))
+;
+;   struct t1 {
+;     int a __tag1 __tag2;
+;   } __tag1 __tag2;
+;
+;   int g1 __tag1 __tag2;
+;
+;   int __tag1 __tag2 foo(struct t1 __tag1 __tag2 *arg) {
+;     return arg->a;
+;   }
+; Compilation flag:
+;   clang -target x86_64 -g -S -emit-llvm t.c
+
+%struct.t1 = type { i32 }
+
+@g1 = dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @foo(%struct.t1* %arg) #0 !dbg !16 {
+entry:
+  %arg.addr = alloca %struct.t1*, align 8
+  store %struct.t1* %arg, %struct.t1** %arg.addr, align 8
+  call void @llvm.dbg.declare(metadata %struct.t1** %arg.addr, metadata !23, metadata !DIExpression()), !dbg !24
+  %0 = load %struct.t1*, %struct.t1** %arg.addr, align 8, !dbg !25
+  %a = getelementptr inbounds %struct.t1, %struct.t1* %0, i32 0, i32 0, !dbg !26
+  %1 = load i32, i32* %a, align 4, !dbg !26
+  ret i32 %1, !dbg !27
+}
+
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind optnone uwtable "frame-pointer"="all" "min-legal-vector-width"="0" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "tune-cpu"="generic" }
+attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!10, !11, !12, !13, !14}
+!llvm.ident = !{!15}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "g1", scope: !2, file: !3, line: 8, type: !6, isLocal: false, isDefinition: true, annotations: !7)
+
+; CHECK:       DW_TAG_variable
+; CHECK-NEXT:     DW_AT_name      ("g1")
+; CHECK:          DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag1")
+; CHECK-EMPTY:
+; CHECK-NEXT:     DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag2")
+; CHECK-EMPTY:
+; CHECK-NEXT:     NULL
+
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 13.0.0 (https://github.com/llvm/llvm-project.git 305231a4f71b68945b4dd92925c76ff49e377c86)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "t.c", directory: "/tmp/home/yhs/work/tests/llvm/btf_tag")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{!8, !9}
+!8 = !{!"btf_tag", !"tag1"}
+!9 = !{!"btf_tag", !"tag2"}
+!10 = !{i32 7, !"Dwarf Version", i32 4}
+!11 = !{i32 2, !"Debug Info Version", i32 3}
+!12 = !{i32 1, !"wchar_size", i32 4}
+!13 = !{i32 7, !"uwtable", i32 1}
+!14 = !{i32 7, !"frame-pointer", i32 2}
+!15 = !{!"clang version 13.0.0 (https://github.com/llvm/llvm-project.git 305231a4f71b68945b4dd92925c76ff49e377c86)"}
+!16 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 10, type: !17, scopeLine: 10, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !2, retainedNodes: !4, annotations: !7)
+
+; CHECK:      DW_TAG_subprogram
+; CHECK:        DW_AT_name      ("foo")
+; CHECK:        DW_TAG_formal_parameter
+; CHECK:          DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag1")
+; CHECK-EMPTY:
+; CHECK-NEXT:     DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag2")
+; CHECK-EMPTY:
+; CHECK-NEXT:     NULL
+; CHECK-EMPTY:
+; CHECK-NEXT:   DW_TAG_LLVM_annotation
+; CHECK-NEXT:     DW_AT_name    ("btf_tag")
+; CHECK-NEXT:     DW_AT_const_value     ("tag1")
+; CHECK-EMPTY:
+; CHECK-NEXT:   DW_TAG_LLVM_annotation
+; CHECK-NEXT:     DW_AT_name    ("btf_tag")
+; CHECK-NEXT:     DW_AT_const_value     ("tag2")
+; CHECK-EMPTY:
+; CHECK-NEXT:   NULL
+
+!17 = !DISubroutineType(types: !18)
+!18 = !{!6, !19}
+!19 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !20, size: 64)
+!20 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "t1", file: !3, line: 4, size: 32, elements: !21, annotations: !7)
+!21 = !{!22}
+!22 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !20, file: !3, line: 5, baseType: !6, size: 32, annotations: !7)
+
+; CHECK:      DW_TAG_structure_type
+; CHECK-NEXT:   DW_AT_name      ("t1")
+; CHECK:        DW_TAG_member
+; CHECK-NEXT:     DW_AT_name      ("a")
+; CHECK:          DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag1")
+; CHECK-EMPTY:
+; CHECK-NEXT:     DW_TAG_LLVM_annotation
+; CHECK-NEXT:       DW_AT_name    ("btf_tag")
+; CHECK-NEXT:       DW_AT_const_value     ("tag2")
+; CHECK-EMPTY:
+; CHECK-NEXT:     NULL
+; CHECK-EMPTY:
+; CHECK-NEXT:   DW_TAG_LLVM_annotation
+; CHECK-NEXT:     DW_AT_name    ("btf_tag")
+; CHECK-NEXT:     DW_AT_const_value     ("tag1")
+; CHECK-EMPTY:
+; CHECK-NEXT:   DW_TAG_LLVM_annotation
+; CHECK-NEXT:     DW_AT_name    ("btf_tag")
+; CHECK-NEXT:     DW_AT_const_value     ("tag2")
+; CHECK-EMPTY:
+; CHECK-NEXT:   NULL
+
+!23 = !DILocalVariable(name: "arg", arg: 1, scope: !16, file: !3, line: 10, type: !19, annotations: !7)
+!24 = !DILocation(line: 10, column: 48, scope: !16)
+!25 = !DILocation(line: 11, column: 10, scope: !16)
+!26 = !DILocation(line: 11, column: 15, scope: !16)
+!27 = !DILocation(line: 11, column: 3, scope: !16)