Skip to content

Commit 140e189

Browse files
OCHyamsOCHyams
authored
[KeyInstr] Add DISubprogram::keyInstructions bit (#144107)
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). PR 144104 and 144103 use it during DWARF emission. PR 44102 adds bitcode support. See pull request for overview of alternative attempts.
1 parent 629126e commit 140e189

34 files changed

+190
-105
lines changed

‎clang/lib/CodeGen/CGDebugInfo.cpp

Lines changed: 14 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1904,7 +1904,9 @@ CGDebugInfo::createInlinedSubprogram(StringRef FuncName,
19041904
/*ScopeLine=*/0,
19051905
/*Flags=*/llvm::DINode::FlagArtificial,
19061906
/*SPFlags=*/llvm::DISubprogram::SPFlagDefinition,
1907-
/*TParams=*/nullptr, /*ThrownTypes=*/nullptr, /*Annotations=*/nullptr);
1907+
/*TParams=*/nullptr, /*Decl=*/nullptr, /*ThrownTypes=*/nullptr,
1908+
/*Annotations=*/nullptr, /*TargetFuncName=*/StringRef(),
1909+
/*UseKeyInstructions=*/CGM.getCodeGenOpts().DebugKeyInstructions);
19081910
}
19091911

19101912
return SP;
@@ -2284,7 +2286,8 @@ llvm::DISubprogram *CGDebugInfo::CreateCXXMemberFunction(
22842286
llvm::DISubprogram *SP = DBuilder.createMethod(
22852287
RecordTy, MethodName, MethodLinkageName, MethodDefUnit, MethodLine,
22862288
MethodTy, VIndex, ThisAdjustment, ContainingType, Flags, SPFlags,
2287-
TParamsArray.get());
2289+
TParamsArray.get(), /*ThrownTypes*/ nullptr,
2290+
CGM.getCodeGenOpts().DebugKeyInstructions);
22882291

22892292
SPCache[Method->getCanonicalDecl()].reset(SP);
22902293

@@ -4350,7 +4353,9 @@ llvm::DISubprogram *CGDebugInfo::getFunctionFwdDeclOrStub(GlobalDecl GD,
43504353
return DBuilder.createFunction(
43514354
DContext, Name, LinkageName, Unit, Line,
43524355
getOrCreateFunctionType(GD.getDecl(), FnType, Unit), 0, Flags, SPFlags,
4353-
TParamsArray.get(), getFunctionDeclaration(FD));
4356+
TParamsArray.get(), getFunctionDeclaration(FD), /*ThrownTypes*/ nullptr,
4357+
/*Annotations*/ nullptr, /*TargetFuncName*/ "",
4358+
CGM.getCodeGenOpts().DebugKeyInstructions);
43544359
}
43554360

43564361
llvm::DISubprogram *SP = DBuilder.createTempFunctionFwdDecl(
@@ -4686,8 +4691,9 @@ void CGDebugInfo::emitFunctionStart(GlobalDecl GD, SourceLocation Loc,
46864691
llvm::DISubprogram *SP = DBuilder.createFunction(
46874692
FDContext, Name, LinkageName, Unit, LineNo, DIFnType, ScopeLine,
46884693
FlagsForDef, SPFlagsForDef, TParamsArray.get(), Decl, nullptr,
4689-
Annotations);
4694+
Annotations, "", CGM.getCodeGenOpts().DebugKeyInstructions);
46904695
Fn->setSubprogram(SP);
4696+
46914697
// We might get here with a VarDecl in the case we're generating
46924698
// code for the initialization of globals. Do not record these decls
46934699
// as they will overwrite the actual VarDecl Decl in the cache.
@@ -4746,9 +4752,12 @@ void CGDebugInfo::EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc,
47464752

47474753
llvm::DINodeArray Annotations = CollectBTFDeclTagAnnotations(D);
47484754
llvm::DISubroutineType *STy = getOrCreateFunctionType(D, FnType, Unit);
4755+
// Key Instructions: Don't set flag on declarations.
4756+
assert(~SPFlags & llvm::DISubprogram::SPFlagDefinition);
47494757
llvm::DISubprogram *SP = DBuilder.createFunction(
47504758
FDContext, Name, LinkageName, Unit, LineNo, STy, ScopeLine, Flags,
4751-
SPFlags, TParamsArray.get(), nullptr, nullptr, Annotations);
4759+
SPFlags, TParamsArray.get(), nullptr, nullptr, Annotations,
4760+
/*TargetFunctionName*/ "", /*UseKeyInstructions*/ false);
47524761

47534762
// Preserve btf_decl_tag attributes for parameters of extern functions
47544763
// for BPF target. The parameters created in this loop are attached as

‎llvm/include/llvm/IR/DIBuilder.h

Lines changed: 13 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -950,14 +950,17 @@ namespace llvm {
950950
/// \param Annotations Attribute Annotations.
951951
/// \param TargetFuncName The name of the target function if this is
952952
/// a trampoline.
953+
/// \param UseKeyInstructions Instruct DWARF emission to interpret Key
954+
/// Instructions metadata on instructions to determine is_stmt placement.
953955
LLVM_ABI DISubprogram *createFunction(
954956
DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
955957
unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
956958
DINode::DIFlags Flags = DINode::FlagZero,
957959
DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
958960
DITemplateParameterArray TParams = nullptr,
959961
DISubprogram *Decl = nullptr, DITypeArray ThrownTypes = nullptr,
960-
DINodeArray Annotations = nullptr, StringRef TargetFuncName = "");
962+
DINodeArray Annotations = nullptr, StringRef TargetFuncName = "",
963+
bool UseKeyInstructions = false);
961964

962965
/// Identical to createFunction,
963966
/// except that the resulting DbgNode is meant to be RAUWed.
@@ -988,15 +991,15 @@ namespace llvm {
988991
/// \param SPFlags Additional flags specific to subprograms.
989992
/// \param TParams Function template parameters.
990993
/// \param ThrownTypes Exception types this function may throw.
991-
LLVM_ABI DISubprogram *
992-
createMethod(DIScope *Scope, StringRef Name, StringRef LinkageName,
993-
DIFile *File, unsigned LineNo, DISubroutineType *Ty,
994-
unsigned VTableIndex = 0, int ThisAdjustment = 0,
995-
DIType *VTableHolder = nullptr,
996-
DINode::DIFlags Flags = DINode::FlagZero,
997-
DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
998-
DITemplateParameterArray TParams = nullptr,
999-
DITypeArray ThrownTypes = nullptr);
994+
/// \param UseKeyInstructions Enable Key Instructions debug info.
995+
LLVM_ABI DISubprogram *createMethod(
996+
DIScope *Scope, StringRef Name, StringRef LinkageName, DIFile *File,
997+
unsigned LineNo, DISubroutineType *Ty, unsigned VTableIndex = 0,
998+
int ThisAdjustment = 0, DIType *VTableHolder = nullptr,
999+
DINode::DIFlags Flags = DINode::FlagZero,
1000+
DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero,
1001+
DITemplateParameterArray TParams = nullptr,
1002+
DITypeArray ThrownTypes = nullptr, bool UseKeyInstructions = false);
10001003

10011004
/// Create common block entry for a Fortran common block.
10021005
/// \param Scope Scope of this common block.

‎llvm/include/llvm/IR/DebugInfoMetadata.h

Lines changed: 19 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -2217,7 +2217,7 @@ class DILocalScope : public DIScope {
22172217
}
22182218
};
22192219

2220-
/// Subprogram description.
2220+
/// Subprogram description. Uses SubclassData1.
22212221
class DISubprogram : public DILocalScope {
22222222
friend class LLVMContextImpl;
22232223
friend class MDNode;
@@ -2264,7 +2264,8 @@ class DISubprogram : public DILocalScope {
22642264

22652265
DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
22662266
unsigned ScopeLine, unsigned VirtualIndex, int ThisAdjustment,
2267-
DIFlags Flags, DISPFlags SPFlags, ArrayRef<Metadata *> Ops);
2267+
DIFlags Flags, DISPFlags SPFlags, bool UsesKeyInstructions,
2268+
ArrayRef<Metadata *> Ops);
22682269
~DISubprogram() = default;
22692270

22702271
static DISubprogram *
@@ -2276,24 +2277,26 @@ class DISubprogram : public DILocalScope {
22762277
DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
22772278
DINodeArray RetainedNodes, DITypeArray ThrownTypes,
22782279
DINodeArray Annotations, StringRef TargetFuncName,
2279-
StorageType Storage, bool ShouldCreate = true) {
2280+
bool UsesKeyInstructions, StorageType Storage,
2281+
bool ShouldCreate = true) {
22802282
return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
22812283
getCanonicalMDString(Context, LinkageName), File, Line, Type,
22822284
ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
22832285
Flags, SPFlags, Unit, TemplateParams.get(), Declaration,
22842286
RetainedNodes.get(), ThrownTypes.get(), Annotations.get(),
22852287
getCanonicalMDString(Context, TargetFuncName),
2286-
Storage, ShouldCreate);
2288+
UsesKeyInstructions, Storage, ShouldCreate);
22872289
}
2290+
22882291
LLVM_ABI static DISubprogram *
22892292
getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
22902293
MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
22912294
unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
22922295
int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
22932296
Metadata *TemplateParams, Metadata *Declaration,
22942297
Metadata *RetainedNodes, Metadata *ThrownTypes, Metadata *Annotations,
2295-
MDString *TargetFuncName, StorageType Storage,
2296-
bool ShouldCreate = true);
2298+
MDString *TargetFuncName, bool UsesKeyInstructions,
2299+
StorageType Storage, bool ShouldCreate = true);
22972300

22982301
TempDISubprogram cloneImpl() const {
22992302
return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
@@ -2302,7 +2305,7 @@ class DISubprogram : public DILocalScope {
23022305
getThisAdjustment(), getFlags(), getSPFlags(),
23032306
getUnit(), getTemplateParams(), getDeclaration(),
23042307
getRetainedNodes(), getThrownTypes(), getAnnotations(),
2305-
getTargetFuncName());
2308+
getTargetFuncName(), getKeyInstructionsEnabled());
23062309
}
23072310

23082311
public:
@@ -2315,10 +2318,11 @@ class DISubprogram : public DILocalScope {
23152318
DITemplateParameterArray TemplateParams = nullptr,
23162319
DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr,
23172320
DITypeArray ThrownTypes = nullptr, DINodeArray Annotations = nullptr,
2318-
StringRef TargetFuncName = ""),
2321+
StringRef TargetFuncName = "", bool UsesKeyInstructions = false),
23192322
(Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
23202323
VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
2321-
Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
2324+
Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName,
2325+
UsesKeyInstructions))
23222326

23232327
DEFINE_MDNODE_GET(
23242328
DISubprogram,
@@ -2328,10 +2332,12 @@ class DISubprogram : public DILocalScope {
23282332
DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
23292333
Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr,
23302334
Metadata *RetainedNodes = nullptr, Metadata *ThrownTypes = nullptr,
2331-
Metadata *Annotations = nullptr, MDString *TargetFuncName = nullptr),
2335+
Metadata *Annotations = nullptr, MDString *TargetFuncName = nullptr,
2336+
bool UsesKeyInstructions = false),
23322337
(Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
23332338
VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
2334-
Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
2339+
Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName,
2340+
UsesKeyInstructions))
23352341

23362342
TempDISubprogram clone() const { return cloneImpl(); }
23372343

@@ -2342,6 +2348,8 @@ class DISubprogram : public DILocalScope {
23422348
return NewSP;
23432349
}
23442350

2351+
bool getKeyInstructionsEnabled() const { return SubclassData1; }
2352+
23452353
public:
23462354
unsigned getLine() const { return Line; }
23472355
unsigned getVirtuality() const { return getSPFlags() & SPFlagVirtuality; }

‎llvm/lib/AsmParser/LLParser.cpp

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -5876,7 +5876,8 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
58765876
OPTIONAL(retainedNodes, MDField, ); \
58775877
OPTIONAL(thrownTypes, MDField, ); \
58785878
OPTIONAL(annotations, MDField, ); \
5879-
OPTIONAL(targetFuncName, MDStringField, );
5879+
OPTIONAL(targetFuncName, MDStringField, ); \
5880+
OPTIONAL(keyInstructions, MDBoolField, );
58805881
PARSE_MD_FIELDS();
58815882
#undef VISIT_MD_FIELDS
58825883

@@ -5896,7 +5897,7 @@ bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
58965897
type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
58975898
thisAdjustment.Val, flags.Val, SPFlags, unit.Val, templateParams.Val,
58985899
declaration.Val, retainedNodes.Val, thrownTypes.Val, annotations.Val,
5899-
targetFuncName.Val));
5900+
targetFuncName.Val, keyInstructions.Val));
59005901
return false;
59015902
}
59025903

‎llvm/lib/IR/AsmWriter.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2459,6 +2459,7 @@ static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
24592459
Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
24602460
Printer.printMetadata("annotations", N->getRawAnnotations());
24612461
Printer.printString("targetFuncName", N->getTargetFuncName());
2462+
Printer.printBool("keyInstructions", N->getKeyInstructionsEnabled(), false);
24622463
Out << ")";
24632464
}
24642465

‎llvm/lib/IR/DIBuilder.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -975,14 +975,14 @@ DISubprogram *DIBuilder::createFunction(
975975
unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
976976
DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
977977
DITemplateParameterArray TParams, DISubprogram *Decl,
978-
DITypeArray ThrownTypes, DINodeArray Annotations,
979-
StringRef TargetFuncName) {
978+
DITypeArray ThrownTypes, DINodeArray Annotations, StringRef TargetFuncName,
979+
bool UseKeyInstructions) {
980980
bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
981981
auto *Node = getSubprogram(
982982
/*IsDistinct=*/IsDefinition, VMContext, getNonCompileUnitScope(Context),
983983
Name, LinkageName, File, LineNo, Ty, ScopeLine, nullptr, 0, 0, Flags,
984984
SPFlags, IsDefinition ? CUNode : nullptr, TParams, Decl, nullptr,
985-
ThrownTypes, Annotations, TargetFuncName);
985+
ThrownTypes, Annotations, TargetFuncName, UseKeyInstructions);
986986

987987
AllSubprograms.push_back(Node);
988988
trackIfUnresolved(Node);
@@ -1009,7 +1009,7 @@ DISubprogram *DIBuilder::createMethod(
10091009
unsigned LineNo, DISubroutineType *Ty, unsigned VIndex, int ThisAdjustment,
10101010
DIType *VTableHolder, DINode::DIFlags Flags,
10111011
DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams,
1012-
DITypeArray ThrownTypes) {
1012+
DITypeArray ThrownTypes, bool UseKeyInstructions) {
10131013
assert(getNonCompileUnitScope(Context) &&
10141014
"Methods should have both a Context and a context that isn't "
10151015
"the compile unit.");
@@ -1019,7 +1019,7 @@ DISubprogram *DIBuilder::createMethod(
10191019
/*IsDistinct=*/IsDefinition, VMContext, cast<DIScope>(Context), Name,
10201020
LinkageName, F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
10211021
Flags, SPFlags, IsDefinition ? CUNode : nullptr, TParams, nullptr,
1022-
nullptr, ThrownTypes);
1022+
nullptr, ThrownTypes, nullptr, "", IsDefinition && UseKeyInstructions);
10231023

10241024
AllSubprograms.push_back(SP);
10251025
trackIfUnresolved(SP);

‎llvm/lib/IR/DebugInfoMetadata.cpp

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1292,11 +1292,12 @@ const char *DICompileUnit::nameTableKindString(DebugNameTableKind NTK) {
12921292
DISubprogram::DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
12931293
unsigned ScopeLine, unsigned VirtualIndex,
12941294
int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags,
1295-
ArrayRef<Metadata *> Ops)
1295+
bool UsesKeyInstructions, ArrayRef<Metadata *> Ops)
12961296
: DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram, Ops),
12971297
Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
12981298
ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags) {
12991299
static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
1300+
SubclassData1 = UsesKeyInstructions;
13001301
}
13011302
DISubprogram::DISPFlags
13021303
DISubprogram::toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized,
@@ -1395,7 +1396,7 @@ DISubprogram *DISubprogram::getImpl(
13951396
int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
13961397
Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
13971398
Metadata *ThrownTypes, Metadata *Annotations, MDString *TargetFuncName,
1398-
StorageType Storage, bool ShouldCreate) {
1399+
bool UsesKeyInstructions, StorageType Storage, bool ShouldCreate) {
13991400
assert(isCanonical(Name) && "Expected canonical MDString");
14001401
assert(isCanonical(LinkageName) && "Expected canonical MDString");
14011402
assert(isCanonical(TargetFuncName) && "Expected canonical MDString");
@@ -1404,7 +1405,7 @@ DISubprogram *DISubprogram::getImpl(
14041405
ContainingType, VirtualIndex, ThisAdjustment, Flags,
14051406
SPFlags, Unit, TemplateParams, Declaration,
14061407
RetainedNodes, ThrownTypes, Annotations,
1407-
TargetFuncName));
1408+
TargetFuncName, UsesKeyInstructions));
14081409
SmallVector<Metadata *, 13> Ops = {
14091410
File, Scope, Name, LinkageName,
14101411
Type, Unit, Declaration, RetainedNodes,
@@ -1424,10 +1425,10 @@ DISubprogram *DISubprogram::getImpl(
14241425
}
14251426
}
14261427
}
1427-
DEFINE_GETIMPL_STORE_N(
1428-
DISubprogram,
1429-
(Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
1430-
Ops.size());
1428+
DEFINE_GETIMPL_STORE_N(DISubprogram,
1429+
(Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags,
1430+
SPFlags, UsesKeyInstructions),
1431+
Ops, Ops.size());
14311432
}
14321433

14331434
bool DISubprogram::describes(const Function *F) const {

‎llvm/lib/IR/LLVMContextImpl.h

Lines changed: 11 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -924,8 +924,8 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
924924
MDString *LinkageName;
925925
Metadata *File;
926926
unsigned Line;
927-
Metadata *Type;
928927
unsigned ScopeLine;
928+
Metadata *Type;
929929
Metadata *ContainingType;
930930
unsigned VirtualIndex;
931931
int ThisAdjustment;
@@ -938,6 +938,7 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
938938
Metadata *ThrownTypes;
939939
Metadata *Annotations;
940940
MDString *TargetFuncName;
941+
bool UsesKeyInstructions;
941942

942943
MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
943944
Metadata *File, unsigned Line, Metadata *Type,
@@ -946,18 +947,19 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
946947
unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams,
947948
Metadata *Declaration, Metadata *RetainedNodes,
948949
Metadata *ThrownTypes, Metadata *Annotations,
949-
MDString *TargetFuncName)
950+
MDString *TargetFuncName, bool UsesKeyInstructions)
950951
: Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
951-
Line(Line), Type(Type), ScopeLine(ScopeLine),
952+
Line(Line), ScopeLine(ScopeLine), Type(Type),
952953
ContainingType(ContainingType), VirtualIndex(VirtualIndex),
953954
ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
954955
Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
955956
RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes),
956-
Annotations(Annotations), TargetFuncName(TargetFuncName) {}
957+
Annotations(Annotations), TargetFuncName(TargetFuncName),
958+
UsesKeyInstructions(UsesKeyInstructions) {}
957959
MDNodeKeyImpl(const DISubprogram *N)
958960
: Scope(N->getRawScope()), Name(N->getRawName()),
959961
LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
960-
Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
962+
Line(N->getLine()), ScopeLine(N->getScopeLine()), Type(N->getRawType()),
961963
ContainingType(N->getRawContainingType()),
962964
VirtualIndex(N->getVirtualIndex()),
963965
ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
@@ -967,7 +969,8 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
967969
RetainedNodes(N->getRawRetainedNodes()),
968970
ThrownTypes(N->getRawThrownTypes()),
969971
Annotations(N->getRawAnnotations()),
970-
TargetFuncName(N->getRawTargetFuncName()) {}
972+
TargetFuncName(N->getRawTargetFuncName()),
973+
UsesKeyInstructions(N->getKeyInstructionsEnabled()) {}
971974

972975
bool isKeyOf(const DISubprogram *RHS) const {
973976
return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
@@ -984,7 +987,8 @@ template <> struct MDNodeKeyImpl<DISubprogram> {
984987
RetainedNodes == RHS->getRawRetainedNodes() &&
985988
ThrownTypes == RHS->getRawThrownTypes() &&
986989
Annotations == RHS->getRawAnnotations() &&
987-
TargetFuncName == RHS->getRawTargetFuncName();
990+
TargetFuncName == RHS->getRawTargetFuncName() &&
991+
UsesKeyInstructions == RHS->getKeyInstructionsEnabled();
988992
}
989993

990994
bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; }

‎llvm/lib/IR/Verifier.cpp

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3178,6 +3178,12 @@ void Verifier::visitFunction(const Function &F) {
31783178
CheckDI(SP->describes(&F),
31793179
"!dbg attachment points at wrong subprogram for function", N, &F,
31803180
&I, DL, Scope, SP);
3181+
3182+
if (DL->getAtomGroup())
3183+
CheckDI(DL->getScope()->getSubprogram()->getKeyInstructionsEnabled(),
3184+
"DbgLoc uses atomGroup but DISubprogram doesn't have Key "
3185+
"Instructions enabled",
3186+
DL, DL->getScope()->getSubprogram());
31813187
};
31823188
for (auto &BB : F)
31833189
for (auto &I : BB) {

0 commit comments

Comments
 (0)