[clang] [llvm] [KeyInstr] Add DISubprogram::keyInstructions bit (PR #144107)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Jun 13 09:06:05 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-debuginfo
Author: Orlando Cazalet-Hyams (OCHyams)
<details>
<summary>Changes</summary>
Patch 1/4 adding bitcode support.
Store whether or not a function is using Key Instructions in its DISubprogram so that we don't need to rely on the -mllvm flag -dwarf-use-key-instructions to determine whether or not to interpret Key Instructions metadata to decide is_stmt placement at DWARF emission time. This makes bitcode support simple and enables well defined mixing of non-key-instructions and key-instructions functions in an LTO context.
This patch adds the bit (using DISubprogram::SubclassData1).
#<!-- -->144104 and #<!-- -->144103 use it during DWARF emission.
#<!-- -->144102 adds bitcode support.
---
I explored an alternative - tracking a function-local nextAtomRank number in DISubprogram, allowing us the benefit of this patch and in addition letting us move away from the global LLVMContextImpl::NextAtomGroup. I discarded that approach as there were no substantial compile time or max-rss savings (despite allowing us to shrink atomGroup to 32-bits) and it added some weird complexities:
* The DISubprogram had to be updated frequently, which would mean be expensive in the normal "metadata is constant once created" model. There's precedent with edit-able fields for distinct-only DISubprograms with scopeLine, and this approach worked fine for nextAtomGroup, but it seems like a bit of a hack.
* The DILocation's subprogram isn't the one that tracks its nextAtomGroup, it's the subprogram the intsruction it's attached to is in (i.e., it's inlined-at scope if inlined). This meant to avoid inlined-at chain lookups DISubprogram has to get passed into functions like CloneBasicBlock, which is a bit weird.
---
Patch is 62.93 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/144107.diff
34 Files Affected:
- (modified) clang/lib/CodeGen/CGDebugInfo.cpp (+13-5)
- (modified) llvm/include/llvm/IR/DIBuilder.h (+13-10)
- (modified) llvm/include/llvm/IR/DebugInfoMetadata.h (+19-11)
- (modified) llvm/lib/AsmParser/LLParser.cpp (+3-2)
- (modified) llvm/lib/IR/AsmWriter.cpp (+1)
- (modified) llvm/lib/IR/DIBuilder.cpp (+5-5)
- (modified) llvm/lib/IR/DebugInfoMetadata.cpp (+8-7)
- (modified) llvm/lib/IR/LLVMContextImpl.h (+11-7)
- (modified) llvm/lib/IR/Verifier.cpp (+6)
- (modified) llvm/lib/Transforms/Utils/Debugify.cpp (+3-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/inline-nodbg.ll (+3-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/inline.ll (+3-3)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/jump-threading-2-bbs.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/jump-threading-basic.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/jump-threading-dup-cond-br-on-phi-into-pred.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/loop-rotate.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/loop-unroll-runtime.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/loop-unroll.ll (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/loop-unswitch.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/parse.ll (+2-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/simplifycfg-branch-fold.ll (+2-2)
- (modified) llvm/test/DebugInfo/KeyInstructions/Generic/simplifycfg-thread-phi.ll (+3-1)
- (added) llvm/test/DebugInfo/KeyInstructions/Generic/verify.ll (+22)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/cgp-break-critical-edge.ll (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/dwarf-basic-ranks.ll (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/dwarf-basic.ll (+2-2)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/dwarf-buoy-multi-key.mir (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/dwarf-buoy.mir (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/dwarf-calls.ll (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/X86/dwarf-ranks-blocks.ll (+1-1)
- (modified) llvm/test/DebugInfo/KeyInstructions/debugify.ll (+3)
- (modified) llvm/unittests/IR/BasicBlockDbgInfoTest.cpp (+1-1)
- (modified) llvm/unittests/IR/MetadataTest.cpp (+45-31)
- (modified) llvm/unittests/Transforms/Utils/CloningTest.cpp (+2-2)
``````````diff
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index ee5e3d68a5ffa..7b8b001d4921e 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -1904,7 +1904,8 @@ CGDebugInfo::createInlinedSubprogram(StringRef FuncName,
/*ScopeLine=*/0,
/*Flags=*/llvm::DINode::FlagArtificial,
/*SPFlags=*/llvm::DISubprogram::SPFlagDefinition,
- /*TParams=*/nullptr, /*ThrownTypes=*/nullptr, /*Annotations=*/nullptr);
+ /*TParams=*/nullptr, /*ThrownTypes=*/nullptr, /*Annotations=*/nullptr,
+ nullptr, StringRef(), CGM.getCodeGenOpts().DebugKeyInstructions);
}
return SP;
@@ -2284,7 +2285,8 @@ llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
llvm::DISubprogram *SP = DBuilder.createMethod(
RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags,
- TParamsArray.get());
+ TParamsArray.get(), /*ThrownTypes*/ nullptr,
+ CGM.getCodeGenOpts().DebugKeyInstructions);
SPCache[Method->getCanonicalDecl()].reset(SP);
@@ -4350,7 +4352,9 @@ llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
return DBuilder.createFunction(
DContext, Name, LinkageName, Unit, Line,
getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
- TParamsArray.get(), getFunctionDeclaration(FD));
+ TParamsArray.get(), getFunctionDeclaration(FD), /*ThrownTypes*/ nullptr,
+ /*Annotations*/ nullptr, /*TargetFuncName*/ "",
+ CGM.getCodeGenOpts().DebugKeyInstructions);
}
llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
@@ -4686,8 +4690,9 @@ void CGDebugInfo::emitFunctionStart(GlobalDecl GD, SourceLocation Loc,
llvm::DISubprogram *SP = DBuilder.createFunction(
FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
FlagsForDef, SPFlagsForDef, TParamsArray.get(), Decl, nullptr,
- Annotations);
+ Annotations, "", CGM.getCodeGenOpts().DebugKeyInstructions);
Fn->setSubprogram(SP);
+
// We might get here with a VarDecl in the case we're generating
// code for the initialization of globals. Do not record these decls
// as they will overwrite the actual VarDecl Decl in the cache.
@@ -4746,9 +4751,12 @@ void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
llvm::DISubroutineType *STy = getOrCreateFunctionType(D, FnType, Unit);
+ // Key Instructions: Don't set flag on declarations.
+ assert(~SPFlags & llvm::DISubprogram::SPFlagDefinition);
llvm::DISubprogram *SP = DBuilder.createFunction(
FDContext, Name, LinkageName, Unit, LineNo, STy, ScopeLine, Flags,
- SPFlags, TParamsArray.get(), nullptr, nullptr, Annotations);
+ SPFlags, TParamsArray.get(), nullptr, nullptr, Annotations,
+ /*TargetFunctionName*/ "", /*UseKeyInstructions*/ false);
// Preserve btf_decl_tag attributes for parameters of extern functions
// for BPF target. The parameters created in this loop are attached as
diff --git a/llvm/include/llvm/IR/DIBuilder.h b/llvm/include/llvm/IR/DIBuilder.h
index 43fca571ee6d5..7d3e331a40184 100644
--- a/llvm/include/llvm/IR/DIBuilder.h
+++ b/llvm/include/llvm/IR/DIBuilder.h
@@ -894,6 +894,8 @@ namespace llvm {
/// \param Annotations Attribute Annotations.
/// \param TargetFuncName The name of the target function if this is
/// a trampoline.
+ /// \param UseKeyInstructions Instruct DWARF emission to interpret Key
+ /// Instructions metadata on instructions to determine is_stmt placement.
LLVM_ABI DISubprogram *createFunction(
DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
@@ -901,7 +903,8 @@ namespace llvm {
DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
DITemplateParameterArray TParams = nullptr,
DISubprogram *Decl = nullptr, DITypeArray ThrownTypes = nullptr,
- DINodeArray Annotations = nullptr, StringRef TargetFuncName = "");
+ DINodeArray Annotations = nullptr, StringRef TargetFuncName = "",
+ bool UseKeyInstructions = false);
/// Identical to createFunction,
/// except that the resulting DbgNode is meant to be RAUWed.
@@ -932,15 +935,15 @@ namespace llvm {
/// \param SPFlags Additional flags specific to subprograms.
/// \param TParams Function template parameters.
/// \param ThrownTypes Exception types this function may throw.
- LLVM_ABI DISubprogram *
- createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName,
- DIFile *File, unsigned LineNo, DISubroutineType *Ty,
- unsigned VTableIndex = 0, int ThisAdjustment = 0,
- DIType *VTableHolder = nullptr,
- DINode::DIFlags Flags = DINode::FlagZero,
- DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
- DITemplateParameterArray TParams = nullptr,
- DITypeArray ThrownTypes = nullptr);
+ /// \param UseKeyInstructions Enable Key Instructions debug info.
+ LLVM_ABI DISubprogram *createMethod(
+ DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
+ unsigned LineNo, DISubroutineType *Ty, unsigned VTableIndex = 0,
+ int ThisAdjustment = 0, DIType *VTableHolder = nullptr,
+ DINode::DIFlags Flags = DINode::FlagZero,
+ DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
+ DITemplateParameterArray TParams = nullptr,
+ DITypeArray ThrownTypes = nullptr, bool UseKeyInstructions = false);
/// Create common block entry for a Fortran common block.
/// \param Scope Scope of this common block.
diff --git a/llvm/include/llvm/IR/DebugInfoMetadata.h b/llvm/include/llvm/IR/DebugInfoMetadata.h
index 18228b7757897..42bbb0b1d1ee2 100644
--- a/llvm/include/llvm/IR/DebugInfoMetadata.h
+++ b/llvm/include/llvm/IR/DebugInfoMetadata.h
@@ -1962,7 +1962,7 @@ class DILocalScope : public DIScope {
}
};
-/// Subprogram description.
+/// Subprogram description. Uses SubclassData1.
class DISubprogram : public DILocalScope {
friend class LLVMContextImpl;
friend class MDNode;
@@ -2009,7 +2009,8 @@ class DISubprogram : public DILocalScope {
DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
unsigned ScopeLine, unsigned VirtualIndex, int ThisAdjustment,
- DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops);
+ DIFlags Flags, DISPFlags SPFlags, bool UsesKeyInstructions,
+ ArrayRef<Metadata *> Ops);
~DISubprogram() = default;
static DISubprogram *
@@ -2021,15 +2022,17 @@ class DISubprogram : public DILocalScope {
DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
DINodeArray RetainedNodes, DITypeArray ThrownTypes,
DINodeArray Annotations, StringRef TargetFuncName,
- StorageType Storage, bool ShouldCreate = true) {
+ bool UsesKeyInstructions, StorageType Storage,
+ bool ShouldCreate = true) {
return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
getCanonicalMDString(Context, LinkageName), File, Line, Type,
ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
Flags, SPFlags, Unit, TemplateParams.get(), Declaration,
RetainedNodes.get(), ThrownTypes.get(), Annotations.get(),
getCanonicalMDString(Context, TargetFuncName),
- Storage, ShouldCreate);
+ UsesKeyInstructions, Storage, ShouldCreate);
}
+
LLVM_ABI static DISubprogram *
getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
@@ -2037,8 +2040,8 @@ class DISubprogram : public DILocalScope {
int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
Metadata *TemplateParams, Metadata *Declaration,
Metadata *RetainedNodes, Metadata *ThrownTypes, Metadata *Annotations,
- MDString *TargetFuncName, StorageType Storage,
- bool ShouldCreate = true);
+ MDString *TargetFuncName, bool UsesKeyInstructions,
+ StorageType Storage, bool ShouldCreate = true);
TempDISubprogram cloneImpl() const {
return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
@@ -2047,7 +2050,7 @@ class DISubprogram : public DILocalScope {
getThisAdjustment(), getFlags(), getSPFlags(),
getUnit(), getTemplateParams(), getDeclaration(),
getRetainedNodes(), getThrownTypes(), getAnnotations(),
- getTargetFuncName());
+ getTargetFuncName(), getKeyInstructionsEnabled());
}
public:
@@ -2060,10 +2063,11 @@ class DISubprogram : public DILocalScope {
DITemplateParameterArray TemplateParams = nullptr,
DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr,
DITypeArray ThrownTypes = nullptr, DINodeArray Annotations = nullptr,
- StringRef TargetFuncName = ""),
+ StringRef TargetFuncName = "", bool UsesKeyInstructions = false),
(Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
- Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
+ Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName,
+ UsesKeyInstructions))
DEFINE_MDNODE_GET(
DISubprogram,
@@ -2073,10 +2077,12 @@ class DISubprogram : public DILocalScope {
DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr,
Metadata *RetainedNodes = nullptr, Metadata *ThrownTypes = nullptr,
- Metadata *Annotations = nullptr, MDString *TargetFuncName = nullptr),
+ Metadata *Annotations = nullptr, MDString *TargetFuncName = nullptr,
+ bool UsesKeyInstructions = false),
(Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
- Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
+ Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName,
+ UsesKeyInstructions))
TempDISubprogram clone() const { return cloneImpl(); }
@@ -2087,6 +2093,8 @@ class DISubprogram : public DILocalScope {
return NewSP;
}
+ bool getKeyInstructionsEnabled() const { return SubclassData1; }
+
public:
unsigned getLine() const { return Line; }
unsigned getVirtuality() const { return getSPFlags() & SPFlagVirtuality; }
diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp
index 926dc6211eb8d..6f19711669743 100644
--- a/llvm/lib/AsmParser/LLParser.cpp
+++ b/llvm/lib/AsmParser/LLParser.cpp
@@ -5821,7 +5821,8 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
OPTIONAL(retainedNodes, MDField, ); \
OPTIONAL(thrownTypes, MDField, ); \
OPTIONAL(annotations, MDField, ); \
- OPTIONAL(targetFuncName, MDStringField, );
+ OPTIONAL(targetFuncName, MDStringField, ); \
+ OPTIONAL(keyInstructions, MDBoolField, );
PARSE_MD_FIELDS();
#undef VISIT_MD_FIELDS
@@ -5841,7 +5842,7 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
thisAdjustment.Val, flags.Val, SPFlags, unit.Val, templateParams.Val,
declaration.Val, retainedNodes.Val, thrownTypes.Val, annotations.Val,
- targetFuncName.Val));
+ targetFuncName.Val, keyInstructions.Val));
return false;
}
diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
index 7828ba45ec27f..ff45afe399c82 100644
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -2459,6 +2459,7 @@ static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
Printer.printMetadata("annotations", N->getRawAnnotations());
Printer.printString("targetFuncName", N->getTargetFuncName());
+ Printer.printBool("keyInstructions", N->getKeyInstructionsEnabled(), false);
Out << ")";
}
diff --git a/llvm/lib/IR/DIBuilder.cpp b/llvm/lib/IR/DIBuilder.cpp
index fd8c2d7bb5cc3..367c52271c5a1 100644
--- a/llvm/lib/IR/DIBuilder.cpp
+++ b/llvm/lib/IR/DIBuilder.cpp
@@ -933,14 +933,14 @@ DISubprogram *DIBuilder::createFunction(
unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
DITemplateParameterArray TParams, DISubprogram *Decl,
- DITypeArray ThrownTypes, DINodeArray Annotations,
- StringRef TargetFuncName) {
+ DITypeArray ThrownTypes, DINodeArray Annotations, StringRef TargetFuncName,
+ bool UseKeyInstructions) {
bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
auto *Node = getSubprogram(
/*IsDistinct=*/IsDefinition, VMContext, getNonCompileUnitScope(Context),
Name, LinkageName, File, LineNo, Ty, ScopeLine, nullptr, 0, 0, Flags,
SPFlags, IsDefinition ? CUNode : nullptr, TParams, Decl, nullptr,
- ThrownTypes, Annotations, TargetFuncName);
+ ThrownTypes, Annotations, TargetFuncName, UseKeyInstructions);
AllSubprograms.push_back(Node);
trackIfUnresolved(Node);
@@ -967,7 +967,7 @@ DISubprogram *DIBuilder::createMethod(
unsigned LineNo, DISubroutineType *Ty, unsigned VIndex, int ThisAdjustment,
DIType *VTableHolder, DINode::DIFlags Flags,
DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams,
- DITypeArray ThrownTypes) {
+ DITypeArray ThrownTypes, bool UseKeyInstructions) {
assert(getNonCompileUnitScope(Context) &&
"Methods should have both a Context and a context that isn't "
"the compile unit.");
@@ -977,7 +977,7 @@ DISubprogram *DIBuilder::createMethod(
/*IsDistinct=*/IsDefinition, VMContext, cast<DIScope>(Context), Name,
LinkageName, F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
Flags, SPFlags, IsDefinition ? CUNode : nullptr, TParams, nullptr,
- nullptr, ThrownTypes);
+ nullptr, ThrownTypes, nullptr, "", IsDefinition && UseKeyInstructions);
AllSubprograms.push_back(SP);
trackIfUnresolved(SP);
diff --git a/llvm/lib/IR/DebugInfoMetadata.cpp b/llvm/lib/IR/DebugInfoMetadata.cpp
index 473114b99225b..ec62756bc0366 100644
--- a/llvm/lib/IR/DebugInfoMetadata.cpp
+++ b/llvm/lib/IR/DebugInfoMetadata.cpp
@@ -1293,11 +1293,12 @@ const char *DICompileUnit::nameTableKindString(DebugNameTableKind NTK) {
DISubprogram::DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
unsigned ScopeLine, unsigned VirtualIndex,
int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
- ArrayRef<Metadata *> Ops)
+ bool UsesKeyInstructions, ArrayRef<Metadata *> Ops)
: DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
+ SubclassData1 = UsesKeyInstructions;
}
DISubprogram::DISPFlags
DISubprogram::toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized,
@@ -1396,7 +1397,7 @@ DISubprogram *DISubprogram::getImpl(
int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
Metadata *ThrownTypes, Metadata *Annotations, MDString *TargetFuncName,
- StorageType Storage, bool ShouldCreate) {
+ bool UsesKeyInstructions, StorageType Storage, bool ShouldCreate) {
assert(isCanonical(Name) && "Expected canonical MDString");
assert(isCanonical(LinkageName) && "Expected canonical MDString");
assert(isCanonical(TargetFuncName) && "Expected canonical MDString");
@@ -1405,7 +1406,7 @@ DISubprogram *DISubprogram::getImpl(
ContainingType, VirtualIndex, ThisAdjustment, Flags,
SPFlags, Unit, TemplateParams, Declaration,
RetainedNodes, ThrownTypes, Annotations,
- TargetFuncName));
+ TargetFuncName, UsesKeyInstructions));
SmallVector<Metadata *, 13> Ops = {
File, Scope, Name, LinkageName,
Type, Unit, Declaration, RetainedNodes,
@@ -1425,10 +1426,10 @@ DISubprogram *DISubprogram::getImpl(
}
}
}
- DEFINE_GETIMPL_STORE_N(
- DISubprogram,
- (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
- Ops.size());
+ DEFINE_GETIMPL_STORE_N(DISubprogram,
+ (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags,
+ SPFlags, UsesKeyInstructions),
+ Ops, Ops.size());
}
bool DISubprogram::describes(const Function *F) const {
diff --git a/llvm/lib/IR/LLVMContextImpl.h b/llvm/lib/IR/LLVMContextImpl.h
index ef279721b9643..ac90363b9e4b1 100644
--- a/llvm/lib/IR/LLVMContextImpl.h
+++ b/llvm/lib/IR/LLVMContextImpl.h
@@ -922,8 +922,8 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
MDString *LinkageName;
Metadata *File;
unsigned Line;
- Metadata *Type;
unsigned ScopeLine;
+ Metadata *Type;
Metadata *ContainingType;
unsigned VirtualIndex;
int ThisAdjustment;
@@ -936,6 +936,7 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
Metadata *ThrownTypes;
Metadata *Annotations;
MDString *TargetFuncName;
+ bool UsesKeyInstructions;
MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
Metadata *File, unsigned Line, Metadata *Type,
@@ -944,18 +945,19 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams,
Metadata *Declaration, Metadata *RetainedNodes,
Metadata *ThrownTypes, Metadata *Annotations,
- MDString *TargetFuncName)
+ MDString *TargetFuncName, bool UsesKeyInstructions)
: Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
- Line(Line), Type(Type), ScopeLine(ScopeLine),
+ Line(Line), ScopeLine(ScopeLine), Type(Type),
ContainingType(ContainingType), VirtualIndex(VirtualIndex),
ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes),
- Annotations(Annotations), TargetFuncName(TargetFuncName) {}
+ Annotations(Annotations), TargetFuncName(TargetFuncName),
+ UsesKeyInstructions(UsesKeyInstructions) {}
MDNodeKeyImpl(const DISubprogram *N)
: Scope(N->getRawScope()), Name(N->getRawName()),
LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
- Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
+ Line(N->getLine()), ScopeLine(N->getScopeLine()), Type(N->getRawType()),
ContainingType(N->getRawContainingType()),
VirtualIndex(N->getVirtualIndex()),
ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
@@ -965,7 +967,8 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
RetainedNodes(N->getRawRetainedNodes()),
ThrownTypes(N->getRawThrownTypes()),
Annotations(N->getRawAnnotations()),
- TargetFuncName(N->getRawTargetFuncName()) {}
+ TargetFuncName(N->getRawTargetFuncName()),
+ UsesKeyInstructions(N->getKeyInstructionsEnabled()) {}
bool isKeyOf(const DISubprogram *RHS) const {
...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/144107
More information about the llvm-commits
mailing list