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