LLVM 22.0.0git
Macros | Functions
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/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/CtxProfAnalysis.h"
#include "llvm/Analysis/CycleAnalysis.h"
#include "llvm/Analysis/DDG.h"
#include "llvm/Analysis/DDGPrinter.h"
#include "llvm/Analysis/DXILMetadataAnalysis.h"
#include "llvm/Analysis/DXILResource.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/EphemeralValuesCache.h"
#include "llvm/Analysis/FunctionPropertiesAnalysis.h"
#include "llvm/Analysis/GlobalsModRef.h"
#include "llvm/Analysis/HashRecognize.h"
#include "llvm/Analysis/IR2Vec.h"
#include "llvm/Analysis/IVUsers.h"
#include "llvm/Analysis/InlineAdvisor.h"
#include "llvm/Analysis/InlineSizeEstimatorAnalysis.h"
#include "llvm/Analysis/InstCount.h"
#include "llvm/Analysis/KernelInfo.h"
#include "llvm/Analysis/LastRunTrackingAnalysis.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/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/ScalarEvolutionDivision.h"
#include "llvm/Analysis/ScopedNoAliasAA.h"
#include "llvm/Analysis/StackLifetime.h"
#include "llvm/Analysis/StackSafetyAnalysis.h"
#include "llvm/Analysis/StructuralHash.h"
#include "llvm/Analysis/TargetLibraryInfo.h"
#include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
#include "llvm/Analysis/UniformityAnalysis.h"
#include "llvm/CodeGen/AssignmentTrackingAnalysis.h"
#include "llvm/CodeGen/AtomicExpand.h"
#include "llvm/CodeGen/BasicBlockSectionsProfileReader.h"
#include "llvm/CodeGen/BranchFoldingPass.h"
#include "llvm/CodeGen/BranchRelaxation.h"
#include "llvm/CodeGen/CallBrPrepare.h"
#include "llvm/CodeGen/CodeGenPrepare.h"
#include "llvm/CodeGen/ComplexDeinterleavingPass.h"
#include "llvm/CodeGen/DeadMachineInstructionElim.h"
#include "llvm/CodeGen/DetectDeadLanes.h"
#include "llvm/CodeGen/DwarfEHPrepare.h"
#include "llvm/CodeGen/EarlyIfConversion.h"
#include "llvm/CodeGen/EdgeBundles.h"
#include "llvm/CodeGen/ExpandFp.h"
#include "llvm/CodeGen/ExpandLargeDivRem.h"
#include "llvm/CodeGen/ExpandMemCmp.h"
#include "llvm/CodeGen/ExpandPostRAPseudos.h"
#include "llvm/CodeGen/ExpandReductions.h"
#include "llvm/CodeGen/FEntryInserter.h"
#include "llvm/CodeGen/FinalizeISel.h"
#include "llvm/CodeGen/FixupStatepointCallerSaved.h"
#include "llvm/CodeGen/GCMetadata.h"
#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
#include "llvm/CodeGen/GlobalMerge.h"
#include "llvm/CodeGen/GlobalMergeFunctions.h"
#include "llvm/CodeGen/HardwareLoops.h"
#include "llvm/CodeGen/IndirectBrExpand.h"
#include "llvm/CodeGen/InitUndef.h"
#include "llvm/CodeGen/InterleavedAccess.h"
#include "llvm/CodeGen/InterleavedLoadCombine.h"
#include "llvm/CodeGen/JMCInstrumenter.h"
#include "llvm/CodeGen/LiveDebugValuesPass.h"
#include "llvm/CodeGen/LiveDebugVariables.h"
#include "llvm/CodeGen/LiveIntervals.h"
#include "llvm/CodeGen/LiveRegMatrix.h"
#include "llvm/CodeGen/LiveStacks.h"
#include "llvm/CodeGen/LiveVariables.h"
#include "llvm/CodeGen/LocalStackSlotAllocation.h"
#include "llvm/CodeGen/LowerEmuTLS.h"
#include "llvm/CodeGen/MIRPrinter.h"
#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
#include "llvm/CodeGen/MachineBlockPlacement.h"
#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
#include "llvm/CodeGen/MachineCSE.h"
#include "llvm/CodeGen/MachineCopyPropagation.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/CodeGen/MachineLICM.h"
#include "llvm/CodeGen/MachineLateInstrsCleanup.h"
#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachinePostDominators.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/MachineScheduler.h"
#include "llvm/CodeGen/MachineSink.h"
#include "llvm/CodeGen/MachineTraceMetrics.h"
#include "llvm/CodeGen/MachineUniformityAnalysis.h"
#include "llvm/CodeGen/MachineVerifier.h"
#include "llvm/CodeGen/OptimizePHIs.h"
#include "llvm/CodeGen/PEI.h"
#include "llvm/CodeGen/PHIElimination.h"
#include "llvm/CodeGen/PatchableFunction.h"
#include "llvm/CodeGen/PeepholeOptimizer.h"
#include "llvm/CodeGen/PostRAHazardRecognizer.h"
#include "llvm/CodeGen/PostRAMachineSink.h"
#include "llvm/CodeGen/PostRASchedulerList.h"
#include "llvm/CodeGen/PreISelIntrinsicLowering.h"
#include "llvm/CodeGen/ProcessImplicitDefs.h"
#include "llvm/CodeGen/RegAllocEvictionAdvisor.h"
#include "llvm/CodeGen/RegAllocFast.h"
#include "llvm/CodeGen/RegAllocGreedyPass.h"
#include "llvm/CodeGen/RegAllocPriorityAdvisor.h"
#include "llvm/CodeGen/RegUsageInfoCollector.h"
#include "llvm/CodeGen/RegUsageInfoPropagate.h"
#include "llvm/CodeGen/RegisterCoalescerPass.h"
#include "llvm/CodeGen/RegisterUsageInfo.h"
#include "llvm/CodeGen/RemoveLoadsIntoFakeUses.h"
#include "llvm/CodeGen/RemoveRedundantDebugValues.h"
#include "llvm/CodeGen/RenameIndependentSubregs.h"
#include "llvm/CodeGen/ReplaceWithVeclib.h"
#include "llvm/CodeGen/SafeStack.h"
#include "llvm/CodeGen/SanitizerBinaryMetadata.h"
#include "llvm/CodeGen/SelectOptimize.h"
#include "llvm/CodeGen/ShadowStackGCLowering.h"
#include "llvm/CodeGen/ShrinkWrap.h"
#include "llvm/CodeGen/SjLjEHPrepare.h"
#include "llvm/CodeGen/SlotIndexes.h"
#include "llvm/CodeGen/SpillPlacement.h"
#include "llvm/CodeGen/StackColoring.h"
#include "llvm/CodeGen/StackFrameLayoutAnalysisPass.h"
#include "llvm/CodeGen/StackProtector.h"
#include "llvm/CodeGen/StackSlotColoring.h"
#include "llvm/CodeGen/TailDuplication.h"
#include "llvm/CodeGen/TargetPassConfig.h"
#include "llvm/CodeGen/TwoAddressInstructionPass.h"
#include "llvm/CodeGen/TypePromotion.h"
#include "llvm/CodeGen/UnreachableBlockElim.h"
#include "llvm/CodeGen/VirtRegMap.h"
#include "llvm/CodeGen/WasmEHPrepare.h"
#include "llvm/CodeGen/WinEHPrepare.h"
#include "llvm/CodeGen/XRayInstrumentation.h"
#include "llvm/IR/DebugInfo.h"
#include "llvm/IR/Dominators.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/SafepointIRVerifier.h"
#include "llvm/IR/Verifier.h"
#include "llvm/IRPrinter/IRPrintingPasses.h"
#include "llvm/Passes/OptimizationLevel.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/CFGuard.h"
#include "llvm/Transforms/Coroutines/CoroAnnotationElide.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/HipStdPar/HipStdPar.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/EmbedBitcodePass.h"
#include "llvm/Transforms/IPO/ExpandVariadics.h"
#include "llvm/Transforms/IPO/FatLTOCleanup.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/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/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/WholeProgramDevirt.h"
#include "llvm/Transforms/InstCombine/InstCombine.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/InstrProfiling.h"
#include "llvm/Transforms/Instrumentation/KCFI.h"
#include "llvm/Transforms/Instrumentation/LowerAllowCheckPass.h"
#include "llvm/Transforms/Instrumentation/MemProfInstrumentation.h"
#include "llvm/Transforms/Instrumentation/MemProfUse.h"
#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
#include "llvm/Transforms/Instrumentation/NumericalStabilitySanitizer.h"
#include "llvm/Transforms/Instrumentation/PGOCtxProfFlattening.h"
#include "llvm/Transforms/Instrumentation/PGOCtxProfLowering.h"
#include "llvm/Transforms/Instrumentation/PGOForceFunctionAttrs.h"
#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
#include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
#include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
#include "llvm/Transforms/Instrumentation/TypeSanitizer.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/InferAlignment.h"
#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
#include "llvm/Transforms/Scalar/JumpTableToSwitch.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/LoopRotation.h"
#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
#include "llvm/Transforms/Scalar/LoopSink.h"
#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
#include "llvm/Transforms/Scalar/LoopTermFold.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/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/DXILUpgrade.h"
#include "llvm/Transforms/Utils/Debugify.h"
#include "llvm/Transforms/Utils/DeclareRuntimeLibcalls.h"
#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
#include "llvm/Transforms/Utils/FixIrreducible.h"
#include "llvm/Transforms/Utils/HelloWorld.h"
#include "llvm/Transforms/Utils/IRNormalizer.h"
#include "llvm/Transforms/Utils/InjectTLIMappings.h"
#include "llvm/Transforms/Utils/InstructionNamer.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/ProfileVerify.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/EVLIndVarSimplify.h"
#include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h"
#include "llvm/Transforms/Vectorize/LoopIdiomVectorize.h"
#include "llvm/Transforms/Vectorize/LoopVectorize.h"
#include "llvm/Transforms/Vectorize/SLPVectorizer.h"
#include "llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h"
#include "llvm/Transforms/Vectorize/VectorCombine.h"
#include <optional>
#include "PassRegistry.def"
#include "llvm/Passes/MachinePassRegistry.def"

