[llvm] [DebugInfo][BPF] Add 'annotations' field for DIBasicType & DISubroutineType (PR #91422)
via llvm-commits
llvm-commits at lists.llvm.org
Wed May 8 10:53:57 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-debuginfo
Author: None (eddyz87)
<details>
<summary>Changes</summary>
Extend `DIBasicType` and `DISubroutineType` with additional field `annotations`, e.g. as below:
```
!5 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed, annotations: !6)
!6 = !{!7}
!7 = !{!"btf:type_tag", !"tag1"}
```
The field would be used by BPF backend to generate DWARF attributes corresponding to `btf_type_tag` type attributes, e.g.:
```
0x00000029: DW_TAG_base_type
DW_AT_name ("int")
DW_AT_encoding (DW_ATE_signed)
DW_AT_byte_size (0x04)
0x0000002d: DW_TAG_LLVM_annotation
DW_AT_name ("btf:type_tag")
DW_AT_const_value ("tag1")
```
Such DWARF entries would be used to generate BTF definitions by tools like [pahole](https://github.com/acmel/dwarves).
Note: similar fields with similar purposes are already present in DIDerivedType and DICompositeType.
Currently "btf_type_tag" attributes are represented in debug information as 'annotations' fields in DIDerivedType with DW_TAG_pointer_type tag. The annotation on a pointer corresponds to pointee having the attributes in the final BTF.
The discussion in [thread](https://lore.kernel.org/bpf/87r0w9jjoq.fsf@<!-- -->oracle.com/) came to conclusion, that such annotations should apply to the annotated type itself. Hence the necessity to extend `DIBasicType` & `DISubroutineType` types with 'annotations' field to represent cases like below:
```
int __attribute__((btf_type_tag("foo"))) bar;
```
This was previously tracked as differential revision: https://reviews.llvm.org/D143966
---
Patch is 31.94 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/91422.diff
11 Files Affected:
- (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/DebugInfoMetadata.cpp (+8-7)
- (modified) llvm/lib/IR/LLVMContextImpl.h (+20-10)
- (added) llvm/test/Bitcode/attr-btf_tag-dibasic.ll (+36)
- (added) llvm/test/Bitcode/attr-btf_tag-disubroutine.ll (+41)
- (modified) llvm/test/DebugInfo/attr-btf_type_tag.ll (+99-37)
``````````diff
diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h
index 42291d45da2be..1dfaa4aced791 100644
--- a/llvm/include/llvm/IR/DebugInfoMetadata.h
+++ b/llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -828,40 +828,45 @@ class DIBasicType : public DIType {
static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
StringRef Name, uint64_t SizeInBits,
uint32_t AlignInBits, unsigned Encoding,
- DIFlags Flags, StorageType Storage,
- bool ShouldCreate = true) {
+ DIFlags Flags, DINodeArray Annotations,
+ StorageType Storage, bool ShouldCreate = true) {
return getImpl(Context, Tag, getCanonicalMDString(Context, Name),
- SizeInBits, AlignInBits, Encoding, Flags, Storage,
- ShouldCreate);
+ SizeInBits, AlignInBits, Encoding, Flags, Annotations.get(),
+ Storage, ShouldCreate);
}
static DIBasicType *getImpl(LLVMContext &Context, unsigned Tag,
MDString *Name, uint64_t SizeInBits,
uint32_t AlignInBits, unsigned Encoding,
- DIFlags Flags, StorageType Storage,
- bool ShouldCreate = true);
+ DIFlags Flags, Metadata *Annotations,
+ StorageType Storage, bool ShouldCreate = true);
TempDIBasicType cloneImpl() const {
return getTemporary(getContext(), getTag(), getName(), getSizeInBits(),
- getAlignInBits(), getEncoding(), getFlags());
+ getAlignInBits(), getEncoding(), getFlags(),
+ getAnnotations());
}
public:
DEFINE_MDNODE_GET(DIBasicType, (unsigned Tag, StringRef Name),
- (Tag, Name, 0, 0, 0, FlagZero))
+ (Tag, Name, 0, 0, 0, FlagZero, {}))
DEFINE_MDNODE_GET(DIBasicType,
(unsigned Tag, StringRef Name, uint64_t SizeInBits),
- (Tag, Name, SizeInBits, 0, 0, FlagZero))
+ (Tag, Name, SizeInBits, 0, 0, FlagZero, {}))
DEFINE_MDNODE_GET(DIBasicType,
(unsigned Tag, MDString *Name, uint64_t SizeInBits),
- (Tag, Name, SizeInBits, 0, 0, FlagZero))
+ (Tag, Name, SizeInBits, 0, 0, FlagZero, {}))
DEFINE_MDNODE_GET(DIBasicType,
(unsigned Tag, StringRef Name, uint64_t SizeInBits,
- uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
- (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
+ uint32_t AlignInBits, unsigned Encoding, DIFlags Flags,
+ DINodeArray Annotations = {}),
+ (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags,
+ Annotations))
DEFINE_MDNODE_GET(DIBasicType,
(unsigned Tag, MDString *Name, uint64_t SizeInBits,
- uint32_t AlignInBits, unsigned Encoding, DIFlags Flags),
- (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags))
+ uint32_t AlignInBits, unsigned Encoding, DIFlags Flags,
+ Metadata *Annotations = nullptr),
+ (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags,
+ Annotations))
TempDIBasicType clone() const { return cloneImpl(); }
@@ -873,6 +878,16 @@ class DIBasicType : public DIType {
/// neither signed nor unsigned.
std::optional<Signedness> getSignedness() const;
+ Metadata *getRawAnnotations() const { return getOperand(3); }
+
+ DINodeArray getAnnotations() const {
+ return cast_or_null<MDTuple>(getRawAnnotations());
+ }
+
+ void replaceAnnotations(DINodeArray Annotations) {
+ replaceOperandWith(3, Annotations.get());
+ }
+
static bool classof(const Metadata *MD) {
return MD->getMetadataID() == DIBasicTypeKind;
}
@@ -1112,6 +1127,10 @@ class DIDerivedType : public DIType {
}
Metadata *getRawAnnotations() const { return getOperand(5); }
+ void replaceAnnotations(DINodeArray Annotations) {
+ replaceOperandWith(5, Annotations.get());
+ }
+
/// Get casted version of extra data.
/// @{
DIType *getClassType() const;
@@ -1339,6 +1358,10 @@ class DICompositeType : public DIType {
return cast_or_null<MDTuple>(getRawAnnotations());
}
+ void replaceAnnotations(DINodeArray Annotations) {
+ replaceOperandWith(13, Annotations.get());
+ }
+
/// Replace operands.
///
/// If this \a isUniqued() and not \a isResolved(), on a uniquing collision
@@ -1385,26 +1408,30 @@ class DISubroutineType : public DIType {
static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
uint8_t CC, DITypeRefArray TypeArray,
- StorageType Storage,
+ DINodeArray Annotations, StorageType Storage,
bool ShouldCreate = true) {
- return getImpl(Context, Flags, CC, TypeArray.get(), Storage, ShouldCreate);
+ return getImpl(Context, Flags, CC, TypeArray.get(), Annotations.get(),
+ Storage, ShouldCreate);
}
static DISubroutineType *getImpl(LLVMContext &Context, DIFlags Flags,
uint8_t CC, Metadata *TypeArray,
- StorageType Storage,
+ Metadata *Annotations, StorageType Storage,
bool ShouldCreate = true);
TempDISubroutineType cloneImpl() const {
- return getTemporary(getContext(), getFlags(), getCC(), getTypeArray());
+ return getTemporary(getContext(), getFlags(), getCC(), getTypeArray(),
+ getAnnotations());
}
public:
DEFINE_MDNODE_GET(DISubroutineType,
- (DIFlags Flags, uint8_t CC, DITypeRefArray TypeArray),
- (Flags, CC, TypeArray))
+ (DIFlags Flags, uint8_t CC, DITypeRefArray TypeArray,
+ DINodeArray Annotations = nullptr),
+ (Flags, CC, TypeArray, Annotations))
DEFINE_MDNODE_GET(DISubroutineType,
- (DIFlags Flags, uint8_t CC, Metadata *TypeArray),
- (Flags, CC, TypeArray))
+ (DIFlags Flags, uint8_t CC, Metadata *TypeArray,
+ Metadata *Annotations = nullptr),
+ (Flags, CC, TypeArray, Annotations))
TempDISubroutineType clone() const { return cloneImpl(); }
// Returns a new temporary DISubroutineType with updated CC
@@ -1422,6 +1449,15 @@ class DISubroutineType : public DIType {
Metadata *getRawTypeArray() const { return getOperand(3); }
+ Metadata *getRawAnnotations() const { return getOperand(4); }
+ DINodeArray getAnnotations() const {
+ return cast_or_null<MDTuple>(getRawAnnotations());
+ }
+
+ void replaceAnnotations(DINodeArray Annotations) {
+ replaceOperandWith(4, Annotations.get());
+ }
+
static bool classof(const Metadata *MD) {
return MD->getMetadataID() == DISubroutineTypeKind;
}
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 34053a5ca9c8e..813454aefd9e1 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -5210,7 +5210,7 @@ bool LLParser::parseDIEnumerator(MDNode *&Result, bool IsDistinct) {
/// parseDIBasicType:
/// ::= !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32,
-/// encoding: DW_ATE_encoding, flags: 0)
+/// encoding: DW_ATE_encoding, flags: 0, annotations: !1)
bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) {
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
OPTIONAL(tag, DwarfTagField, (dwarf::DW_TAG_base_type)); \
@@ -5218,12 +5218,14 @@ bool LLParser::parseDIBasicType(MDNode *&Result, bool IsDistinct) {
OPTIONAL(size, MDUnsignedField, (0, UINT64_MAX)); \
OPTIONAL(align, MDUnsignedField, (0, UINT32_MAX)); \
OPTIONAL(encoding, DwarfAttEncodingField, ); \
- OPTIONAL(flags, DIFlagField, );
+ OPTIONAL(flags, DIFlagField, ); \
+ OPTIONAL(annotations, MDField, );
PARSE_MD_FIELDS();
#undef VISIT_MD_FIELDS
- Result = GET_OR_DISTINCT(DIBasicType, (Context, tag.Val, name.Val, size.Val,
- align.Val, encoding.Val, flags.Val));
+ Result = GET_OR_DISTINCT(DIBasicType,
+ (Context, tag.Val, name.Val, size.Val, align.Val,
+ encoding.Val, flags.Val, annotations.Val));
return false;
}
@@ -5360,12 +5362,13 @@ bool LLParser::parseDISubroutineType(MDNode *&Result, bool IsDistinct) {
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED) \
OPTIONAL(flags, DIFlagField, ); \
OPTIONAL(cc, DwarfCCField, ); \
- REQUIRED(types, MDField, );
+ REQUIRED(types, MDField, ); \
+ OPTIONAL(annotations, MDField, );
PARSE_MD_FIELDS();
#undef VISIT_MD_FIELDS
- Result = GET_OR_DISTINCT(DISubroutineType,
- (Context, flags.Val, cc.Val, types.Val));
+ Result = GET_OR_DISTINCT(DISubroutineType, (Context, flags.Val, cc.Val,
+ types.Val, annotations.Val));
return false;
}
diff --git a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
index 9102f3a60cffc..bc06c55f1662c 100644
--- a/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
+++ b/llvm/lib/Bitcode/Reader/MetadataLoader.cpp
@@ -1527,7 +1527,7 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
break;
}
case bitc::METADATA_BASIC_TYPE: {
- if (Record.size() < 6 || Record.size() > 7)
+ if (Record.size() < 6 || Record.size() > 8)
return error("Invalid record");
IsDistinct = Record[0];
@@ -1535,10 +1535,14 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
? static_cast<DINode::DIFlags>(Record[6])
: DINode::FlagZero;
+ Metadata *Annotations = nullptr;
+ if (Record.size() > 7 && Record[7])
+ Annotations = getMDOrNull(Record[7]);
+
MetadataList.assignValue(
GET_OR_DISTINCT(DIBasicType,
(Context, Record[1], getMDString(Record[2]), Record[3],
- Record[4], Record[5], Flags)),
+ Record[4], Record[5], Flags, Annotations)),
NextMetadataNo);
NextMetadataNo++;
break;
@@ -1703,7 +1707,7 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
break;
}
case bitc::METADATA_SUBROUTINE_TYPE: {
- if (Record.size() < 3 || Record.size() > 4)
+ if (Record.size() < 3 || Record.size() > 5)
return error("Invalid record");
bool IsOldTypeRefArray = Record[0] < 2;
unsigned CC = (Record.size() > 3) ? Record[3] : 0;
@@ -1713,9 +1717,13 @@ Error MetadataLoader::MetadataLoaderImpl::parseOneMetadata(
Metadata *Types = getMDOrNull(Record[2]);
if (LLVM_UNLIKELY(IsOldTypeRefArray))
Types = MetadataList.upgradeTypeRefArray(Types);
+ Metadata *Annotations = nullptr;
+ if (Record.size() > 4 && Record[4])
+ Annotations = getMDOrNull(Record[4]);
MetadataList.assignValue(
- GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
+ GET_OR_DISTINCT(DISubroutineType,
+ (Context, Flags, CC, Types, Annotations)),
NextMetadataNo);
NextMetadataNo++;
break;
diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
index 6d01e3b4d8218..d7b5c4f7f3a1f 100644
--- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -1798,6 +1798,7 @@ void ModuleBitcodeWriter::writeDIBasicType(const DIBasicType *N,
Record.push_back(N->getAlignInBits());
Record.push_back(N->getEncoding());
Record.push_back(N->getFlags());
+ Record.push_back(VE.getMetadataOrNullID(N->getRawAnnotations()));
Stream.EmitRecord(bitc::METADATA_BASIC_TYPE, Record, Abbrev);
Record.clear();
@@ -1893,6 +1894,7 @@ void ModuleBitcodeWriter::writeDISubroutineType(
Record.push_back(N->getFlags());
Record.push_back(VE.getMetadataOrNullID(N->getTypeArray().get()));
Record.push_back(N->getCC());
+ Record.push_back(VE.getMetadataOrNullID(N->getRawAnnotations()));
Stream.EmitRecord(bitc::METADATA_SUBROUTINE_TYPE, Record, Abbrev);
Record.clear();
diff --git a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
index 56c288ee95b43..203f496536002 100644
--- a/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
+++ b/llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp
@@ -696,7 +696,9 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DIBasicType *BTy) {
if (!Name.empty())
addString(Buffer, dwarf::DW_AT_name, Name);
- // An unspecified type only has a name attribute.
+ addAnnotation(Buffer, BTy->getAnnotations());
+
+ // An unspecified type only has a name attribute & annotations.
if (BTy->getTag() == dwarf::DW_TAG_unspecified_type)
return;
@@ -865,6 +867,8 @@ void DwarfUnit::constructTypeDIE(DIE &Buffer, const DISubroutineType *CTy) {
if (CTy->isRValueReference())
addFlag(Buffer, dwarf::DW_AT_rvalue_reference);
+
+ addAnnotation(Buffer, CTy->getAnnotations());
}
void DwarfUnit::addAnnotation(DIE &Buffer, DINodeArray Annotations) {
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index 941f6a7a7d823..b37c01a10d025 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -2096,9 +2096,9 @@ static void writeDIEnumerator(raw_ostream &Out, const DIEnumerator *N,
}
static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
- AsmWriterContext &) {
+ AsmWriterContext &WriterCtx) {
Out << "!DIBasicType(";
- MDFieldPrinter Printer(Out);
+ MDFieldPrinter Printer(Out, WriterCtx);
if (N->getTag() != dwarf::DW_TAG_base_type)
Printer.printTag(N);
Printer.printString("name", N->getName());
@@ -2107,6 +2107,7 @@ static void writeDIBasicType(raw_ostream &Out, const DIBasicType *N,
Printer.printDwarfEnum("encoding", N->getEncoding(),
dwarf::AttributeEncodingString);
Printer.printDIFlags("flags", N->getFlags());
+ Printer.printMetadata("annotations", N->getRawAnnotations());
Out << ")";
}
@@ -2202,6 +2203,7 @@ static void writeDISubroutineType(raw_ostream &Out, const DISubroutineType *N,
Printer.printDwarfEnum("cc", N->getCC(), dwarf::ConventionString);
Printer.printMetadata("types", N->getRawTypeArray(),
/* ShouldSkipNull */ false);
+ Printer.printMetadata("annotations", N->getRawAnnotations());
Out << ")";
}
diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp
index 570515505607f..264d8e467fde0 100644
--- a/llvm/lib/IR/DebugInfoMetadata.cpp
+++ b/llvm/lib/IR/DebugInfoMetadata.cpp
@@ -663,12 +663,12 @@ DIEnumerator *DIEnumerator::getImpl(LLVMContext &Context, const APInt &Value,
DIBasicType *DIBasicType::getImpl(LLVMContext &Context, unsigned Tag,
MDString *Name, uint64_t SizeInBits,
uint32_t AlignInBits, unsigned Encoding,
- DIFlags Flags, StorageType Storage,
- bool ShouldCreate) {
+ DIFlags Flags, Metadata *Annotations,
+ StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
- DEFINE_GETIMPL_LOOKUP(DIBasicType,
- (Tag, Name, SizeInBits, AlignInBits, Encoding, Flags));
- Metadata *Ops[] = {nullptr, nullptr, Name};
+ DEFINE_GETIMPL_LOOKUP(DIBasicType, (Tag, Name, SizeInBits, AlignInBits,
+ Encoding, Flags, Annotations));
+ Metadata *Ops[] = {nullptr, nullptr, Name, Annotations};
DEFINE_GETIMPL_STORE(DIBasicType,
(Tag, SizeInBits, AlignInBits, Encoding, Flags), Ops);
}
@@ -872,10 +872,11 @@ DISubroutineType::DISubroutineType(LLVMContext &C, StorageType Storage,
DISubroutineType *DISubroutineType::getImpl(LLVMContext &Context, DIFlags Flags,
uint8_t CC, Metadata *TypeArray,
+ Metadata *Annotations,
StorageType Storage,
bool ShouldCreate) {
- DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray));
- Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray};
+ DEFINE_GETIMPL_LOOKUP(DISubroutineType, (Flags, CC, TypeArray, Annotations));
+ Metadata *Ops[] = {nullptr, nullptr, nullptr, TypeArray, Annotations};
DEFINE_GETIMPL_STORE(DISubroutineType, (Flags, CC), Ops);
}
diff --git a/llvm/lib/IR/LLVMContextImpl.h b/llvm/lib/IR/LLVMContextImpl.h
index 399fe0dad26c7..86bfcce599e77 100644
--- a/llvm/lib/IR/LLVMContextImpl.h
+++ b/llvm/lib/IR/LLVMContextImpl.h
@@ -465,25 +465,29 @@ template <> struct MDNodeKeyImpl<DIBasicType> {
uint32_t AlignInBits;
unsigned Encoding;
unsigned Flags;
+ Metadata *Annotations;
MDNodeKeyImpl(unsigned Tag, MDString *Name, uint64_t SizeInBits,
- uint32_t AlignInBits, unsigned Encoding, unsigned Flags)
+ uint32_t AlignInBits, unsigned Encoding, unsigned Flags,
+ Metadata *Annotations)
: Tag(Tag), Name(Name), SizeInBits(SizeInBits), AlignInBits(AlignInBits),
- Encoding(Encoding), Flags(Flags) {}
+ Encoding(Encoding), Flags(Flags), Annotations(Annotations) {}
MDNodeKeyImpl(const DIBasicType *N)
: Tag(N->getTag()), Name(N->getRawName()), SizeInBits(N->getSizeInBits()),
AlignInBits(N->getAlignInBits()), Encoding(N->getEncoding()),
- Flags(N->getFlags()) {}
+ Flags(N->getFlags()), Annotations(N->getRawAnnotations()) {}
bool isKeyOf(const DIBasicType *RHS) const {
return Tag == RHS->getTag() && Name == RHS->getRawName() &&
SizeInBits == RHS->getSizeInBits() &&
AlignInBits == RHS->getAlignInBits() &&
- Encoding == RHS->getEncoding() && Flags == RHS->getFlags();
+ Encoding == RHS->getEncoding() && Flags == RHS->getFlags() &&
+ Annotations == RHS->getRawAnnotations();
}
unsigned getHashValue() const {
- return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding);
+ return hash_combine(Tag, Name, SizeInBits, AlignInBits, Encoding,
+ Annotations);
}
};
@@ -712,18 +716,24 @@ template <> struct MDNodeKeyImpl<DISubroutineType> {
unsigned Flags;
uint8_t CC;
Metadata *TypeArray;
+ Metadata *Annotations;
- MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray)
- : Flags(Flags), CC(CC), TypeArray(TypeArray) {}
+ MDNodeKeyImpl(unsigned Flags, uint8_t CC, Metadata *TypeArray,
+ Metadata *Annotations)
+ : Flags(Flags), CC(CC), TypeArray(TypeArray), Annotations(Annotations) {}
MDNodeKeyImpl(const DISubroutineType *N)
- : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()) {}
+ : Flags(N->getFlags()), CC(N->getCC()), TypeArray(N->getRawTypeArray()),
+ Annotations(N->getRawAnnotations()) {}
bool isKeyOf(const DISubroutineType *RHS) const {
return Flags == RHS->getFlags() && CC == RHS->getCC() &&
- TypeArray == RHS->getRawTypeArray();
+ TypeArray == RHS->getRawTypeArray() &&
+ Annotations == RHS->getRawAnnotations();
}
- unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
+ unsigned getHashValue() const {
+ return hash_combine(Flags, CC, TypeArray, Anno...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/91422
More information about the llvm-commits
mailing list