LLVM  13.0.0git
Namespaces | Macros | Functions | Variables
PassBuilder.cpp File Reference
#include "llvm/Passes/PassBuilder.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Analysis/AliasAnalysisEvaluator.h"
#include "llvm/Analysis/AliasSetTracker.h"
#include "llvm/Analysis/AssumptionCache.h"
#include "llvm/Analysis/BasicAliasAnalysis.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/Analysis/BranchProbabilityInfo.h"
#include "llvm/Analysis/CFGPrinter.h"
#include "llvm/Analysis/CFLAndersAliasAnalysis.h"
#include "llvm/Analysis/CFLSteensAliasAnalysis.h"
#include "llvm/Analysis/CGSCCPassManager.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Analysis/DDG.h"
#include "llvm/Analysis/DDGPrinter.h"
#include "llvm/Analysis/Delinearization.h"
#include "llvm/Analysis/DemandedBits.h"
#include "llvm/Analysis/DependenceAnalysis.h"
#include "llvm/Analysis/DivergenceAnalysis.h"
#include "llvm/Analysis/DominanceFrontier.h"
#include "llvm/Analysis/FunctionPropertiesAnalysis.h"
#include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/IRSimilarityIdentifier.h"
#include "llvm/Analysis/IVUsers.h"
#include "llvm/Analysis/InlineAdvisor.h"
#include "llvm/Analysis/InlineSizeEstimatorAnalysis.h"
#include "llvm/Analysis/InstCount.h"
#include "llvm/Analysis/LazyCallGraph.h"
#include "llvm/Analysis/LazyValueInfo.h"
#include "llvm/Analysis/Lint.h"
#include "llvm/Analysis/LoopAccessAnalysis.h"
#include "llvm/Analysis/LoopCacheAnalysis.h"
#include "llvm/Analysis/LoopInfo.h"
#include "llvm/Analysis/LoopNestAnalysis.h"
#include "llvm/Analysis/MemDerefPrinter.h"
#include "llvm/Analysis/MemoryDependenceAnalysis.h"
#include "llvm/Analysis/MemorySSA.h"
#include "llvm/Analysis/ModuleDebugInfoPrinter.h"
#include "llvm/Analysis/ModuleSummaryAnalysis.h"
#include "llvm/Analysis/MustExecute.h"
#include "llvm/Analysis/ObjCARCAliasAnalysis.h"
#include "llvm/Analysis/OptimizationRemarkEmitter.h"
#include "llvm/Analysis/PhiValues.h"
#include "llvm/Analysis/PostDominators.h"
#include "llvm/Analysis/ProfileSummaryInfo.h"
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/Analysis/ScalarEvolution.h"
#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
#include "llvm/Analysis/ScopedNoAliasAA.h"
#include "llvm/Analysis/StackLifetime.h"
#include "llvm/Analysis/StackSafetyAnalysis.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/PrintPasses.h"
#include "llvm/IR/SafepointIRVerifier.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/Regex.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
#include "llvm/Transforms/Coroutines/CoroCleanup.h"
#include "llvm/Transforms/Coroutines/CoroEarly.h"
#include "llvm/Transforms/Coroutines/CoroElide.h"
#include "llvm/Transforms/Coroutines/CoroSplit.h"
#include "llvm/Transforms/IPO/AlwaysInliner.h"
#include "llvm/Transforms/IPO/Annotation2Metadata.h"
#include "llvm/Transforms/IPO/ArgumentPromotion.h"
#include "llvm/Transforms/IPO/Attributor.h"
#include "llvm/Transforms/IPO/BlockExtractor.h"
#include "llvm/Transforms/IPO/CalledValuePropagation.h"
#include "llvm/Transforms/IPO/ConstantMerge.h"
#include "llvm/Transforms/IPO/CrossDSOCFI.h"
#include "llvm/Transforms/IPO/DeadArgumentElimination.h"
#include "llvm/Transforms/IPO/ElimAvailExtern.h"
#include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
#include "llvm/Transforms/IPO/FunctionAttrs.h"
#include "llvm/Transforms/IPO/FunctionImport.h"
#include "llvm/Transforms/IPO/GlobalDCE.h"
#include "llvm/Transforms/IPO/GlobalOpt.h"
#include "llvm/Transforms/IPO/GlobalSplit.h"
#include "llvm/Transforms/IPO/HotColdSplitting.h"
#include "llvm/Transforms/IPO/IROutliner.h"
#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
#include "llvm/Transforms/IPO/Inliner.h"
#include "llvm/Transforms/IPO/Internalize.h"
#include "llvm/Transforms/IPO/LoopExtractor.h"
#include "llvm/Transforms/IPO/LowerTypeTests.h"
#include "llvm/Transforms/IPO/MergeFunctions.h"
#include "llvm/Transforms/IPO/OpenMPOpt.h"
#include "llvm/Transforms/IPO/PartialInlining.h"
#include "llvm/Transforms/IPO/SCCP.h"
#include "llvm/Transforms/IPO/SampleProfile.h"
#include "llvm/Transforms/IPO/SampleProfileProbe.h"
#include "llvm/Transforms/IPO/StripDeadPrototypes.h"
#include "llvm/Transforms/IPO/StripSymbols.h"
#include "llvm/Transforms/IPO/SyntheticCountsPropagation.h"
#include "llvm/Transforms/IPO/WholeProgramDevirt.h"
#include "llvm/Transforms/InstCombine/InstCombine.h"
#include "llvm/Transforms/Instrumentation.h"
#include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
#include "llvm/Transforms/Instrumentation/BoundsChecking.h"
#include "llvm/Transforms/Instrumentation/CGProfile.h"
#include "llvm/Transforms/Instrumentation/ControlHeightReduction.h"
#include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
#include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
#include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
#include "llvm/Transforms/Instrumentation/InstrOrderFile.h"
#include "llvm/Transforms/Instrumentation/InstrProfiling.h"
#include "llvm/Transforms/Instrumentation/MemProfiler.h"
#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
#include "llvm/Transforms/Instrumentation/PoisonChecking.h"
#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
#include "llvm/Transforms/ObjCARC.h"
#include "llvm/Transforms/Scalar/ADCE.h"
#include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
#include "llvm/Transforms/Scalar/AnnotationRemarks.h"
#include "llvm/Transforms/Scalar/BDCE.h"
#include "llvm/Transforms/Scalar/CallSiteSplitting.h"
#include "llvm/Transforms/Scalar/ConstantHoisting.h"
#include "llvm/Transforms/Scalar/ConstraintElimination.h"
#include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
#include "llvm/Transforms/Scalar/DCE.h"
#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
#include "llvm/Transforms/Scalar/DivRemPairs.h"
#include "llvm/Transforms/Scalar/EarlyCSE.h"
#include "llvm/Transforms/Scalar/Float2Int.h"
#include "llvm/Transforms/Scalar/GVN.h"
#include "llvm/Transforms/Scalar/GuardWidening.h"
#include "llvm/Transforms/Scalar/IVUsersPrinter.h"
#include "llvm/Transforms/Scalar/IndVarSimplify.h"
#include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h"
#include "llvm/Transforms/Scalar/InferAddressSpaces.h"
#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
#include "llvm/Transforms/Scalar/JumpThreading.h"
#include "llvm/Transforms/Scalar/LICM.h"
#include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h"
#include "llvm/Transforms/Scalar/LoopDataPrefetch.h"
#include "llvm/Transforms/Scalar/LoopDeletion.h"
#include "llvm/Transforms/Scalar/LoopDistribute.h"
#include "llvm/Transforms/Scalar/LoopFlatten.h"
#include "llvm/Transforms/Scalar/LoopFuse.h"
#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
#include "llvm/Transforms/Scalar/LoopInstSimplify.h"
#include "llvm/Transforms/Scalar/LoopInterchange.h"
#include "llvm/Transforms/Scalar/LoopLoadElimination.h"
#include "llvm/Transforms/Scalar/LoopPassManager.h"
#include "llvm/Transforms/Scalar/LoopPredication.h"
#include "llvm/Transforms/Scalar/LoopReroll.h"
#include "llvm/Transforms/Scalar/LoopRotation.h"
#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
#include "llvm/Transforms/Scalar/LoopSink.h"
#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
#include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
#include "llvm/Transforms/Scalar/LoopUnrollPass.h"
#include "llvm/Transforms/Scalar/LoopVersioningLICM.h"
#include "llvm/Transforms/Scalar/LowerAtomic.h"
#include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
#include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
#include "llvm/Transforms/Scalar/LowerMatrixIntrinsics.h"
#include "llvm/Transforms/Scalar/LowerWidenableCondition.h"
#include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
#include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
#include "llvm/Transforms/Scalar/MergeICmps.h"
#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
#include "llvm/Transforms/Scalar/NaryReassociate.h"
#include "llvm/Transforms/Scalar/NewGVN.h"
#include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
#include "llvm/Transforms/Scalar/Reassociate.h"
#include "llvm/Transforms/Scalar/Reg2Mem.h"
#include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
#include "llvm/Transforms/Scalar/SCCP.h"
#include "llvm/Transforms/Scalar/SROA.h"
#include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h"
#include "llvm/Transforms/Scalar/Scalarizer.h"
#include "llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h"
#include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
#include "llvm/Transforms/Scalar/SimplifyCFG.h"
#include "llvm/Transforms/Scalar/Sink.h"
#include "llvm/Transforms/Scalar/SpeculateAroundPHIs.h"
#include "llvm/Transforms/Scalar/SpeculativeExecution.h"
#include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
#include "llvm/Transforms/Scalar/StructurizeCFG.h"
#include "llvm/Transforms/Scalar/TailRecursionElimination.h"
#include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
#include "llvm/Transforms/Utils/AddDiscriminators.h"
#include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
#include "llvm/Transforms/Utils/BreakCriticalEdges.h"
#include "llvm/Transforms/Utils/CanonicalizeAliases.h"
#include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h"
#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
#include "llvm/Transforms/Utils/FixIrreducible.h"
#include "llvm/Transforms/Utils/HelloWorld.h"
#include "llvm/Transforms/Utils/InjectTLIMappings.h"
#include "llvm/Transforms/Utils/InstructionNamer.h"
#include "llvm/Transforms/Utils/LCSSA.h"
#include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
#include "llvm/Transforms/Utils/LoopSimplify.h"
#include "llvm/Transforms/Utils/LoopVersioning.h"
#include "llvm/Transforms/Utils/LowerInvoke.h"
#include "llvm/Transforms/Utils/LowerSwitch.h"
#include "llvm/Transforms/Utils/Mem2Reg.h"
#include "llvm/Transforms/Utils/MetaRenamer.h"
#include "llvm/Transforms/Utils/NameAnonGlobals.h"
#include "llvm/Transforms/Utils/RelLookupTableConverter.h"
#include "llvm/Transforms/Utils/StripGCRelocates.h"
#include "llvm/Transforms/Utils/StripNonLineTableDebugInfo.h"
#include "llvm/Transforms/Utils/SymbolRewriter.h"
#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
#include "llvm/Transforms/Utils/UnifyLoopExits.h"
#include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h"
#include "llvm/Transforms/Vectorize/LoopVectorize.h"
#include "llvm/Transforms/Vectorize/SLPVectorizer.h"
#include "llvm/Transforms/Vectorize/VectorCombine.h"
#include "PassRegistry.def"