Go to the source code of this file.

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 MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)    PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
 
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)    PIC->addClassToPassName(CLASS, 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 MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)    MFAM.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 MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
 
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
 
#define MACHINE_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 MACHINE_MODULE_PASS(NAME, CREATE_PASS)
 
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
 
#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
 
#define MACHINE_FUNCTION_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);
 
#define MACHINE_MODULE_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)   printPassName(NAME, OS);
 

Functions

static std::optional< std::pair< bool, bool > > parseFunctionPipelineName (StringRef Name)
 
static std::optional< int > parseDevirtPassName (StringRef Name)
 
static std::optional< OptimizationLevel > parseOptLevel (StringRef S)
 
static Expected< OptimizationLevel > parseOptLevelParam (StringRef S)
 
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 isMachineFunctionPassName (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 setupOptionsForPipelineAlias (PipelineTuningOptions &PTO, OptimizationLevel L)
 
static void printPassName (StringRef PassName, raw_ostream &OS)
 
static void printPassName (StringRef PassName, StringRef Params, raw_ostream &OS)
 

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;
Name
std::string Name
Definition: ELFObjHandler.cpp:77

◆ 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(); \
}
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:255
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition: Error.h:336
llvm::LazyCallGraph::SCC
An SCC of the call graph.
Definition: LazyCallGraph.h:417
llvm::LazyCallGraph
A lazily constructed view of the call graph of a module.
Definition: LazyCallGraph.h:109
llvm::CGSCCUpdateResult
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Definition: CGSCCPassManager.h:233
llvm::InvalidateAnalysisPass
A no-op pass template which simply forces a specific analysis result to be invalidated.
Definition: PassManager.h:930
llvm::RequireAnalysisPass
A utility pass template to force an analysis result to be available.
Definition: PassManager.h:903

