LLVM 23.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/ADT/StringTable.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/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/RuntimeLibcallInfo.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/StaticDataProfileInfo.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/BreakFalseDeps.h"
#include "llvm/CodeGen/CFIFixup.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/ExpandIRInsts.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/GCEmptyBasicBlocks.h"
#include "llvm/CodeGen/GCMetadata.h"
#include "llvm/CodeGen/GlobalISel/CSEInfo.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/InlineAsmPrepare.h"
#include "llvm/CodeGen/InterleavedAccess.h"
#include "llvm/CodeGen/InterleavedLoadCombine.h"
#include "llvm/CodeGen/JMCInstrumenter.h"
#include "llvm/CodeGen/KCFI.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/MachineBlockHashInfo.h"
#include "llvm/CodeGen/MachineBlockPlacement.h"
#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
#include "llvm/CodeGen/MachineCFGPrinter.h"
#include "llvm/CodeGen/MachineCSE.h"
#include "llvm/CodeGen/MachineCheckDebugify.h"
#include "llvm/CodeGen/MachineCopyPropagation.h"
#include "llvm/CodeGen/MachineDebugify.h"
#include "llvm/CodeGen/MachineDominanceFrontier.h"
#include "llvm/CodeGen/MachineDominators.h"
#include "llvm/CodeGen/MachineFunctionAnalysis.h"
#include "llvm/CodeGen/MachineInstrBundle.h"
#include "llvm/CodeGen/MachineLICM.h"
#include "llvm/CodeGen/MachineLateInstrsCleanup.h"
#include "llvm/CodeGen/MachinePassManager.h"
#include "llvm/CodeGen/MachinePostDominators.h"
#include "llvm/CodeGen/MachineRegionInfo.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/MachineScheduler.h"
#include "llvm/CodeGen/MachineSink.h"
#include "llvm/CodeGen/MachineStripDebug.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/ReachingDefAnalysis.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/StaticDataAnnotator.h"
#include "llvm/CodeGen/StaticDataSplitter.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/CodeGen.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormatAdapters.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/Instrumentor.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/AllocToken.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/DropUnnecessaryAssumes.h"
#include "llvm/Transforms/Scalar/EarlyCSE.h"
#include "llvm/Transforms/Scalar/ExpandMemCmp.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/AssignGUID.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/LowerCommentStringPass.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/StripConvergenceIntrinsics.h"
#include "llvm/Transforms/Utils/StripGCRelocates.h"
#include "llvm/Transforms/Utils/StripNonLineTableDebugInfo.h"
#include "llvm/Transforms/Utils/SymbolRewriter.h"
#include "llvm/Transforms/Utils/TriggerCrashPass.h"
#include "llvm/Transforms/Utils/UnifyLoopExits.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)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_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 CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MACHINE_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 MODULE_CALLBACK(NAME, INVOKE)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_LTO_CALLBACK(NAME, INVOKE)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_CALLBACK(NAME, INVOKE)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_CALLBACK(NAME, INVOKE)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define LOOP_CALLBACK(NAME, INVOKE)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_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 FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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 MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define LOOPNEST_PASS(NAME, CREATE_PASS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_PASS(NAME, CREATE_PASS)
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#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_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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 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 MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_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 LOOPNEST_PASS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_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_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_PASS(NAME, CREATE_PASS)
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#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_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_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 FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define LOOPNEST_PASS(NAME, CREATE_PASS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_PASS(NAME, CREATE_PASS)
#define LOOPNEST_PASS(NAME, CREATE_PASS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_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_ANALYSIS(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 MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_PASS(NAME, CREATE_PASS)
#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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_ANALYSIS(NAME, CREATE_PASS)
#define LOOP_PASS(NAME, CREATE_PASS)
#define LOOP_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS)
#define MODULE_PASS(NAME, CREATE_PASS)
#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define CGSCC_ANALYSIS(NAME, CREATE_PASS)
#define CGSCC_PASS(NAME, CREATE_PASS)
#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS)
#define FUNCTION_ANALYSIS(NAME, CREATE_PASS)
#define FUNCTION_ALIAS_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 MACHINE_MODULE_PASS(NAME, CREATE_PASS)
#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS)
#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS)

Functions