Go to the source code of this file.

Namespaces

 llvm
 

Macros

#define MODULE_PASS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define MODULE_ANALYSIS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define FUNCTION_PASS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define LOOP_PASS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define CGSCC_PASS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)   PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define MODULE_ANALYSIS(NAME, CREATE_PASS)   MAM.registerPass([&] { return CREATE_PASS; });
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)   CGAM.registerPass([&] { return CREATE_PASS; });
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)   FAM.registerPass([&] { return CREATE_PASS; });
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)   LAM.registerPass([&] { return CREATE_PASS; });
 
#define MODULE_PASS(NAME, CREATE_PASS)
 
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
 
#define CGSCC_PASS(NAME, CREATE_PASS)
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 
#define LOOP_PASS(NAME, CREATE_PASS)
 
#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
 
#define MODULE_PASS(NAME, CREATE_PASS)
 
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
 
#define CGSCC_PASS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define LOOP_PASS(NAME, CREATE_PASS)
 
#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define CGSCC_PASS(NAME, CREATE_PASS)
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define LOOP_PASS(NAME, CREATE_PASS)
 
#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define FUNCTION_PASS(NAME, CREATE_PASS)
 
#define FUNCTION_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 
#define LOOP_PASS(NAME, CREATE_PASS)
 
#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define LOOP_PASS(NAME, CREATE_PASS)
 
#define LOOP_PASS_WITH_PARAMS(NAME, CREATE_PASS, PARSER)
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
 
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
 
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
 
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
 
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
 
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
 
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
 
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
 
#define MODULE_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define MODULE_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define CGSCC_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define FUNCTION_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define LOOP_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define LOOP_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 

Functions

static void addAnnotationRemarksPass (ModulePassManager &MPM)
 
static bool isLTOPreLink (ThinOrFullLTOPhase Phase)
 
static InlineParams getInlineParamsFromOptLevel (PassBuilder::OptimizationLevel Level)
 
static Optional< intparseRepeatPassName (StringRef Name)
 
static Optional< intparseDevirtPassName (StringRef Name)
 
static bool checkParametrizedPassName (StringRef Name, StringRef PassName)
 
static bool startsWithDefaultPipelineAliasPrefix (StringRef Name)
 Tests whether a pass name starts with a valid prefix for a default pipeline alias. More...
 
template<typename PassManagerT , typename CallbacksT >
static bool callbacksAcceptPassName (StringRef Name, CallbacksT &Callbacks)
 Tests whether registered callbacks will accept a given pass name. More...
 
template<typename CallbacksT >
static bool isModulePassName (StringRef Name, CallbacksT &Callbacks)
 
template<typename CallbacksT >
static bool isCGSCCPassName (StringRef Name, CallbacksT &Callbacks)
 
template<typename CallbacksT >
static bool isFunctionPassName (StringRef Name, CallbacksT &Callbacks)
 
template<typename CallbacksT >
static bool isLoopPassName (StringRef Name, CallbacksT &Callbacks)
 
static void printPassName (StringRef PassName, raw_ostream &OS)
 

Variables

static cl::opt< InliningAdvisorModeUseInlineAdvisor ("enable-ml-inliner", cl::init(InliningAdvisorMode::Default), cl::Hidden, cl::desc("Enable ML policy for inliner. Currently trained for -Oz only"), cl::values(clEnumValN(InliningAdvisorMode::Default, "default", "Heuristics-based inliner version."), clEnumValN(InliningAdvisorMode::Development, "development", "Use development mode (runtime-loadable model)."), clEnumValN(InliningAdvisorMode::Release, "release", "Use release mode (AOT-compiled model).")))
 
static cl::opt< bool > EnableSyntheticCounts ("enable-npm-synthetic-counts", cl::init(false), cl::Hidden, cl::ZeroOrMore, cl::desc("Run synthetic function entry count generation " "pass"))
 
static const Regex DefaultAliasRegex ("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
 
static cl::opt< bool > EnablePGOInlineDeferral ("enable-npm-pgo-inline-deferral", cl::init(true), cl::Hidden, cl::desc("Enable inline deferral during PGO"))
 Flag to enable inline deferral during PGO. More...
 
static cl::opt< bool > EnableMemProfiler ("enable-mem-prof", cl::init(false), cl::Hidden, cl::ZeroOrMore, cl::desc("Enable memory profiler"))
 
static cl::opt< bool > PerformMandatoryInliningsFirst ("mandatory-inlining-first", cl::init(true), cl::Hidden, cl::ZeroOrMore, cl::desc("Perform mandatory inlinings module-wide, before performing " "inlining."))
 
static cl::opt< bool > EnableO3NonTrivialUnswitching ("enable-npm-O3-nontrivial-unswitch", cl::init(true), cl::Hidden, cl::ZeroOrMore, cl::desc("Enable non-trivial loop unswitching for -O3"))
 
static cl::opt< bool > DoNotRerunFunctionPasses ("cgscc-npm-no-fp-rerun", cl::init(false), cl::desc("Do not rerun function passes wrapped by the scc pass adapter, if " "they were run already and the function hasn't changed."))
 
cl::opt< bool > llvm::EnableConstraintElimination
 
cl::opt< bool > llvm::EnableGVNHoist
 
cl::opt< bool > llvm::EnableGVNSink
 
cl::opt< bool > llvm::EnableHotColdSplit
 
cl::opt< bool > llvm::EnableIROutliner
 
cl::opt< bool > llvm::EnableOrderFileInstrumentation
 
cl::opt< bool > llvm::EnableCHR
 
cl::opt< bool > llvm::EnableLoopInterchange
 
cl::opt< bool > llvm::EnableUnrollAndJam
 
cl::opt< bool > llvm::EnableLoopFlatten
 
cl::opt< bool > llvm::RunNewGVN
 
cl::opt< bool > llvm::RunPartialInlining
 
cl::opt< bool > llvm::ExtraVectorizerPasses
 
cl::opt< bool > llvm::FlattenedProfileUsed
 
cl::opt< AttributorRunOption > llvm::AttributorRun
 
cl::opt< bool > llvm::EnableKnowledgeRetention
 enable preservation of attributes in assume like: call void @llvm.assume(i1 true) [ "nonnull"(i32* PTR) ] More...
 
cl::opt< bool > llvm::EnableMatrix
 
cl::opt< bool > llvm::DisablePreInliner
 
cl::opt< intllvm::PreInlineThreshold
 

Detailed Description

This file provides the implementation of the PassBuilder based on our static pass registry as well as related functionality. It also provides helpers to aid in analyzing, debugging, and testing passes and pass pipelines.

Definition in file PassBuilder.cpp.

Macro Definition Documentation

◆ CGSCC_ANALYSIS [1/6]

#define CGSCC_ANALYSIS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ CGSCC_ANALYSIS [2/6]

#define CGSCC_ANALYSIS (   NAME,
  CREATE_PASS 
)    CGAM.registerPass([&] { return CREATE_PASS; });

◆ CGSCC_ANALYSIS [3/6]

#define CGSCC_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
return true;

◆ CGSCC_ANALYSIS [4/6]

#define CGSCC_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">") { \
CGPM.addPass(RequireAnalysisPass< \
std::remove_reference<decltype(CREATE_PASS)>::type, \
return Error::success(); \
} \
if (Name == "invalidate<" NAME ">") { \
CGPM.addPass(InvalidateAnalysisPass< \
std::remove_reference<decltype(CREATE_PASS)>::type>()); \
return Error::success(); \
}

◆ CGSCC_ANALYSIS [5/6]

#define CGSCC_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ CGSCC_ANALYSIS [6/6]

#define CGSCC_ANALYSIS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ CGSCC_PASS [1/5]

#define CGSCC_PASS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ CGSCC_PASS [2/5]

#define CGSCC_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) \
return true;

◆ CGSCC_PASS [3/5]

#define CGSCC_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
return Error::success(); \
}

◆ CGSCC_PASS [4/5]

#define CGSCC_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
CGPM.addPass(CREATE_PASS); \
return Error::success(); \
}

◆ CGSCC_PASS [5/5]

#define CGSCC_PASS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ FUNCTION_ALIAS_ANALYSIS [1/4]

#define FUNCTION_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
AA.registerFunctionAnalysis< \
std::remove_reference<decltype(CREATE_PASS)>::type>(); \
return true; \
}

◆ FUNCTION_ALIAS_ANALYSIS [2/4]

#define FUNCTION_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ FUNCTION_ALIAS_ANALYSIS [3/4]

#define FUNCTION_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ FUNCTION_ALIAS_ANALYSIS [4/4]

#define FUNCTION_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ FUNCTION_ANALYSIS [1/6]

#define FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ FUNCTION_ANALYSIS [2/6]

#define FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)    FAM.registerPass([&] { return CREATE_PASS; });

◆ FUNCTION_ANALYSIS [3/6]

#define FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
return true;

◆ FUNCTION_ANALYSIS [4/6]

#define FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">") { \
FPM.addPass( \
std::remove_reference<decltype(CREATE_PASS)>::type, Function>()); \
return Error::success(); \
} \
if (Name == "invalidate<" NAME ">") { \
FPM.addPass(InvalidateAnalysisPass< \
std::remove_reference<decltype(CREATE_PASS)>::type>()); \
return Error::success(); \
}

◆ FUNCTION_ANALYSIS [5/6]

#define FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ FUNCTION_ANALYSIS [6/6]

#define FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ FUNCTION_PASS [1/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ FUNCTION_PASS [2/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) \
return true;

◆ FUNCTION_PASS [3/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
return Error::success(); \
}

◆ FUNCTION_PASS [4/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
return Error::success(); \
}

◆ FUNCTION_PASS [5/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
FPM.addPass(CREATE_PASS); \
return Error::success(); \
}

◆ FUNCTION_PASS [6/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ FUNCTION_PASS_WITH_PARAMS [1/4]

#define FUNCTION_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
return true;

◆ FUNCTION_PASS_WITH_PARAMS [2/4]

#define FUNCTION_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
return Error::success(); \
}

◆ FUNCTION_PASS_WITH_PARAMS [3/4]

#define FUNCTION_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
return Error::success(); \
}

◆ FUNCTION_PASS_WITH_PARAMS [4/4]

#define FUNCTION_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
FPM.addPass(CREATE_PASS(Params.get())); \
return Error::success(); \
}

◆ LOOP_ANALYSIS [1/6]

#define LOOP_ANALYSIS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ LOOP_ANALYSIS [2/6]

#define LOOP_ANALYSIS (   NAME,
  CREATE_PASS 
)    LAM.registerPass([&] { return CREATE_PASS; });

◆ LOOP_ANALYSIS [3/6]

#define LOOP_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
return true;

◆ LOOP_ANALYSIS [4/6]

#define LOOP_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">") { \
LPM.addPass(RequireAnalysisPass< \
std::remove_reference<decltype(CREATE_PASS)>::type, Loop, \
LPMUpdater &>()); \
return Error::success(); \
} \
if (Name == "invalidate<" NAME ">") { \
LPM.addPass(InvalidateAnalysisPass< \
std::remove_reference<decltype(CREATE_PASS)>::type>()); \
return Error::success(); \
}

◆ LOOP_ANALYSIS [5/6]

#define LOOP_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ LOOP_ANALYSIS [6/6]

#define LOOP_ANALYSIS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ LOOP_PASS [1/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ LOOP_PASS [2/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) \
return true;

◆ LOOP_PASS [3/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
MPM.addPass( \
CREATE_PASS, false, false, DebugLogging))); \
return Error::success(); \
}

◆ LOOP_PASS [4/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
CGPM.addPass( \
CREATE_PASS, false, false, DebugLogging))); \
return Error::success(); \
}

◆ LOOP_PASS [5/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false, \
DebugLogging)); \
return Error::success(); \
}

◆ LOOP_PASS [6/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
LPM.addPass(CREATE_PASS); \
return Error::success(); \
}

◆ LOOP_PASS [7/7]

#define LOOP_PASS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ LOOP_PASS_WITH_PARAMS [1/5]

#define LOOP_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
return true;

◆ LOOP_PASS_WITH_PARAMS [2/5]

#define LOOP_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
MPM.addPass( \
CREATE_PASS(Params.get()), false, false, DebugLogging))); \
return Error::success(); \
}

◆ LOOP_PASS_WITH_PARAMS [3/5]

#define LOOP_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
CGPM.addPass( \
CREATE_PASS(Params.get()), false, false, DebugLogging))); \
return Error::success(); \
}

◆ LOOP_PASS_WITH_PARAMS [4/5]

#define LOOP_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
false, false, DebugLogging)); \
return Error::success(); \
}

◆ LOOP_PASS_WITH_PARAMS [5/5]

#define LOOP_PASS_WITH_PARAMS (   NAME,
  CREATE_PASS,
  PARSER 
)
Value:
auto Params = parsePassParameters(PARSER, Name, NAME); \
if (!Params) \
return Params.takeError(); \
LPM.addPass(CREATE_PASS(Params.get())); \
return Error::success(); \
}

◆ MODULE_ALIAS_ANALYSIS [1/4]

#define MODULE_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
AA.registerModuleAnalysis< \
std::remove_reference<decltype(CREATE_PASS)>::type>(); \
return true; \
}

◆ MODULE_ALIAS_ANALYSIS [2/4]

#define MODULE_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ MODULE_ALIAS_ANALYSIS [3/4]

#define MODULE_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ MODULE_ALIAS_ANALYSIS [4/4]

#define MODULE_ALIAS_ANALYSIS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ MODULE_ANALYSIS [1/6]

#define MODULE_ANALYSIS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ MODULE_ANALYSIS [2/6]

#define MODULE_ANALYSIS (   NAME,
  CREATE_PASS 
)    MAM.registerPass([&] { return CREATE_PASS; });

◆ MODULE_ANALYSIS [3/6]

#define MODULE_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
return true;

◆ MODULE_ANALYSIS [4/6]

#define MODULE_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">") { \
MPM.addPass( \
std::remove_reference<decltype(CREATE_PASS)>::type, Module>()); \
return Error::success(); \
} \
if (Name == "invalidate<" NAME ">") { \
MPM.addPass(InvalidateAnalysisPass< \
std::remove_reference<decltype(CREATE_PASS)>::type>()); \
return Error::success(); \
}

◆ MODULE_ANALYSIS [5/6]

#define MODULE_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (PassName == NAME) \
return true;

◆ MODULE_ANALYSIS [6/6]

#define MODULE_ANALYSIS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

◆ MODULE_PASS [1/4]

#define MODULE_PASS (   NAME,
  CREATE_PASS 
)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);

◆ MODULE_PASS [2/4]

#define MODULE_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) \
return true;

◆ MODULE_PASS [3/4]

#define MODULE_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
MPM.addPass(CREATE_PASS); \
return Error::success(); \
}

◆ MODULE_PASS [4/4]

#define MODULE_PASS (   NAME,
  CREATE_PASS 
)    printPassName(NAME, OS);

Function Documentation

◆ addAnnotationRemarksPass()

static void addAnnotationRemarksPass ( ModulePassManager MPM)
static

◆ callbacksAcceptPassName()

template<typename PassManagerT , typename CallbacksT >
static bool callbacksAcceptPassName ( StringRef  Name,
CallbacksT &  Callbacks 
)
static

Tests whether registered callbacks will accept a given pass name.

When parsing a pipeline text, the type of the outermost pipeline may be omitted, in which case the type is automatically determined from the first pass name in the text. This may be a name that is handled through one of the callbacks. We check this through the oridinary parsing callbacks by setting up a dummy PassManager in order to not force the client to also handle this type of query.

Definition at line 2335 of file PassBuilder.cpp.

◆ checkParametrizedPassName()

static bool checkParametrizedPassName ( StringRef  Name,
StringRef  PassName 
)
static

Definition at line 2055 of file PassBuilder.cpp.

References PassName.

◆ getInlineParamsFromOptLevel()

static InlineParams getInlineParamsFromOptLevel ( PassBuilder::OptimizationLevel  Level)
static

◆ isCGSCCPassName()

template<typename CallbacksT >
static bool isCGSCCPassName ( StringRef  Name,
CallbacksT &  Callbacks 
)
static

Definition at line 2375 of file PassBuilder.cpp.

References parseDevirtPassName(), and parseRepeatPassName().

Referenced by llvm::PassBuilder::parsePassPipeline().

◆ isFunctionPassName()

template<typename CallbacksT >
static bool isFunctionPassName ( StringRef  Name,
CallbacksT &  Callbacks 
)
static

Definition at line 2400 of file PassBuilder.cpp.

References parseRepeatPassName().

Referenced by llvm::PassBuilder::parsePassPipeline().

◆ isLoopPassName()

template<typename CallbacksT >
static bool isLoopPassName ( StringRef  Name,
CallbacksT &  Callbacks 
)
static

Definition at line 2426 of file PassBuilder.cpp.

References parseRepeatPassName().

Referenced by llvm::PassBuilder::parsePassPipeline().

◆ isLTOPreLink()

static bool isLTOPreLink ( ThinOrFullLTOPhase  Phase)
static

◆ isModulePassName()

template<typename CallbacksT >
static bool isModulePassName ( StringRef  Name,
CallbacksT &  Callbacks 
)
static

◆ parseDevirtPassName()

static Optional<int> parseDevirtPassName ( StringRef  Name)
static

Definition at line 2046 of file PassBuilder.cpp.

References llvm::None.

Referenced by isCGSCCPassName().

◆ parseRepeatPassName()

static Optional<int> parseRepeatPassName ( StringRef  Name)
static

Definition at line 2037 of file PassBuilder.cpp.

References llvm::None.

Referenced by isCGSCCPassName(), isFunctionPassName(), isLoopPassName(), and isModulePassName().

◆ printPassName()

static void printPassName ( StringRef  PassName,
raw_ostream OS 
)
static

Definition at line 3167 of file PassBuilder.cpp.

