LLVM 24.0.0git
PassBuilder.cpp
Go to the documentation of this file.
1//===- Parsing and selection of pass pipelines ----------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file provides the implementation of the PassBuilder based on our
11/// static pass registry as well as related functionality. It also provides
12/// helpers to aid in analyzing, debugging, and testing passes and pass
13/// pipelines.
14///
15//===----------------------------------------------------------------------===//
16
17#include "llvm/Passes/PassBuilder.h"
18#include "llvm/ADT/StringSwitch.h"
19#include "llvm/ADT/StringTable.h"
20#include "llvm/Analysis/AliasAnalysisEvaluator.h"
21#include "llvm/Analysis/AliasSetTracker.h"
22#include "llvm/Analysis/AssumptionCache.h"
23#include "llvm/Analysis/BasicAliasAnalysis.h"
24#include "llvm/Analysis/BlockFrequencyInfo.h"
25#include "llvm/Analysis/BranchProbabilityInfo.h"
26#include "llvm/Analysis/CFGSCCPrinter.h"
27#include "llvm/Analysis/CGSCCPassManager.h"
28#include "llvm/Analysis/CallGraph.h"
29#include "llvm/Analysis/CallPrinter.h"
30#include "llvm/Analysis/CostModel.h"
31#include "llvm/Analysis/CtxProfAnalysis.h"
32#include "llvm/Analysis/CycleAnalysis.h"
33#include "llvm/Analysis/DDG.h"
34#include "llvm/Analysis/DDGPrinter.h"
35#include "llvm/Analysis/DXILMetadataAnalysis.h"
36#include "llvm/Analysis/DXILResource.h"
37#include "llvm/Analysis/Delinearization.h"
38#include "llvm/Analysis/DemandedBits.h"
39#include "llvm/Analysis/DependenceAnalysis.h"
40#include "llvm/Analysis/DomPrinter.h"
41#include "llvm/Analysis/DominanceFrontier.h"
42#include "llvm/Analysis/EphemeralValuesCache.h"
43#include "llvm/Analysis/FunctionPropertiesAnalysis.h"
44#include "llvm/Analysis/GlobalsModRef.h"
45#include "llvm/Analysis/HashRecognize.h"
46#include "llvm/Analysis/IR2Vec.h"
47#include "llvm/Analysis/IVUsers.h"
48#include "llvm/Analysis/InlineAdvisor.h"
49#include "llvm/Analysis/InstCount.h"
50#include "llvm/Analysis/KernelInfo.h"
51#include "llvm/Analysis/LastRunTrackingAnalysis.h"
52#include "llvm/Analysis/LazyCallGraph.h"
53#include "llvm/Analysis/LazyValueInfo.h"
54#include "llvm/Analysis/LibcallLoweringInfo.h"
55#include "llvm/Analysis/Lint.h"
56#include "llvm/Analysis/LoopAccessAnalysis.h"
57#include "llvm/Analysis/LoopCacheAnalysis.h"
58#include "llvm/Analysis/LoopInfo.h"
59#include "llvm/Analysis/LoopNestAnalysis.h"
60#include "llvm/Analysis/MemDerefPrinter.h"
61#include "llvm/Analysis/MemoryDependenceAnalysis.h"
62#include "llvm/Analysis/MemorySSA.h"
63#include "llvm/Analysis/ModuleDebugInfoPrinter.h"
64#include "llvm/Analysis/ModuleSummaryAnalysis.h"
65#include "llvm/Analysis/MustExecute.h"
66#include "llvm/Analysis/ObjCARCAliasAnalysis.h"
67#include "llvm/Analysis/PhiValues.h"
68#include "llvm/Analysis/PostDominators.h"
69#include "llvm/Analysis/ProfileSummaryInfo.h"
70#include "llvm/Analysis/RegionInfo.h"
71#include "llvm/Analysis/RuntimeLibcallInfo.h"
72#include "llvm/Analysis/ScalarEvolution.h"
73#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
74#include "llvm/Analysis/ScalarEvolutionDivision.h"
75#include "llvm/Analysis/ScopedNoAliasAA.h"
76#include "llvm/Analysis/StackLifetime.h"
77#include "llvm/Analysis/StackSafetyAnalysis.h"
78#include "llvm/Analysis/StaticDataProfileInfo.h"
79#include "llvm/Analysis/StructuralHash.h"
80#include "llvm/Analysis/TargetLibraryInfo.h"
81#include "llvm/Analysis/TargetTransformInfo.h"
82#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
83#include "llvm/Analysis/UniformityAnalysis.h"
84#include "llvm/CodeGen/AssignmentTrackingAnalysis.h"
85#include "llvm/CodeGen/AtomicExpand.h"
86#include "llvm/CodeGen/BasicBlockSectionsProfileReader.h"
87#include "llvm/CodeGen/BranchFoldingPass.h"
88#include "llvm/CodeGen/BranchRelaxation.h"
89#include "llvm/CodeGen/BreakFalseDeps.h"
90#include "llvm/CodeGen/CFIFixup.h"
91#include "llvm/CodeGen/CFIInstrInserter.h"
92#include "llvm/CodeGen/CodeGenPrepare.h"
93#include "llvm/CodeGen/ComplexDeinterleavingPass.h"
94#include "llvm/CodeGen/DeadMachineInstructionElim.h"
95#include "llvm/CodeGen/DetectDeadLanes.h"
96#include "llvm/CodeGen/DwarfEHPrepare.h"
97#include "llvm/CodeGen/EHContGuardTargets.h"
98#include "llvm/CodeGen/EarlyIfConversion.h"
99#include "llvm/CodeGen/EdgeBundles.h"
100#include "llvm/CodeGen/ExpandIRInsts.h"
101#include "llvm/CodeGen/ExpandPostRAPseudos.h"
102#include "llvm/CodeGen/ExpandReductions.h"
103#include "llvm/CodeGen/FEntryInserter.h"
104#include "llvm/CodeGen/FinalizeISel.h"
105#include "llvm/CodeGen/FixupStatepointCallerSaved.h"
106#include "llvm/CodeGen/FuncletLayout.h"
107#include "llvm/CodeGen/GCEmptyBasicBlocks.h"
108#include "llvm/CodeGen/GCMetadata.h"
109#include "llvm/CodeGen/GlobalISel/CSEInfo.h"
110#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
111#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
112#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
113#include "llvm/CodeGen/GlobalISel/Legalizer.h"
114#include "llvm/CodeGen/GlobalISel/LoadStoreOpt.h"
115#include "llvm/CodeGen/GlobalISel/Localizer.h"
116#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
117#include "llvm/CodeGen/GlobalMerge.h"
118#include "llvm/CodeGen/GlobalMergeFunctions.h"
119#include "llvm/CodeGen/HardwareLoops.h"
120#include "llvm/CodeGen/ImplicitNullChecks.h"
121#include "llvm/CodeGen/IndirectBrExpand.h"
122#include "llvm/CodeGen/InitUndef.h"
123#include "llvm/CodeGen/InlineAsmPrepare.h"
124#include "llvm/CodeGen/InterleavedAccess.h"
125#include "llvm/CodeGen/InterleavedLoadCombine.h"
126#include "llvm/CodeGen/JMCInstrumenter.h"
127#include "llvm/CodeGen/KCFI.h"
128#include "llvm/CodeGen/LiveDebugValuesPass.h"
129#include "llvm/CodeGen/LiveDebugVariables.h"
130#include "llvm/CodeGen/LiveIntervals.h"
131#include "llvm/CodeGen/LiveRegMatrix.h"
132#include "llvm/CodeGen/LiveStacks.h"
133#include "llvm/CodeGen/LiveVariables.h"
134#include "llvm/CodeGen/LocalStackSlotAllocation.h"
135#include "llvm/CodeGen/LowerEmuTLS.h"
136#include "llvm/CodeGen/MIRPrinter.h"
137#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
138#include "llvm/CodeGen/MachineBlockHashInfo.h"
139#include "llvm/CodeGen/MachineBlockPlacement.h"
140#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
141#include "llvm/CodeGen/MachineCFGPrinter.h"
142#include "llvm/CodeGen/MachineCSE.h"
143#include "llvm/CodeGen/MachineCheckDebugify.h"
144#include "llvm/CodeGen/MachineCombiner.h"
145#include "llvm/CodeGen/MachineCopyPropagation.h"
146#include "llvm/CodeGen/MachineDebugify.h"
147#include "llvm/CodeGen/MachineDominanceFrontier.h"
148#include "llvm/CodeGen/MachineDominators.h"
149#include "llvm/CodeGen/MachineFunctionAnalysis.h"
150#include "llvm/CodeGen/MachineInstrBundle.h"
151#include "llvm/CodeGen/MachineLICM.h"
152#include "llvm/CodeGen/MachineLateInstrsCleanup.h"
153#include "llvm/CodeGen/MachinePassManager.h"
154#include "llvm/CodeGen/MachinePipeliner.h"
155#include "llvm/CodeGen/MachinePostDominators.h"
156#include "llvm/CodeGen/MachineRegionInfo.h"
157#include "llvm/CodeGen/MachineRegisterInfo.h"
158#include "llvm/CodeGen/MachineScheduler.h"
159#include "llvm/CodeGen/MachineSink.h"
160#include "llvm/CodeGen/MachineStripDebug.h"
161#include "llvm/CodeGen/MachineTraceMetrics.h"
162#include "llvm/CodeGen/MachineUniformityAnalysis.h"
163#include "llvm/CodeGen/MachineVerifier.h"
164#include "llvm/CodeGen/OptimizePHIs.h"
165#include "llvm/CodeGen/PEI.h"
166#include "llvm/CodeGen/PHIElimination.h"
167#include "llvm/CodeGen/PatchableFunction.h"
168#include "llvm/CodeGen/PeepholeOptimizer.h"
169#include "llvm/CodeGen/PostRAHazardRecognizer.h"
170#include "llvm/CodeGen/PostRAMachineSink.h"
171#include "llvm/CodeGen/PostRASchedulerList.h"
172#include "llvm/CodeGen/PreISelIntrinsicLowering.h"
173#include "llvm/CodeGen/ProcessImplicitDefs.h"
174#include "llvm/CodeGen/ReachingDefAnalysis.h"
175#include "llvm/CodeGen/RegAllocEvictionAdvisor.h"
176#include "llvm/CodeGen/RegAllocFast.h"
177#include "llvm/CodeGen/RegAllocGreedyPass.h"
178#include "llvm/CodeGen/RegAllocPriorityAdvisor.h"
179#include "llvm/CodeGen/RegUsageInfoCollector.h"
180#include "llvm/CodeGen/RegUsageInfoPropagate.h"
181#include "llvm/CodeGen/RegisterClassInfo.h"
182#include "llvm/CodeGen/RegisterCoalescerPass.h"
183#include "llvm/CodeGen/RegisterUsageInfo.h"
184#include "llvm/CodeGen/RemoveLoadsIntoFakeUses.h"
185#include "llvm/CodeGen/RemoveRedundantDebugValues.h"
186#include "llvm/CodeGen/RenameIndependentSubregs.h"
187#include "llvm/CodeGen/ReplaceWithVeclib.h"
188#include "llvm/CodeGen/ResetMachineFunctionPass.h"
189#include "llvm/CodeGen/SafeStack.h"
190#include "llvm/CodeGen/SanitizerBinaryMetadata.h"
191#include "llvm/CodeGen/SelectOptimize.h"
192#include "llvm/CodeGen/ShadowStackGCLowering.h"
193#include "llvm/CodeGen/ShrinkWrap.h"
194#include "llvm/CodeGen/SjLjEHPrepare.h"
195#include "llvm/CodeGen/SlotIndexes.h"
196#include "llvm/CodeGen/SpillPlacement.h"
197#include "llvm/CodeGen/StackColoring.h"
198#include "llvm/CodeGen/StackFrameLayoutAnalysisPass.h"
199#include "llvm/CodeGen/StackProtector.h"
200#include "llvm/CodeGen/StackSlotColoring.h"
201#include "llvm/CodeGen/StaticDataAnnotator.h"
202#include "llvm/CodeGen/StaticDataSplitter.h"
203#include "llvm/CodeGen/TailDuplication.h"
204#include "llvm/CodeGen/TargetPassConfig.h"
205#include "llvm/CodeGen/TwoAddressInstructionPass.h"
206#include "llvm/CodeGen/TypePromotion.h"
207#include "llvm/CodeGen/UnreachableBlockElim.h"
208#include "llvm/CodeGen/VirtRegMap.h"
209#include "llvm/CodeGen/WasmEHPrepare.h"
210#include "llvm/CodeGen/WinEHPrepare.h"
211#include "llvm/CodeGen/XRayInstrumentation.h"
212#include "llvm/IR/DebugInfo.h"
213#include "llvm/IR/Dominators.h"
214#include "llvm/IR/PassManager.h"
215#include "llvm/IR/SafepointIRVerifier.h"
216#include "llvm/IR/Verifier.h"
217#include "llvm/IRPrinter/IRPrintingPasses.h"
218#include "llvm/Passes/OptimizationLevel.h"
219#include "llvm/Passes/TriggerCrashPasses.h"
220#include "llvm/Support/CodeGen.h"
221#include "llvm/Support/CommandLine.h"
222#include "llvm/Support/Debug.h"
223#include "llvm/Support/Error.h"
224#include "llvm/Support/ErrorHandling.h"
225#include "llvm/Support/FormatAdapters.h"
226#include "llvm/Support/FormatVariadic.h"
227#include "llvm/Support/Regex.h"
228#include "llvm/Target/TargetMachine.h"
229#include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
230#include "llvm/Transforms/CFGuard.h"
231#include "llvm/Transforms/Coroutines/CoroAnnotationElide.h"
232#include "llvm/Transforms/Coroutines/CoroCleanup.h"
233#include "llvm/Transforms/Coroutines/CoroConditionalWrapper.h"
234#include "llvm/Transforms/Coroutines/CoroEarly.h"
235#include "llvm/Transforms/Coroutines/CoroElide.h"
236#include "llvm/Transforms/Coroutines/CoroSplit.h"
237#include "llvm/Transforms/HipStdPar/HipStdPar.h"
238#include "llvm/Transforms/IPO/AlwaysInliner.h"
239#include "llvm/Transforms/IPO/Annotation2Metadata.h"
240#include "llvm/Transforms/IPO/ArgumentPromotion.h"
241#include "llvm/Transforms/IPO/Attributor.h"
242#include "llvm/Transforms/IPO/BlockExtractor.h"
243#include "llvm/Transforms/IPO/CalledValuePropagation.h"
244#include "llvm/Transforms/IPO/ConstantMerge.h"
245#include "llvm/Transforms/IPO/CrossDSOCFI.h"
246#include "llvm/Transforms/IPO/DeadArgumentElimination.h"
247#include "llvm/Transforms/IPO/ElimAvailExtern.h"
248#include "llvm/Transforms/IPO/EmbedBitcodePass.h"
249#include "llvm/Transforms/IPO/ExpandVariadics.h"
250#include "llvm/Transforms/IPO/FatLTOCleanup.h"
251#include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
252#include "llvm/Transforms/IPO/FunctionAttrs.h"
253#include "llvm/Transforms/IPO/FunctionImport.h"
254#include "llvm/Transforms/IPO/GlobalDCE.h"
255#include "llvm/Transforms/IPO/GlobalOpt.h"
256#include "llvm/Transforms/IPO/GlobalSplit.h"
257#include "llvm/Transforms/IPO/HotColdSplitting.h"
258#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
259#include "llvm/Transforms/IPO/Instrumentor.h"
260#include "llvm/Transforms/IPO/Internalize.h"
261#include "llvm/Transforms/IPO/LowerTypeTests.h"
262#include "llvm/Transforms/IPO/MemProfContextDisambiguation.h"
263#include "llvm/Transforms/IPO/MergeFunctions.h"
264#include "llvm/Transforms/IPO/OpenMPOpt.h"
265#include "llvm/Transforms/IPO/PartialInlining.h"
266#include "llvm/Transforms/IPO/SCCP.h"
267#include "llvm/Transforms/IPO/SampleProfile.h"
268#include "llvm/Transforms/IPO/SampleProfileProbe.h"
269#include "llvm/Transforms/IPO/StripDeadPrototypes.h"
270#include "llvm/Transforms/IPO/StripSymbols.h"
271#include "llvm/Transforms/IPO/WholeProgramDevirt.h"
272#include "llvm/Transforms/InstCombine/InstCombine.h"
273#include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
274#include "llvm/Transforms/Instrumentation/AllocToken.h"
275#include "llvm/Transforms/Instrumentation/BoundsChecking.h"
276#include "llvm/Transforms/Instrumentation/CGProfile.h"
277#include "llvm/Transforms/Instrumentation/ControlHeightReduction.h"
278#include "llvm/Transforms/Instrumentation/CopyProf.h"
279#include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
280#include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
281#include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
282#include "llvm/Transforms/Instrumentation/InstrProfiling.h"
283#include "llvm/Transforms/Instrumentation/KCFI.h"
284#include "llvm/Transforms/Instrumentation/LowerAllowCheckPass.h"
285#include "llvm/Transforms/Instrumentation/MemProfInstrumentation.h"
286#include "llvm/Transforms/Instrumentation/MemProfUse.h"
287#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
288#include "llvm/Transforms/Instrumentation/NumericalStabilitySanitizer.h"
289#include "llvm/Transforms/Instrumentation/PGOCtxProfFlattening.h"
290#include "llvm/Transforms/Instrumentation/PGOCtxProfLowering.h"
291#include "llvm/Transforms/Instrumentation/PGOForceFunctionAttrs.h"
292#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
293#include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
294#include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
295#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
296#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
297#include "llvm/Transforms/Instrumentation/TypeSanitizer.h"
298#include "llvm/Transforms/ObjCARC.h"
299#include "llvm/Transforms/Scalar/ADCE.h"
300#include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
301#include "llvm/Transforms/Scalar/AnnotationRemarks.h"
302#include "llvm/Transforms/Scalar/BDCE.h"
303#include "llvm/Transforms/Scalar/CallSiteSplitting.h"
304#include "llvm/Transforms/Scalar/ConstantHoisting.h"
305#include "llvm/Transforms/Scalar/ConstraintElimination.h"
306#include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
307#include "llvm/Transforms/Scalar/DCE.h"
308#include "llvm/Transforms/Scalar/DFAJumpThreading.h"
309#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
310#include "llvm/Transforms/Scalar/DivRemPairs.h"
311#include "llvm/Transforms/Scalar/DropUnnecessaryAssumes.h"
312#include "llvm/Transforms/Scalar/EarlyCSE.h"
313#include "llvm/Transforms/Scalar/ExpandMemCmp.h"
314#include "llvm/Transforms/Scalar/FlattenCFG.h"
315#include "llvm/Transforms/Scalar/Float2Int.h"
316#include "llvm/Transforms/Scalar/GVN.h"
317#include "llvm/Transforms/Scalar/GVNHoist.h"
318#include "llvm/Transforms/Scalar/GVNSink.h"
319#include "llvm/Transforms/Scalar/GuardWidening.h"
320#include "llvm/Transforms/Scalar/IVUsersPrinter.h"
321#include "llvm/Transforms/Scalar/IndVarSimplify.h"
322#include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h"
323#include "llvm/Transforms/Scalar/InferAddressSpaces.h"
324#include "llvm/Transforms/Scalar/InferAlignment.h"
325#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
326#include "llvm/Transforms/Scalar/JumpTableToSwitch.h"
327#include "llvm/Transforms/Scalar/JumpThreading.h"
328#include "llvm/Transforms/Scalar/LICM.h"
329#include "llvm/Transforms/Scalar/LogicalSROA.h"
330#include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h"
331#include "llvm/Transforms/Scalar/LoopBoundSplit.h"
332#include "llvm/Transforms/Scalar/LoopDataPrefetch.h"
333#include "llvm/Transforms/Scalar/LoopDeletion.h"
334#include "llvm/Transforms/Scalar/LoopDistribute.h"
335#include "llvm/Transforms/Scalar/LoopFlatten.h"
336#include "llvm/Transforms/Scalar/LoopFuse.h"
337#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
338#include "llvm/Transforms/Scalar/LoopInstSimplify.h"
339#include "llvm/Transforms/Scalar/LoopInterchange.h"
340#include "llvm/Transforms/Scalar/LoopLoadElimination.h"
341#include "llvm/Transforms/Scalar/LoopPassManager.h"
342#include "llvm/Transforms/Scalar/LoopPredication.h"
343#include "llvm/Transforms/Scalar/LoopRotation.h"
344#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
345#include "llvm/Transforms/Scalar/LoopSink.h"
346#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
347#include "llvm/Transforms/Scalar/LoopTermFold.h"
348#include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
349#include "llvm/Transforms/Scalar/LoopUnrollPass.h"
350#include "llvm/Transforms/Scalar/LoopVersioningLICM.h"
351#include "llvm/Transforms/Scalar/LowerAtomicPass.h"
352#include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
353#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
354#include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
355#include "llvm/Transforms/Scalar/LowerMatrixIntrinsics.h"
356#include "llvm/Transforms/Scalar/LowerWidenableCondition.h"
357#include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
358#include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
359#include "llvm/Transforms/Scalar/MergeICmps.h"
360#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
361#include "llvm/Transforms/Scalar/NaryReassociate.h"
362#include "llvm/Transforms/Scalar/NewGVN.h"
363#include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
364#include "llvm/Transforms/Scalar/PlaceSafepoints.h"
365#include "llvm/Transforms/Scalar/Reassociate.h"
366#include "llvm/Transforms/Scalar/Reg2Mem.h"
367#include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
368#include "llvm/Transforms/Scalar/SCCP.h"
369#include "llvm/Transforms/Scalar/SROA.h"
370#include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h"
371#include "llvm/Transforms/Scalar/Scalarizer.h"
372#include "llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h"
373#include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
374#include "llvm/Transforms/Scalar/SimplifyCFG.h"
375#include "llvm/Transforms/Scalar/Sink.h"
376#include "llvm/Transforms/Scalar/SpeculativeExecution.h"
377#include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
378#include "llvm/Transforms/Scalar/StructurizeCFG.h"
379#include "llvm/Transforms/Scalar/TailRecursionElimination.h"
380#include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
381#include "llvm/Transforms/Utils/AddDiscriminators.h"
382#include "llvm/Transforms/Utils/AssignGUID.h"
383#include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
384#include "llvm/Transforms/Utils/BreakCriticalEdges.h"
385#include "llvm/Transforms/Utils/CanonicalizeAliases.h"
386#include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h"
387#include "llvm/Transforms/Utils/CountVisits.h"
388#include "llvm/Transforms/Utils/DXILUpgrade.h"
389#include "llvm/Transforms/Utils/Debugify.h"
390#include "llvm/Transforms/Utils/DeclareRuntimeLibcalls.h"
391#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
392#include "llvm/Transforms/Utils/FixIrreducible.h"
393#include "llvm/Transforms/Utils/HelloWorld.h"
394#include "llvm/Transforms/Utils/IRNormalizer.h"
395#include "llvm/Transforms/Utils/InjectTLIMappings.h"
396#include "llvm/Transforms/Utils/InstructionNamer.h"
397#include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
398#include "llvm/Transforms/Utils/LoopSimplify.h"
399#include "llvm/Transforms/Utils/LoopVersioning.h"
400#include "llvm/Transforms/Utils/LowerCommentStringPass.h"
401#include "llvm/Transforms/Utils/LowerGlobalDtors.h"
402#include "llvm/Transforms/Utils/LowerIFunc.h"
403#include "llvm/Transforms/Utils/LowerInvoke.h"
404#include "llvm/Transforms/Utils/LowerSwitch.h"
405#include "llvm/Transforms/Utils/Mem2Reg.h"
406#include "llvm/Transforms/Utils/MetaRenamer.h"
407#include "llvm/Transforms/Utils/MoveAutoInit.h"
408#include "llvm/Transforms/Utils/NameAnonGlobals.h"
409#include "llvm/Transforms/Utils/PredicateInfo.h"
410#include "llvm/Transforms/Utils/ProfileVerify.h"
411#include "llvm/Transforms/Utils/RelLookupTableConverter.h"
412#include "llvm/Transforms/Utils/StripConvergenceIntrinsics.h"
413#include "llvm/Transforms/Utils/StripGCRelocates.h"
414#include "llvm/Transforms/Utils/StripNonLineTableDebugInfo.h"
415#include "llvm/Transforms/Utils/SymbolRewriter.h"
416#include "llvm/Transforms/Utils/UnifyLoopExits.h"
417#include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h"
418#include "llvm/Transforms/Vectorize/LoopIdiomVectorize.h"
419#include "llvm/Transforms/Vectorize/LoopVectorize.h"
420#include "llvm/Transforms/Vectorize/SLPVectorizer.h"
421#include "llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h"
422#include "llvm/Transforms/Vectorize/VectorCombine.h"
423#include <optional>
424
425using namespace llvm;
426
427cl::opt<std::optional<PrintPipelinePassesFormat>, false,
428 PrintPipelinePassesFormatParser>
429 llvm::PrintPipelinePasses(
430 "print-pipeline-passes", cl::ValueOptional,
431 cl::desc(
432 "Print string describing the pipeline (best-effort only).\n"
433 " - =text\tPrint a '-passes' compatible string describing the "
434 "pipeline.\n"
435 " - =tree\tPrint a tree-like structure describing the pipeline."));
436
437bool PrintPipelinePassesFormatParser::parse(
438 cl::Option &O, StringRef ArgName, StringRef Arg,
439 std::optional<PrintPipelinePassesFormat> &Val) {
440 std::optional<PrintPipelinePassesFormat> Format =
441 StringSwitch<std::optional<PrintPipelinePassesFormat>>(Arg)
442 .Case("text", PrintPipelinePassesFormat::Text)
443 .Case("", PrintPipelinePassesFormat::Text)
444 .Case("tree", PrintPipelinePassesFormat::Tree)
445 .Default(std::nullopt);
446
447 if (!Format)
448 return O.error(formatv(
449 "'{0}' value invalid for print-pipeline-passes argument!", Arg));
450
451 Val = Format;
452 return false;
453}
454
455void llvm::printFormattedPipelinePasses(raw_ostream &OS, StringRef Pipeline,
456 PrintPipelinePassesFormat Format) {
457 switch (Format) {
458 case PrintPipelinePassesFormat::Text:
459 OS << Pipeline;
460 break;
461 case PrintPipelinePassesFormat::Tree: {
462 int IndentLevel = 0;
463 for (char C : Pipeline) {
464 switch (C) {
465 case '(':
466 ++IndentLevel;
467 OS << formatv("\n{0}", fmt_repeat(" ", IndentLevel));
468 break;
469 case ')':
470 --IndentLevel;
471 assert(IndentLevel >= 0 && "Invalid pipeline string!");
472 break;
473 case ',':
474 OS << formatv("\n{0}", fmt_repeat(" ", IndentLevel));
475 break;
476 default:
477 OS << C;
478 }
479 }
480 break;
481 }
482 }
483}
484
485AnalysisKey NoOpModuleAnalysis::Key;
486AnalysisKey NoOpCGSCCAnalysis::Key;
487AnalysisKey NoOpFunctionAnalysis::Key;
488AnalysisKey NoOpLoopAnalysis::Key;
489
490namespace {
491
492bool applyMIRDebugify(DIBuilder &DIB, Function &F, ModuleAnalysisManager &AM) {
493 FunctionAnalysisManager &FAM =
494 AM.getResult<FunctionAnalysisManagerModuleProxy>(*F.getParent())
495 .getManager();
496
497 return applyDebugifyMetadataToMachineFunction(
498 DIB, F, [&](Function &Func) -> MachineFunction * {
499 MachineFunctionAnalysis::Result *MFA =
500 FAM.getCachedResult<MachineFunctionAnalysis>(Func);
501 return MFA ? &MFA->getMF() : nullptr;
502 });
503}
504
505// A pass for testing message reporting of -verify-each failures.
506// DO NOT USE THIS EXCEPT FOR TESTING!
507class TriggerVerifierErrorPass
508 : public OptionalPassInfoMixin<TriggerVerifierErrorPass> {
509public:
510 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
511 // Intentionally break the Module by creating an alias without setting the
512 // aliasee.
513 auto *PtrTy = PointerType::getUnqual(M.getContext());
514 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
515 GlobalValue::LinkageTypes::InternalLinkage,
516 "__bad_alias", nullptr, &M);
517 return PreservedAnalyses::none();
518 }
519
520 PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
521 // Intentionally break the Function by inserting a terminator
522 // instruction in the middle of a basic block.
523 BasicBlock &BB = F.getEntryBlock();
524 new UnreachableInst(F.getContext(), BB.getTerminator()->getIterator());
525 return PreservedAnalyses::none();
526 }
527
528 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
529 // Intentionally create a virtual register and set NoVRegs property.
530 auto &MRI = MF.getRegInfo();
531 MRI.createGenericVirtualRegister(LLT::scalar(8));
532 MF.getProperties().setNoVRegs();
533 return PreservedAnalyses::all();
534 }
535
536 static StringRef name() { return "TriggerVerifierErrorPass"; }
537};
538
539// A pass requires all MachineFunctionProperties.
540// DO NOT USE THIS EXCEPT FOR TESTING!
541class RequireAllMachineFunctionPropertiesPass
542 : public OptionalPassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
543public:
544 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
545 MFPropsModifier _(*this, MF);
546 return PreservedAnalyses::none();
547 }
548
549 static MachineFunctionProperties getRequiredProperties() {
550 return MachineFunctionProperties()
551 .setFailedISel()
552 .setFailsVerification()
553 .setIsSSA()
554 .setLegalized()
555 .setNoPHIs()
556 .setNoVRegs()
557 .setRegBankSelected()
558 .setSelected()
559 .setTiedOpsRewritten()
560 .setTracksDebugUserValues()
561 .setTracksLiveness();
562 }
563 static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
564};
565
566} // namespace
567
568static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
569 if (S == "Os" || S == "Oz")
570 reportFatalUsageError(
571 Twine("The optimization level \"") + S +
572 "\" is no longer supported. Use O2 in conjunction with the " +
573 (S == "Os" ? "optsize" : "minsize") + " attribute instead.");
574
575 return StringSwitch<std::optional<OptimizationLevel>>(S)
576 .Case("O0", OptimizationLevel::O0)
577 .Case("O1", OptimizationLevel::O1)
578 .Case("O2", OptimizationLevel::O2)
579 .Case("O3", OptimizationLevel::O3)
580 .Default(std::nullopt);
581}
582
583static Expected<OptimizationLevel> parseOptLevelParam(StringRef S) {
584 std::optional<OptimizationLevel> OptLevel = parseOptLevel(S);
585 if (OptLevel)
586 return *OptLevel;
587 return make_error<StringError>(
588 formatv("invalid optimization level '{}'", S).str(),
589 inconvertibleErrorCode());
590}
591
592PassBuilder::PassBuilder(TargetMachine *TM, PipelineTuningOptions PTO,
593 std::optional<PGOOptions> PGOOpt,
594 PassInstrumentationCallbacks *PIC,
595 IntrusiveRefCntPtr<vfs::FileSystem> FS)
596 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC), FS(std::move(FS)) {
597 if (TM)
598 TM->registerPassBuilderCallbacks(*this);
599 if (PIC) {
600 PIC->registerClassToPassNameCallback([this, PIC]() {
601 // MSVC requires this to be captured if it's used inside decltype.
602 // Other compilers consider it an unused lambda capture.
603 (void)this;
604#define MODULE_PASS(NAME, CREATE_PASS) \
605 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
606#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
607 PIC->addClassToPassName(CLASS, NAME);
608#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
609 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
610#define FUNCTION_PASS(NAME, CREATE_PASS) \
611 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
612#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
613 PIC->addClassToPassName(CLASS, NAME);
614#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
615 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
616#define LOOPNEST_PASS(NAME, CREATE_PASS) \
617 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
618#define LOOP_PASS(NAME, CREATE_PASS) \
619 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
620#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
621 PIC->addClassToPassName(CLASS, NAME);
622#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
623 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
624#define CGSCC_PASS(NAME, CREATE_PASS) \
625 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
626#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
627 PIC->addClassToPassName(CLASS, NAME);
628#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
629 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
630#include "PassRegistry.def"
631
632#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
633 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
634#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
635 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
636#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
637 PARAMS) \
638 PIC->addClassToPassName(CLASS, NAME);
639#include "llvm/Passes/MachinePassRegistry.def"
640 });
641 }
642
643 // Module-level callbacks without LTO phase
644 registerPipelineParsingCallback(
645 [this](StringRef Name, ModulePassManager &PM,
646 ArrayRef<PassBuilder::PipelineElement>) {
647#define MODULE_CALLBACK(NAME, INVOKE) \
648 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
649 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
650 if (!L) { \
651 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
652 return false; \
653 } \
654 INVOKE(PM, L.get()); \
655 return true; \
656 }
657#include "PassRegistry.def"
658 return false;
659 });
660
661 // Module-level callbacks with LTO phase (use Phase::None for string API)
662 registerPipelineParsingCallback(
663 [this](StringRef Name, ModulePassManager &PM,
664 ArrayRef<PassBuilder::PipelineElement>) {
665#define MODULE_LTO_CALLBACK(NAME, INVOKE) \
666 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
667 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
668 if (!L) { \
669 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
670 return false; \
671 } \
672 INVOKE(PM, L.get(), ThinOrFullLTOPhase::None); \
673 return true; \
674 }
675#include "PassRegistry.def"
676 return false;
677 });
678
679 // Function-level callbacks
680 registerPipelineParsingCallback(
681 [this](StringRef Name, FunctionPassManager &PM,
682 ArrayRef<PassBuilder::PipelineElement>) {
683#define FUNCTION_CALLBACK(NAME, INVOKE) \
684 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
685 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
686 if (!L) { \
687 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
688 return false; \
689 } \
690 INVOKE(PM, L.get()); \
691 return true; \
692 }
693#include "PassRegistry.def"
694 return false;
695 });
696
697 // CGSCC-level callbacks
698 registerPipelineParsingCallback(
699 [this](StringRef Name, CGSCCPassManager &PM,
700 ArrayRef<PassBuilder::PipelineElement>) {
701#define CGSCC_CALLBACK(NAME, INVOKE) \
702 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
703 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
704 if (!L) { \
705 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
706 return false; \
707 } \
708 INVOKE(PM, L.get()); \
709 return true; \
710 }
711#include "PassRegistry.def"
712 return false;
713 });
714
715 // Loop-level callbacks
716 registerPipelineParsingCallback(
717 [this](StringRef Name, LoopPassManager &PM,
718 ArrayRef<PassBuilder::PipelineElement>) {
719#define LOOP_CALLBACK(NAME, INVOKE) \
720 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
721 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
722 if (!L) { \
723 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
724 return false; \
725 } \
726 INVOKE(PM, L.get()); \
727 return true; \
728 }
729#include "PassRegistry.def"
730 return false;
731 });
732}
733
734void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
735#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
736 MAM.registerPass([&] { return CREATE_PASS; });
737#include "PassRegistry.def"
738
739 for (auto &C : ModuleAnalysisRegistrationCallbacks)
740 C(MAM);
741}
742
743void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) {
744#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
745 CGAM.registerPass([&] { return CREATE_PASS; });
746#include "PassRegistry.def"
747
748 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
749 C(CGAM);
750}
751
752void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
753 // We almost always want the default alias analysis pipeline.
754 // If a user wants a different one, they can register their own before calling
755 // registerFunctionAnalyses().
756 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
757
758#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
759 if constexpr (std::is_constructible_v< \
760 std::remove_reference_t<decltype(CREATE_PASS)>, \
761 const TargetMachine &>) { \
762 if (TM) \
763 FAM.registerPass([&] { return CREATE_PASS; }); \
764 } else { \
765 FAM.registerPass([&] { return CREATE_PASS; }); \
766 }
767#include "PassRegistry.def"
768
769 for (auto &C : FunctionAnalysisRegistrationCallbacks)
770 C(FAM);
771}
772
773void PassBuilder::registerMachineFunctionAnalyses(
774 MachineFunctionAnalysisManager &MFAM) {
775
776#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
777 MFAM.registerPass([&] { return CREATE_PASS; });
778#include "llvm/Passes/MachinePassRegistry.def"
779
780 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
781 C(MFAM);
782}
783
784void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
785#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
786 LAM.registerPass([&] { return CREATE_PASS; });
787#include "PassRegistry.def"
788
789 for (auto &C : LoopAnalysisRegistrationCallbacks)
790 C(LAM);
791}
792
793static std::optional<std::pair<bool, bool>>
794parseFunctionPipelineName(StringRef Name) {
795 std::pair<bool, bool> Params;
796 if (!Name.consume_front("function"))
797 return std::nullopt;
798 if (Name.empty())
799 return Params;
800 if (!Name.consume_front("<") || !Name.consume_back(">"))
801 return std::nullopt;
802 while (!Name.empty()) {
803 auto [Front, Back] = Name.split(';');
804 Name = Back;
805 if (Front == "eager-inv")
806 Params.first = true;
807 else if (Front == "no-rerun")
808 Params.second = true;
809 else
810 return std::nullopt;
811 }
812 return Params;
813}
814
815static std::optional<int> parseDevirtPassName(StringRef Name) {
816 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
817 return std::nullopt;
818 int Count;
819 if (Name.getAsInteger(0, Count) || Count < 0)
820 return std::nullopt;
821 return Count;
822}
823
824Expected<bool> PassBuilder::parseSinglePassOption(StringRef Params,
825 StringRef OptionName,
826 StringRef PassName) {
827 bool Result = false;
828 while (!Params.empty()) {
829 StringRef ParamName;
830 std::tie(ParamName, Params) = Params.split(';');
831
832 if (ParamName == OptionName) {
833 Result = true;
834 } else {
835 return make_error<StringError>(
836 formatv("invalid {} pass parameter '{}'", PassName, ParamName).str(),
837 inconvertibleErrorCode());
838 }
839 }
840 return Result;
841}
842
843namespace {
844
845/// Parser of parameters for HardwareLoops pass.
846Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
847 HardwareLoopOptions HardwareLoopOpts;
848
849 while (!Params.empty()) {
850 StringRef ParamName;
851 std::tie(ParamName, Params) = Params.split(';');
852 if (ParamName.consume_front("hardware-loop-decrement=")) {
853 int Count;
854 if (ParamName.getAsInteger(0, Count))
855 return make_error<StringError>(
856 formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
857 inconvertibleErrorCode());
858 HardwareLoopOpts.setDecrement(Count);
859 continue;
860 }
861 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
862 int Count;
863 if (ParamName.getAsInteger(0, Count))
864 return make_error<StringError>(
865 formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
866 inconvertibleErrorCode());
867 HardwareLoopOpts.setCounterBitwidth(Count);
868 continue;
869 }
870 if (ParamName == "force-hardware-loops") {
871 HardwareLoopOpts.setForce(true);
872 } else if (ParamName == "force-hardware-loop-phi") {
873 HardwareLoopOpts.setForcePhi(true);
874 } else if (ParamName == "force-nested-hardware-loop") {
875 HardwareLoopOpts.setForceNested(true);
876 } else if (ParamName == "force-hardware-loop-guard") {
877 HardwareLoopOpts.setForceGuard(true);
878 } else {
879 return make_error<StringError>(
880 formatv("invalid HardwarePass parameter '{}'", ParamName).str(),
881 inconvertibleErrorCode());
882 }
883 }
884 return HardwareLoopOpts;
885}
886
887/// Parser of parameters for Lint pass.
888Expected<bool> parseLintOptions(StringRef Params) {
889 return PassBuilder::parseSinglePassOption(Params, "abort-on-error",
890 "LintPass");
891}
892
893/// Parser of parameters for FunctionPropertiesStatistics pass.
894Expected<bool> parseFunctionPropertiesStatisticsOptions(StringRef Params) {
895 return PassBuilder::parseSinglePassOption(Params, "pre-opt",
896 "FunctionPropertiesStatisticsPass");
897}
898
899/// Parser of parameters for InstCount pass.
900Expected<bool> parseInstCountOptions(StringRef Params) {
901 return PassBuilder::parseSinglePassOption(Params, "pre-opt", "InstCountPass");
902}
903
904Expected<bool> parseInferAddressSpacesPassOptions(StringRef Params) {
905 return PassBuilder::parseSinglePassOption(
906 Params, "assume-default-is-flat-addrspace", "InferAddressSpacesPass");
907}
908
909/// Parser of parameters for LoopUnroll pass.
910Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
911 LoopUnrollOptions UnrollOpts;
912 while (!Params.empty()) {
913 StringRef ParamName;
914 std::tie(ParamName, Params) = Params.split(';');
915 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
916 if (OptLevel) {
917 UnrollOpts.setOptLevel(static_cast<int>(*OptLevel));
918 continue;
919 }
920 if (ParamName.consume_front("full-unroll-max=")) {
921 int Count;
922 if (ParamName.getAsInteger(0, Count))
923 return make_error<StringError>(
924 formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
925 inconvertibleErrorCode());
926 UnrollOpts.setFullUnrollMaxCount(Count);
927 continue;
928 }
929
930 bool Enable = !ParamName.consume_front("no-");
931 if (ParamName == "partial") {
932 UnrollOpts.setPartial(Enable);
933 } else if (ParamName == "peeling") {
934 UnrollOpts.setPeeling(Enable);
935 } else if (ParamName == "profile-peeling") {
936 UnrollOpts.setProfileBasedPeeling(Enable);
937 } else if (ParamName == "runtime") {
938 UnrollOpts.setRuntime(Enable);
939 } else if (ParamName == "upperbound") {
940 UnrollOpts.setUpperBound(Enable);
941 } else if (ParamName == "prepare-for-lto") {
942 UnrollOpts.setPrepareForLTO(Enable);
943 } else {
944 return make_error<StringError>(
945 formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
946 inconvertibleErrorCode());
947 }
948 }
949 return UnrollOpts;
950}
951
952Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
953 return PassBuilder::parseSinglePassOption(
954 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
955}
956
957Expected<bool> parseCGProfilePassOptions(StringRef Params) {
958 return PassBuilder::parseSinglePassOption(Params, "in-lto-post-link",
959 "CGProfile");
960}
961
962Expected<bool> parseInlinerPassOptions(StringRef Params) {
963 return PassBuilder::parseSinglePassOption(Params, "only-mandatory",
964 "InlinerPass");
965}
966
967Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
968 return PassBuilder::parseSinglePassOption(Params, "reuse-storage",
969 "CoroSplitPass");
970}
971
972Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
973 return PassBuilder::parseSinglePassOption(
974 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
975}
976
977Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
978 return PassBuilder::parseSinglePassOption(Params, "memssa", "EarlyCSE");
979}
980
981Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
982 return PassBuilder::parseSinglePassOption(Params, "post-inline",
983 "EntryExitInstrumenter");
984}
985
986Expected<bool> parseDropUnnecessaryAssumesPassOptions(StringRef Params) {
987 return PassBuilder::parseSinglePassOption(Params, "drop-deref",
988 "DropUnnecessaryAssumes");
989}
990
991Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
992 return PassBuilder::parseSinglePassOption(Params, "minimal",
993 "LowerMatrixIntrinsics");
994}
995
996Expected<IRNormalizerOptions> parseIRNormalizerPassOptions(StringRef Params) {
997 IRNormalizerOptions Result;
998 while (!Params.empty()) {
999 StringRef ParamName;
1000 std::tie(ParamName, Params) = Params.split(';');
1001
1002 bool Enable = !ParamName.consume_front("no-");
1003 if (ParamName == "preserve-order")
1004 Result.PreserveOrder = Enable;
1005 else if (ParamName == "rename-all")
1006 Result.RenameAll = Enable;
1007 else if (ParamName == "fold-all") // FIXME: Name mismatch
1008 Result.FoldPreOutputs = Enable;
1009 else if (ParamName == "reorder-operands")
1010 Result.ReorderOperands = Enable;
1011 else {
1012 return make_error<StringError>(
1013 formatv("invalid normalize pass parameter '{}'", ParamName).str(),
1014 inconvertibleErrorCode());
1015 }
1016 }
1017
1018 return Result;
1019}
1020
1021Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
1022 AddressSanitizerOptions Result;
1023 while (!Params.empty()) {
1024 StringRef ParamName;
1025 std::tie(ParamName, Params) = Params.split(';');
1026
1027 if (ParamName == "kernel") {
1028 Result.CompileKernel = true;
1029 } else if (ParamName == "use-after-scope") {
1030 Result.UseAfterScope = true;
1031 } else {
1032 return make_error<StringError>(
1033 formatv("invalid AddressSanitizer pass parameter '{}'", ParamName)
1034 .str(),
1035 inconvertibleErrorCode());
1036 }
1037 }
1038 return Result;
1039}
1040
1041Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
1042 HWAddressSanitizerOptions Result;
1043 while (!Params.empty()) {
1044 StringRef ParamName;
1045 std::tie(ParamName, Params) = Params.split(';');
1046
1047 if (ParamName == "recover") {
1048 Result.Recover = true;
1049 } else if (ParamName == "kernel") {
1050 Result.CompileKernel = true;
1051 } else {
1052 return make_error<StringError>(
1053 formatv("invalid HWAddressSanitizer pass parameter '{}'", ParamName)
1054 .str(),
1055 inconvertibleErrorCode());
1056 }
1057 }
1058 return Result;
1059}
1060
1061Expected<lowertypetests::DropTestKind>
1062parseDropTypeTestsPassOptions(StringRef Params) {
1063 lowertypetests::DropTestKind Result = lowertypetests::DropTestKind::Assume;
1064 while (!Params.empty()) {
1065 StringRef ParamName;
1066 std::tie(ParamName, Params) = Params.split(';');
1067
1068 if (ParamName == "all") {
1069 Result = lowertypetests::DropTestKind::All;
1070 } else if (ParamName == "assume") {
1071 Result = lowertypetests::DropTestKind::Assume;
1072 } else {
1073 return make_error<StringError>(
1074 formatv("invalid DropTypeTestsPass parameter '{}'", ParamName).str(),
1075 inconvertibleErrorCode());
1076 }
1077 }
1078 return Result;
1079}
1080
1081Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
1082 EmbedBitcodeOptions Result;
1083 while (!Params.empty()) {
1084 StringRef ParamName;
1085 std::tie(ParamName, Params) = Params.split(';');
1086
1087 if (ParamName == "thinlto") {
1088 Result.IsThinLTO = true;
1089 } else if (ParamName == "emit-summary") {
1090 Result.EmitLTOSummary = true;
1091 } else {
1092 return make_error<StringError>(
1093 formatv("invalid EmbedBitcode pass parameter '{}'", ParamName).str(),
1094 inconvertibleErrorCode());
1095 }
1096 }
1097 return Result;
1098}
1099
1100Expected<LowerAllowCheckPass::Options>
1101parseLowerAllowCheckPassOptions(StringRef Params) {
1102 LowerAllowCheckPass::Options Result;
1103 while (!Params.empty()) {
1104 StringRef ParamName;
1105 std::tie(ParamName, Params) = Params.split(';');
1106
1107 // Format is <cutoffs[1,2,3]=70000;cutoffs[5,6,8]=90000>
1108 //
1109 // Parsing allows duplicate indices (last one takes precedence).
1110 // It would technically be in spec to specify
1111 // cutoffs[0]=70000,cutoffs[1]=90000,cutoffs[0]=80000,...
1112 if (ParamName.starts_with("cutoffs[")) {
1113 StringRef IndicesStr;
1114 StringRef CutoffStr;
1115
1116 std::tie(IndicesStr, CutoffStr) = ParamName.split("]=");
1117 // cutoffs[1,2,3
1118 // 70000
1119
1120 int cutoff;
1121 if (CutoffStr.getAsInteger(0, cutoff))
1122 return make_error<StringError>(
1123 formatv("invalid LowerAllowCheck pass cutoffs parameter '{}' ({})",
1124 CutoffStr, Params)
1125 .str(),
1126 inconvertibleErrorCode());
1127
1128 if (!IndicesStr.consume_front("cutoffs[") || IndicesStr == "")
1129 return make_error<StringError>(
1130 formatv("invalid LowerAllowCheck pass index parameter '{}' ({})",
1131 IndicesStr, CutoffStr)
1132 .str(),
1133 inconvertibleErrorCode());
1134
1135 while (IndicesStr != "") {
1136 StringRef firstIndexStr;
1137 std::tie(firstIndexStr, IndicesStr) = IndicesStr.split('|');
1138
1139 unsigned int index;
1140 if (firstIndexStr.getAsInteger(0, index))
1141 return make_error<StringError>(
1142 formatv(
1143 "invalid LowerAllowCheck pass index parameter '{}' ({}) {}",
1144 firstIndexStr, IndicesStr)
1145 .str(),
1146 inconvertibleErrorCode());
1147
1148 // In the common case (sequentially increasing indices), we will issue
1149 // O(n) resize requests. We assume the underlying data structure has
1150 // O(1) runtime for each added element.
1151 if (index >= Result.cutoffs.size())
1152 Result.cutoffs.resize(index + 1, 0);
1153
1154 Result.cutoffs[index] = cutoff;
1155 }
1156 } else if (ParamName.starts_with("runtime_check")) {
1157 StringRef ValueString;
1158 std::tie(std::ignore, ValueString) = ParamName.split("=");
1159 int runtime_check;
1160 if (ValueString.getAsInteger(0, runtime_check)) {
1161 return make_error<StringError>(
1162 formatv("invalid LowerAllowCheck pass runtime_check parameter '{}' "
1163 "({})",
1164 ValueString, Params)
1165 .str(),
1166 inconvertibleErrorCode());
1167 }
1168 Result.runtime_check = runtime_check;
1169 } else {
1170 return make_error<StringError>(
1171 formatv("invalid LowerAllowCheck pass parameter '{}'", ParamName)
1172 .str(),
1173 inconvertibleErrorCode());
1174 }
1175 }
1176
1177 return Result;
1178}
1179
1180Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
1181 MemorySanitizerOptions Result;
1182 while (!Params.empty()) {
1183 StringRef ParamName;
1184 std::tie(ParamName, Params) = Params.split(';');
1185
1186 if (ParamName == "recover") {
1187 Result.Recover = true;
1188 } else if (ParamName == "kernel") {
1189 Result.Kernel = true;
1190 } else if (ParamName.consume_front("track-origins=")) {
1191 if (ParamName.getAsInteger(0, Result.TrackOrigins))
1192 return make_error<StringError>(
1193 formatv("invalid argument to MemorySanitizer pass track-origins "
1194 "parameter: '{}'",
1195 ParamName)
1196 .str(),
1197 inconvertibleErrorCode());
1198 } else if (ParamName == "eager-checks") {
1199 Result.EagerChecks = true;
1200 } else {
1201 return make_error<StringError>(
1202 formatv("invalid MemorySanitizer pass parameter '{}'", ParamName)
1203 .str(),
1204 inconvertibleErrorCode());
1205 }
1206 }
1207 return Result;
1208}
1209
1210Expected<AllocTokenOptions> parseAllocTokenPassOptions(StringRef Params) {
1211 AllocTokenOptions Result;
1212 while (!Params.empty()) {
1213 StringRef ParamName;
1214 std::tie(ParamName, Params) = Params.split(';');
1215
1216 if (ParamName.consume_front("mode=")) {
1217 if (auto Mode = getAllocTokenModeFromString(ParamName))
1218 Result.Mode = *Mode;
1219 else
1220 return make_error<StringError>(
1221 formatv("invalid argument to AllocToken pass mode "
1222 "parameter: '{}'",
1223 ParamName)
1224 .str(),
1225 inconvertibleErrorCode());
1226 } else {
1227 return make_error<StringError>(
1228 formatv("invalid AllocToken pass parameter '{}'", ParamName).str(),
1229 inconvertibleErrorCode());
1230 }
1231 }
1232 return Result;
1233}
1234
1235/// Parser of parameters for SimplifyCFG pass.
1236Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
1237 SimplifyCFGOptions Result;
1238 while (!Params.empty()) {
1239 StringRef ParamName;
1240 std::tie(ParamName, Params) = Params.split(';');
1241
1242 bool Enable = !ParamName.consume_front("no-");
1243 if (ParamName == "speculate-blocks") {
1244 Result.speculateBlocks(Enable);
1245 } else if (ParamName == "simplify-cond-branch") {
1246 Result.setSimplifyCondBranch(Enable);
1247 } else if (ParamName == "forward-switch-cond") {
1248 Result.forwardSwitchCondToPhi(Enable);
1249 } else if (ParamName == "switch-range-to-icmp") {
1250 Result.convertSwitchRangeToICmp(Enable);
1251 } else if (ParamName == "switch-to-arithmetic") {
1252 Result.convertSwitchToArithmetic(Enable);
1253 } else if (ParamName == "switch-to-lookup") {
1254 Result.convertSwitchToLookupTable(Enable);
1255 } else if (ParamName == "keep-loops") {
1256 Result.needCanonicalLoops(Enable);
1257 } else if (ParamName == "hoist-common-insts") {
1258 Result.hoistCommonInsts(Enable);
1259 } else if (ParamName == "hoist-loads-stores-with-cond-faulting") {
1260 Result.hoistLoadsStoresWithCondFaulting(Enable);
1261 } else if (ParamName == "sink-common-insts") {
1262 Result.sinkCommonInsts(Enable);
1263 } else if (ParamName == "speculate-unpredictables") {
1264 Result.speculateUnpredictables(Enable);
1265 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
1266 APInt BonusInstThreshold;
1267 if (ParamName.getAsInteger(0, BonusInstThreshold))
1268 return make_error<StringError>(
1269 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
1270 "parameter: '{}'",
1271 ParamName)
1272 .str(),
1273 inconvertibleErrorCode());
1274 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
1275 } else {
1276 return make_error<StringError>(
1277 formatv("invalid SimplifyCFG pass parameter '{}'", ParamName).str(),
1278 inconvertibleErrorCode());
1279 }
1280 }
1281 return Result;
1282}
1283
1284Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
1285 InstCombineOptions Result;
1286 // When specifying "instcombine" in -passes enable fix-point verification by
1287 // default, as this is what most tests should use.
1288 Result.setVerifyFixpoint(true);
1289 while (!Params.empty()) {
1290 StringRef ParamName;
1291 std::tie(ParamName, Params) = Params.split(';');
1292
1293 bool Enable = !ParamName.consume_front("no-");
1294 if (ParamName == "verify-fixpoint") {
1295 Result.setVerifyFixpoint(Enable);
1296 } else if (Enable && ParamName.consume_front("max-iterations=")) {
1297 APInt MaxIterations;
1298 if (ParamName.getAsInteger(0, MaxIterations))
1299 return make_error<StringError>(
1300 formatv("invalid argument to InstCombine pass max-iterations "
1301 "parameter: '{}'",
1302 ParamName)
1303 .str(),
1304 inconvertibleErrorCode());
1305 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
1306 } else {
1307 return make_error<StringError>(
1308 formatv("invalid InstCombine pass parameter '{}'", ParamName).str(),
1309 inconvertibleErrorCode());
1310 }
1311 }
1312 return Result;
1313}
1314
1315/// Parser of parameters for LoopVectorize pass.
1316Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
1317 LoopVectorizeOptions Opts;
1318 while (!Params.empty()) {
1319 StringRef ParamName;
1320 std::tie(ParamName, Params) = Params.split(';');
1321
1322 bool Enable = !ParamName.consume_front("no-");
1323 if (ParamName == "interleave-forced-only") {
1324 Opts.setInterleaveOnlyWhenForced(Enable);
1325 } else if (ParamName == "vectorize-forced-only") {
1326 Opts.setVectorizeOnlyWhenForced(Enable);
1327 } else {
1328 return make_error<StringError>(
1329 formatv("invalid LoopVectorize parameter '{}'", ParamName).str(),
1330 inconvertibleErrorCode());
1331 }
1332 }
1333 return Opts;
1334}
1335
1336Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
1337 std::pair<bool, bool> Result = {false, true};
1338 while (!Params.empty()) {
1339 StringRef ParamName;
1340 std::tie(ParamName, Params) = Params.split(';');
1341
1342 bool Enable = !ParamName.consume_front("no-");
1343 if (ParamName == "nontrivial") {
1344 Result.first = Enable;
1345 } else if (ParamName == "trivial") {
1346 Result.second = Enable;
1347 } else {
1348 return make_error<StringError>(
1349 formatv("invalid LoopUnswitch pass parameter '{}'", ParamName).str(),
1350 inconvertibleErrorCode());
1351 }
1352 }
1353 return Result;
1354}
1355
1356Expected<LICMOptions> parseLICMOptions(StringRef Params) {
1357 LICMOptions Result;
1358 while (!Params.empty()) {
1359 StringRef ParamName;
1360 std::tie(ParamName, Params) = Params.split(';');
1361
1362 bool Enable = !ParamName.consume_front("no-");
1363 if (ParamName == "allowspeculation") {
1364 Result.AllowSpeculation = Enable;
1365 } else {
1366 return make_error<StringError>(
1367 formatv("invalid LICM pass parameter '{}'", ParamName).str(),
1368 inconvertibleErrorCode());
1369 }
1370 }
1371 return Result;
1372}
1373
1374struct LoopRotateOptions {
1375 bool EnableHeaderDuplication = true;
1376 bool PrepareForLTO = false;
1377 bool CheckExitCount = false;
1378};
1379
1380Expected<LoopRotateOptions> parseLoopRotateOptions(StringRef Params) {
1381 LoopRotateOptions Result;
1382 while (!Params.empty()) {
1383 StringRef ParamName;
1384 std::tie(ParamName, Params) = Params.split(';');
1385
1386 bool Enable = !ParamName.consume_front("no-");
1387 if (ParamName == "header-duplication") {
1388 Result.EnableHeaderDuplication = Enable;
1389 } else if (ParamName == "prepare-for-lto") {
1390 Result.PrepareForLTO = Enable;
1391 } else if (ParamName == "check-exit-count") {
1392 Result.CheckExitCount = Enable;
1393 } else {
1394 return make_error<StringError>(
1395 formatv("invalid LoopRotate pass parameter '{}'", ParamName).str(),
1396 inconvertibleErrorCode());
1397 }
1398 }
1399 return Result;
1400}
1401
1402Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
1403 bool Result = false;
1404 while (!Params.empty()) {
1405 StringRef ParamName;
1406 std::tie(ParamName, Params) = Params.split(';');
1407
1408 bool Enable = !ParamName.consume_front("no-");
1409 if (ParamName == "split-footer-bb") {
1410 Result = Enable;
1411 } else {
1412 return make_error<StringError>(
1413 formatv("invalid MergedLoadStoreMotion pass parameter '{}'",
1414 ParamName)
1415 .str(),
1416 inconvertibleErrorCode());
1417 }
1418 }
1419 return Result;
1420}
1421
1422Expected<GVNOptions> parseGVNOptions(StringRef Params) {
1423 GVNOptions Result;
1424 while (!Params.empty()) {
1425 StringRef ParamName;
1426 std::tie(ParamName, Params) = Params.split(';');
1427
1428 bool Enable = !ParamName.consume_front("no-");
1429 if (ParamName == "scalar-pre") {
1430 Result.setScalarPRE(Enable);
1431 } else if (ParamName == "load-pre") {
1432 Result.setLoadPRE(Enable);
1433 } else if (ParamName == "split-backedge-load-pre") {
1434 Result.setLoadPRESplitBackedge(Enable);
1435 } else if (ParamName == "memdep") {
1436 // MemDep and MemorySSA are mutually exclusive.
1437 Result.setMemDep(Enable);
1438 Result.setMemorySSA(!Enable);
1439 } else if (ParamName == "memoryssa") {
1440 // MemDep and MemorySSA are mutually exclusive.
1441 Result.setMemorySSA(Enable);
1442 Result.setMemDep(!Enable);
1443 } else {
1444 return make_error<StringError>(
1445 formatv("invalid GVN pass parameter '{}'", ParamName).str(),
1446 inconvertibleErrorCode());
1447 }
1448 }
1449 return Result;
1450}
1451
1452Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
1453 IPSCCPOptions Result;
1454 while (!Params.empty()) {
1455 StringRef ParamName;
1456 std::tie(ParamName, Params) = Params.split(';');
1457
1458 bool Enable = !ParamName.consume_front("no-");
1459 if (ParamName == "func-spec")
1460 Result.setFuncSpec(Enable);
1461 else
1462 return make_error<StringError>(
1463 formatv("invalid IPSCCP pass parameter '{}'", ParamName).str(),
1464 inconvertibleErrorCode());
1465 }
1466 return Result;
1467}
1468
1469Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
1470 ScalarizerPassOptions Result;
1471 while (!Params.empty()) {
1472 StringRef ParamName;
1473 std::tie(ParamName, Params) = Params.split(';');
1474
1475 if (ParamName.consume_front("min-bits=")) {
1476 if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) {
1477 return make_error<StringError>(
1478 formatv("invalid argument to Scalarizer pass min-bits "
1479 "parameter: '{}'",
1480 ParamName)
1481 .str(),
1482 inconvertibleErrorCode());
1483 }
1484
1485 continue;
1486 }
1487
1488 bool Enable = !ParamName.consume_front("no-");
1489 if (ParamName == "load-store")
1490 Result.ScalarizeLoadStore = Enable;
1491 else if (ParamName == "variable-insert-extract")
1492 Result.ScalarizeVariableInsertExtract = Enable;
1493 else {
1494 return make_error<StringError>(
1495 formatv("invalid Scalarizer pass parameter '{}'", ParamName).str(),
1496 inconvertibleErrorCode());
1497 }
1498 }
1499
1500 return Result;
1501}
1502
1503Expected<SROAOptions> parseSROAOptions(StringRef Params) {
1504 SROAOptions Result(SROAOptions::ModifyCFG);
1505 bool SawCFGOption = false;
1506 while (!Params.empty()) {
1507 StringRef ParamName;
1508 std::tie(ParamName, Params) = Params.split(';');
1509
1510 if (ParamName == "modify-cfg") {
1511 if (SawCFGOption)
1512 return make_error<StringError>("multiple SROA CFG options specified",
1513 inconvertibleErrorCode());
1514 Result.CFG = SROAOptions::ModifyCFG;
1515 SawCFGOption = true;
1516 } else if (ParamName == "preserve-cfg") {
1517 if (SawCFGOption)
1518 return make_error<StringError>("multiple SROA CFG options specified",
1519 inconvertibleErrorCode());
1520 Result.CFG = SROAOptions::PreserveCFG;
1521 SawCFGOption = true;
1522 } else if (ParamName == "aggregate-to-vector") {
1523 Result.AggregateToVector = true;
1524 } else {
1525 return make_error<StringError>(
1526 formatv("invalid SROA pass parameter '{}' (expected preserve-cfg, "
1527 "modify-cfg, or aggregate-to-vector)",
1528 ParamName)
1529 .str(),
1530 inconvertibleErrorCode());
1531 }
1532 }
1533 return Result;
1534}
1535
1536Expected<StackLifetime::LivenessType>
1537parseStackLifetimeOptions(StringRef Params) {
1538 StackLifetime::LivenessType Result = StackLifetime::LivenessType::May;
1539 while (!Params.empty()) {
1540 StringRef ParamName;
1541 std::tie(ParamName, Params) = Params.split(';');
1542
1543 if (ParamName == "may") {
1544 Result = StackLifetime::LivenessType::May;
1545 } else if (ParamName == "must") {
1546 Result = StackLifetime::LivenessType::Must;
1547 } else {
1548 return make_error<StringError>(
1549 formatv("invalid StackLifetime parameter '{}'", ParamName).str(),
1550 inconvertibleErrorCode());
1551 }
1552 }
1553 return Result;
1554}
1555
1556Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1557 return PassBuilder::parseSinglePassOption(Params, "normalized-results",
1558 "DependenceAnalysisPrinter");
1559}
1560
1561Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1562 return PassBuilder::parseSinglePassOption(Params, "lower-gep",
1563 "SeparateConstOffsetFromGEP");
1564}
1565
1566Expected<bool> parseStructurizeCFGPassOptions(StringRef Params) {
1567 return PassBuilder::parseSinglePassOption(Params, "skip-uniform-regions",
1568 "StructurizeCFG");
1569}
1570
1571Expected<OptimizationLevel>
1572parseFunctionSimplificationPipelineOptions(StringRef Params) {
1573 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1574 if (!L || *L == OptimizationLevel::O0) {
1575 return make_error<StringError>(
1576 formatv("invalid function-simplification parameter '{}'", Params).str(),
1577 inconvertibleErrorCode());
1578 };
1579 return *L;
1580}
1581
1582Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1583 return PassBuilder::parseSinglePassOption(Params, "no-ensure-optimized-uses",
1584 "MemorySSAPrinterPass");
1585}
1586
1587Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1588 return PassBuilder::parseSinglePassOption(Params, "only-if-divergent-target",
1589 "SpeculativeExecutionPass");
1590}
1591
1592Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1593 std::string Result;
1594 while (!Params.empty()) {
1595 StringRef ParamName;
1596 std::tie(ParamName, Params) = Params.split(';');
1597
1598 if (ParamName.consume_front("profile-filename=")) {
1599 Result = ParamName.str();
1600 } else {
1601 return make_error<StringError>(
1602 formatv("invalid MemProfUse pass parameter '{}'", ParamName).str(),
1603 inconvertibleErrorCode());
1604 }
1605 }
1606 return Result;
1607}
1608
1609Expected<StructuralHashOptions>
1610parseStructuralHashPrinterPassOptions(StringRef Params) {
1611 if (Params.empty())
1612 return StructuralHashOptions::None;
1613 if (Params == "detailed")
1614 return StructuralHashOptions::Detailed;
1615 if (Params == "call-target-ignored")
1616 return StructuralHashOptions::CallTargetIgnored;
1617 return make_error<StringError>(
1618 formatv("invalid structural hash printer parameter '{}'", Params).str(),
1619 inconvertibleErrorCode());
1620}
1621
1622Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1623 GlobalMergeOptions Result;
1624 while (!Params.empty()) {
1625 StringRef ParamName;
1626 std::tie(ParamName, Params) = Params.split(';');
1627
1628 bool Enable = !ParamName.consume_front("no-");
1629 if (ParamName == "group-by-use")
1630 Result.GroupByUse = Enable;
1631 else if (ParamName == "ignore-single-use")
1632 Result.IgnoreSingleUse = Enable;
1633 else if (ParamName == "merge-const")
1634 Result.MergeConstantGlobals = Enable;
1635 else if (ParamName == "merge-const-aggressive")
1636 Result.MergeConstAggressive = Enable;
1637 else if (ParamName == "merge-external")
1638 Result.MergeExternal = Enable;
1639 else if (ParamName.consume_front("max-offset=")) {
1640 if (ParamName.getAsInteger(0, Result.MaxOffset))
1641 return make_error<StringError>(
1642 formatv("invalid GlobalMergePass parameter '{}'", ParamName).str(),
1643 inconvertibleErrorCode());
1644 } else {
1645 return make_error<StringError>(
1646 formatv("invalid global-merge pass parameter '{}'", Params).str(),
1647 inconvertibleErrorCode());
1648 }
1649 }
1650 return Result;
1651}
1652
1653Expected<SmallVector<std::string, 0>> parseInternalizeGVs(StringRef Params) {
1654 SmallVector<std::string, 1> PreservedGVs;
1655 while (!Params.empty()) {
1656 StringRef ParamName;
1657 std::tie(ParamName, Params) = Params.split(';');
1658
1659 if (ParamName.consume_front("preserve-gv=")) {
1660 PreservedGVs.push_back(ParamName.str());
1661 } else {
1662 return make_error<StringError>(
1663 formatv("invalid Internalize pass parameter '{}'", ParamName).str(),
1664 inconvertibleErrorCode());
1665 }
1666 }
1667
1668 return Expected<SmallVector<std::string, 0>>(std::move(PreservedGVs));
1669}
1670
1671Expected<RegAllocFastPass::Options>
1672parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
1673 RegAllocFastPass::Options Opts;
1674 while (!Params.empty()) {
1675 StringRef ParamName;
1676 std::tie(ParamName, Params) = Params.split(';');
1677
1678 if (ParamName.consume_front("filter=")) {
1679 std::optional<RegAllocFilterFunc> Filter =
1680 PB.parseRegAllocFilter(ParamName);
1681 if (!Filter) {
1682 return make_error<StringError>(
1683 formatv("invalid regallocfast register filter '{}'", ParamName)
1684 .str(),
1685 inconvertibleErrorCode());
1686 }
1687 Opts.Filter = *Filter;
1688 Opts.FilterName = ParamName;
1689 continue;
1690 }
1691
1692 if (ParamName == "no-clear-vregs") {
1693 Opts.ClearVRegs = false;
1694 continue;
1695 }
1696
1697 return make_error<StringError>(
1698 formatv("invalid regallocfast pass parameter '{}'", ParamName).str(),
1699 inconvertibleErrorCode());
1700 }
1701 return Opts;
1702}
1703
1704Expected<BoundsCheckingPass::Options>
1705parseBoundsCheckingOptions(StringRef Params) {
1706 BoundsCheckingPass::Options Options;
1707 while (!Params.empty()) {
1708 StringRef ParamName;
1709 std::tie(ParamName, Params) = Params.split(';');
1710 if (ParamName == "trap") {
1711 Options.Rt = std::nullopt;
1712 } else if (ParamName == "rt") {
1713 Options.Rt = {
1714 /*MinRuntime=*/false,
1715 /*MayReturn=*/true,
1716 /*HandlerPreserveAllRegs=*/false,
1717 };
1718 } else if (ParamName == "rt-abort") {
1719 Options.Rt = {
1720 /*MinRuntime=*/false,
1721 /*MayReturn=*/false,
1722 /*HandlerPreserveAllRegs=*/false,
1723 };
1724 } else if (ParamName == "min-rt") {
1725 Options.Rt = {
1726 /*MinRuntime=*/true,
1727 /*MayReturn=*/true,
1728 /*HandlerPreserveAllRegs=*/false,
1729 };
1730 } else if (ParamName == "min-rt-abort") {
1731 Options.Rt = {
1732 /*MinRuntime=*/true,
1733 /*MayReturn=*/false,
1734 /*HandlerPreserveAllRegs=*/false,
1735 };
1736 } else if (ParamName == "merge") {
1737 Options.Merge = true;
1738 } else if (ParamName == "handler-preserve-all-regs") {
1739 if (Options.Rt)
1740 Options.Rt->HandlerPreserveAllRegs = true;
1741 } else {
1742 StringRef ParamEQ;
1743 StringRef Val;
1744 std::tie(ParamEQ, Val) = ParamName.split('=');
1745 int8_t Id;
1746 if (ParamEQ == "guard" && !Val.getAsInteger(0, Id)) {
1747 Options.GuardKind = Id;
1748 } else {
1749 return make_error<StringError>(
1750 formatv("invalid BoundsChecking pass parameter '{}'", ParamName)
1751 .str(),
1752 inconvertibleErrorCode());
1753 }
1754 }
1755 }
1756 return Options;
1757}
1758
1759Expected<CodeGenOptLevel> parseExpandIRInstsOptions(StringRef Param) {
1760 if (Param.empty())
1761 return CodeGenOptLevel::None;
1762
1763 // Parse a CodeGenOptLevel, e.g. "O1", "O2", "O3".
1764 auto [Prefix, Digit] = Param.split('O');
1765
1766 uint8_t N;
1767 if (!Prefix.empty() || Digit.getAsInteger(10, N))
1768 return createStringError("invalid expand-ir-insts pass parameter '%s'",
1769 Param.str().c_str());
1770
1771 std::optional<CodeGenOptLevel> Level = CodeGenOpt::getLevel(N);
1772 if (!Level.has_value())
1773 return createStringError(
1774 "invalid optimization level for expand-ir-insts pass: %s",
1775 Digit.str().c_str());
1776
1777 return *Level;
1778}
1779
1780Expected<RAGreedyPass::Options>
1781parseRegAllocGreedyFilterFunc(PassBuilder &PB, StringRef Params) {
1782 if (Params.empty() || Params == "all")
1783 return RAGreedyPass::Options();
1784
1785 std::optional<RegAllocFilterFunc> Filter = PB.parseRegAllocFilter(Params);
1786 if (Filter)
1787 return RAGreedyPass::Options{*Filter, Params};
1788
1789 return make_error<StringError>(
1790 formatv("invalid regallocgreedy register filter '{}'", Params).str(),
1791 inconvertibleErrorCode());
1792}
1793
1794Expected<bool> parseMachineSinkingPassOptions(StringRef Params) {
1795 return PassBuilder::parseSinglePassOption(Params, "enable-sink-fold",
1796 "MachineSinkingPass");
1797}
1798
1799Expected<bool> parseMachineBlockPlacementPassOptions(StringRef Params) {
1800 bool AllowTailMerge = true;
1801 if (!Params.empty()) {
1802 AllowTailMerge = !Params.consume_front("no-");
1803 if (Params != "tail-merge")
1804 return make_error<StringError>(
1805 formatv("invalid MachineBlockPlacementPass parameter '{}'", Params)
1806 .str(),
1807 inconvertibleErrorCode());
1808 }
1809 return AllowTailMerge;
1810}
1811
1812Expected<bool> parseVirtRegRewriterPassOptions(StringRef Params) {
1813 bool ClearVirtRegs = true;
1814 if (!Params.empty()) {
1815 ClearVirtRegs = !Params.consume_front("no-");
1816 if (Params != "clear-vregs")
1817 return make_error<StringError>(
1818 formatv("invalid VirtRegRewriter pass parameter '{}'", Params).str(),
1819 inconvertibleErrorCode());
1820 }
1821 return ClearVirtRegs;
1822}
1823
1824struct FatLTOOptions {
1825 OptimizationLevel OptLevel;
1826 bool ThinLTO = false;
1827 bool EmitSummary = false;
1828};
1829
1830Expected<FatLTOOptions> parseFatLTOOptions(StringRef Params) {
1831 FatLTOOptions Result;
1832 bool HaveOptLevel = false;
1833 while (!Params.empty()) {
1834 StringRef ParamName;
1835 std::tie(ParamName, Params) = Params.split(';');
1836
1837 if (ParamName == "thinlto") {
1838 Result.ThinLTO = true;
1839 } else if (ParamName == "emit-summary") {
1840 Result.EmitSummary = true;
1841 } else if (std::optional<OptimizationLevel> OptLevel =
1842 parseOptLevel(ParamName)) {
1843 Result.OptLevel = *OptLevel;
1844 HaveOptLevel = true;
1845 } else {
1846 return make_error<StringError>(
1847 formatv("invalid fatlto-pre-link pass parameter '{}'", ParamName)
1848 .str(),
1849 inconvertibleErrorCode());
1850 }
1851 }
1852 if (!HaveOptLevel)
1853 return make_error<StringError>(
1854 "missing optimization level for fatlto-pre-link pipeline",
1855 inconvertibleErrorCode());
1856 return Result;
1857}
1858
1859} // namespace
1860
1861/// Tests whether registered callbacks will accept a given pass name.
1862///
1863/// When parsing a pipeline text, the type of the outermost pipeline may be
1864/// omitted, in which case the type is automatically determined from the first
1865/// pass name in the text. This may be a name that is handled through one of the
1866/// callbacks. We check this through the oridinary parsing callbacks by setting
1867/// up a dummy PassManager in order to not force the client to also handle this
1868/// type of query.
1869template <typename PassManagerT, typename CallbacksT>
1870static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1871 if (!Callbacks.empty()) {
1872 PassManagerT DummyPM;
1873 for (auto &CB : Callbacks)
1874 if (CB(Name, DummyPM, {}))
1875 return true;
1876 }
1877 return false;
1878}
1879
1880template <typename CallbacksT>
1881static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1882 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1883
1884 // Explicitly handle pass manager names.
1885 if (Name == "module")
1886 return true;
1887 if (Name == "cgscc")
1888 return true;
1889 if (NameNoBracket == "function")
1890 return true;
1891 if (Name == "coro-cond")
1892 return true;
1893
1894#define MODULE_PASS(NAME, CREATE_PASS) \
1895 if (Name == NAME) \
1896 return true;
1897#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1898 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1899 return true;
1900#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1901 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1902 return true;
1903#include "PassRegistry.def"
1904
1905 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1906}
1907
1908template <typename CallbacksT>
1909static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1910 // Explicitly handle pass manager names.
1911 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1912 if (Name == "cgscc")
1913 return true;
1914 if (NameNoBracket == "function")
1915 return true;
1916
1917 // Explicitly handle custom-parsed pass names.
1918 if (parseDevirtPassName(Name))
1919 return true;
1920
1921#define CGSCC_PASS(NAME, CREATE_PASS) \
1922 if (Name == NAME) \
1923 return true;
1924#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1925 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1926 return true;
1927#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1928 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1929 return true;
1930#include "PassRegistry.def"
1931
1932 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1933}
1934
1935template <typename CallbacksT>
1936static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1937 // Explicitly handle pass manager names.
1938 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1939 if (NameNoBracket == "function")
1940 return true;
1941 if (Name == "loop" || Name == "loop-mssa" || Name == "machine-function")
1942 return true;
1943
1944#define FUNCTION_PASS(NAME, CREATE_PASS) \
1945 if (Name == NAME) \
1946 return true;
1947#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1948 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1949 return true;
1950#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1951 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1952 return true;
1953#include "PassRegistry.def"
1954
1955 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1956}
1957
1958template <typename CallbacksT>
1959static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1960 // Explicitly handle pass manager names.
1961 if (Name == "machine-function")
1962 return true;
1963
1964#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1965 if (Name == NAME) \
1966 return true;
1967#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1968 PARAMS) \
1969 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1970 return true;
1971
1972#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1973 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1974 return true;
1975
1976#include "llvm/Passes/MachinePassRegistry.def"
1977
1978 return callbacksAcceptPassName<MachineFunctionPassManager>(Name, Callbacks);
1979}
1980
1981template <typename CallbacksT>
1982static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1983 bool &UseMemorySSA) {
1984 UseMemorySSA = false;
1985
1986 if (PassBuilder::checkParametrizedPassName(Name, "lnicm")) {
1987 UseMemorySSA = true;
1988 return true;
1989 }
1990
1991#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1992 if (Name == NAME) \
1993 return true;
1994#include "PassRegistry.def"
1995
1996 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1997}
1998
1999template <typename CallbacksT>
2000static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
2001 bool &UseMemorySSA) {
2002 UseMemorySSA = false;
2003
2004 if (PassBuilder::checkParametrizedPassName(Name, "licm")) {
2005 UseMemorySSA = true;
2006 return true;
2007 }
2008
2009#define LOOP_PASS(NAME, CREATE_PASS) \
2010 if (Name == NAME) \
2011 return true;
2012#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2013 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
2014 return true;
2015#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2016 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
2017 return true;
2018#include "PassRegistry.def"
2019
2020 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
2021}
2022
2023std::optional<std::vector<PassBuilder::PipelineElement>>
2024PassBuilder::parsePipelineText(StringRef Text) {
2025 std::vector<PipelineElement> ResultPipeline;
2026
2027 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
2028 &ResultPipeline};
2029 for (;;) {
2030 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
2031 size_t Pos = Text.find_first_of(",()");
2032 Pipeline.push_back({Text.substr(0, Pos), {}});
2033
2034 // If we have a single terminating name, we're done.
2035 if (Pos == Text.npos)
2036 break;
2037
2038 char Sep = Text[Pos];
2039 Text = Text.substr(Pos + 1);
2040 if (Sep == ',')
2041 // Just a name ending in a comma, continue.
2042 continue;
2043
2044 if (Sep == '(') {
2045 // Push the inner pipeline onto the stack to continue processing.
2046 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
2047 continue;
2048 }
2049
2050 assert(Sep == ')' && "Bogus separator!");
2051 // When handling the close parenthesis, we greedily consume them to avoid
2052 // empty strings in the pipeline.
2053 do {
2054 // If we try to pop the outer pipeline we have unbalanced parentheses.
2055 if (PipelineStack.size() == 1)
2056 return std::nullopt;
2057
2058 PipelineStack.pop_back();
2059 } while (Text.consume_front(")"));
2060
2061 // Check if we've finished parsing.
2062 if (Text.empty())
2063 break;
2064
2065 // Otherwise, the end of an inner pipeline always has to be followed by
2066 // a comma, and then we can continue.
2067 if (!Text.consume_front(","))
2068 return std::nullopt;
2069 }
2070
2071 if (PipelineStack.size() > 1)
2072 // Unbalanced paretheses.
2073 return std::nullopt;
2074
2075 assert(PipelineStack.back() == &ResultPipeline &&
2076 "Wrong pipeline at the bottom of the stack!");
2077 return {std::move(ResultPipeline)};
2078}
2079
2085
2086Error PassBuilder::parseModulePass(ModulePassManager &MPM,
2087 const PipelineElement &E) {
2088 auto &Name = E.Name;
2089 auto &InnerPipeline = E.InnerPipeline;
2090
2091 // First handle complex passes like the pass managers which carry pipelines.
2092 if (!InnerPipeline.empty()) {
2093 if (Name == "module") {
2094 ModulePassManager NestedMPM;
2095 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
2096 return Err;
2097 MPM.addPass(std::move(NestedMPM));
2098 return Error::success();
2099 }
2100 if (Name == "coro-cond") {
2101 ModulePassManager NestedMPM;
2102 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
2103 return Err;
2104 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
2105 return Error::success();
2106 }
2107 if (Name == "cgscc") {
2108 CGSCCPassManager CGPM;
2109 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
2110 return Err;
2111 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
2112 return Error::success();
2113 }
2114 if (auto Params = parseFunctionPipelineName(Name)) {
2115 if (Params->second)
2116 return make_error<StringError>(
2117 "cannot have a no-rerun module to function adaptor",
2118 inconvertibleErrorCode());
2119 FunctionPassManager FPM;
2120 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2121 return Err;
2122 MPM.addPass(
2123 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
2124 return Error::success();
2125 }
2126
2127 for (auto &C : ModulePipelineParsingCallbacks)
2128 if (C(Name, MPM, InnerPipeline))
2129 return Error::success();
2130
2131 // Normal passes can't have pipelines.
2132 return make_error<StringError>(
2133 formatv("invalid use of '{}' pass as module pipeline", Name).str(),
2134 inconvertibleErrorCode());
2135 ;
2136 }
2137
2138 // Finally expand the basic registered passes from the .inc file.
2139#define MODULE_PASS(NAME, CREATE_PASS) \
2140 if (Name == NAME) { \
2141 MPM.addPass(CREATE_PASS); \
2142 return Error::success(); \
2143 }
2144#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2145 if (checkParametrizedPassName(Name, NAME)) { \
2146 auto Params = parsePassParameters(PARSER, Name, NAME); \
2147 if (!Params) \
2148 return Params.takeError(); \
2149 MPM.addPass(CREATE_PASS(Params.get())); \
2150 return Error::success(); \
2151 }
2152#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
2153 if (Name == "require<" NAME ">") { \
2154 MPM.addPass( \
2155 RequireAnalysisPass< \
2156 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
2157 return Error::success(); \
2158 } \
2159 if (Name == "invalidate<" NAME ">") { \
2160 MPM.addPass(InvalidateAnalysisPass< \
2161 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2162 return Error::success(); \
2163 }
2164#define CGSCC_PASS(NAME, CREATE_PASS) \
2165 if (Name == NAME) { \
2166 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
2167 return Error::success(); \
2168 }
2169#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2170 if (checkParametrizedPassName(Name, NAME)) { \
2171 auto Params = parsePassParameters(PARSER, Name, NAME); \
2172 if (!Params) \
2173 return Params.takeError(); \
2174 MPM.addPass( \
2175 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
2176 return Error::success(); \
2177 }
2178#define FUNCTION_PASS(NAME, CREATE_PASS) \
2179 if (Name == NAME) { \
2180 if constexpr (std::is_constructible_v< \
2181 std::remove_reference_t<decltype(CREATE_PASS)>, \
2182 const TargetMachine &>) { \
2183 if (!TM) \
2184 return make_error<StringError>( \
2185 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2186 inconvertibleErrorCode()); \
2187 } \
2188 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
2189 return Error::success(); \
2190 }
2191#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2192 if (checkParametrizedPassName(Name, NAME)) { \
2193 auto Params = parsePassParameters(PARSER, Name, NAME); \
2194 if (!Params) \
2195 return Params.takeError(); \
2196 auto CreatePass = CREATE_PASS; \
2197 if constexpr (std::is_constructible_v< \
2198 std::remove_reference_t<decltype(CreatePass( \
2199 Params.get()))>, \
2200 const TargetMachine &, \
2201 std::remove_reference_t<decltype(Params.get())>>) { \
2202 if (!TM) { \
2203 return make_error<StringError>( \
2204 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2205 inconvertibleErrorCode()); \
2206 } \
2207 } \
2208 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2209 return Error::success(); \
2210 }
2211#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2212 if (Name == NAME) { \
2213 MPM.addPass(createModuleToFunctionPassAdaptor( \
2214 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2215 return Error::success(); \
2216 }
2217#define LOOP_PASS(NAME, CREATE_PASS) \
2218 if (Name == NAME) { \
2219 MPM.addPass(createModuleToFunctionPassAdaptor( \
2220 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2221 return Error::success(); \
2222 }
2223#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2224 if (checkParametrizedPassName(Name, NAME)) { \
2225 auto Params = parsePassParameters(PARSER, Name, NAME); \
2226 if (!Params) \
2227 return Params.takeError(); \
2228 MPM.addPass(createModuleToFunctionPassAdaptor( \
2229 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2230 return Error::success(); \
2231 }
2232#include "PassRegistry.def"
2233
2234 for (auto &C : ModulePipelineParsingCallbacks)
2235 if (C(Name, MPM, InnerPipeline))
2236 return Error::success();
2237 return make_error<StringError>(
2238 formatv("unknown module pass '{}'", Name).str(),
2239 inconvertibleErrorCode());
2240}
2241
2242Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
2243 const PipelineElement &E) {
2244 auto &Name = E.Name;
2245 auto &InnerPipeline = E.InnerPipeline;
2246
2247 // First handle complex passes like the pass managers which carry pipelines.
2248 if (!InnerPipeline.empty()) {
2249 if (Name == "cgscc") {
2250 CGSCCPassManager NestedCGPM;
2251 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2252 return Err;
2253 // Add the nested pass manager with the appropriate adaptor.
2254 CGPM.addPass(std::move(NestedCGPM));
2255 return Error::success();
2256 }
2257 if (auto Params = parseFunctionPipelineName(Name)) {
2258 FunctionPassManager FPM;
2259 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2260 return Err;
2261 // Add the nested pass manager with the appropriate adaptor.
2262 CGPM.addPass(createCGSCCToFunctionPassAdaptor(
2263 std::move(FPM), Params->first, Params->second));
2264 return Error::success();
2265 }
2266 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
2267 CGSCCPassManager NestedCGPM;
2268 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2269 return Err;
2270 CGPM.addPass(
2271 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
2272 return Error::success();
2273 }
2274
2275 for (auto &C : CGSCCPipelineParsingCallbacks)
2276 if (C(Name, CGPM, InnerPipeline))
2277 return Error::success();
2278
2279 // Normal passes can't have pipelines.
2280 return make_error<StringError>(
2281 formatv("invalid use of '{}' pass as cgscc pipeline", Name).str(),
2282 inconvertibleErrorCode());
2283 }
2284
2285// Now expand the basic registered passes from the .inc file.
2286#define CGSCC_PASS(NAME, CREATE_PASS) \
2287 if (Name == NAME) { \
2288 CGPM.addPass(CREATE_PASS); \
2289 return Error::success(); \
2290 }
2291#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2292 if (checkParametrizedPassName(Name, NAME)) { \
2293 auto Params = parsePassParameters(PARSER, Name, NAME); \
2294 if (!Params) \
2295 return Params.takeError(); \
2296 CGPM.addPass(CREATE_PASS(Params.get())); \
2297 return Error::success(); \
2298 }
2299#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
2300 if (Name == "require<" NAME ">") { \
2301 CGPM.addPass(RequireAnalysisPass< \
2302 std::remove_reference_t<decltype(CREATE_PASS)>, \
2303 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
2304 CGSCCUpdateResult &>()); \
2305 return Error::success(); \
2306 } \
2307 if (Name == "invalidate<" NAME ">") { \
2308 CGPM.addPass(InvalidateAnalysisPass< \
2309 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2310 return Error::success(); \
2311 }
2312#define FUNCTION_PASS(NAME, CREATE_PASS) \
2313 if (Name == NAME) { \
2314 if constexpr (std::is_constructible_v< \
2315 std::remove_reference_t<decltype(CREATE_PASS)>, \
2316 const TargetMachine &>) { \
2317 if (!TM) \
2318 return make_error<StringError>( \
2319 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2320 inconvertibleErrorCode()); \
2321 } \
2322 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
2323 return Error::success(); \
2324 }
2325#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2326 if (checkParametrizedPassName(Name, NAME)) { \
2327 auto Params = parsePassParameters(PARSER, Name, NAME); \
2328 if (!Params) \
2329 return Params.takeError(); \
2330 auto CreatePass = CREATE_PASS; \
2331 if constexpr (std::is_constructible_v< \
2332 std::remove_reference_t<decltype(CreatePass( \
2333 Params.get()))>, \
2334 const TargetMachine &, \
2335 std::remove_reference_t<decltype(Params.get())>>) { \
2336 if (!TM) { \
2337 return make_error<StringError>( \
2338 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2339 inconvertibleErrorCode()); \
2340 } \
2341 } \
2342 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2343 return Error::success(); \
2344 }
2345#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2346 if (Name == NAME) { \
2347 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2348 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2349 return Error::success(); \
2350 }
2351#define LOOP_PASS(NAME, CREATE_PASS) \
2352 if (Name == NAME) { \
2353 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2354 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2355 return Error::success(); \
2356 }
2357#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2358 if (checkParametrizedPassName(Name, NAME)) { \
2359 auto Params = parsePassParameters(PARSER, Name, NAME); \
2360 if (!Params) \
2361 return Params.takeError(); \
2362 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2363 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2364 return Error::success(); \
2365 }
2366#include "PassRegistry.def"
2367
2368 for (auto &C : CGSCCPipelineParsingCallbacks)
2369 if (C(Name, CGPM, InnerPipeline))
2370 return Error::success();
2371 return make_error<StringError>(formatv("unknown cgscc pass '{}'", Name).str(),
2372 inconvertibleErrorCode());
2373}
2374
2375Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
2376 const PipelineElement &E) {
2377 auto &Name = E.Name;
2378 auto &InnerPipeline = E.InnerPipeline;
2379
2380 // First handle complex passes like the pass managers which carry pipelines.
2381 if (!InnerPipeline.empty()) {
2382 if (Name == "function") {
2383 FunctionPassManager NestedFPM;
2384 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
2385 return Err;
2386 // Add the nested pass manager with the appropriate adaptor.
2387 FPM.addPass(std::move(NestedFPM));
2388 return Error::success();
2389 }
2390 if (Name == "loop" || Name == "loop-mssa") {
2391 LoopPassManager LPM;
2392 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
2393 return Err;
2394 // Add the nested pass manager with the appropriate adaptor.
2395 bool UseMemorySSA = (Name == "loop-mssa");
2396 FPM.addPass(
2397 createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA));
2398 return Error::success();
2399 }
2400 if (Name == "machine-function") {
2401 MachineFunctionPassManager MFPM;
2402 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
2403 return Err;
2404 FPM.addPass(createFunctionToMachineFunctionPassAdaptor(std::move(MFPM)));
2405 return Error::success();
2406 }
2407
2408 for (auto &C : FunctionPipelineParsingCallbacks)
2409 if (C(Name, FPM, InnerPipeline))
2410 return Error::success();
2411
2412 // Normal passes can't have pipelines.
2413 return make_error<StringError>(
2414 formatv("invalid use of '{}' pass as function pipeline", Name).str(),
2415 inconvertibleErrorCode());
2416 }
2417
2418// Now expand the basic registered passes from the .inc file.
2419#define FUNCTION_PASS(NAME, CREATE_PASS) \
2420 if (Name == NAME) { \
2421 if constexpr (std::is_constructible_v< \
2422 std::remove_reference_t<decltype(CREATE_PASS)>, \
2423 const TargetMachine &>) { \
2424 if (!TM) \
2425 return make_error<StringError>( \
2426 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2427 inconvertibleErrorCode()); \
2428 } \
2429 FPM.addPass(CREATE_PASS); \
2430 return Error::success(); \
2431 }
2432#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2433 if (checkParametrizedPassName(Name, NAME)) { \
2434 auto Params = parsePassParameters(PARSER, Name, NAME); \
2435 if (!Params) \
2436 return Params.takeError(); \
2437 auto CreatePass = CREATE_PASS; \
2438 if constexpr (std::is_constructible_v< \
2439 std::remove_reference_t<decltype(CreatePass( \
2440 Params.get()))>, \
2441 const TargetMachine &, \
2442 std::remove_reference_t<decltype(Params.get())>>) { \
2443 if (!TM) { \
2444 return make_error<StringError>( \
2445 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2446 inconvertibleErrorCode()); \
2447 } \
2448 } \
2449 FPM.addPass(CREATE_PASS(Params.get())); \
2450 return Error::success(); \
2451 }
2452#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2453 if (Name == "require<" NAME ">") { \
2454 if constexpr (std::is_constructible_v< \
2455 std::remove_reference_t<decltype(CREATE_PASS)>, \
2456 const TargetMachine &>) { \
2457 if (!TM) \
2458 return make_error<StringError>( \
2459 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2460 inconvertibleErrorCode()); \
2461 } \
2462 FPM.addPass( \
2463 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2464 Function>()); \
2465 return Error::success(); \
2466 } \
2467 if (Name == "invalidate<" NAME ">") { \
2468 FPM.addPass(InvalidateAnalysisPass< \
2469 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2470 return Error::success(); \
2471 }
2472// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
2473// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
2474// "guard-widening");
2475// The risk is that it may become obsolete if we're not careful.
2476#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2477 if (Name == NAME) { \
2478 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2479 return Error::success(); \
2480 }
2481#define LOOP_PASS(NAME, CREATE_PASS) \
2482 if (Name == NAME) { \
2483 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2484 return Error::success(); \
2485 }
2486#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2487 if (checkParametrizedPassName(Name, NAME)) { \
2488 auto Params = parsePassParameters(PARSER, Name, NAME); \
2489 if (!Params) \
2490 return Params.takeError(); \
2491 FPM.addPass( \
2492 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false)); \
2493 return Error::success(); \
2494 }
2495#include "PassRegistry.def"
2496
2497 for (auto &C : FunctionPipelineParsingCallbacks)
2498 if (C(Name, FPM, InnerPipeline))
2499 return Error::success();
2500 return make_error<StringError>(
2501 formatv("unknown function pass '{}'", Name).str(),
2502 inconvertibleErrorCode());
2503}
2504
2505Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
2506 const PipelineElement &E) {
2507 StringRef Name = E.Name;
2508 auto &InnerPipeline = E.InnerPipeline;
2509
2510 // First handle complex passes like the pass managers which carry pipelines.
2511 if (!InnerPipeline.empty()) {
2512 if (Name == "loop") {
2513 LoopPassManager NestedLPM;
2514 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
2515 return Err;
2516 // Add the nested pass manager with the appropriate adaptor.
2517 LPM.addPass(std::move(NestedLPM));
2518 return Error::success();
2519 }
2520
2521 for (auto &C : LoopPipelineParsingCallbacks)
2522 if (C(Name, LPM, InnerPipeline))
2523 return Error::success();
2524
2525 // Normal passes can't have pipelines.
2526 return make_error<StringError>(
2527 formatv("invalid use of '{}' pass as loop pipeline", Name).str(),
2528 inconvertibleErrorCode());
2529 }
2530
2531// Now expand the basic registered passes from the .inc file.
2532#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2533 if (Name == NAME) { \
2534 LPM.addPass(CREATE_PASS); \
2535 return Error::success(); \
2536 }
2537#define LOOP_PASS(NAME, CREATE_PASS) \
2538 if (Name == NAME) { \
2539 LPM.addPass(CREATE_PASS); \
2540 return Error::success(); \
2541 }
2542#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2543 if (checkParametrizedPassName(Name, NAME)) { \
2544 auto Params = parsePassParameters(PARSER, Name, NAME); \
2545 if (!Params) \
2546 return Params.takeError(); \
2547 LPM.addPass(CREATE_PASS(Params.get())); \
2548 return Error::success(); \
2549 }
2550#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2551 if (Name == "require<" NAME ">") { \
2552 LPM.addPass(RequireAnalysisPass< \
2553 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2554 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2555 LPMUpdater &>()); \
2556 return Error::success(); \
2557 } \
2558 if (Name == "invalidate<" NAME ">") { \
2559 LPM.addPass(InvalidateAnalysisPass< \
2560 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2561 return Error::success(); \
2562 }
2563#include "PassRegistry.def"
2564
2565 for (auto &C : LoopPipelineParsingCallbacks)
2566 if (C(Name, LPM, InnerPipeline))
2567 return Error::success();
2568 return make_error<StringError>(formatv("unknown loop pass '{}'", Name).str(),
2569 inconvertibleErrorCode());
2570}
2571
2572Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
2573 const PipelineElement &E) {
2574 StringRef Name = E.Name;
2575 // Handle any nested pass managers.
2576 if (!E.InnerPipeline.empty()) {
2577 if (E.Name == "machine-function") {
2578 MachineFunctionPassManager NestedPM;
2579 if (auto Err = parseMachinePassPipeline(NestedPM, E.InnerPipeline))
2580 return Err;
2581 MFPM.addPass(std::move(NestedPM));
2582 return Error::success();
2583 }
2584 return make_error<StringError>("invalid pipeline",
2585 inconvertibleErrorCode());
2586 }
2587
2588#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2589 if (Name == NAME) { \
2590 MFPM.addPass(CREATE_PASS); \
2591 return Error::success(); \
2592 }
2593#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2594 if (Name == NAME) { \
2595 MFPM.addPass(CREATE_PASS); \
2596 return Error::success(); \
2597 }
2598#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2599 PARAMS) \
2600 if (checkParametrizedPassName(Name, NAME)) { \
2601 auto Params = parsePassParameters(PARSER, Name, NAME); \
2602 if (!Params) \
2603 return Params.takeError(); \
2604 MFPM.addPass(CREATE_PASS(Params.get())); \
2605 return Error::success(); \
2606 }
2607#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2608 if (Name == "require<" NAME ">") { \
2609 MFPM.addPass( \
2610 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2611 MachineFunction>()); \
2612 return Error::success(); \
2613 } \
2614 if (Name == "invalidate<" NAME ">") { \
2615 MFPM.addPass(InvalidateAnalysisPass< \
2616 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2617 return Error::success(); \
2618 }
2619#include "llvm/Passes/MachinePassRegistry.def"
2620
2621 for (auto &C : MachineFunctionPipelineParsingCallbacks)
2622 if (C(Name, MFPM, E.InnerPipeline))
2623 return Error::success();
2624 return make_error<StringError>(
2625 formatv("unknown machine pass '{}'", Name).str(),
2626 inconvertibleErrorCode());
2627}
2628
2629bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
2630#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2631 if (Name == NAME) { \
2632 AA.registerModuleAnalysis< \
2633 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2634 return true; \
2635 }
2636#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2637 if (Name == NAME) { \
2638 AA.registerFunctionAnalysis< \
2639 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2640 return true; \
2641 }
2642#include "PassRegistry.def"
2643
2644 for (auto &C : AAParsingCallbacks)
2645 if (C(Name, AA))
2646 return true;
2647 return false;
2648}
2649
2650Error PassBuilder::parseMachinePassPipeline(
2651 MachineFunctionPassManager &MFPM, ArrayRef<PipelineElement> Pipeline) {
2652 for (const auto &Element : Pipeline) {
2653 if (auto Err = parseMachinePass(MFPM, Element))
2654 return Err;
2655 }
2656 return Error::success();
2657}
2658
2659Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
2660 ArrayRef<PipelineElement> Pipeline) {
2661 for (const auto &Element : Pipeline) {
2662 if (auto Err = parseLoopPass(LPM, Element))
2663 return Err;
2664 }
2665 return Error::success();
2666}
2667
2668Error PassBuilder::parseFunctionPassPipeline(
2669 FunctionPassManager &FPM, ArrayRef<PipelineElement> Pipeline) {
2670 for (const auto &Element : Pipeline) {
2671 if (auto Err = parseFunctionPass(FPM, Element))
2672 return Err;
2673 }
2674 return Error::success();
2675}
2676
2677Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
2678 ArrayRef<PipelineElement> Pipeline) {
2679 for (const auto &Element : Pipeline) {
2680 if (auto Err = parseCGSCCPass(CGPM, Element))
2681 return Err;
2682 }
2683 return Error::success();
2684}
2685
2686void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
2687 FunctionAnalysisManager &FAM,
2688 CGSCCAnalysisManager &CGAM,
2689 ModuleAnalysisManager &MAM,
2690 MachineFunctionAnalysisManager *MFAM) {
2691 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
2692 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
2693 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
2694 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
2695 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
2696 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
2697 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
2698 if (MFAM) {
2699 MAM.registerPass(
2700 [&] { return MachineFunctionAnalysisManagerModuleProxy(*MFAM); });
2701 FAM.registerPass(
2702 [&] { return MachineFunctionAnalysisManagerFunctionProxy(*MFAM); });
2703 MFAM->registerPass(
2704 [&] { return ModuleAnalysisManagerMachineFunctionProxy(MAM); });
2705 MFAM->registerPass(
2706 [&] { return FunctionAnalysisManagerMachineFunctionProxy(FAM); });
2707 }
2708}
2709
2710Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
2711 ArrayRef<PipelineElement> Pipeline) {
2712 for (const auto &Element : Pipeline) {
2713 if (auto Err = parseModulePass(MPM, Element))
2714 return Err;
2715 }
2716 return Error::success();
2717}
2718
2719// Primary pass pipeline description parsing routine for a \c ModulePassManager
2720// FIXME: Should this routine accept a TargetMachine or require the caller to
2721// pre-populate the analysis managers with target-specific stuff?
2722Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
2723 StringRef PipelineText) {
2724 auto Pipeline = parsePipelineText(PipelineText);
2725 if (!Pipeline || Pipeline->empty())
2726 return make_error<StringError>(
2727 formatv("invalid pipeline '{}'", PipelineText).str(),
2728 inconvertibleErrorCode());
2729
2730 // If the first name isn't at the module layer, wrap the pipeline up
2731 // automatically.
2732 StringRef FirstName = Pipeline->front().Name;
2733
2734 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
2735 bool UseMemorySSA;
2736 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
2737 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2738 } else if (isFunctionPassName(FirstName,
2739 FunctionPipelineParsingCallbacks)) {
2740 Pipeline = {{"function", std::move(*Pipeline)}};
2741 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
2742 UseMemorySSA)) {
2743 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2744 std::move(*Pipeline)}}}};
2745 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2746 UseMemorySSA)) {
2747 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2748 std::move(*Pipeline)}}}};
2749 } else if (isMachineFunctionPassName(
2750 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2751 Pipeline = {{"function", {{"machine-function", std::move(*Pipeline)}}}};
2752 } else {
2753 for (auto &C : TopLevelPipelineParsingCallbacks)
2754 if (C(MPM, *Pipeline))
2755 return Error::success();
2756
2757 // Unknown pass or pipeline name!
2758 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2759 return make_error<StringError>(
2760 formatv("unknown {} name '{}'",
2761 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2762 .str(),
2763 inconvertibleErrorCode());
2764 }
2765 }
2766
2767 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2768 return Err;
2769 return Error::success();
2770}
2771
2772// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
2773Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
2774 StringRef PipelineText) {
2775 auto Pipeline = parsePipelineText(PipelineText);
2776 if (!Pipeline || Pipeline->empty())
2777 return make_error<StringError>(
2778 formatv("invalid pipeline '{}'", PipelineText).str(),
2779 inconvertibleErrorCode());
2780
2781 StringRef FirstName = Pipeline->front().Name;
2782 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2783 return make_error<StringError>(
2784 formatv("unknown cgscc pass '{}' in pipeline '{}'", FirstName,
2785 PipelineText)
2786 .str(),
2787 inconvertibleErrorCode());
2788
2789 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2790 return Err;
2791 return Error::success();
2792}
2793
2794// Primary pass pipeline description parsing routine for a \c
2795// FunctionPassManager
2796Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
2797 StringRef PipelineText) {
2798 auto Pipeline = parsePipelineText(PipelineText);
2799 if (!Pipeline || Pipeline->empty())
2800 return make_error<StringError>(
2801 formatv("invalid pipeline '{}'", PipelineText).str(),
2802 inconvertibleErrorCode());
2803
2804 StringRef FirstName = Pipeline->front().Name;
2805 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2806 return make_error<StringError>(
2807 formatv("unknown function pass '{}' in pipeline '{}'", FirstName,
2808 PipelineText)
2809 .str(),
2810 inconvertibleErrorCode());
2811
2812 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2813 return Err;
2814 return Error::success();
2815}
2816
2817// Primary pass pipeline description parsing routine for a \c LoopPassManager
2818Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM,
2819 StringRef PipelineText) {
2820 auto Pipeline = parsePipelineText(PipelineText);
2821 if (!Pipeline || Pipeline->empty())
2822 return make_error<StringError>(
2823 formatv("invalid pipeline '{}'", PipelineText).str(),
2824 inconvertibleErrorCode());
2825
2826 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2827 return Err;
2828
2829 return Error::success();
2830}
2831
2832Error PassBuilder::parsePassPipeline(MachineFunctionPassManager &MFPM,
2833 StringRef PipelineText) {
2834 auto Pipeline = parsePipelineText(PipelineText);
2835 if (!Pipeline || Pipeline->empty())
2836 return make_error<StringError>(
2837 formatv("invalid machine pass pipeline '{}'", PipelineText).str(),
2838 inconvertibleErrorCode());
2839
2840 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2841 return Err;
2842
2843 return Error::success();
2844}
2845
2846Error PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) {
2847 // If the pipeline just consists of the word 'default' just replace the AA
2848 // manager with our default one.
2849 if (PipelineText == "default") {
2850 AA = buildDefaultAAPipeline();
2851 return Error::success();
2852 }
2853
2854 while (!PipelineText.empty()) {
2855 StringRef Name;
2856 std::tie(Name, PipelineText) = PipelineText.split(',');
2857 if (!parseAAPassName(AA, Name))
2858 return make_error<StringError>(
2859 formatv("unknown alias analysis name '{}'", Name).str(),
2860 inconvertibleErrorCode());
2861 }
2862
2863 return Error::success();
2864}
2865
2866std::optional<RegAllocFilterFunc>
2867PassBuilder::parseRegAllocFilter(StringRef FilterName) {
2868 if (FilterName == "all")
2869 return nullptr;
2870 for (auto &C : RegClassFilterParsingCallbacks)
2871 if (auto F = C(FilterName))
2872 return F;
2873 return std::nullopt;
2874}
2875
2876LLVM_ATTRIBUTE_NOINLINE static void printPassNameList(StringTable PassNames,
2877 raw_ostream &OS) {
2878 for (StringRef PassName : PassNames)
2879 OS << " " << PassName << '\n';
2880}
2881
2882LLVM_ATTRIBUTE_NOINLINE static void
2883printPassNameListWithParams(StringTable PassNames, raw_ostream &OS) {
2884 auto I = PassNames.begin();
2885 auto End = PassNames.end();
2886 while (I != End) {
2887 StringRef Name = *I;
2888 ++I;
2889 assert(I != End);
2890 StringRef Params = *I;
2891 ++I;
2892 OS << " " << Name << '<' << Params << ">\n";
2893 }
2894}
2895
2896void PassBuilder::printPassNames(raw_ostream &OS) {
2897 // TODO: print pass descriptions when they are available
2898
2899 OS << "Module passes:\n";
2900 static constexpr char ModulePassNames[] = {"\0"
2901#define MODULE_PASS(NAME, CREATE_PASS) NAME "\0"
2902#include "PassRegistry.def"
2903 };
2904 printPassNameList(StringTable(ModulePassNames), OS);
2905
2906 OS << "Module passes with params:\n";
2907 static constexpr char ModulePassNamesWithParams[] = {"\0"
2908#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2909 NAME "\0" PARAMS "\0"
2910#include "PassRegistry.def"
2911 };
2912 printPassNameListWithParams(StringTable(ModulePassNamesWithParams), OS);
2913
2914 OS << "Module analyses:\n";
2915 static constexpr char ModuleAnalysisNames[] = {"\0"
2916#define MODULE_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2917#include "PassRegistry.def"
2918 };
2919 printPassNameList(StringTable(ModuleAnalysisNames), OS);
2920
2921 OS << "Module alias analyses:\n";
2922 static constexpr char ModuleAliasAnalysisNames[] = {"\0"
2923#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2924#include "PassRegistry.def"
2925 };
2926 printPassNameList(StringTable(ModuleAliasAnalysisNames), OS);
2927
2928 OS << "CGSCC passes:\n";
2929 static constexpr char CGSCCPassNames[] = {"\0"
2930#define CGSCC_PASS(NAME, CREATE_PASS) NAME "\0"
2931#include "PassRegistry.def"
2932 };
2933 printPassNameList(StringTable(CGSCCPassNames), OS);
2934
2935 OS << "CGSCC passes with params:\n";
2936 static constexpr char CGSCCPassNamesWithParams[] = {"\0"
2937#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2938 NAME "\0" PARAMS "\0"
2939#include "PassRegistry.def"
2940 };
2941 printPassNameListWithParams(StringTable(CGSCCPassNamesWithParams), OS);
2942
2943 OS << "CGSCC analyses:\n";
2944 static constexpr char CGSCCAnalysisNames[] = {"\0"
2945#define CGSCC_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2946#include "PassRegistry.def"
2947 };
2948 printPassNameList(StringTable(CGSCCAnalysisNames), OS);
2949
2950 OS << "Function passes:\n";
2951 static constexpr char FunctionPassNames[] = {"\0"
2952#define FUNCTION_PASS(NAME, CREATE_PASS) NAME "\0"
2953#include "PassRegistry.def"
2954 };
2955 printPassNameList(StringTable(FunctionPassNames), OS);
2956
2957 OS << "Function passes with params:\n";
2958 static constexpr char FunctionPassNamesWithParams[] = {"\0"
2959#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2960 NAME "\0" PARAMS "\0"
2961#include "PassRegistry.def"
2962 };
2963 printPassNameListWithParams(StringTable(FunctionPassNamesWithParams), OS);
2964
2965 OS << "Function analyses:\n";
2966 static constexpr char FunctionAnalysisNames[] = {"\0"
2967#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2968#include "PassRegistry.def"
2969 };
2970 printPassNameList(StringTable(FunctionAnalysisNames), OS);
2971
2972 OS << "Function alias analyses:\n";
2973 static constexpr char FunctionAliasAnalysisNames[] = {"\0"
2974#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2975#include "PassRegistry.def"
2976 };
2977 printPassNameList(StringTable(FunctionAliasAnalysisNames), OS);
2978
2979 OS << "LoopNest passes:\n";
2980 static constexpr char LoopNestPassNames[] = {"\0"
2981#define LOOPNEST_PASS(NAME, CREATE_PASS) NAME "\0"
2982#include "PassRegistry.def"
2983 };
2984 printPassNameList(StringTable(LoopNestPassNames), OS);
2985
2986 OS << "Loop passes:\n";
2987 static constexpr char LoopPassNames[] = {"\0"
2988#define LOOP_PASS(NAME, CREATE_PASS) NAME "\0"
2989#include "PassRegistry.def"
2990 };
2991 printPassNameList(StringTable(LoopPassNames), OS);
2992
2993 OS << "Loop passes with params:\n";
2994 static constexpr char LoopPassNamesWithParams[] = {"\0"
2995#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2996 NAME "\0" PARAMS "\0"
2997#include "PassRegistry.def"
2998 };
2999 printPassNameListWithParams(StringTable(LoopPassNamesWithParams), OS);
3000
3001 OS << "Loop analyses:\n";
3002 static constexpr char LoopAnalysisNames[] = {"\0"
3003#define LOOP_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
3004#include "PassRegistry.def"
3005 };
3006 printPassNameList(StringTable(LoopAnalysisNames), OS);
3007
3008 OS << "Machine module passes (WIP):\n";
3009 static constexpr char MachineModulePassNames[] = {"\0"
3010#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) NAME "\0"
3011#include "llvm/Passes/MachinePassRegistry.def"
3012 };
3013 printPassNameList(StringTable(MachineModulePassNames), OS);
3014
3015 OS << "Machine function passes (WIP):\n";
3016 static constexpr char MachineFunctionPassNames[] = {"\0"
3017#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) NAME "\0"
3018#include "llvm/Passes/MachinePassRegistry.def"
3019 };
3020 printPassNameList(StringTable(MachineFunctionPassNames), OS);
3021
3022 OS << "Machine function analyses (WIP):\n";
3023 static constexpr char MachineFunctionAnalysisNames[] = {"\0"
3024#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
3025#include "llvm/Passes/MachinePassRegistry.def"
3026 };
3027 printPassNameList(StringTable(MachineFunctionAnalysisNames), OS);
3028}
3029
3030void PassBuilder::registerParseTopLevelPipelineCallback(
3031 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
3032 &C) {
3033 TopLevelPipelineParsingCallbacks.push_back(C);
3034}
assert
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
AggressiveInstCombine.h
AggressiveInstCombiner - Combine expression patterns to form expressions with fewer,...
AliasAnalysisEvaluator.h
This file implements a simple N^2 alias analysis accuracy evaluator.
AlwaysInliner.h
Provides passes to inlining "always_inline" functions.
BasicAliasAnalysis.h
This is the interface for LLVM's primary stateless and local alias analysis.
BreakFalseDeps.h
This file contains the declaration of the BreakFalseDepsPass class, used to identify and avoid false ...
C
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
CFIFixup.h
Contains definition of the base CFIFixup pass.
CGProfile.h
This file provides the interface for LLVM's Call Graph Profile pass.
CGSCCPassManager.h
This header provides classes for managing passes over SCCs of the call graph.
CSEInfo.h
Provides analysis for continuously CSEing during GISel passes.
CallGraph.h
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
CodeGenPrepare.h
Defines an IR pass for CodeGen Prepare.
KCFI.h
This file contains the declaration of the MachineKCFI class, which is a Machine Pass that implements ...
LLVM_ATTRIBUTE_NOINLINE
#define LLVM_ATTRIBUTE_NOINLINE
LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, mark a method "not for inl...
Definition Compiler.h:359
CycleAnalysis.h
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
DetectDeadLanes.h
Analysis that tracks defined/used subregister lanes across COPY instructions and instructions that ge...
EarlyCSE.h
This file provides the interface for a simple, fast CSE pass.
EmbedBitcodePass.h
This file provides a pass which clones the current module and runs the provided pass pipeline on the ...
ForceFunctionAttrs.h
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
FunctionAttrs.h
Provides passes for computing function attributes based on interprocedural analyses.
GCOVProfiler.h
This file provides the interface for the GCOV style profiler pass.
GISelValueTracking.h
Provides analysis for querying information about KnownBits during GISel passes.
GVNHoist.h
This file provides the interface for the GVNHoist pass.
GVNSink.h
This file provides the interface for the GVNSink pass.
GVN.h
This file provides the interface for LLVM's Global Value Numbering pass which eliminates fully redund...
GlobalsModRef.h
This is the interface for a simple mod/ref and alias analysis over globals.
HardwareLoops.h
Defines an IR pass for the creation of hardware loops.
_
#define _
Definition HexagonMCCodeEmitter.cpp:46
HipStdPar.h
AcceleratorCodeSelection - Identify all functions reachable from a kernel, removing those that are un...
IR2Vec.h
This file defines the IR2Vec vocabulary analysis(IR2VecVocabAnalysis), the core ir2vec::Embedder inte...
IRPrintingPasses.h
This file defines passes to print out IR in various granularities.
IRTranslator.h
This file declares the IRTranslator pass.
PassManager.h
This header defines various interfaces for pass management in LLVM.
InferFunctionAttrs.h
Interfaces for passes which infer implicit function attributes from the name and signature of functio...
InstCombine.h
This file provides the primary interface to the instcombine pass.
InstSimplifyPass.h
Defines passes for running instruction simplification across chunks of IR.
InstrProfiling.h
This file provides the interface for LLVM's PGO Instrumentation lowering pass.
InterleavedAccess.h
This file contains the declaration of the InterleavedAccessPass class, its corresponding pass name is...
JumpThreading.h
See the comments on JumpThreadingPass.
Options
static LVOptions Options
Definition LVOptions.cpp:25
LazyCallGraph.h
Implements a lazy call graph analysis and related passes for the new pass manager.
LogicalSROA.h
This file provides the interface for LLVM's Logical Scalar Replacement of Aggregates pass.
LoopCacheAnalysis.h
This file defines the interface for the loop cache analysis.
LoopDataPrefetch.h
This file provides the interface for LLVM's Loop Data Prefetching Pass.
LoopFuse.h
This file implements the Loop Fusion pass.
LoopLoadElimination.h
This header defines the LoopLoadEliminationPass object.
LoopNestAnalysis.h
This file defines the interface for the loop nest analysis.
LoopPassManager.h
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
LowerAllowCheckPass.h
This file provides the interface for the pass responsible for removing expensive ubsan checks.
LowerConstantIntrinsics.h
The header file for the LowerConstantIntrinsics pass as used by the new pass manager.
LowerExpectIntrinsic.h
The header file for the LowerExpectIntrinsic pass as used by the new pass manager.
F
#define F(x, y, z)
Definition MD5.cpp:54
I
#define I(x, y, z)
Definition MD5.cpp:57
Module
Machine Check Debug Module
Definition MachineCheckDebugify.cpp:133
MachineCheckDebugify.h
This file contains the declaration of the CheckDebugMachineModulePass class, used by the new pass man...
MachineUniformityAnalysis.h
Machine IR instance of the generic uniformity analysis.
MemorySSA.h
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
MergedLoadStoreMotion.h
This pass performs merges of loads and stores on both sides of a.
ModuleSummaryAnalysis.h
This is the interface to build a ModuleSummaryIndex for a module.
MustExecute.h
Contains a collection of routines for determining if a given instruction is guaranteed to execute if ...
NewGVN.h
This file provides the interface for LLVM's Global Value Numbering pass.
ObjCARCAliasAnalysis.h
This file declares a simple ARC-aware AliasAnalysis using special knowledge of Objective C to enhance...
OptimizationLevel.h
This header enumerates the LLVM-provided high-level optimization levels.
PGOInstrumentation.h
This file provides the interface for IR based instrumentation passes ( (profile-gen,...
CGAM
CGSCCAnalysisManager CGAM
Definition PassBuilderBindings.cpp:62
LAM
LoopAnalysisManager LAM
Definition PassBuilderBindings.cpp:60
FAM
FunctionAnalysisManager FAM
Definition PassBuilderBindings.cpp:61
MAM
ModuleAnalysisManager MAM
Definition PassBuilderBindings.cpp:63
if
if(PassOpts->AAPipeline)
Definition PassBuilderBindings.cpp:64
PB
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
isModulePassName
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1881
callbacksAcceptPassName
static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks)
Tests whether registered callbacks will accept a given pass name.
Definition PassBuilder.cpp:1870
parseDevirtPassName
static std::optional< int > parseDevirtPassName(StringRef Name)
Definition PassBuilder.cpp:815
printPassNameList
static LLVM_ATTRIBUTE_NOINLINE void printPassNameList(StringTable PassNames, raw_ostream &OS)
Definition PassBuilder.cpp:2876
isLoopNestPassName
static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
Definition PassBuilder.cpp:1982
isMachineFunctionPassName
static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1959
parseOptLevelParam
static Expected< OptimizationLevel > parseOptLevelParam(StringRef S)
Definition PassBuilder.cpp:583
parseOptLevel
static std::optional< OptimizationLevel > parseOptLevel(StringRef S)
Definition PassBuilder.cpp:568
isLoopPassName
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
Definition PassBuilder.cpp:2000
parseFunctionPipelineName
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
Definition PassBuilder.cpp:794
isCGSCCPassName
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1909
printPassNameListWithParams
static LLVM_ATTRIBUTE_NOINLINE void printPassNameListWithParams(StringTable PassNames, raw_ostream &OS)
Definition PassBuilder.cpp:2883
isFunctionPassName
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1936
setupOptionsForPipelineAlias
static void setupOptionsForPipelineAlias(PipelineTuningOptions &PTO, OptimizationLevel L)
Definition PassBuilder.cpp:2080
PredicateInfo.h
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
Mode
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
RegBankSelect.h
This file describes the interface of the MachineFunctionPass responsible for assigning the generic vi...
RegisterUsageInfo.h
This pass is required to take advantage of the interprocedural register allocation infrastructure.
RelLookupTableConverter.h
This file implements relative lookup table converter that converts lookup tables to relative lookup t...
ResetMachineFunctionPass.h
This file contains the declaration of the ResetMachineFunctionPass class.
SROA.h
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
name
static const char * name
Definition SVEShuffleOpts.cpp:269
SampleProfileProbe.h
This file provides the interface for the pseudo probe implementation for AutoFDO.
SampleProfile.h
This file provides the interface for the sampled PGO loader pass.
ScalarEvolutionAliasAnalysis.h
This is the interface for a SCEV-based alias analysis.
Scalarizer.h
This pass converts vector operations into scalar operations (or, optionally, operations on smaller ve...
ScopedNoAliasAA.h
This is the interface for a metadata-based scoped no-alias analysis.
SelectOptimize.h
This file contains the declaration of the SelectOptimizePass class, its corresponding pass name is se...
SimplifyCFG.h
This file provides the interface for the pass responsible for both simplifying and canonicalizing the...
StringSwitch.h
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
StripConvergenceIntrinsics.h
This pass strips convergence intrinsics and operand bundles as those are only useful when modifying t...
TargetPassConfig.h
Target-Independent Code Generator Pass Configuration Options pass.
TargetTransformInfo.h
This pass exposes codegen information to IR-level passes.
TypeBasedAliasAnalysis.h
This is the interface for a metadata-based TBAA.
TypePromotion.h
Defines an IR pass for type promotion.
UniformityAnalysis.h
LLVM IR instance of the generic uniformity analysis.
PassName
static const char PassName[]
Definition X86LowerAMXIntrinsics.cpp:709
llvm::AAManager
A manager for alias analyses.
Definition AliasAnalysis.h:967
llvm::APInt
Class for arbitrary precision integers.
Definition APInt.h:78
llvm::APInt::getZExtValue
uint64_t getZExtValue() const
Get zero extended value.
Definition APInt.h:1560
llvm::APInt::getSExtValue
int64_t getSExtValue() const
Get sign extended value.
Definition APInt.h:1582
llvm::AnalysisManager::registerPass
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition PassManager.h:497
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition PassManager.h:436
llvm::ArrayRef
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
Definition BasicBlock.h:237
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
llvm::Expected
Tagged union holding either a T or a Error.
Definition Error.h:485
llvm::GlobalAlias::create
static LLVM_ABI GlobalAlias * create(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage, const Twine &Name, Constant *Aliasee, Module *Parent)
If a parent module is specified, the alias is automatically inserted into the end of the specified mo...
Definition Globals.cpp:692
llvm::IntrusiveRefCntPtr
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
Definition IntrusiveRefCntPtr.h:174
llvm::LLT::scalar
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
Definition LowLevelType.h:89
llvm::MachineFunctionAnalysis
This analysis create MachineFunction for given Function.
Definition MachineFunctionAnalysis.h:27
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition MachineFunction.h:788
llvm::MachineFunction::getProperties
const MachineFunctionProperties & getProperties() const
Get the function properties.
Definition MachineFunction.h:875
llvm::MachineRegisterInfo::createGenericVirtualRegister
LLVM_ABI Register createGenericVirtualRegister(LLT Ty, StringRef Name="")
Create and return a new generic virtual register with low-level type Ty.
Definition MachineRegisterInfo.cpp:193
llvm::PassBuilder
This class provides access to building LLVM's passes.
Definition PassBuilder.h:114
llvm::PassBuilder::printPassNames
LLVM_ABI void printPassNames(raw_ostream &OS)
Print pass names.
Definition PassBuilder.cpp:2896
llvm::PassBuilder::checkParametrizedPassName
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition PassBuilder.h:712
llvm::PassBuilder::buildDefaultAAPipeline
LLVM_ABI AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Definition PassBuilderPipelines.cpp:2549
llvm::PassBuilder::parseAAPipeline
LLVM_ABI Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
Definition PassBuilder.cpp:2846
llvm::PassBuilder::registerLoopAnalyses
LLVM_ABI void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
Definition PassBuilder.cpp:784
llvm::PassBuilder::parseRegAllocFilter
LLVM_ABI std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)
Parse RegAllocFilterName to get RegAllocFilterFunc.
Definition PassBuilder.cpp:2867
llvm::PassBuilder::crossRegisterProxies
LLVM_ABI void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
Definition PassBuilder.cpp:2686
llvm::PassBuilder::PassBuilder
LLVM_ABI PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr, IntrusiveRefCntPtr< vfs::FileSystem > FS=vfs::getRealFileSystem())
Definition PassBuilder.cpp:592
llvm::PassBuilder::parsePassPipeline
LLVM_ABI Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
Definition PassBuilder.cpp:2722
llvm::PassBuilder::registerPipelineParsingCallback
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, CGSCCPassManager &, ArrayRef< PipelineElement >)> &C)
{{@ Register pipeline parsing callbacks with this pass builder instance.
Definition PassBuilder.h:608
llvm::PassBuilder::registerModuleAnalyses
LLVM_ABI void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
Definition PassBuilder.cpp:734
llvm::PassBuilder::registerCGSCCAnalyses
LLVM_ABI void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
Definition PassBuilder.cpp:743
llvm::PassBuilder::parseSinglePassOption
static LLVM_ABI Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
Definition PassBuilder.cpp:824
llvm::PassBuilder::registerMachineFunctionAnalyses
LLVM_ABI void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
Definition PassBuilder.cpp:773
llvm::PassBuilder::registerParseTopLevelPipelineCallback
LLVM_ABI void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
Definition PassBuilder.cpp:3030
llvm::PassBuilder::registerFunctionAnalyses
LLVM_ABI void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
Definition PassBuilder.cpp:752
llvm::PassInstrumentationCallbacks
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
Definition PassInstrumentation.h:67
llvm::PassManager::addPass
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
Definition PassManager.h:225
llvm::PipelineTuningOptions
Tunable parameters for passes in the default pipelines.
Definition PassBuilder.h:41
llvm::PipelineTuningOptions::SLPVectorization
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition PassBuilder.h:56
llvm::PipelineTuningOptions::LoopVectorization
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition PassBuilder.h:52
llvm::PreservedAnalyses::none
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition Analysis.h:115
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition Analysis.h:118
llvm::SmallVectorTemplateBase::push_back
void push_back(const T &Elt)
Definition SmallVector.h:423
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1252
llvm::StringRef
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
llvm::StringRef::split
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition StringRef.h:736
llvm::StringRef::getAsInteger
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition StringRef.h:490
llvm::StringRef::str
std::string str() const
Get the contents as an std::string.
Definition StringRef.h:222
llvm::StringRef::starts_with
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition StringRef.h:258
llvm::StringRef::empty
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
llvm::StringRef::front
char front() const
Get the first character in the string.
Definition StringRef.h:147
llvm::StringRef::consume_front
bool consume_front(char Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition StringRef.h:661
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition StringSwitch.h:47
llvm::StringSwitch::Case
StringSwitch & Case(StringLiteral S, T Value)
Definition StringSwitch.h:69
llvm::StringTable
A table of densely packed, null-terminated strings indexed by offset.
Definition StringTable.h:34
llvm::StringTable::begin
constexpr Iterator begin() const
Definition StringTable.h:144
llvm::StringTable::end
constexpr Iterator end() const
Definition StringTable.h:145
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition TargetMachine.h:84
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition ilist_node.h:123
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
PassBuilder.h
Interfaces for registering analysis passes, producing common pass manager configurations,...
llvm::AA
Abstract Attribute helper functions.
Definition Attributor.h:165
llvm::CodeGenOpt::getLevel
std::optional< CodeGenOptLevel > getLevel(int OL)
Get the Level identified by the integer OL.
Definition CodeGen.h:238
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition ISDOpcodes.h:83
llvm::dxil::PointerTypeAnalysis::run
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
Definition PointerTypeAnalysis.cpp:216
llvm::lowertypetests::DropTestKind
DropTestKind
Specifies how to drop type tests.
Definition LowerTypeTests.h:236
llvm::lowertypetests::DropTestKind::All
@ All
Drop only llvm.assumes using type test value.
Definition LowerTypeTests.h:238
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
Definition MicrosoftDemangle.h:132
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition DefaultTargetInfo.h:21
llvm::CGSCCAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
Definition CGSCCPassManager.h:408
llvm::ModuleAnalysisManagerMachineFunctionProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition MachinePassManager.h:126
llvm::PrintPipelinePasses
LLVM_ABI cl::opt< std::optional< PrintPipelinePassesFormat >, false, PrintPipelinePassesFormatParser > PrintPipelinePasses
Common option used by multiple tools to print pipeline passes.
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:902
llvm::createDevirtSCCRepeatedPass
DevirtSCCRepeatedPass createDevirtSCCRepeatedPass(CGSCCPassT &&Pass, int MaxIterations)
A function to deduce a function pass type and wrap it in the templated adaptor.
Definition CGSCCPassManager.h:567
llvm::ModuleAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition PassManager.h:852
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::FunctionAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
Definition PassManager.h:698
llvm::OptimizationLevel::O1
@ O1
Optimize quickly without destroying debuggability.
Definition OptimizationLevel.h:43
llvm::OptimizationLevel::O0
@ O0
Disable as many optimizations as possible.
Definition OptimizationLevel.h:27
llvm::OptimizationLevel::O3
@ O3
Optimize for fast execution as much as possible.
Definition OptimizationLevel.h:76
llvm::OptimizationLevel::O2
@ O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
Definition OptimizationLevel.h:61
llvm::LoopAnalysisManagerFunctionProxy
InnerAnalysisManagerProxy< LoopAnalysisManager, Function > LoopAnalysisManagerFunctionProxy
A proxy from a LoopAnalysisManager to a Function.
Definition LoopAnalysisManager.h:79
llvm::MachineFunctionAnalysisManager
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
Definition MachineFunctionAnalysisManager.h:24
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition Error.h:1321
llvm::CGSCCPassManager
PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager
The CGSCC pass manager.
Definition CGSCCPassManager.h:143
llvm::CGSCCAnalysisManager
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
Definition CGSCCPassManager.h:123
llvm::LoopAnalysisManager
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
Definition LoopAnalysisManager.h:75
llvm::LoopPassManager
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
Definition LoopPassManager.h:173
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
llvm::formatv
auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)
Definition FormatVariadic.h:247
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:432
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:498
llvm::createFunctionToMachineFunctionPassAdaptor
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
Definition MachinePassManager.h:212
llvm::ModulePassManager
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
Definition PassManager.h:263
llvm::SmallVector
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition SmallVector.h:1178
llvm::MachineFunctionAnalysisManagerFunctionProxy
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Function > MachineFunctionAnalysisManagerFunctionProxy
Definition MachinePassManager.h:113
llvm::FunctionAnalysisManagerLoopProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
Definition LoopAnalysisManager.h:156
llvm::make_error
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
Definition Error.h:340
llvm::fmt_repeat
support::detail::RepeatAdapter< T > fmt_repeat(T &&Item, size_t Count)
Definition FormatAdapters.h:98
llvm::ModuleAnalysisManagerCGSCCProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
Definition CGSCCPassManager.h:214
llvm::MachineFunctionAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
Definition MachinePassManager.h:104
llvm::Count
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
Definition InstrProf.h:145
llvm::CGSCCAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< CGSCCAnalysisManager, Module > CGSCCAnalysisManagerModuleProxy
A proxy from a CGSCCAnalysisManager to a Module.
Definition CGSCCPassManager.h:168
llvm::FunctionPassManager
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
Definition PassManager.h:272
llvm::MFPropsModifier
MFPropsModifier(PassT &P, MachineFunction &MF) -> MFPropsModifier< PassT >
llvm::printFormattedPipelinePasses
LLVM_ABI void printFormattedPipelinePasses(raw_ostream &OS, StringRef Pipeline, PrintPipelinePassesFormat Format=PrintPipelinePassesFormat::Text)
Definition PassBuilder.cpp:455
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1933
llvm::MachineFunctionPassManager
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
Definition MachinePassManager.h:225
llvm::applyDebugifyMetadataToMachineFunction
LLVM_ABI bool applyDebugifyMetadataToMachineFunction(DIBuilder &DIB, Function &F, llvm::function_ref< MachineFunction *(Function &)> GetMF)
Definition MachineDebugify.cpp:31
llvm::FunctionAnalysisManager
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition PassManager.h:591
llvm::getAllocTokenModeFromString
LLVM_ABI std::optional< AllocTokenMode > getAllocTokenModeFromString(StringRef Name)
Returns the AllocTokenMode from its canonical string name; if an invalid name was provided returns nu...
Definition AllocToken.cpp:21
llvm::PrintPipelinePassesFormat
PrintPipelinePassesFormat
Definition PassBuilder.h:1031
llvm::StructuralHashOptions::Detailed
@ Detailed
Hash with opcode only.
Definition StructuralHash.h:18
llvm::StructuralHashOptions::CallTargetIgnored
@ CallTargetIgnored
Hash with opcode and operands.
Definition StructuralHash.h:19
llvm::ModuleAnalysisManager
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39
llvm::ColorMode::Enable
@ Enable
Enable colors.
Definition WithColor.h:47
llvm::reportFatalUsageError
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Definition Error.cpp:177
std
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:878
N
#define N
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition Analysis.h:29
llvm::GVNOptions
A set of parameters to control various transforms performed by GVN pass.
Definition GVN.h:32
llvm::HardwareLoopOptions::setForceNested
HardwareLoopOptions & setForceNested(bool Force)
Definition HardwareLoops.h:45
llvm::HardwareLoopOptions::setDecrement
HardwareLoopOptions & setDecrement(unsigned Count)
Definition HardwareLoops.h:29
llvm::HardwareLoopOptions::setForceGuard
HardwareLoopOptions & setForceGuard(bool Force)
Definition HardwareLoops.h:49
llvm::HardwareLoopOptions::setForce
HardwareLoopOptions & setForce(bool Force)
Definition HardwareLoops.h:37
llvm::HardwareLoopOptions::setCounterBitwidth
HardwareLoopOptions & setCounterBitwidth(unsigned Width)
Definition HardwareLoops.h:33
llvm::HardwareLoopOptions::setForcePhi
HardwareLoopOptions & setForcePhi(bool Force)
Definition HardwareLoops.h:41
llvm::IPSCCPOptions
A set of parameters to control various transforms performed by IPSCCP pass.
Definition SCCP.h:35
llvm::LoopUnrollOptions
A set of parameters used to control various transforms performed by the LoopUnroll pass.
Definition LoopUnrollPass.h:67
llvm::LoopUnrollOptions::setPeeling
LoopUnrollOptions & setPeeling(bool Peeling)
Enables or disables loop peeling.
Definition LoopUnrollPass.h:109
llvm::LoopUnrollOptions::setOptLevel
LoopUnrollOptions & setOptLevel(int O)
Definition LoopUnrollPass.h:122
llvm::LoopUnrollOptions::setPartial
LoopUnrollOptions & setPartial(bool Partial)
Enables or disables partial unrolling.
Definition LoopUnrollPass.h:97
llvm::LoopUnrollOptions::setFullUnrollMaxCount
LoopUnrollOptions & setFullUnrollMaxCount(unsigned O)
Definition LoopUnrollPass.h:134
llvm::LoopUnrollOptions::setPrepareForLTO
LoopUnrollOptions & setPrepareForLTO(bool V)
Definition LoopUnrollPass.h:139
llvm::LoopUnrollOptions::setUpperBound
LoopUnrollOptions & setUpperBound(bool UpperBound)
Enables or disables the use of trip count upper bound in loop unrolling.
Definition LoopUnrollPass.h:116
llvm::LoopUnrollOptions::setRuntime
LoopUnrollOptions & setRuntime(bool Runtime)
Enables or disables unrolling of loops with runtime trip count.
Definition LoopUnrollPass.h:103
llvm::LoopUnrollOptions::setProfileBasedPeeling
LoopUnrollOptions & setProfileBasedPeeling(int O)
Definition LoopUnrollPass.h:128
llvm::LoopVectorizeOptions::setVectorizeOnlyWhenForced
LoopVectorizeOptions & setVectorizeOnlyWhenForced(bool Value)
Definition LoopVectorize.h:116
llvm::LoopVectorizeOptions::setInterleaveOnlyWhenForced
LoopVectorizeOptions & setInterleaveOnlyWhenForced(bool Value)
Definition LoopVectorize.h:111
llvm::OptionalPassInfoMixin
A CRTP mix-in for passes that can be skipped.
Definition PassManager.h:114
llvm::PrintPipelinePassesFormatParser::parse
LLVM_ABI bool parse(cl::Option &O, StringRef ArgName, StringRef ArgValue, std::optional< PrintPipelinePassesFormat > &Val)
Definition PassBuilder.cpp:437
Generated on for LLVM by doxygen 1.14.0