PassBuilder.cpp File Reference

This file provides the implementation of the PassBuilder based on our static pass registry as well as related functionality. More...

#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/CFGSCCPrinter.h"
#include "llvm/Analysis/CGSCCPassManager.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Analysis/CallPrinter.h"
#include "llvm/Analysis/CostModel.h"
#include "llvm/Analysis/CycleAnalysis.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/DomPrinter.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/Analysis/UniformityAnalysis.h"
#include "llvm/CodeGen/HardwareLoops.h"
#include "llvm/CodeGen/TypePromotion.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/PrintPasses.h"
#include "llvm/IR/SafepointIRVerifier.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IRPrinter/IRPrintingPasses.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/CoroConditionalWrapper.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/MemProfContextDisambiguation.h"
#include "llvm/Transforms/IPO/MergeFunctions.h"
#include "llvm/Transforms/IPO/ModuleInliner.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/KCFI.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/SanitizerBinaryMetadata.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/DFAJumpThreading.h"
#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
#include "llvm/Transforms/Scalar/DivRemPairs.h"
#include "llvm/Transforms/Scalar/EarlyCSE.h"
#include "llvm/Transforms/Scalar/FlattenCFG.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/LoopBoundSplit.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/LowerAtomicPass.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/PlaceSafepoints.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/SpeculativeExecution.h"
#include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
#include "llvm/Transforms/Scalar/StructurizeCFG.h"
#include "llvm/Transforms/Scalar/TLSVariableHoist.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/CountVisits.h"
#include "llvm/Transforms/Utils/Debugify.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/LowerGlobalDtors.h"
#include "llvm/Transforms/Utils/LowerIFunc.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/MoveAutoInit.h"
#include "llvm/Transforms/Utils/NameAnonGlobals.h"
#include "llvm/Transforms/Utils/PredicateInfo.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 <optional>
#include "PassRegistry.def"

Go to the source code of this file.

Namespaces
namespace	llvm
	This is an optimization pass for GlobalISel generic memory operations.

Macros
#define	MODULE_PASS(NAME, CREATE_PASS)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
#define	MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    PIC->addClassToPassName(CLASS, 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_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    PIC->addClassToPassName(CLASS, NAME);
#define	FUNCTION_ANALYSIS(NAME, CREATE_PASS)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
#define	LOOPNEST_PASS(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_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    PIC->addClassToPassName(CLASS, 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_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    PIC->addClassToPassName(CLASS, 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_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	MODULE_ANALYSIS(NAME, CREATE_PASS)
#define	CGSCC_PASS(NAME, CREATE_PASS)
#define	CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define	FUNCTION_PASS(NAME, CREATE_PASS)
#define	FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define	LOOPNEST_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	LOOP_ANALYSIS(NAME, CREATE_PASS)
#define	MODULE_PASS(NAME, CREATE_PASS)
#define	MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	MODULE_ANALYSIS(NAME, CREATE_PASS)
#define	CGSCC_PASS(NAME, CREATE_PASS)
#define	CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	FUNCTION_PASS(NAME, CREATE_PASS)
#define	FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	LOOPNEST_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	CGSCC_PASS(NAME, CREATE_PASS)
#define	CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define	FUNCTION_PASS(NAME, CREATE_PASS)
#define	FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	LOOPNEST_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	FUNCTION_PASS(NAME, CREATE_PASS)
#define	FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define	LOOPNEST_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	LOOPNEST_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS(NAME, CREATE_PASS)
#define	LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define	LOOP_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_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    printPassName(NAME, PARAMS, 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_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    printPassName(NAME, PARAMS, OS);
#define	CGSCC_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
#define	FUNCTION_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
#define	FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    printPassName(NAME, PARAMS, OS);
#define	FUNCTION_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
#define	FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
#define	LOOPNEST_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
#define	LOOP_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
#define	LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    printPassName(NAME, PARAMS, OS);
#define	LOOP_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);

Functions
static std::optional< int >	parseRepeatPassName (StringRef Name)
static std::optional< std::pair< bool, bool > >	parseFunctionPipelineName (StringRef Name)
static std::optional< int >	parseDevirtPassName (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.
template<typename PassManagerT , typename CallbacksT >
static bool	callbacksAcceptPassName (StringRef Name, CallbacksT &Callbacks)
	Tests whether registered callbacks will accept a given pass name.
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	isLoopNestPassName (StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
template<typename CallbacksT >
static bool	isLoopPassName (StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
static void	printPassName (StringRef PassName, raw_ostream &OS)
static void	printPassName (StringRef PassName, StringRef Params, raw_ostream &OS)

Variables
static const Regex	DefaultAliasRegex ("^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$")
cl::opt< bool >	llvm::PrintPipelinePasses ("print-pipeline-passes", cl::desc("Print a '-passes' compatible string describing the pipeline " "(best-effort only)."))

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/5]

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

CGSCC_ANALYSIS [2/5]

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

CGSCC_ANALYSIS [3/5]

#define CGSCC_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
    return true;

CGSCC_ANALYSIS [4/5]

#define CGSCC_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">") {                                           \
    CGPM.addPass(RequireAnalysisPass<                                          \
                 std::remove_reference_t<decltype(CREATE_PASS)>,               \
                 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &,    \
                 CGSCCUpdateResult &>());                                      \
    return Error::success();                                                   \
  }                                                                            \
  if (Name == "invalidate<" NAME ">") {                                        \
    CGPM.addPass(InvalidateAnalysisPass<                                       \
                 std::remove_reference_t<decltype(CREATE_PASS)>>());           \
    return Error::success();                                                   \
  }

CGSCC_ANALYSIS [5/5]

#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);

CGSCC_PASS_WITH_PARAMS [1/5]

#define CGSCC_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		PIC->addClassToPassName(CLASS, NAME);

CGSCC_PASS_WITH_PARAMS [2/5]

#define CGSCC_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME))                                   \
    return true;

CGSCC_PASS_WITH_PARAMS [3/5]

#define CGSCC_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    auto Params = parsePassParameters(PARSER, Name, NAME);                     \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    MPM.addPass(                                                               \
        createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get())));   \
    return Error::success();                                                   \
  }

CGSCC_PASS_WITH_PARAMS [4/5]

#define CGSCC_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    auto Params = parsePassParameters(PARSER, Name, NAME);                     \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    CGPM.addPass(CREATE_PASS(Params.get()));                                   \
    return Error::success();                                                   \
  }

CGSCC_PASS_WITH_PARAMS [5/5]

#define CGSCC_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		printPassName(NAME, PARAMS, OS);

FUNCTION_ALIAS_ANALYSIS [1/2]

#define FUNCTION_ALIAS_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    AA.registerFunctionAnalysis<                                               \
        std::remove_reference_t<decltype(CREATE_PASS)>>();                     \
    return true;                                                               \
  }

FUNCTION_ALIAS_ANALYSIS [2/2]

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

FUNCTION_ANALYSIS [1/5]

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

FUNCTION_ANALYSIS [2/5]

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

FUNCTION_ANALYSIS [3/5]

#define FUNCTION_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
    return true;

FUNCTION_ANALYSIS [4/5]

#define FUNCTION_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">") {                                           \
    FPM.addPass(                                                               \
        RequireAnalysisPass<                                                   \
            std::remove_reference_t<decltype(CREATE_PASS)>, Function>());      \
    return Error::success();                                                   \
  }                                                                            \
  if (Name == "invalidate<" NAME ">") {                                        \
    FPM.addPass(InvalidateAnalysisPass<                                        \
                std::remove_reference_t<decltype(CREATE_PASS)>>());            \
    return Error::success();                                                   \
  }

FUNCTION_ANALYSIS [5/5]

#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/6]

#define FUNCTION_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		PIC->addClassToPassName(CLASS, NAME);

FUNCTION_PASS_WITH_PARAMS [2/6]

#define FUNCTION_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME))                                   \
    return true;

FUNCTION_PASS_WITH_PARAMS [3/6]

#define FUNCTION_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    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 [4/6]

#define FUNCTION_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    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 [5/6]

#define FUNCTION_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

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

FUNCTION_PASS_WITH_PARAMS [6/6]

#define FUNCTION_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		printPassName(NAME, PARAMS, OS);

LOOP_ANALYSIS [1/5]

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

LOOP_ANALYSIS [2/5]

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

LOOP_ANALYSIS [3/5]

#define LOOP_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
    return true;

LOOP_ANALYSIS [4/5]

#define LOOP_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">") {                                           \
    LPM.addPass(RequireAnalysisPass<                                           \
                std::remove_reference_t<decltype(CREATE_PASS)>, Loop,          \
                LoopAnalysisManager, LoopStandardAnalysisResults &,            \
                LPMUpdater &>());                                              \
    return Error::success();                                                   \
  }                                                                            \
  if (Name == "invalidate<" NAME ">") {                                        \
    LPM.addPass(InvalidateAnalysisPass<                                        \
                std::remove_reference_t<decltype(CREATE_PASS)>>());            \
    return Error::success();                                                   \
  }

LOOP_ANALYSIS [5/5]

#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(createModuleToFunctionPassAdaptor(                             \
        createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)));          \
    return Error::success();                                                   \
  }

LOOP_PASS [4/7]

#define LOOP_PASS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    CGPM.addPass(createCGSCCToFunctionPassAdaptor(                             \
        createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)));          \
    return Error::success();                                                   \
  }

LOOP_PASS [5/7]

#define LOOP_PASS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false));   \
    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/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		PIC->addClassToPassName(CLASS, NAME);

LOOP_PASS_WITH_PARAMS [2/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME))                                   \
    return true;

LOOP_PASS_WITH_PARAMS [3/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    auto Params = parsePassParameters(PARSER, Name, NAME);                     \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    MPM.addPass(                                                               \
        createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor(     \
            CREATE_PASS(Params.get()), false, false)));                        \
    return Error::success();                                                   \
  }

LOOP_PASS_WITH_PARAMS [4/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    auto Params = parsePassParameters(PARSER, Name, NAME);                     \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    CGPM.addPass(                                                              \
        createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor(      \
            CREATE_PASS(Params.get()), false, false)));                        \
    return Error::success();                                                   \
  }

LOOP_PASS_WITH_PARAMS [5/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    auto Params = parsePassParameters(PARSER, Name, NAME);                     \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()),     \
                                                false, false));                \
    return Error::success();                                                   \
  }

LOOP_PASS_WITH_PARAMS [6/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

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

LOOP_PASS_WITH_PARAMS [7/7]

#define LOOP_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		printPassName(NAME, PARAMS, OS);

LOOPNEST_PASS [1/7]

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

LOOPNEST_PASS [2/7]

#define LOOPNEST_PASS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME)                                                            \
    return true;

LOOPNEST_PASS [3/7]

#define LOOPNEST_PASS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    MPM.addPass(createModuleToFunctionPassAdaptor(                             \
        createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)));          \
    return Error::success();                                                   \
  }

LOOPNEST_PASS [4/7]

#define LOOPNEST_PASS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    CGPM.addPass(createCGSCCToFunctionPassAdaptor(                             \
        createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)));          \
    return Error::success();                                                   \
  }

LOOPNEST_PASS [5/7]

#define LOOPNEST_PASS	(		NAME,
			CREATE_PASS
	)

Value:

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

LOOPNEST_PASS [6/7]

#define LOOPNEST_PASS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    LPM.addPass(CREATE_PASS);                                                  \
    return Error::success();                                                   \
  }

LOOPNEST_PASS [7/7]

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

MODULE_ALIAS_ANALYSIS [1/2]

#define MODULE_ALIAS_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == NAME) {                                                          \
    AA.registerModuleAnalysis<                                                 \
        std::remove_reference_t<decltype(CREATE_PASS)>>();                     \
    return true;                                                               \
  }

MODULE_ALIAS_ANALYSIS [2/2]

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

MODULE_ANALYSIS [1/5]

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

MODULE_ANALYSIS [2/5]

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

MODULE_ANALYSIS [3/5]

#define MODULE_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">")           \
    return true;

MODULE_ANALYSIS [4/5]

#define MODULE_ANALYSIS	(		NAME,
			CREATE_PASS
	)

Value:

  if (Name == "require<" NAME ">") {                                           \
    MPM.addPass(                                                               \
        RequireAnalysisPass<                                                   \
            std::remove_reference_t<decltype(CREATE_PASS)>, Module>());        \
    return Error::success();                                                   \
  }                                                                            \
  if (Name == "invalidate<" NAME ">") {                                        \
    MPM.addPass(InvalidateAnalysisPass<                                        \
                std::remove_reference_t<decltype(CREATE_PASS)>>());            \
    return Error::success();                                                   \
  }

MODULE_ANALYSIS [5/5]

#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);

MODULE_PASS_WITH_PARAMS [1/4]

#define MODULE_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		PIC->addClassToPassName(CLASS, NAME);

MODULE_PASS_WITH_PARAMS [2/4]

#define MODULE_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME))                                   \
    return true;

MODULE_PASS_WITH_PARAMS [3/4]

#define MODULE_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)

Value:

  if (checkParametrizedPassName(Name, NAME)) {                                 \
    auto Params = parsePassParameters(PARSER, Name, NAME);                     \
    if (!Params)                                                               \
      return Params.takeError();                                               \
    MPM.addPass(CREATE_PASS(Params.get()));                                    \
    return Error::success();                                                   \
  }

MODULE_PASS_WITH_PARAMS [4/4]

#define MODULE_PASS_WITH_PARAMS	(		NAME,
			CLASS,
			CREATE_PASS,
			PARSER,
			PARAMS
	)		printPassName(NAME, PARAMS, OS);

Function Documentation

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 1018 of file PassBuilder.cpp.

References Name.

checkParametrizedPassName()

static bool checkParametrizedPassName ( StringRef  Name, StringRef  PassName  )

static

Definition at line 520 of file PassBuilder.cpp.

References Name, and PassName.

Referenced by isLoopNestPassName(), and isLoopPassName().

isCGSCCPassName()

template<typename CallbacksT >

static bool isCGSCCPassName ( StringRef  Name, CallbacksT &  Callbacks  )

static

Definition at line 1065 of file PassBuilder.cpp.

References llvm::CallingConv::C, Name, parseDevirtPassName(), and parseRepeatPassName().

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

isFunctionPassName()

template<typename CallbacksT >

static bool isFunctionPassName ( StringRef  Name, CallbacksT &  Callbacks  )

static

Definition at line 1094 of file PassBuilder.cpp.

References llvm::CallingConv::C, Name, and parseRepeatPassName().

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

isLoopNestPassName()

template<typename CallbacksT >

static bool isLoopNestPassName ( StringRef  Name, CallbacksT &  Callbacks, bool &  UseMemorySSA  )

static

Definition at line 1121 of file PassBuilder.cpp.

References checkParametrizedPassName(), Name, and parseRepeatPassName().

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

isLoopPassName()

template<typename CallbacksT >

static bool isLoopPassName ( StringRef  Name, CallbacksT &  Callbacks, bool &  UseMemorySSA  )

static

Definition at line 1143 of file PassBuilder.cpp.

References checkParametrizedPassName(), Name, and parseRepeatPassName().

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

isModulePassName()

template<typename CallbacksT >

static bool isModulePassName ( StringRef  Name, CallbacksT &  Callbacks  )

static

Definition at line 1029 of file PassBuilder.cpp.

References llvm::CallingConv::C, DefaultAliasRegex, llvm::Regex::match(), Name, parseRepeatPassName(), and startsWithDefaultPipelineAliasPrefix().

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

parseDevirtPassName()

static std::optional< int > parseDevirtPassName ( StringRef  Name )

static

Definition at line 511 of file PassBuilder.cpp.

References Name.

Referenced by isCGSCCPassName().

parseFunctionPipelineName()

static std::optional< std::pair< bool, bool > > parseFunctionPipelineName ( StringRef  Name )

static

Definition at line 490 of file PassBuilder.cpp.

References Name.

parseRepeatPassName()

static std::optional< int > parseRepeatPassName ( StringRef  Name )

static

Definition at line 480 of file PassBuilder.cpp.

References Name.

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

printPassName() [1/2]

static void printPassName ( StringRef  PassName, raw_ostream &  OS  )

static

Definition at line 1916 of file PassBuilder.cpp.

References OS, and PassName.

printPassName() [2/2]

static void printPassName ( StringRef  PassName, StringRef  Params, raw_ostream &  OS  )

static

Definition at line 1919 of file PassBuilder.cpp.

References OS, and 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 1004 of file PassBuilder.cpp.

References Name.

Referenced by isModulePassName().

Variable Documentation

DefaultAliasRegex

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

static

Referenced by isModulePassName().