References PassName.

◆ startsWithDefaultPipelineAliasPrefix()

static bool startsWithDefaultPipelineAliasPrefix ( StringRef  Name)
static

Tests whether a pass name starts with a valid prefix for a default pipeline alias.

Definition at line 2321 of file PassBuilder.cpp.

Referenced by isModulePassName().

Variable Documentation

◆ DefaultAliasRegex

const Regex DefaultAliasRegex("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
static

Referenced by isModulePassName().

◆ DoNotRerunFunctionPasses

cl::opt<bool> DoNotRerunFunctionPasses("cgscc-npm-no-fp-rerun", cl::init(false), cl::desc("Do not rerun function passes wrapped by the scc pass adapter, if " "they were run already and the function hasn't changed."))
static

◆ EnableMemProfiler

cl::opt<bool> EnableMemProfiler("enable-mem-prof", cl::init(false), cl::Hidden, cl::ZeroOrMore, cl::desc("Enable memory profiler"))
static

◆ EnableO3NonTrivialUnswitching

cl::opt<bool> EnableO3NonTrivialUnswitching("enable-npm-O3-nontrivial-unswitch", cl::init(true), cl::Hidden, cl::ZeroOrMore, cl::desc("Enable non-trivial loop unswitching for -O3"))
static

◆ EnablePGOInlineDeferral

cl::opt<bool> EnablePGOInlineDeferral("enable-npm-pgo-inline-deferral", cl::init(true), cl::Hidden, cl::desc("Enable inline deferral during PGO"))
static

Flag to enable inline deferral during PGO.

Referenced by llvm::PassBuilder::buildInlinerPipeline().

◆ EnableSyntheticCounts

cl::opt<bool> EnableSyntheticCounts("enable-npm-synthetic-counts", cl::init(false), cl::Hidden, cl::ZeroOrMore, cl::desc("Run synthetic function entry count generation " "pass"))
static

◆ PerformMandatoryInliningsFirst

cl::opt<bool> PerformMandatoryInliningsFirst("mandatory-inlining-first", cl::init(true), cl::Hidden, cl::ZeroOrMore, cl::desc("Perform mandatory inlinings module-wide, before performing " "inlining."))
static

◆ UseInlineAdvisor

cl::opt<InliningAdvisorMode> UseInlineAdvisor("enable-ml-inliner", cl::init(InliningAdvisorMode::Default), cl::Hidden, cl::desc("Enable ML policy for inliner. Currently trained for -Oz only"), cl::values(clEnumValN(InliningAdvisorMode::Default, "default", "Heuristics-based inliner version."), clEnumValN(InliningAdvisorMode::Development, "development", "Use development mode (runtime-loadable model)."), clEnumValN(InliningAdvisorMode::Release, "release", "Use release mode (AOT-compiled model).")))
static
type
llvm::Function
Definition: Function.h:61
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:530
llvm::LoopStandardAnalysisResults
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
Definition: LoopAnalysisManager.h:52
llvm::createCGSCCToFunctionPassAdaptor
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: CGSCCPassManager.h:506
llvm::createModuleToPostOrderCGSCCPassAdaptor
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: CGSCCPassManager.h:376
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:421
llvm::createModuleToFunctionPassAdaptor
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: PassManager.h:1228
checkParametrizedPassName
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition: PassBuilder.cpp:2055
llvm::LPMUpdater
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
Definition: LoopPassManager.h:243
llvm::InvalidateAnalysisPass
A no-op pass template which simply forces a specific analysis result to be invalidated.
Definition: PassManager.h:1271
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::CGSCCUpdateResult
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Definition: CGSCCPassManager.h:232
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::createFunctionToLoopPassAdaptor
std::enable_if_t< is_detected< HasRunOnLoopT, LoopPassT >::value, FunctionToLoopPassAdaptor > createFunctionToLoopPassAdaptor(LoopPassT Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool DebugLogging=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
Definition: LoopPassManager.h:449
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::RequireAnalysisPass
A utility pass template to force an analysis result to be available.
Definition: PassManager.h:1249
llvm::LazyCallGraph
A lazily constructed view of the call graph of a module.
Definition: LazyCallGraph.h:112
PassName
static const char PassName[]
Definition: X86LowerAMXIntrinsics.cpp:666