◆ 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(); \
}
llvm::createModuleToPostOrderCGSCCPassAdaptor
ModuleToPostOrderCGSCCPassAdaptor createModuleToPostOrderCGSCCPassAdaptor(CGSCCPassT &&Pass)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: CGSCCPassManager.h:359

◆ 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 (PassBuilder::checkParametrizedPassName(Name, NAME)) \
return true;
llvm::PassBuilder::checkParametrizedPassName
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition: PassBuilder.h:677

◆ 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(); \
}
llvm::createModuleToFunctionPassAdaptor
ModuleToFunctionPassAdaptor createModuleToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: PassManager.h:877

◆ FUNCTION_PASS [4/6]

#define FUNCTION_PASS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == NAME) { \
CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
return Error::success(); \
}
llvm::createCGSCCToFunctionPassAdaptor
CGSCCToFunctionPassAdaptor createCGSCCToFunctionPassAdaptor(FunctionPassT &&Pass, bool EagerlyInvalidate=false, bool NoRerun=false)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition: CGSCCPassManager.h:506

◆ 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 (PassBuilder::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(); \
}
llvm::LPMUpdater
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
Definition: LoopPassManager.h:226
llvm::Loop
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:40
llvm::LoopStandardAnalysisResults
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
Definition: LoopAnalysisManager.h:54

◆ 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(); \
}
llvm::createFunctionToLoopPassAdaptor
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false, bool UseBlockFrequencyInfo=false, bool UseBranchProbabilityInfo=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
Definition: LoopPassManager.h:448

◆ 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 (PassBuilder::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);

