llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-analysis Author: S. VenkataKeerthy (svkeerthy) <details> <summary>Changes</summary> Changes to use Symbolic embeddings in MLInliner. (Fixes #<!-- -->141836, Tracking issue - #<!-- -->141817) --- Patch is 36.65 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/143479.diff 10 Files Affected: - (modified) llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h (+21-5) - (modified) llvm/include/llvm/Analysis/IR2Vec.h (+1-1) - (modified) llvm/include/llvm/Analysis/InlineAdvisor.h (+3) - (modified) llvm/include/llvm/Analysis/InlineModelFeatureMaps.h (+5-1) - (modified) llvm/include/llvm/Analysis/MLInlineAdvisor.h (+1) - (modified) llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp (+112-3) - (modified) llvm/lib/Analysis/IR2Vec.cpp (+2-2) - (modified) llvm/lib/Analysis/InlineAdvisor.cpp (+29) - (modified) llvm/lib/Analysis/MLInlineAdvisor.cpp (+33-1) - (modified) llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp (+154-25) ``````````diff diff --git a/llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h b/llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h index babb6d9d6cf0c..06dbfc35a5294 100644 --- a/llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h +++ b/llvm/include/llvm/Analysis/FunctionPropertiesAnalysis.h @@ -15,6 +15,7 @@ #define LLVM_ANALYSIS_FUNCTIONPROPERTIESANALYSIS_H #include "llvm/ADT/DenseSet.h" +#include "llvm/Analysis/IR2Vec.h" #include "llvm/IR/Dominators.h" #include "llvm/IR/PassManager.h" #include "llvm/Support/Compiler.h" @@ -32,17 +33,19 @@ class FunctionPropertiesInfo { void updateAggregateStats(const Function &F, const LoopInfo &LI); void reIncludeBB(const BasicBlock &BB); + ir2vec::Embedding FunctionEmbedding = ir2vec::Embedding(0.0); + std::optional<ir2vec::Vocab> IR2VecVocab; + public: LLVM_ABI static FunctionPropertiesInfo getFunctionPropertiesInfo(const Function &F, const DominatorTree &DT, - const LoopInfo &LI); + const LoopInfo &LI, + const IR2VecVocabResult *VocabResult); LLVM_ABI static FunctionPropertiesInfo getFunctionPropertiesInfo(Function &F, FunctionAnalysisManager &FAM); - bool operator==(const FunctionPropertiesInfo &FPI) const { - return std::memcmp(this, &FPI, sizeof(FunctionPropertiesInfo)) == 0; - } + bool operator==(const FunctionPropertiesInfo &FPI) const; bool operator!=(const FunctionPropertiesInfo &FPI) const { return !(*this == FPI); @@ -137,6 +140,19 @@ class FunctionPropertiesInfo { int64_t CallReturnsVectorPointerCount = 0; int64_t CallWithManyArgumentsCount = 0; int64_t CallWithPointerArgumentCount = 0; + + const ir2vec::Embedding &getFunctionEmbedding() const { + return FunctionEmbedding; + } + + const std::optional<ir2vec::Vocab> &getIR2VecVocab() const { + return IR2VecVocab; + } + + // Helper intended to be useful for unittests + void setFunctionEmbeddingForTest(const ir2vec::Embedding &Embedding) { + FunctionEmbedding = Embedding; + } }; // Analysis pass @@ -192,7 +208,7 @@ class FunctionPropertiesUpdater { DominatorTree &getUpdatedDominatorTree(FunctionAnalysisManager &FAM) const; - DenseSet<const BasicBlock *> Successors; + DenseSet<const BasicBlock *> Successors, CallUsers; // Edges we might potentially need to remove from the dominator tree. SmallVector<DominatorTree::UpdateType, 2> DomTreeUpdates; diff --git a/llvm/include/llvm/Analysis/IR2Vec.h b/llvm/include/llvm/Analysis/IR2Vec.h index 7976cc7470d5b..3f44c650e640d 100644 --- a/llvm/include/llvm/Analysis/IR2Vec.h +++ b/llvm/include/llvm/Analysis/IR2Vec.h @@ -239,7 +239,7 @@ class IR2VecVocabAnalysis : public AnalysisInfoMixin<IR2VecVocabAnalysis> { public: static AnalysisKey Key; IR2VecVocabAnalysis() = default; - explicit IR2VecVocabAnalysis(ir2vec::Vocab &&Vocab); + explicit IR2VecVocabAnalysis(ir2vec::Vocab Vocab); using Result = IR2VecVocabResult; Result run(Module &M, ModuleAnalysisManager &MAM); }; diff --git a/llvm/include/llvm/Analysis/InlineAdvisor.h b/llvm/include/llvm/Analysis/InlineAdvisor.h index 9d15136e81d10..d2cad4717cbdb 100644 --- a/llvm/include/llvm/Analysis/InlineAdvisor.h +++ b/llvm/include/llvm/Analysis/InlineAdvisor.h @@ -331,6 +331,9 @@ class InlineAdvisorAnalysis : public AnalysisInfoMixin<InlineAdvisorAnalysis> { }; Result run(Module &M, ModuleAnalysisManager &MAM) { return Result(M, MAM); } + +private: + static bool initializeIR2VecVocab(Module &M, ModuleAnalysisManager &MAM); }; /// Printer pass for the InlineAdvisorAnalysis results. diff --git a/llvm/include/llvm/Analysis/InlineModelFeatureMaps.h b/llvm/include/llvm/Analysis/InlineModelFeatureMaps.h index 961d5091bf9f3..91d3378565fc5 100644 --- a/llvm/include/llvm/Analysis/InlineModelFeatureMaps.h +++ b/llvm/include/llvm/Analysis/InlineModelFeatureMaps.h @@ -142,6 +142,10 @@ enum class FeatureIndex : size_t { INLINE_FEATURE_ITERATOR(POPULATE_INDICES) #undef POPULATE_INDICES +// IR2Vec embeddings + callee_embedding, + caller_embedding, + NumberOfFeatures }; // clang-format on @@ -154,7 +158,7 @@ inlineCostFeatureToMlFeature(InlineCostFeatureIndex Feature) { constexpr size_t NumberOfFeatures = static_cast<size_t>(FeatureIndex::NumberOfFeatures); -LLVM_ABI extern const std::vector<TensorSpec> FeatureMap; +LLVM_ABI extern std::vector<TensorSpec> FeatureMap; LLVM_ABI extern const char *const DecisionName; LLVM_ABI extern const TensorSpec InlineDecisionSpec; diff --git a/llvm/include/llvm/Analysis/MLInlineAdvisor.h b/llvm/include/llvm/Analysis/MLInlineAdvisor.h index 580dd5e95d760..935e4c56dfce6 100644 --- a/llvm/include/llvm/Analysis/MLInlineAdvisor.h +++ b/llvm/include/llvm/Analysis/MLInlineAdvisor.h @@ -82,6 +82,7 @@ class MLInlineAdvisor : public InlineAdvisor { int64_t NodeCount = 0; int64_t EdgeCount = 0; int64_t EdgesOfLastSeenNodes = 0; + bool UseIR2Vec = false; std::map<const LazyCallGraph::Node *, unsigned> FunctionLevels; const int32_t InitialIRSize = 0; diff --git a/llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp b/llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp index 9d044c8a35910..29d3aaf46dc06 100644 --- a/llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp +++ b/llvm/lib/Analysis/FunctionPropertiesAnalysis.cpp @@ -199,6 +199,29 @@ void FunctionPropertiesInfo::updateForBB(const BasicBlock &BB, #undef CHECK_OPERAND } } + + if (IR2VecVocab) { + // We instantiate the IR2Vec embedder each time, as having an unique + // pointer to the embedder as member of the class would make it + // non-copyable. Instantiating the embedder in itself is not costly. + auto EmbOrErr = ir2vec::Embedder::create(IR2VecKind::Symbolic, + *BB.getParent(), *IR2VecVocab); + if (Error Err = EmbOrErr.takeError()) { + handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { + BB.getContext().emitError("Error creating IR2Vec embeddings: " + + EI.message()); + }); + return; + } + auto Embedder = std::move(*EmbOrErr); + const auto &BBEmbedding = Embedder->getBBVector(BB); + // Subtract BBEmbedding from Function embedding if the direction is -1, + // and add it if the direction is +1. + if (Direction == -1) + FunctionEmbedding -= BBEmbedding; + else + FunctionEmbedding += BBEmbedding; + } } void FunctionPropertiesInfo::updateAggregateStats(const Function &F, @@ -220,14 +243,24 @@ void FunctionPropertiesInfo::updateAggregateStats(const Function &F, FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo( Function &F, FunctionAnalysisManager &FAM) { + // We use the cached result of the IR2VecVocabAnalysis run by + // InlineAdvisorAnalysis. If the IR2VecVocabAnalysis is not run, we don't + // use IR2Vec embeddings. + auto VocabResult = FAM.getResult<ModuleAnalysisManagerFunctionProxy>(F) + .getCachedResult<IR2VecVocabAnalysis>(*F.getParent()); return getFunctionPropertiesInfo(F, FAM.getResult<DominatorTreeAnalysis>(F), - FAM.getResult<LoopAnalysis>(F)); + FAM.getResult<LoopAnalysis>(F), VocabResult); } FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo( - const Function &F, const DominatorTree &DT, const LoopInfo &LI) { + const Function &F, const DominatorTree &DT, const LoopInfo &LI, + const IR2VecVocabResult *VocabResult) { FunctionPropertiesInfo FPI; + if (VocabResult && VocabResult->isValid()) { + FPI.IR2VecVocab = VocabResult->getVocabulary(); + FPI.FunctionEmbedding = ir2vec::Embedding(VocabResult->getDimension(), 0.0); + } for (const auto &BB : F) if (DT.isReachableFromEntry(&BB)) FPI.reIncludeBB(BB); @@ -235,6 +268,66 @@ FunctionPropertiesInfo FunctionPropertiesInfo::getFunctionPropertiesInfo( return FPI; } +bool FunctionPropertiesInfo::operator==( + const FunctionPropertiesInfo &FPI) const { + if (BasicBlockCount != FPI.BasicBlockCount || + BlocksReachedFromConditionalInstruction != + FPI.BlocksReachedFromConditionalInstruction || + Uses != FPI.Uses || + DirectCallsToDefinedFunctions != FPI.DirectCallsToDefinedFunctions || + LoadInstCount != FPI.LoadInstCount || + StoreInstCount != FPI.StoreInstCount || + MaxLoopDepth != FPI.MaxLoopDepth || + TopLevelLoopCount != FPI.TopLevelLoopCount || + TotalInstructionCount != FPI.TotalInstructionCount || + BasicBlocksWithSingleSuccessor != FPI.BasicBlocksWithSingleSuccessor || + BasicBlocksWithTwoSuccessors != FPI.BasicBlocksWithTwoSuccessors || + BasicBlocksWithMoreThanTwoSuccessors != + FPI.BasicBlocksWithMoreThanTwoSuccessors || + BasicBlocksWithSinglePredecessor != + FPI.BasicBlocksWithSinglePredecessor || + BasicBlocksWithTwoPredecessors != FPI.BasicBlocksWithTwoPredecessors || + BasicBlocksWithMoreThanTwoPredecessors != + FPI.BasicBlocksWithMoreThanTwoPredecessors || + BigBasicBlocks != FPI.BigBasicBlocks || + MediumBasicBlocks != FPI.MediumBasicBlocks || + SmallBasicBlocks != FPI.SmallBasicBlocks || + CastInstructionCount != FPI.CastInstructionCount || + FloatingPointInstructionCount != FPI.FloatingPointInstructionCount || + IntegerInstructionCount != FPI.IntegerInstructionCount || + ConstantIntOperandCount != FPI.ConstantIntOperandCount || + ConstantFPOperandCount != FPI.ConstantFPOperandCount || + ConstantOperandCount != FPI.ConstantOperandCount || + InstructionOperandCount != FPI.InstructionOperandCount || + BasicBlockOperandCount != FPI.BasicBlockOperandCount || + GlobalValueOperandCount != FPI.GlobalValueOperandCount || + InlineAsmOperandCount != FPI.InlineAsmOperandCount || + ArgumentOperandCount != FPI.ArgumentOperandCount || + UnknownOperandCount != FPI.UnknownOperandCount || + CriticalEdgeCount != FPI.CriticalEdgeCount || + ControlFlowEdgeCount != FPI.ControlFlowEdgeCount || + UnconditionalBranchCount != FPI.UnconditionalBranchCount || + IntrinsicCount != FPI.IntrinsicCount || + DirectCallCount != FPI.DirectCallCount || + IndirectCallCount != FPI.IndirectCallCount || + CallReturnsIntegerCount != FPI.CallReturnsIntegerCount || + CallReturnsFloatCount != FPI.CallReturnsFloatCount || + CallReturnsPointerCount != FPI.CallReturnsPointerCount || + CallReturnsVectorIntCount != FPI.CallReturnsVectorIntCount || + CallReturnsVectorFloatCount != FPI.CallReturnsVectorFloatCount || + CallReturnsVectorPointerCount != FPI.CallReturnsVectorPointerCount || + CallWithManyArgumentsCount != FPI.CallWithManyArgumentsCount || + CallWithPointerArgumentCount != FPI.CallWithPointerArgumentCount) { + return false; + } + // Check the equality of the function embeddings. We don't check the equality + // of Vocabulary as it remains the same. + if (!FunctionEmbedding.approximatelyEquals(FPI.FunctionEmbedding)) + return false; + + return true; +} + void FunctionPropertiesInfo::print(raw_ostream &OS) const { #define PRINT_PROPERTY(PROP_NAME) OS << #PROP_NAME ": " << PROP_NAME << "\n"; @@ -322,6 +415,16 @@ FunctionPropertiesUpdater::FunctionPropertiesUpdater( // The caller's entry BB may change due to new alloca instructions. LikelyToChangeBBs.insert(&*Caller.begin()); + // The users of the value returned by call instruction can change + // leading to the change in embeddings being computed, when used. + // We conservatively add the BBs with such uses to LikelyToChangeBBs. + for (const auto *User : CB.users()) + CallUsers.insert(dyn_cast<Instruction>(User)->getParent()); + // CallSiteBB can be removed from CallUsers if present, it's taken care + // separately. + CallUsers.erase(&CallSiteBB); + LikelyToChangeBBs.insert_range(CallUsers); + // The successors may become unreachable in the case of `invoke` inlining. // We track successors separately, too, because they form a boundary, together // with the CB BB ('Entry') between which the inlined callee will be pasted. @@ -435,6 +538,9 @@ void FunctionPropertiesUpdater::finish(FunctionAnalysisManager &FAM) const { if (&CallSiteBB != &*Caller.begin()) Reinclude.insert(&*Caller.begin()); + // Reinclude the BBs which use the values returned by call instruction + Reinclude.insert_range(CallUsers); + // Distribute the successors to the 2 buckets. for (const auto *Succ : Successors) if (DT.isReachableFromEntry(Succ)) @@ -486,6 +592,9 @@ bool FunctionPropertiesUpdater::isUpdateValid(Function &F, return false; DominatorTree DT(F); LoopInfo LI(DT); - auto Fresh = FunctionPropertiesInfo::getFunctionPropertiesInfo(F, DT, LI); + auto VocabResult = FAM.getResult<ModuleAnalysisManagerFunctionProxy>(F) + .getCachedResult<IR2VecVocabAnalysis>(*F.getParent()); + auto Fresh = + FunctionPropertiesInfo::getFunctionPropertiesInfo(F, DT, LI, VocabResult); return FPI == Fresh; } diff --git a/llvm/lib/Analysis/IR2Vec.cpp b/llvm/lib/Analysis/IR2Vec.cpp index 8a392e0709c7f..5f2245ad6aafb 100644 --- a/llvm/lib/Analysis/IR2Vec.cpp +++ b/llvm/lib/Analysis/IR2Vec.cpp @@ -294,8 +294,8 @@ Error IR2VecVocabAnalysis::readVocabulary() { return Error::success(); } -IR2VecVocabAnalysis::IR2VecVocabAnalysis(Vocab &&Vocabulary) - : Vocabulary(std::move(Vocabulary)) {} +IR2VecVocabAnalysis::IR2VecVocabAnalysis(Vocab Vocabulary) + : Vocabulary(Vocabulary) {} void IR2VecVocabAnalysis::emitError(Error Err, LLVMContext &Ctx) { handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { diff --git a/llvm/lib/Analysis/InlineAdvisor.cpp b/llvm/lib/Analysis/InlineAdvisor.cpp index 3d30f3d10a9d0..2e869dfd91713 100644 --- a/llvm/lib/Analysis/InlineAdvisor.cpp +++ b/llvm/lib/Analysis/InlineAdvisor.cpp @@ -16,6 +16,7 @@ #include "llvm/ADT/StringExtras.h" #include "llvm/Analysis/AssumptionCache.h" #include "llvm/Analysis/EphemeralValuesCache.h" +#include "llvm/Analysis/IR2Vec.h" #include "llvm/Analysis/InlineCost.h" #include "llvm/Analysis/OptimizationRemarkEmitter.h" #include "llvm/Analysis/ProfileSummaryInfo.h" @@ -64,6 +65,13 @@ static cl::opt<bool> cl::desc("If true, annotate inline advisor remarks " "with LTO and pass information.")); +// This flag is used to enable IR2Vec embeddings in the ML inliner; Only valid +// with ML inliner. The vocab file is used to initialize the embeddings. +static cl::opt<std::string> IR2VecVocabFile( + "ml-inliner-ir2vec-vocab-file", cl::Hidden, + cl::desc("Vocab file for IR2Vec; Setting this enables " + "configuring the model to use IR2Vec embeddings.")); + namespace llvm { extern cl::opt<InlinerFunctionImportStatsOpts> InlinerFunctionImportStats; } // namespace llvm @@ -206,6 +214,20 @@ void InlineAdvice::recordInliningWithCalleeDeleted() { AnalysisKey InlineAdvisorAnalysis::Key; AnalysisKey PluginInlineAdvisorAnalysis::Key; +bool InlineAdvisorAnalysis::initializeIR2VecVocab(Module &M, + ModuleAnalysisManager &MAM) { + if (!IR2VecVocabFile.empty()) { + auto IR2VecVocabResult = MAM.getResult<IR2VecVocabAnalysis>(M); + if (!IR2VecVocabResult.isValid()) { + M.getContext().emitError("Failed to load IR2Vec vocabulary"); + return false; + } + } + // No vocab file specified is OK; We just don't use IR2Vec + // embeddings. + return true; +} + bool InlineAdvisorAnalysis::Result::tryCreate( InlineParams Params, InliningAdvisorMode Mode, const ReplayInlinerSettings &ReplaySettings, InlineContext IC) { @@ -231,14 +253,21 @@ bool InlineAdvisorAnalysis::Result::tryCreate( /* EmitRemarks =*/true, IC); } break; + // Run IR2VecVocabAnalysis once per module to get the vocabulary. + // We run it here because it is immutable and we want to avoid running it + // multiple times. case InliningAdvisorMode::Development: #ifdef LLVM_HAVE_TFLITE LLVM_DEBUG(dbgs() << "Using development-mode inliner policy.\n"); + if (!InlineAdvisorAnalysis::initializeIR2VecVocab(M, MAM)) + return false; Advisor = llvm::getDevelopmentModeAdvisor(M, MAM, GetDefaultAdvice); #endif break; case InliningAdvisorMode::Release: LLVM_DEBUG(dbgs() << "Using release-mode inliner policy.\n"); + if (!InlineAdvisorAnalysis::initializeIR2VecVocab(M, MAM)) + return false; Advisor = llvm::getReleaseModeAdvisor(M, MAM, GetDefaultAdvice); break; } diff --git a/llvm/lib/Analysis/MLInlineAdvisor.cpp b/llvm/lib/Analysis/MLInlineAdvisor.cpp index 81a3bc94a6ad8..3a9a68670e852 100644 --- a/llvm/lib/Analysis/MLInlineAdvisor.cpp +++ b/llvm/lib/Analysis/MLInlineAdvisor.cpp @@ -107,7 +107,7 @@ static cl::opt<bool> KeepFPICache( cl::init(false)); // clang-format off -const std::vector<TensorSpec> llvm::FeatureMap{ +std::vector<TensorSpec> llvm::FeatureMap{ #define POPULATE_NAMES(DTYPE, SHAPE, NAME, __) TensorSpec::createSpec<DTYPE>(#NAME, SHAPE), // InlineCost features - these must come first INLINE_COST_FEATURE_ITERATOR(POPULATE_NAMES) @@ -186,6 +186,20 @@ MLInlineAdvisor::MLInlineAdvisor( EdgeCount += getLocalCalls(KVP.first->getFunction()); } NodeCount = AllNodes.size(); + + if (auto IR2VecVocabResult = MAM.getCachedResult<IR2VecVocabAnalysis>(M)) { + if (!IR2VecVocabResult->isValid()) { + M.getContext().emitError("IR2VecVocabAnalysis is not valid"); + return; + } + // Add the IR2Vec features to the feature map + auto IR2VecDim = IR2VecVocabResult->getDimension(); + FeatureMap.push_back( + TensorSpec::createSpec<float>("callee_embedding", {IR2VecDim})); + FeatureMap.push_back( + TensorSpec::createSpec<float>("caller_embedding", {IR2VecDim})); + UseIR2Vec = true; + } } unsigned MLInlineAdvisor::getInitialFunctionLevel(const Function &F) const { @@ -433,6 +447,24 @@ std::unique_ptr<InlineAdvice> MLInlineAdvisor::getAdviceImpl(CallBase &CB) { *ModelRunner->getTensor<int64_t>(FeatureIndex::is_caller_avail_external) = Caller.hasAvailableExternallyLinkage(); + if (UseIR2Vec) { + // Python side expects float embeddings. The IR2Vec embeddings are doubles + // as of now due to the restriction of fromJSON method used by the + // readVocabulary method in ir2vec::Embeddings. + auto setEmbedding = [&](const ir2vec::Embedding &Embedding, + FeatureIndex Index) { + auto Embedding_float = + std::vector<float>(Embedding.begin(), Embedding.end()); + std::memcpy(ModelRunner->getTensor<float>(Index), Embedding_float.data(), + Embedding.size() * sizeof(float)); + }; + + setEmbedding(CalleeBefore.getFunctionEmbedding(), + FeatureIndex::callee_embedding); + setEmbedding(CallerBefore.getFunctionEmbedding(), + FeatureIndex::caller_embedding); + } + // Add the cost features for (size_t I = 0; I < static_cast<size_t>(InlineCostFeatureIndex::NumberOfFeatures); ++I) { diff --git a/llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp b/llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp index 0720d935b0362..3ef2964f2d170 100644 --- a/llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp +++ b/llvm/unittests/Analysis/FunctionPropertiesAnalysisTest.cpp @@ -8,6 +8,7 @@ #include "llvm/Analysis/FunctionPropertiesAnalysis.h" #include "llvm/Analysis/AliasAnalysis.h" +#include "llvm/Analysis/IR2Vec.h" #include "llvm/Analysis/LoopInfo.h" #include "llvm/AsmParser/Parser.h" #include "llvm/IR/Dominators.h" @@ -20,15 +21,20 @@ #include "llvm/Support/Compiler.h" #include "llvm/Support/SourceMgr.h" #include "llvm/Transforms/Utils/Cloning.h" +#include "gmock/gmock.h" #include "gtest/gtest.h" #include <cstring> using namespace llvm; +using namespace testing; namespace llvm { LLVM_ABI extern cl::opt<bool> EnableDetailedFunctionProperties; LLVM_ABI extern cl::opt<bool> BigBasicBlockInstructionThreshold; LLVM_ABI extern cl::opt<bool> MediumBasicBlockInstrutionThreshold; +LLVM_ABI extern cl::opt<float> ir2vec::OpcWeight; +LLVM_ABI extern cl::opt<float> ir2vec::TypeWeight; +LLVM_ABI... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/143479 _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
