llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-codegen
Author: None (eddyz87)
<details>
<summary>Changes</summary>
This is a follow-up for BPF mailing list discussion at [1].
Previous commit in a series updated DWARF generation for the following example:
int __attribute__((btf_type_tag("tag1"))) *g;
To generate DWARF that looks as follows:
0x0000001e: DW_TAG_variable
DW_AT_name ("g")
DW_AT_type (0x00000029 "int *")
0x00000029: DW_TAG_pointer_type
DW_AT_type (0x00000032 "int")
0x00000032: DW_TAG_base_type
DW_AT_name ("int")
0x00000036: DW_TAG_LLVM_annotation
DW_AT_name ("btf:type_tag")
DW_AT_const_value ("tag1")
The fresh part is attachment of `btf:type_tag` annotations to types other than
pointers. This commit changes BTF generation to rely on `btf:type_tag`
annotations to generate TYPE_TAG entries. This necessitates the following
changes:
- The logic for `BTFTypeTypeTag` chains creation is moved to
`BTFDebug::addType()`;
- Special logic is added to avoid duplicate BTF entries for tagged and
un-tagged type variants, e.g. in the following case:
```c
#define __tag1 __attribute__((btf_type_tag("tag1")))
#define __tag2 __attribute__((btf_type_tag("tag2")))
struct foo {};
struct bar {
struct foo __tag1 aa;
struct foo __tag2 bb;
struct foo cc;
};
```
Debug information generated for this example contains three instances of
`DICompositeType(name: "foo")` with different `annotations` fields, however
single BTF definition for structure "foo" should be generated. Field
`BTFDebug::DIDedupMap` and method `BTFDebug::lookupType()` are responsible for
this logic;
- Care is taken to avoid references to type tags in relocation entries.
[1] https://lore.kernel.org/bpf/87r0w9jjoq.fsf@<!-- -->oracle.com/
This was previously tracked as differential revision:
https://reviews.llvm.org/D145891
---
Patch is 176.27 KiB, truncated to 20.00 KiB below, full version:
https://github.com/llvm/llvm-project/pull/91424.diff
45 Files Affected:
- (modified) clang/lib/CodeGen/CGDebugInfo.cpp (+180-24)
- (modified) clang/lib/CodeGen/CGDebugInfo.h (+3)
- (added) clang/test/CodeGen/attr-btf_type_tag-circular.c (+18)
- (added) clang/test/CodeGen/attr-btf_type_tag-const.c (+41)
- (modified) clang/test/CodeGen/attr-btf_type_tag-func-ptr.c (+14-5)
- (modified) clang/test/CodeGen/attr-btf_type_tag-func.c (+37-13)
- (added) clang/test/CodeGen/attr-btf_type_tag-restrict.c (+21)
- (modified) clang/test/CodeGen/attr-btf_type_tag-similar-type.c (+34-13)
- (modified) clang/test/CodeGen/attr-btf_type_tag-typedef-field.c (+46-20)
- (modified) clang/test/CodeGen/attr-btf_type_tag-var.c (+55-22)
- (added) clang/test/CodeGen/attr-btf_type_tag-void.c (+12)
- (added) clang/test/CodeGen/attr-btf_type_tag-volatile.c (+18)
- (modified) llvm/include/llvm/IR/DIBuilder.h (+3)
- (modified) llvm/include/llvm/IR/DebugInfoMetadata.h (+58-22)
- (modified) llvm/lib/AsmParser/LLParser.cpp (+10-7)
- (modified) llvm/lib/Bitcode/Reader/MetadataLoader.cpp (+12-4)
- (modified) llvm/lib/Bitcode/Writer/BitcodeWriter.cpp (+2)
- (modified) llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp (+5-1)
- (modified) llvm/lib/IR/AsmWriter.cpp (+4-2)
- (modified) llvm/lib/IR/DIBuilder.cpp (+11)
- (modified) llvm/lib/IR/DebugInfoMetadata.cpp (+8-7)
- (modified) llvm/lib/IR/LLVMContextImpl.h (+20-10)
- (modified) llvm/lib/Target/BPF/BTFDebug.cpp (+554-75)
- (modified) llvm/lib/Target/BPF/BTFDebug.h (+43-3)
- (added) llvm/test/Bitcode/attr-btf_tag-dibasic.ll (+36)
- (added) llvm/test/Bitcode/attr-btf_tag-disubroutine.ll (+41)
- (added) llvm/test/CodeGen/BPF/BTF/print_btf.py (+300)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-cvr-multiple-tags-reuse.ll (+64)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-cvr-multiple-tags.ll (+51)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-cvr-reuse-2.ll (+52)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-cvr-reuse.ll (+55)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-cvr-simple.ll (+44)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-decl-tag-typedef.ll (+66)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-dedup-enum.ll (+87)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-dedup-struct.ll (+82)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-dedup-subroutine.ll (+106)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-dedup-typedef.ll (+84)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-dedup-union.ll (+82)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-field-relo.ll (+103)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-fixup-fwd-v2.ll (+102)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-fixup-resolved-v2.ll (+112)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-skip-var.ll (+49)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-var-v2.ll (+46)
- (added) llvm/test/CodeGen/BPF/BTF/type-tag-void.ll (+43)
- (modified) llvm/test/DebugInfo/attr-btf_type_tag.ll (+99-37)
``````````diff
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp
b/clang/lib/CodeGen/CGDebugInfo.cpp
index fac278f0e20a4..9518a75a3b1f1 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -56,6 +56,16 @@
using namespace clang;
using namespace clang::CodeGen;
+// Temporarily hide new format for btf_type_tags / DW_TAG_LLVM_annotation
+// behind an option to allow transitory period for tooling dependent on
+// this annotation. The goal is to remove this flag after transitory period.
+static llvm::cl::opt<bool> BTFTypeTagV2(
+ "btf-type-tag-v2", llvm::cl::Hidden,
+ llvm::cl::desc("For __attribute__((btf_type_tag(...))) generate "
+ "DW_TAG_LLVM_annotation tags with DW_AT_name 'btf:type_tag'
"
+ "attached to annotated type itself"),
+ llvm::cl::init(false));
+
static uint32_t getTypeAlignIfRequired(const Type *Ty, const ASTContext &Ctx) {
auto TI = Ctx.getTypeInfo(Ty);
return TI.isAlignRequired() ? TI.Align : 0;
@@ -1185,6 +1195,129 @@ CGDebugInfo::getOrCreateRecordFwdDecl(const RecordType
*Ty,
return RetTy;
}
+static QualType collectBTFTypeTagAnnotations(
+ llvm::LLVMContext &Context, llvm::DIBuilder &DBuilder,
+ llvm::SmallVectorImpl<llvm::Metadata *> &Annots,
+ const BTFTagAttributedType *BTFAttrTy, const char *TagName) {
+ QualType WrappedTy;
+
+ do {
+ StringRef TagValue = BTFAttrTy->getAttr()->getBTFTypeTag();
+ if (!TagValue.empty()) {
+ llvm::Metadata *Ops[] = {
+ llvm::MDString::get(Context, TagName),
+ llvm::MDString::get(Context, TagValue),
+ };
+ Annots.insert(Annots.begin(), llvm::MDNode::get(Context, Ops));
+ }
+ WrappedTy = BTFAttrTy->getWrappedType();
+ BTFAttrTy = dyn_cast<BTFTagAttributedType>(WrappedTy);
+ } while (BTFAttrTy);
+
+ return WrappedTy;
+}
+
+static bool retreiveCVR(llvm::DIDerivedType *DTy, QualifierCollector &Qc) {
+ switch (DTy->getTag()) {
+ case llvm::dwarf::DW_TAG_const_type:
+ Qc.addConst();
+ return true;
+ case llvm::dwarf::DW_TAG_volatile_type:
+ Qc.addVolatile();
+ return true;
+ case llvm::dwarf::DW_TAG_restrict_type:
+ Qc.addRestrict();
+ return true;
+ default:
+ return false;
+ }
+}
+
+// Tags returned by QualifierCollector::getNextQualifier() should be
+// applied in the reverse order, thus use recursive function.
+static llvm::DIType *applyQualifiers(llvm::DIBuilder &DBuilder,
+ llvm::DIType *Ty, QualifierCollector &Qc)
{
+ llvm::dwarf::Tag Tag = getNextQualifier(Qc);
+ if (!Tag)
+ return Ty;
+ Ty = applyQualifiers(DBuilder, Ty, Qc);
+ return DBuilder.createQualifiedType(Tag, Ty);
+}
+
+static bool isAnnotationsPlaceholder(llvm::DIDerivedType *DTy) {
+ return DTy->isTemporary() &&
+ DTy->getTag() == llvm::dwarf::DW_TAG_LLVM_annotation;
+}
+
+llvm::DIType *CGDebugInfo::CreateType(const BTFTagAttributedType *Ty,
+ llvm::DIFile *Unit) {
+ SmallVector<llvm::Metadata *, 4> Annotations;
+ auto WrappedTy = collectBTFTypeTagAnnotations(
+ CGM.getLLVMContext(), DBuilder, Annotations, Ty, "btf:type_tag");
+
+ if (!BTFTypeTagV2 || Annotations.empty())
+ return getOrCreateType(WrappedTy, Unit);
+
+ // After discussion with GCC BPF team in [1] it was decided to avoid
+ // attaching BTF type tags to const/volatile/restrict DWARF DIEs.
+ // So, strip qualifiers from WrappedTy and apply those to a final
+ // annotations placeholder instance at the end of this function.
+ //
+ // [1] https://reviews.llvm.org/D143967
+ QualifierCollector Qc;
+ Qc.addCVRQualifiers(WrappedTy.getLocalCVRQualifiers());
+ WrappedTy.removeLocalFastQualifiers(Qualifiers::CVRMask);
+
+ llvm::DIType *WrappedDI = getOrCreateType(WrappedTy, Unit);
+ if (!WrappedDI)
+ WrappedDI = DBuilder.createUnspecifiedType("void");
+
+ // Stripping local CVR qualifiers might not be enough in cases like this:
+ //
+ // #define __tag __attribute__((btf_type_tag("tag")))
+ // const int *foo;
+ // const int *bar(void) {
+ // return (typeof(*foo) __tag *)(0);
+ // }
+ //
+ // Here the AST looks like:
+ //
+ // BTFTagAttributedType
+ // | 'typeof (*foo) __attribute__((btf_type_tag("tag")))' sugar
+ // `-TypeOfExprType 'typeof (*foo)' sugar
+ // |-ParenExpr 'const int' lvalue
+ // | `- ...
+ // `-QualType 'const int' const
+ // `-BuiltinType 'int'
+ //
+ // The BTFTagAttributedType is applied to TypeOfExpr.
+ // For TypeOfExpr the getOrCreateType(), would return instance of
+ // DIDerivedType with tag DW_TAG_const_type.
+ //
+ // To avoid repeating UnwrapTypeForDebugInfo() logic here just
+ // rebuild CVR metadata nodes if necessary.
+ // The above local CVR qualifiers processing is redundant,
+ // but avoids rebuilding metadata nodes in the most common case.
+ while (auto *DTy = dyn_cast<llvm::DIDerivedType>(WrappedDI)) {
+ if (!retreiveCVR(DTy, Qc))
+ break;
+ WrappedDI = DTy->getBaseType();
+ }
+
+ if (auto *DTy = dyn_cast<llvm::DIDerivedType>(WrappedDI))
+ if (isAnnotationsPlaceholder(DTy)) {
+ WrappedDI = DTy->getBaseType();
+ for (llvm::Metadata *O : DTy->getAnnotations()->operands())
+ Annotations.push_back(O);
+ }
+
+ auto *Placeholder = DBuilder.createAnnotationsPlaceholder(
+ WrappedDI, DBuilder.getOrCreateArray(Annotations));
+ AnnotationPlaceholders.push_back(Placeholder);
+
+ return applyQualifiers(DBuilder, Placeholder, Qc);
+}
+
llvm::DIType *CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
const Type *Ty,
QualType PointeeTy,
@@ -1197,32 +1330,23 @@ llvm::DIType
*CGDebugInfo::CreatePointerLikeType(llvm::dwarf::Tag Tag,
CGM.getTarget().getDWARFAddressSpace(
CGM.getTypes().getTargetAddressSpace(PointeeTy));
- SmallVector<llvm::Metadata *, 4> Annots;
- auto *BTFAttrTy = dyn_cast<BTFTagAttributedType>(PointeeTy);
- while (BTFAttrTy) {
- StringRef Tag = BTFAttrTy->getAttr()->getBTFTypeTag();
- if (!Tag.empty()) {
- llvm::Metadata *Ops[2] = {
- llvm::MDString::get(CGM.getLLVMContext(), StringRef("btf_type_tag")),
- llvm::MDString::get(CGM.getLLVMContext(), Tag)};
- Annots.insert(Annots.begin(),
- llvm::MDNode::get(CGM.getLLVMContext(), Ops));
- }
- BTFAttrTy = dyn_cast<BTFTagAttributedType>(BTFAttrTy->getWrappedType());
- }
-
llvm::DINodeArray Annotations = nullptr;
- if (Annots.size() > 0)
- Annotations = DBuilder.getOrCreateArray(Annots);
+ auto *BTFAttrTy = dyn_cast<BTFTagAttributedType>(PointeeTy.getTypePtr());
+ if (!BTFTypeTagV2 && BTFAttrTy) {
+ SmallVector<llvm::Metadata *, 4> AnnotationsVec;
+ collectBTFTypeTagAnnotations(CGM.getLLVMContext(), DBuilder,
AnnotationsVec,
+ BTFAttrTy, "btf_type_tag");
+ Annotations = DBuilder.getOrCreateArray(AnnotationsVec);
+ }
if (Tag == llvm::dwarf::DW_TAG_reference_type ||
Tag == llvm::dwarf::DW_TAG_rvalue_reference_type)
return DBuilder.createReferenceType(Tag, getOrCreateType(PointeeTy, Unit),
Size, Align, DWARFAddressSpace);
- else
- return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
- Align, DWARFAddressSpace, StringRef(),
- Annotations);
+
+ return DBuilder.createPointerType(getOrCreateType(PointeeTy, Unit), Size,
+ Align, DWARFAddressSpace, StringRef(),
+ Annotations);
}
llvm::DIType *CGDebugInfo::getOrCreateStructPtrType(StringRef Name,
@@ -3543,9 +3667,6 @@ static QualType UnwrapTypeForDebugInfo(QualType T, const
ASTContext &C) {
case Type::Attributed:
T = cast<AttributedType>(T)->getEquivalentType();
break;
- case Type::BTFTagAttributed:
- T = cast<BTFTagAttributedType>(T)->getWrappedType();
- break;
case Type::CountAttributed:
T = cast<CountAttributedType>(T)->desugar();
break;
@@ -3745,10 +3866,12 @@ llvm::DIType *CGDebugInfo::CreateTypeNode(QualType Ty,
llvm::DIFile *Unit) {
case Type::TemplateSpecialization:
return CreateType(cast<TemplateSpecializationType>(Ty), Unit);
+ case Type::BTFTagAttributed:
+ return CreateType(cast<BTFTagAttributedType>(Ty), Unit);
+
case Type::CountAttributed:
case Type::Auto:
case Type::Attributed:
- case Type::BTFTagAttributed:
case Type::Adjusted:
case Type::Decayed:
case Type::DeducedTemplateSpecialization:
@@ -5921,6 +6044,35 @@ void CGDebugInfo::setDwoId(uint64_t Signature) {
TheCU->setDWOId(Signature);
}
+static llvm::DIType *copyAnnotations(llvm::DIBuilder &DBuilder,
+ llvm::DIDerivedType *Placeholder) {
+ auto *WrappedDI = Placeholder->getBaseType();
+ SmallVector<llvm::Metadata *, 4> Annotations;
+
+ for (const llvm::Metadata *O : Placeholder->getAnnotations()->operands())
+ Annotations.push_back(const_cast<llvm::Metadata *>(O));
+
+ auto AddAnnotations = [&](auto *Type) {
+ if (llvm::DINodeArray OldAnnotations = Type->getAnnotations())
+ for (const llvm::Metadata *O : OldAnnotations->operands())
+ Annotations.push_back(const_cast<llvm::Metadata *>(O));
+ auto Clone = Type->clone();
+ Clone->replaceAnnotations(DBuilder.getOrCreateArray(Annotations));
+ return llvm::MDNode::replaceWithPermanent(std::move(Clone));
+ };
+
+ if (auto *Ty = dyn_cast<llvm::DIBasicType>(WrappedDI))
+ return AddAnnotations(Ty);
+ if (auto *Ty = dyn_cast<llvm::DICompositeType>(WrappedDI))
+ return AddAnnotations(Ty);
+ if (auto *Ty = dyn_cast<llvm::DIDerivedType>(WrappedDI))
+ return AddAnnotations(Ty);
+ if (auto *Ty = dyn_cast<llvm::DISubroutineType>(WrappedDI))
+ return AddAnnotations(Ty);
+
+ return WrappedDI;
+}
+
void CGDebugInfo::finalize() {
// Creating types might create further types - invalidating the current
// element and the size(), so don't cache/reference them.
@@ -5994,6 +6146,10 @@ void CGDebugInfo::finalize() {
if (auto MD = TypeCache[RT])
DBuilder.retainType(cast<llvm::DIType>(MD));
+ for (auto &Placeholder : AnnotationPlaceholders)
+ DBuilder.replaceTemporary(llvm::TempDIType(Placeholder),
+ copyAnnotations(DBuilder, Placeholder));
+
DBuilder.finalize();
}
diff --git a/clang/lib/CodeGen/CGDebugInfo.h b/clang/lib/CodeGen/CGDebugInfo.h
index d6db4d711366a..43a093c725f6a 100644
--- a/clang/lib/CodeGen/CGDebugInfo.h
+++ b/clang/lib/CodeGen/CGDebugInfo.h
@@ -170,6 +170,8 @@ class CGDebugInfo {
/// The key is coroutine real parameters, value is DIVariable in LLVM IR.
Param2DILocTy ParamDbgMappings;
+ std::vector<llvm::DIDerivedType *> AnnotationPlaceholders;
+
/// Helper functions for getOrCreateType.
/// @{
/// Currently the checksum of an interface includes the number of
@@ -217,6 +219,7 @@ class CGDebugInfo {
llvm::DIType *CreateType(const MemberPointerType *Ty, llvm::DIFile *F);
llvm::DIType *CreateType(const AtomicType *Ty, llvm::DIFile *F);
llvm::DIType *CreateType(const PipeType *Ty, llvm::DIFile *F);
+ llvm::DIType *CreateType(const BTFTagAttributedType *Ty, llvm::DIFile *F);
/// Get enumeration type.
llvm::DIType *CreateEnumType(const EnumType *Ty);
llvm::DIType *CreateTypeDefinition(const EnumType *Ty);
diff --git a/clang/test/CodeGen/attr-btf_type_tag-circular.c
b/clang/test/CodeGen/attr-btf_type_tag-circular.c
new file mode 100644
index 0000000000000..4bcb20e63bead
--- /dev/null
+++ b/clang/test/CodeGen/attr-btf_type_tag-circular.c
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -debug-info-kind=limited \
+// RUN: -mllvm -btf-type-tag-v2 -S -emit-llvm -o - %s | FileCheck %s
+
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+
+struct st {
+ struct st __tag1 *self;
+} g;
+
+// CHECK: distinct !DIGlobalVariable(name: "g", scope: ![[#]], file: ![[#]],
line: [[#]], type: ![[L1:[0-9]+]], isLocal: false, isDefinition: true)
+// CHECK: ![[L1]] = distinct !DICompositeType(tag: DW_TAG_structure_type,
name: "st", file: ![[#]], line: [[#]], size: [[#]], elements: ![[L2:[0-9]+]])
+// CHECK: ![[L2]] = !{![[L3:[0-9]+]]}
+// CHECK: ![[L3]] = !DIDerivedType(tag: DW_TAG_member, name: "self", scope:
![[L1]], file: ![[#]], line: [[#]], baseType: ![[L4:[0-9]+]], size: [[#]])
+// CHECK: ![[L4]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L5:[0-9]+]], size: [[#]])
+// CHECK: ![[L5]] = !DICompositeType(tag: DW_TAG_structure_type, name: "st",
file: ![[#]], line: [[#]], size: [[#]], elements: ![[L2]], annotations:
![[L7:[0-9]+]])
+// CHECK: ![[L7]] = !{![[L8:[0-9]+]]}
+// CHECK: ![[L8]] = !{!"btf:type_tag", !"tag1"}
diff --git a/clang/test/CodeGen/attr-btf_type_tag-const.c
b/clang/test/CodeGen/attr-btf_type_tag-const.c
new file mode 100644
index 0000000000000..94d9c05f5345a
--- /dev/null
+++ b/clang/test/CodeGen/attr-btf_type_tag-const.c
@@ -0,0 +1,41 @@
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -debug-info-kind=limited \
+// RUN: -mllvm -btf-type-tag-v2 -S -emit-llvm -o - %s | FileCheck %s
+
+// Check that BTF type tags are not attached to DW_TAG_const_type DIEs
+// in presence of "sugar" expressions that are transparent for
+// CGDebugInfo.cpp:UnwrapTypeForDebugInfo(), but are not transparent
+// for local qualifiers.
+//
+// For details see:
+// CGDebugInfo::CreateType(const BTFTagAttributedType, llvm::DIFile)
+
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+#define __tag3 __attribute__((btf_type_tag("tag3")))
+
+const int *foo;
+typeof(*foo) __tag1 bar;
+
+// CHECK: distinct !DIGlobalVariable(name: "bar", {{.*}}, type:
![[L01:[0-9]+]], {{.*}})
+// CHECK: ![[L01]] = !DIDerivedType(tag: DW_TAG_const_type, baseType:
![[L02:[0-9]+]])
+// CHECK: ![[L02]] = !DIBasicType(name: "int", {{.*}}, annotations:
![[L03:[0-9]+]])
+// CHECK: ![[L03]] = !{![[L04:[0-9]+]]}
+// CHECK: ![[L04]] = !{!"btf:type_tag", !"tag1"}
+
+const int __tag2 *buz;
+
+// CHECK: distinct !DIGlobalVariable(name: "buz", {{.*}}, type:
![[L05:[0-9]+]], {{.*}})
+// CHECK: ![[L05]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L06:[0-9]+]], {{.*}})
+// CHECK: ![[L06]] = !DIDerivedType(tag: DW_TAG_const_type, baseType:
![[L08:[0-9]+]])
+// CHECK: ![[L08]] = !DIBasicType(name: "int", size: [[#]], {{.*}},
annotations: ![[L09:[0-9]+]])
+// CHECK: ![[L09]] = !{![[L10:[0-9]+]]}
+// CHECK: ![[L10]] = !{!"btf:type_tag", !"tag2"}
+
+typeof(*buz) __tag3 quux;
+
+// CHECK: distinct !DIGlobalVariable(name: "quux", {{.*}}, type:
![[L12:[0-9]+]], {{.*}})
+// CHECK: ![[L12]] = !DIDerivedType(tag: DW_TAG_const_type, baseType:
![[L13:[0-9]+]])
+// CHECK: ![[L13]] = !DIBasicType(name: "int", {{.*}}, annotations:
![[L14:[0-9]+]])
+// CHECK: ![[L14]] = !{![[L15:[0-9]+]], ![[L10]]}
+// CHECK: ![[L15]] = !{!"btf:type_tag", !"tag3"}
diff --git a/clang/test/CodeGen/attr-btf_type_tag-func-ptr.c
b/clang/test/CodeGen/attr-btf_type_tag-func-ptr.c
index 26935c882a017..8567864692202 100644
--- a/clang/test/CodeGen/attr-btf_type_tag-func-ptr.c
+++ b/clang/test/CodeGen/attr-btf_type_tag-func-ptr.c
@@ -1,4 +1,8 @@
// RUN: %clang_cc1 -triple %itanium_abi_triple -debug-info-kind=limited
-emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -debug-info-kind=limited \
+// RUN: -mllvm -btf-type-tag-v2 -emit-llvm -o - %s \
+// RUN: | FileCheck --check-prefix CHECK-V2 %s
struct t {
int (__attribute__((btf_type_tag("rcu"))) *f)();
@@ -8,8 +12,13 @@ int foo(struct t *arg) {
return arg->a;
}
-// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "f"
-// CHECK-SAME: baseType: ![[L18:[0-9]+]]
-// CHECK: ![[L18]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[#]], size: [[#]], annotations: ![[L21:[0-9]+]])
-// CHECK: ![[L21]] = !{![[L22:[0-9]+]]}
-// CHECK: ![[L22]] = !{!"btf_type_tag", !"rcu"}
+// CHECK: !DIDerivedType(tag: DW_TAG_member, name: "f", scope: ![[#]], file:
![[#]], line: [[#]], baseType: ![[L1:[0-9]+]], size: [[#]])
+// CHECK: ![[L1]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: ![[#]],
size: [[#]], annotations: ![[L2:[0-9]+]])
+// CHECK: ![[L2]] = !{![[L3:[0-9]+]]}
+// CHECK: ![[L3]] = !{!"btf_type_tag", !"rcu"}
+
+// CHECK-V2: !DIDerivedType(tag: DW_TAG_member, name: "f", scope: ![[#]],
file: ![[#]], line: [[#]], baseType: ![[L1:[0-9]+]], size: [[#]])
+// CHECK-V2: ![[L1]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L2:[0-9]+]], size: [[#]])
+// CHECK-V2: ![[L2]] = !DISubroutineType(types: ![[#]], annotations:
![[L4:[0-9]+]])
+// CHECK-V2: ![[L4]] = !{![[L5:[0-9]+]]}
+// CHECK-V2: ![[L5]] = !{!"btf:type_tag", !"rcu"}
diff --git a/clang/test/CodeGen/attr-btf_type_tag-func.c
b/clang/test/CodeGen/attr-btf_type_tag-func.c
index dbb8864759148..890d3ab35428b 100644
--- a/clang/test/CodeGen/attr-btf_type_tag-func.c
+++ b/clang/test/CodeGen/attr-btf_type_tag-func.c
@@ -1,5 +1,17 @@
-// RUN: %clang_cc1 -triple %itanium_abi_triple -debug-info-kind=limited
-emit-llvm -o - %s | FileCheck %s
-// RUN: %clang_cc1 -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1
-debug-info-kind=limited -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -debug-info-kind=limited \
+// RUN: -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1
-debug-info-kind=limited \
+// RUN: -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -debug-info-kind=limited \
+// RUN: -mllvm -btf-type-tag-v2 -emit-llvm -o - %s \
+// RUN: | FileCheck --check-prefixes CHECK-V2 %s
+// RUN: %clang_cc1 \
+// RUN: -triple %itanium_abi_triple -DDOUBLE_BRACKET_ATTRS=1 \
+// RUN: -debug-info-kind=limited -mllvm -btf-type-tag-v2 -emit-llvm -o - %s \
+// RUN: | FileCheck --check-prefixes CHECK-V2 %s
#if DOUBLE_BRACKET_ATTRS
#define __tag1 [[clang::btf_type_tag("tag1")]]
@@ -15,14 +27,26 @@
int __tag1 * __tag2 *foo(int __tag1 * __tag2 *arg) { return arg; }
-// CHECK: distinct !DISubprogram(name: "foo", scope: ![[#]], file: ![[#]],
line: [[#]], type: ![[L9:[0-9]+]]
-// CHECK: ![[L9]] = !DISubroutineType(types: ![[L10:[0-9]+]]
-// CHECK: ![[L10]] = !{![[L11:[0-9]+]], ![[L11]]}
-// CHECK: ![[L11]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L12:[0-9]+]], size: [[#]], annotations: ![[L16:[0-9]+]]
-// CHECK: ![[L12]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L13:[0-9]+]], size: [[#]], annotations: ![[L14:[0-9]+]]
-// CHECK: ![[L13]] = !DIBasicType(name: "int", size: 32, encoding:
DW_ATE_signed
-// CHECK: ![[L14]] = !{![[L15:[0-9]+]]}
-// CHECK: ![[L15]] = !{!"btf_type_tag", !"tag1"}
-// CHECK: ![[L16]] = !{![[L17:[0-9]+]]}
-// CHECK: ![[L17]] = !{!"btf_type_tag", !"tag2"}
-// CHECK: !DILocalVariable(name: "arg", arg: 1, scope: ![[#]], file: ![[#]],
line: [[#]], type: ![[L11]])
+// CHECK: distinct !DISubprogram(name: "foo", scope: ![[#]], file: ![[#]],
line: [[#]], type: ![[L01:[0-9]+]], {{.*}})
+// CHECK: ![[L01]] = !DISubroutineType(types: ![[L02:[0-9]+]])
+// CHECK: ![[L02]] = !{![[L03:[0-9]+]], ![[L03]]}
+// CHECK: ![[L03]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L04:[0-9]+]], size: [[#]], annotations: ![[L05:[0-9]+]])
+// CHECK: ![[L04]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L06:[0-9]+]], size: [[#]], annotations: ![[L07:[0-9]+]])
+// CHECK: ![[L06]] = !DIBasicType(name: "int", size: [[#]], encoding:
DW_ATE_signed)
+// CHECK: ![[L07]] = !{![[L11:[0-9]+]]}
+// CHECK: ![[L11]] = !{!"btf_type_tag", !"tag1"}
+// CHECK: ![[L05]] = !{![[L12:[0-9]+]]}
+// CHECK: ![[L12]] = !{!"btf_type_tag", !"tag2"}
+// CHECK: !DILocalVariable(name: "arg", arg: 1, scope: ![[#]], file: ![[#]],
line: [[#]], type: ![[L03]])
+
+// CHECK-V2: distinct !DISubprogram(name: "foo", scope: ![[#]], file: ![[#]],
line: [[#]], type: ![[L01:[0-9]+]], {{.*}})
+// CHECK-V2: ![[L01]] = !DISubroutineType(types: ![[L02:[0-9]+]])
+// CHECK-V2: ![[L02]] = !{![[L03:[0-9]+]], ![[L03]]}
+// CHECK-V2: ![[L03]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L04:[0-9]+]], size: [[#]])
+// CHECK-V2: ![[L04]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType:
![[L06:[0-9]+]], size: [[#]], annotations: ![[L07:[0-9...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/91424
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
