[KeyInstr] Add DISubprogram::keyInstructions bit #144107
Open
+189
−105
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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). <link> uses it at DWARF emission. <link> 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::Context. I discarded that approach as there were no substantial compile time or max-rss savings and it added some weird complexities: * The DISubprogram had to be updated frequently, which would mean no uniqing, i.e., only edit-able for distinct DISubprograms (though that does have precedent with scopeLine). * 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.
llvmbot
added
clang
|
@llvm/pr-subscribers-llvm-ir @llvm/pr-subscribers-debuginfo Author: Orlando Cazalet-Hyams (OCHyams) ChangesPatch 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. 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:
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:
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]
|
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
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: