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 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