static std::optional< OptimizationLevel > parseOptLevel (StringRef S)
static Expected< OptimizationLevel > parseOptLevelParam (StringRef S)
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName (StringRef Name)
static std::optional< int > parseDevirtPassName (StringRef Name)
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 LLVM_ATTRIBUTE_NOINLINE void printPassNameList (StringTable PassNames, raw_ostream &OS)
static LLVM_ATTRIBUTE_NOINLINE void printPassNameListWithParams (StringTable PassNames, 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/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )
Value:
PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
PIC
PassInstrumentationCallbacks PIC
Definition PassBuilderBindings.cpp:57
name
static const char * name
Definition SVEIntrinsicOpts.cpp:65

◆ CGSCC_ANALYSIS [2/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )
Value:
CGAM.registerPass([&] { return CREATE_PASS; });
CGAM
CGSCCAnalysisManager CGAM
Definition PassBuilderBindings.cpp:62

◆ CGSCC_ANALYSIS [3/35]

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

◆ CGSCC_ANALYSIS [4/35]

#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::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::CGSCCAnalysisManager
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
Definition CGSCCPassManager.h:123
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:949
llvm::RequireAnalysisPass
A utility pass template to force an analysis result to be available.
Definition PassManager.h:923

◆ CGSCC_ANALYSIS [5/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ CGSCC_ANALYSIS [6/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [7/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [8/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [9/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [10/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [11/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [12/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [13/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [14/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [15/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [16/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [17/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [18/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [19/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [20/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [21/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [22/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [23/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [24/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [25/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [26/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [27/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [28/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [29/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [30/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [31/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [32/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [33/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [34/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_ANALYSIS [35/35]

#define CGSCC_ANALYSIS ( NAME,
CREATE_PASS )

◆ CGSCC_CALLBACK

#define CGSCC_CALLBACK ( NAME,
INVOKE )
Value:
if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
if (!L) { \
errs() << NAME ": " << toString(L.takeError()) << '\n'; \
return false; \
} \
INVOKE(PM, L.get()); \
return true; \
}
parseOptLevelParam
static Expected< OptimizationLevel > parseOptLevelParam(StringRef S)
Definition PassBuilder.cpp:566
llvm::PassBuilder::checkParametrizedPassName
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition PassBuilder.h:688
llvm::PassBuilder::parsePassParameters
static auto parsePassParameters(ParametersParseCallableT &&Parser, StringRef Name, StringRef PassName) -> decltype(Parser(StringRef{}))
This performs customized parsing of pass name with parameters.
Definition PassBuilder.h:713
llvm::toString
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
Definition StringExtras.h:344

◆ CGSCC_PASS [1/35]

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

◆ CGSCC_PASS [2/35]

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

◆ CGSCC_PASS [3/35]

#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:357

◆ CGSCC_PASS [4/35]

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

◆ CGSCC_PASS [5/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ CGSCC_PASS [6/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [7/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [8/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [9/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [10/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [11/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [12/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [13/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [14/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [15/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [16/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [17/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [18/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [19/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [20/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [21/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [22/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [23/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [24/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [25/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [26/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [27/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [28/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [29/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [30/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [31/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [32/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [33/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [34/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS [35/35]

#define CGSCC_PASS ( NAME,
CREATE_PASS )

◆ CGSCC_PASS_WITH_PARAMS [1/35]

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

◆ CGSCC_PASS_WITH_PARAMS [2/35]

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

◆ CGSCC_PASS_WITH_PARAMS [3/35]

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

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

#define CGSCC_PASS_WITH_PARAMS ( NAME,
CLASS,
CREATE_PASS,
PARSER,
PARAMS )
Value:
NAME "\0" PARAMS "\0"

◆ CGSCC_PASS_WITH_PARAMS [6/35]

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

◆ CGSCC_PASS_WITH_PARAMS [7/35]

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

◆ CGSCC_PASS_WITH_PARAMS [8/35]

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

◆ CGSCC_PASS_WITH_PARAMS [9/35]

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

◆ CGSCC_PASS_WITH_PARAMS [10/35]

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

◆ CGSCC_PASS_WITH_PARAMS [11/35]

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

◆ CGSCC_PASS_WITH_PARAMS [12/35]

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

◆ CGSCC_PASS_WITH_PARAMS [13/35]

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

◆ CGSCC_PASS_WITH_PARAMS [14/35]

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

◆ CGSCC_PASS_WITH_PARAMS [15/35]

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

◆ CGSCC_PASS_WITH_PARAMS [16/35]

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

◆ CGSCC_PASS_WITH_PARAMS [17/35]

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

◆ CGSCC_PASS_WITH_PARAMS [18/35]

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

◆ CGSCC_PASS_WITH_PARAMS [19/35]

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

◆ CGSCC_PASS_WITH_PARAMS [20/35]

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

◆ CGSCC_PASS_WITH_PARAMS [21/35]

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

◆ CGSCC_PASS_WITH_PARAMS [22/35]

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

◆ CGSCC_PASS_WITH_PARAMS [23/35]

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

◆ CGSCC_PASS_WITH_PARAMS [24/35]

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

◆ CGSCC_PASS_WITH_PARAMS [25/35]

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

◆ CGSCC_PASS_WITH_PARAMS [26/35]

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

◆ CGSCC_PASS_WITH_PARAMS [27/35]

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

◆ CGSCC_PASS_WITH_PARAMS [28/35]

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

◆ CGSCC_PASS_WITH_PARAMS [29/35]

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

◆ CGSCC_PASS_WITH_PARAMS [30/35]

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

◆ CGSCC_PASS_WITH_PARAMS [31/35]

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

◆ CGSCC_PASS_WITH_PARAMS [32/35]

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

◆ CGSCC_PASS_WITH_PARAMS [33/35]

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

◆ CGSCC_PASS_WITH_PARAMS [34/35]

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

◆ CGSCC_PASS_WITH_PARAMS [35/35]

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

◆ FUNCTION_ALIAS_ANALYSIS [1/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
if (Name == NAME) { \
AA.registerFunctionAnalysis< \
std::remove_reference_t<decltype(CREATE_PASS)>>(); \
return true; \
}
llvm::AA
Abstract Attribute helper functions.
Definition Attributor.h:165

◆ FUNCTION_ALIAS_ANALYSIS [2/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ FUNCTION_ALIAS_ANALYSIS [3/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [4/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [5/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [6/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [7/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [8/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [9/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [10/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [11/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [12/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [13/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [14/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [15/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [16/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [17/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [18/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [19/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [20/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [21/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [22/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [23/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [24/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [25/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [26/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [27/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [28/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [29/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [30/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [31/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [32/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [33/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [34/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ALIAS_ANALYSIS [35/35]

#define FUNCTION_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
FUNCTION_ANALYSIS(NAME, CREATE_PASS)

◆ FUNCTION_ANALYSIS [1/35]

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

◆ FUNCTION_ANALYSIS [2/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )
Value:
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CREATE_PASS)>, \
const TargetMachine &>) { \
if (TM) \
FAM.registerPass([&] { return CREATE_PASS; }); \
} else { \
FAM.registerPass([&] { return CREATE_PASS; }); \
}
FAM
FunctionAnalysisManager FAM
Definition PassBuilderBindings.cpp:61
llvm::AnalysisManager::registerPass
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition PassManager.h:495
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition TargetMachine.h:84

◆ FUNCTION_ANALYSIS [3/35]

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

◆ FUNCTION_ANALYSIS [4/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )
Value:
if (Name == "require<" NAME ">") { \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CREATE_PASS)>, \
const TargetMachine &>) { \
if (!TM) \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
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(); \
}
llvm::inconvertibleErrorCode
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition Error.cpp:94
llvm::formatv
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
Definition FormatVariadic.h:247
llvm::make_error
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
Definition Error.h:340

◆ FUNCTION_ANALYSIS [5/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ FUNCTION_ANALYSIS [6/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [7/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [8/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [9/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [10/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [11/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [12/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [13/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [14/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [15/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [16/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [17/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [18/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [19/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [20/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [21/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [22/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [23/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [24/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [25/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [26/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [27/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [28/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [29/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [30/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [31/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [32/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [33/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [34/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_ANALYSIS [35/35]

#define FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )

◆ FUNCTION_CALLBACK

#define FUNCTION_CALLBACK ( NAME,
INVOKE )
Value:
if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
if (!L) { \
errs() << NAME ": " << toString(L.takeError()) << '\n'; \
return false; \
} \
INVOKE(PM, L.get()); \
return true; \
}

◆ FUNCTION_PASS [1/35]

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

◆ FUNCTION_PASS [2/35]

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

◆ FUNCTION_PASS [3/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )
Value:
if (Name == NAME) { \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CREATE_PASS)>, \
const TargetMachine &>) { \
if (!TM) \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
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:897

◆ FUNCTION_PASS [4/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )
Value:
if (Name == NAME) { \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CREATE_PASS)>, \
const TargetMachine &>) { \
if (!TM) \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
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:502

◆ FUNCTION_PASS [5/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )
Value:
if (Name == NAME) { \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CREATE_PASS)>, \
const TargetMachine &>) { \
if (!TM) \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
FPM.addPass(CREATE_PASS); \
return Error::success(); \
}

◆ FUNCTION_PASS [6/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ FUNCTION_PASS [7/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [8/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [9/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [10/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [11/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [12/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [13/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [14/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [15/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [16/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [17/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [18/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [19/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [20/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [21/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [22/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [23/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [24/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [25/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [26/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [27/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [28/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [29/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [30/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [31/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [32/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [33/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [34/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS [35/35]

#define FUNCTION_PASS ( NAME,
CREATE_PASS )

◆ FUNCTION_PASS_WITH_PARAMS [1/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [2/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [3/35]

#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(); \
auto CreatePass = CREATE_PASS; \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CreatePass( \
Params.get()))>, \
const TargetMachine &, \
std::remove_reference_t<decltype(Params.get())>>) { \
if (!TM) { \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
} \
MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
return Error::success(); \
}

◆ FUNCTION_PASS_WITH_PARAMS [4/35]

#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(); \
auto CreatePass = CREATE_PASS; \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CreatePass( \
Params.get()))>, \
const TargetMachine &, \
std::remove_reference_t<decltype(Params.get())>>) { \
if (!TM) { \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
} \
CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
return Error::success(); \
}

◆ FUNCTION_PASS_WITH_PARAMS [5/35]

#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(); \
auto CreatePass = CREATE_PASS; \
if constexpr (std::is_constructible_v< \
std::remove_reference_t<decltype(CreatePass( \
Params.get()))>, \
const TargetMachine &, \
std::remove_reference_t<decltype(Params.get())>>) { \
if (!TM) { \
return make_error<StringError>( \
formatv("pass '{0}' requires TargetMachine", Name).str(), \
inconvertibleErrorCode()); \
} \
} \
FPM.addPass(CREATE_PASS(Params.get())); \
return Error::success(); \
}

◆ FUNCTION_PASS_WITH_PARAMS [6/35]

#define FUNCTION_PASS_WITH_PARAMS ( NAME,
CLASS,
CREATE_PASS,
PARSER,
PARAMS )
Value:
NAME "\0" PARAMS "\0"

◆ FUNCTION_PASS_WITH_PARAMS [7/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [8/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [9/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [10/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [11/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [12/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [13/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [14/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [15/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [16/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [17/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [18/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [19/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [20/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [21/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [22/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [23/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [24/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [25/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [26/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [27/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [28/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [29/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [30/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [31/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [32/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [33/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [34/35]

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

◆ FUNCTION_PASS_WITH_PARAMS [35/35]

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

◆ LOOP_ANALYSIS [1/35]

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

◆ LOOP_ANALYSIS [2/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )
Value:
LAM.registerPass([&] { return CREATE_PASS; });
LAM
LoopAnalysisManager LAM
Definition PassBuilderBindings.cpp:60

◆ LOOP_ANALYSIS [3/35]

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

◆ LOOP_ANALYSIS [4/35]

#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:224
llvm::Loop
Represents a single loop in the control flow graph.
Definition LoopInfo.h:40
llvm::LoopAnalysisManager
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
Definition LoopAnalysisManager.h:75
llvm::LoopStandardAnalysisResults
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
Definition LoopAnalysisManager.h:52

◆ LOOP_ANALYSIS [5/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ LOOP_ANALYSIS [6/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [7/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [8/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [9/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [10/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [11/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [12/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [13/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [14/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [15/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [16/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [17/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [18/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [19/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [20/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [21/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [22/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [23/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [24/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [25/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [26/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [27/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [28/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [29/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [30/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [31/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [32/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [33/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [34/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_ANALYSIS [35/35]

#define LOOP_ANALYSIS ( NAME,
CREATE_PASS )

◆ LOOP_CALLBACK

#define LOOP_CALLBACK ( NAME,
INVOKE )
Value:
if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
if (!L) { \
errs() << NAME ": " << toString(L.takeError()) << '\n'; \
return false; \
} \
INVOKE(PM, L.get()); \
return true; \
}

◆ LOOP_PASS [1/35]

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

◆ LOOP_PASS [2/35]

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

◆ LOOP_PASS [3/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )
Value:
if (Name == NAME) { \
MPM.addPass(createModuleToFunctionPassAdaptor( \
createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
return Error::success(); \
}
llvm::createFunctionToLoopPassAdaptor
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
Definition LoopPassManager.h:438

◆ LOOP_PASS [4/35]

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

◆ LOOP_PASS [5/35]

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

◆ LOOP_PASS [6/35]

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

◆ LOOP_PASS [7/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ LOOP_PASS [8/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [9/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [10/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [11/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [12/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [13/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [14/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [15/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [16/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [17/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [18/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [19/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [20/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [21/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [22/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [23/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [24/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [25/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [26/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [27/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [28/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [29/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [30/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [31/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [32/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [33/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [34/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS [35/35]

#define LOOP_PASS ( NAME,
CREATE_PASS )

◆ LOOP_PASS_WITH_PARAMS [1/35]

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

◆ LOOP_PASS_WITH_PARAMS [2/35]

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

◆ LOOP_PASS_WITH_PARAMS [3/35]

#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))); \
return Error::success(); \
}

◆ LOOP_PASS_WITH_PARAMS [4/35]

#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))); \
return Error::success(); \
}

◆ LOOP_PASS_WITH_PARAMS [5/35]

#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)); \
return Error::success(); \
}

◆ LOOP_PASS_WITH_PARAMS [6/35]

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

#define LOOP_PASS_WITH_PARAMS ( NAME,
CLASS,
CREATE_PASS,
PARSER,
PARAMS )
Value:
NAME "\0" PARAMS "\0"

◆ LOOP_PASS_WITH_PARAMS [8/35]

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

◆ LOOP_PASS_WITH_PARAMS [9/35]

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

◆ LOOP_PASS_WITH_PARAMS [10/35]

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

◆ LOOP_PASS_WITH_PARAMS [11/35]

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

◆ LOOP_PASS_WITH_PARAMS [12/35]

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

◆ LOOP_PASS_WITH_PARAMS [13/35]

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

◆ LOOP_PASS_WITH_PARAMS [14/35]

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

◆ LOOP_PASS_WITH_PARAMS [15/35]

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

◆ LOOP_PASS_WITH_PARAMS [16/35]

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

◆ LOOP_PASS_WITH_PARAMS [17/35]

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

◆ LOOP_PASS_WITH_PARAMS [18/35]

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

◆ LOOP_PASS_WITH_PARAMS [19/35]

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

◆ LOOP_PASS_WITH_PARAMS [20/35]

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

◆ LOOP_PASS_WITH_PARAMS [21/35]

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

◆ LOOP_PASS_WITH_PARAMS [22/35]

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

◆ LOOP_PASS_WITH_PARAMS [23/35]

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

◆ LOOP_PASS_WITH_PARAMS [24/35]

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

◆ LOOP_PASS_WITH_PARAMS [25/35]

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

◆ LOOP_PASS_WITH_PARAMS [26/35]

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

◆ LOOP_PASS_WITH_PARAMS [27/35]

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

◆ LOOP_PASS_WITH_PARAMS [28/35]

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

◆ LOOP_PASS_WITH_PARAMS [29/35]

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

◆ LOOP_PASS_WITH_PARAMS [30/35]

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

◆ LOOP_PASS_WITH_PARAMS [31/35]

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

◆ LOOP_PASS_WITH_PARAMS [32/35]

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

◆ LOOP_PASS_WITH_PARAMS [33/35]

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

◆ LOOP_PASS_WITH_PARAMS [34/35]

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

◆ LOOP_PASS_WITH_PARAMS [35/35]

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

◆ LOOPNEST_PASS [1/35]

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

◆ LOOPNEST_PASS [2/35]

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

◆ LOOPNEST_PASS [3/35]

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

◆ LOOPNEST_PASS [4/35]

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

◆ LOOPNEST_PASS [5/35]

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

◆ LOOPNEST_PASS [6/35]

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

◆ LOOPNEST_PASS [7/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ LOOPNEST_PASS [8/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [9/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [10/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [11/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [12/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [13/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [14/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [15/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [16/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [17/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [18/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [19/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [20/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [21/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [22/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [23/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [24/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [25/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [26/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [27/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [28/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [29/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [30/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [31/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [32/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [33/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [34/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ LOOPNEST_PASS [35/35]

#define LOOPNEST_PASS ( NAME,
CREATE_PASS )

◆ MACHINE_FUNCTION_ANALYSIS [1/5]

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

◆ MACHINE_FUNCTION_ANALYSIS [2/5]

#define MACHINE_FUNCTION_ANALYSIS ( NAME,
CREATE_PASS )
Value:
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 )
Value:
NAME "\0"

◆ MACHINE_FUNCTION_PASS [1/4]

#define MACHINE_FUNCTION_PASS ( NAME,
CREATE_PASS )
Value:
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 )
Value:
NAME "\0"

◆ MACHINE_FUNCTION_PASS_WITH_PARAMS [1/3]

#define MACHINE_FUNCTION_PASS_WITH_PARAMS ( NAME,
CLASS,
CREATE_PASS,
PARSER,
PARAMS )
Value:
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 )
Value:
NAME "\0"

◆ MODULE_ALIAS_ANALYSIS [1/35]

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

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ MODULE_ALIAS_ANALYSIS [3/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [4/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [5/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [6/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [7/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [8/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [9/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [10/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [11/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [12/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [13/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [14/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [15/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [16/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [17/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [18/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [19/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [20/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [21/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [22/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [23/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [24/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [25/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [26/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [27/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [28/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [29/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [30/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [31/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [32/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [33/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [34/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ALIAS_ANALYSIS [35/35]

#define MODULE_ALIAS_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MODULE_ANALYSIS(NAME, CREATE_PASS)

◆ MODULE_ANALYSIS [1/35]

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

◆ MODULE_ANALYSIS [2/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )
Value:
MAM.registerPass([&] { return CREATE_PASS; });
MAM
ModuleAnalysisManager MAM
Definition PassBuilderBindings.cpp:63

◆ MODULE_ANALYSIS [3/35]

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

◆ MODULE_ANALYSIS [4/35]

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

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ MODULE_ANALYSIS [6/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [7/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [8/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [9/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [10/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [11/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [12/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [13/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [14/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [15/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [16/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [17/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [18/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [19/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [20/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [21/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [22/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [23/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [24/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [25/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [26/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [27/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [28/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [29/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [30/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [31/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [32/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [33/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [34/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_ANALYSIS [35/35]

#define MODULE_ANALYSIS ( NAME,
CREATE_PASS )

◆ MODULE_CALLBACK

#define MODULE_CALLBACK ( NAME,
INVOKE )
Value:
if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
if (!L) { \
errs() << NAME ": " << toString(L.takeError()) << '\n'; \
return false; \
} \
INVOKE(PM, L.get()); \
return true; \
}

◆ MODULE_LTO_CALLBACK

#define MODULE_LTO_CALLBACK ( NAME,
INVOKE )
Value:
if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
if (!L) { \
errs() << NAME ": " << toString(L.takeError()) << '\n'; \
return false; \
} \
INVOKE(PM, L.get(), ThinOrFullLTOPhase::None); \
return true; \
}

◆ MODULE_PASS [1/35]

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

◆ MODULE_PASS [2/35]

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

◆ MODULE_PASS [3/35]

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

◆ MODULE_PASS [4/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )
Value:
NAME "\0"

◆ MODULE_PASS [5/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [6/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [7/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [8/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [9/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [10/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [11/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [12/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [13/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [14/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [15/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [16/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [17/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [18/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [19/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [20/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [21/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [22/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [23/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [24/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [25/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [26/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [27/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [28/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [29/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [30/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [31/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [32/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [33/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [34/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS [35/35]

#define MODULE_PASS ( NAME,
CREATE_PASS )

◆ MODULE_PASS_WITH_PARAMS [1/35]

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

◆ MODULE_PASS_WITH_PARAMS [2/35]

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

◆ MODULE_PASS_WITH_PARAMS [3/35]

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

#define MODULE_PASS_WITH_PARAMS ( NAME,
CLASS,
CREATE_PASS,
PARSER,
PARAMS )
Value:
NAME "\0" PARAMS "\0"

◆ MODULE_PASS_WITH_PARAMS [5/35]

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

◆ MODULE_PASS_WITH_PARAMS [6/35]

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

◆ MODULE_PASS_WITH_PARAMS [7/35]

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

◆ MODULE_PASS_WITH_PARAMS [8/35]

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

◆ MODULE_PASS_WITH_PARAMS [9/35]

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

◆ MODULE_PASS_WITH_PARAMS [10/35]

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

◆ MODULE_PASS_WITH_PARAMS [11/35]

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

◆ MODULE_PASS_WITH_PARAMS [12/35]

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

◆ MODULE_PASS_WITH_PARAMS [13/35]

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

◆ MODULE_PASS_WITH_PARAMS [14/35]

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

◆ MODULE_PASS_WITH_PARAMS [15/35]

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

◆ MODULE_PASS_WITH_PARAMS [16/35]

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

◆ MODULE_PASS_WITH_PARAMS [17/35]

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

◆ MODULE_PASS_WITH_PARAMS [18/35]

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

◆ MODULE_PASS_WITH_PARAMS [19/35]

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

◆ MODULE_PASS_WITH_PARAMS [20/35]

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

◆ MODULE_PASS_WITH_PARAMS [21/35]

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

◆ MODULE_PASS_WITH_PARAMS [22/35]

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

◆ MODULE_PASS_WITH_PARAMS [23/35]

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

◆ MODULE_PASS_WITH_PARAMS [24/35]

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

◆ MODULE_PASS_WITH_PARAMS [25/35]

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

◆ MODULE_PASS_WITH_PARAMS [26/35]

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

◆ MODULE_PASS_WITH_PARAMS [27/35]

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

◆ MODULE_PASS_WITH_PARAMS [28/35]

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

◆ MODULE_PASS_WITH_PARAMS [29/35]

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

◆ MODULE_PASS_WITH_PARAMS [30/35]

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

◆ MODULE_PASS_WITH_PARAMS [31/35]

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

◆ MODULE_PASS_WITH_PARAMS [32/35]

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

◆ MODULE_PASS_WITH_PARAMS [33/35]

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

◆ MODULE_PASS_WITH_PARAMS [34/35]

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

◆ MODULE_PASS_WITH_PARAMS [35/35]

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

Function Documentation

◆ callbacksAcceptPassName()

template<typename PassManagerT, typename CallbacksT>
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 1855 of file PassBuilder.cpp.

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

◆ isCGSCCPassName()

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

Definition at line 1894 of file PassBuilder.cpp.

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

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

◆ isFunctionPassName()

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

Definition at line 1921 of file PassBuilder.cpp.

References llvm::CallingConv::C, and callbacksAcceptPassName().

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

◆ isLoopNestPassName()

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

Definition at line 1967 of file PassBuilder.cpp.

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

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

◆ isLoopPassName()

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

Definition at line 1985 of file PassBuilder.cpp.

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

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

◆ isMachineFunctionPassName()

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

Definition at line 1944 of file PassBuilder.cpp.

References callbacksAcceptPassName().

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

◆ isModulePassName()

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

Definition at line 1866 of file PassBuilder.cpp.

References llvm::CallingConv::C, and callbacksAcceptPassName().

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

◆ parseDevirtPassName()

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

Definition at line 798 of file PassBuilder.cpp.

References llvm::Count.

Referenced by isCGSCCPassName().

◆ parseFunctionPipelineName()

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

Definition at line 777 of file PassBuilder.cpp.

◆ parseOptLevel()

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

Definition at line 551 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, and llvm::reportFatalUsageError().

Referenced by parseOptLevelParam().

◆ parseOptLevelParam()

Expected< OptimizationLevel > parseOptLevelParam ( StringRef S)
static

Definition at line 566 of file PassBuilder.cpp.

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

◆ printPassNameList()

LLVM_ATTRIBUTE_NOINLINE void printPassNameList ( StringTable PassNames,
raw_ostream & OS )
static

Definition at line 2861 of file PassBuilder.cpp.

References llvm::drop_begin(), LLVM_ATTRIBUTE_NOINLINE, and PassName.

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

◆ printPassNameListWithParams()

LLVM_ATTRIBUTE_NOINLINE void printPassNameListWithParams ( StringTable PassNames,
raw_ostream & OS )
static

Definition at line 2868 of file PassBuilder.cpp.

References assert(), llvm::StringTable::begin(), llvm::StringTable::end(), and I.

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

◆ setupOptionsForPipelineAlias()

void setupOptionsForPipelineAlias ( PipelineTuningOptions & PTO,
OptimizationLevel L )
static

Definition at line 2065 of file PassBuilder.cpp.

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

Generated on for LLVM by doxygen 1.14.0