◆ MACHINE_FUNCTION_ANALYSIS [1/5]

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

◆ MACHINE_FUNCTION_ANALYSIS [2/5]

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

◆ MACHINE_FUNCTION_ANALYSIS [3/5]

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

◆ MACHINE_FUNCTION_ANALYSIS [4/5]

#define MACHINE_FUNCTION_ANALYSIS (   NAME,
  CREATE_PASS 
)
Value:
if (Name == "require<" NAME ">") { \
MFPM.addPass( \
RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
MachineFunction>()); \
return Error::success(); \
} \
if (Name == "invalidate<" NAME ">") { \
MFPM.addPass(InvalidateAnalysisPass< \
std::remove_reference_t<decltype(CREATE_PASS)>>()); \
return Error::success(); \
}

◆ MACHINE_FUNCTION_ANALYSIS [5/5]

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

◆ MACHINE_FUNCTION_PASS [1/4]

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

◆ MACHINE_FUNCTION_PASS [2/4]

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

◆ MACHINE_FUNCTION_PASS [3/4]

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

◆ MACHINE_FUNCTION_PASS [4/4]

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

◆ MACHINE_FUNCTION_PASS_WITH_PARAMS [1/3]

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

◆ MACHINE_FUNCTION_PASS_WITH_PARAMS [2/3]

#define MACHINE_FUNCTION_PASS_WITH_PARAMS (   NAME,
  CLASS,
  CREATE_PASS,
  PARSER,
  PARAMS 
)
Value:
if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
return true;

◆ MACHINE_FUNCTION_PASS_WITH_PARAMS [3/3]

#define MACHINE_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(); \
MFPM.addPass(CREATE_PASS(Params.get())); \
return Error::success(); \
}

◆ MACHINE_MODULE_PASS [1/2]

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

◆ MACHINE_MODULE_PASS [2/2]

#define MACHINE_MODULE_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(); \
}
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67

◆ 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 (PassBuilder::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 1585 of file PassBuilder.cpp.

References Name.

◆ isCGSCCPassName()

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

Definition at line 1624 of file PassBuilder.cpp.

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

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

◆ isFunctionPassName()

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

Definition at line 1651 of file PassBuilder.cpp.

References llvm::CallingConv::C, and Name.

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

◆ isLoopNestPassName()

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

Definition at line 1697 of file PassBuilder.cpp.

References llvm::PassBuilder::checkParametrizedPassName(), and Name.

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

◆ isLoopPassName()

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

Definition at line 1715 of file PassBuilder.cpp.

References llvm::PassBuilder::checkParametrizedPassName(), and Name.

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

◆ isMachineFunctionPassName()

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

Definition at line 1674 of file PassBuilder.cpp.

References Name.

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

◆ isModulePassName()

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

Definition at line 1596 of file PassBuilder.cpp.

References llvm::CallingConv::C, and Name.

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

◆ parseDevirtPassName()

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

Definition at line 606 of file PassBuilder.cpp.

References Name.

Referenced by isCGSCCPassName().

◆ parseFunctionPipelineName()

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

Definition at line 585 of file PassBuilder.cpp.

References Name.

◆ parseOptLevel()

static std::optional< OptimizationLevel > parseOptLevel ( StringRef  S)
static

Definition at line 615 of file PassBuilder.cpp.

References llvm::StringSwitch< T, R >::Case(), llvm::StringSwitch< T, R >::Default(), llvm::OptimizationLevel::O0, llvm::OptimizationLevel::O1, llvm::OptimizationLevel::O2, llvm::OptimizationLevel::O3, llvm::OptimizationLevel::Os, and llvm::OptimizationLevel::Oz.

Referenced by parseOptLevelParam().

◆ parseOptLevelParam()

static Expected< OptimizationLevel > parseOptLevelParam ( StringRef  S)
static

Definition at line 626 of file PassBuilder.cpp.

References llvm::formatv(), llvm::inconvertibleErrorCode(), and parseOptLevel().

◆ printPassName() [1/2]

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

Definition at line 2534 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 2537 of file PassBuilder.cpp.

References OS, and PassName.

◆ setupOptionsForPipelineAlias()

static void setupOptionsForPipelineAlias ( PipelineTuningOptions &  PTO,
OptimizationLevel  L 
)
static

Definition at line 1795 of file PassBuilder.cpp.

References llvm::PipelineTuningOptions::LoopVectorization, llvm::OptimizationLevel::Oz, and llvm::PipelineTuningOptions::SLPVectorization.

Generated on Sat Aug 30 2025 13:57:19 for LLVM by doxygen 1.9.6