1 //===- Parsing and selection of pass pipelines ----------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 ///
10 /// This file provides the implementation of the PassBuilder based on our
11 /// static pass registry as well as related functionality. It also provides
12 /// helpers to aid in analyzing, debugging, and testing passes and pass
13 /// pipelines.
14 ///
15 //===----------------------------------------------------------------------===//
16
17 #include "llvm/Passes/PassBuilder.h"
18 #include "llvm/ADT/StringSwitch.h"
19 #include "llvm/Analysis/AliasAnalysisEvaluator.h"
20 #include "llvm/Analysis/AliasSetTracker.h"
21 #include "llvm/Analysis/AssumptionCache.h"
22 #include "llvm/Analysis/BasicAliasAnalysis.h"
23 #include "llvm/Analysis/BlockFrequencyInfo.h"
24 #include "llvm/Analysis/BranchProbabilityInfo.h"
25 #include "llvm/Analysis/CFGPrinter.h"
26 #include "llvm/Analysis/CFGSCCPrinter.h"
27 #include "llvm/Analysis/CGSCCPassManager.h"
28 #include "llvm/Analysis/CallGraph.h"
29 #include "llvm/Analysis/CallPrinter.h"
30 #include "llvm/Analysis/CostModel.h"
31 #include "llvm/Analysis/CycleAnalysis.h"
32 #include "llvm/Analysis/DDG.h"
33 #include "llvm/Analysis/DDGPrinter.h"
34 #include "llvm/Analysis/Delinearization.h"
35 #include "llvm/Analysis/DemandedBits.h"
36 #include "llvm/Analysis/DependenceAnalysis.h"
37 #include "llvm/Analysis/DomPrinter.h"
38 #include "llvm/Analysis/DominanceFrontier.h"
39 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
40 #include "llvm/Analysis/GlobalsModRef.h"
41 #include "llvm/Analysis/IRSimilarityIdentifier.h"
42 #include "llvm/Analysis/IVUsers.h"
43 #include "llvm/Analysis/InlineAdvisor.h"
44 #include "llvm/Analysis/InlineSizeEstimatorAnalysis.h"
45 #include "llvm/Analysis/InstCount.h"
46 #include "llvm/Analysis/LazyCallGraph.h"
47 #include "llvm/Analysis/LazyValueInfo.h"
48 #include "llvm/Analysis/Lint.h"
49 #include "llvm/Analysis/LoopAccessAnalysis.h"
50 #include "llvm/Analysis/LoopCacheAnalysis.h"
51 #include "llvm/Analysis/LoopInfo.h"
52 #include "llvm/Analysis/LoopNestAnalysis.h"
53 #include "llvm/Analysis/MemDerefPrinter.h"
54 #include "llvm/Analysis/MemoryDependenceAnalysis.h"
55 #include "llvm/Analysis/MemorySSA.h"
56 #include "llvm/Analysis/ModuleDebugInfoPrinter.h"
57 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
58 #include "llvm/Analysis/MustExecute.h"
59 #include "llvm/Analysis/ObjCARCAliasAnalysis.h"
60 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
61 #include "llvm/Analysis/PhiValues.h"
62 #include "llvm/Analysis/PostDominators.h"
63 #include "llvm/Analysis/ProfileSummaryInfo.h"
64 #include "llvm/Analysis/RegionInfo.h"
65 #include "llvm/Analysis/ScalarEvolution.h"
66 #include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
67 #include "llvm/Analysis/ScopedNoAliasAA.h"
68 #include "llvm/Analysis/StackLifetime.h"
69 #include "llvm/Analysis/StackSafetyAnalysis.h"
70 #include "llvm/Analysis/StructuralHash.h"
71 #include "llvm/Analysis/TargetLibraryInfo.h"
72 #include "llvm/Analysis/TargetTransformInfo.h"
73 #include "llvm/Analysis/TypeBasedAliasAnalysis.h"
74 #include "llvm/Analysis/UniformityAnalysis.h"
75 #include "llvm/CodeGen/AssignmentTrackingAnalysis.h"
76 #include "llvm/CodeGen/BasicBlockSectionsProfileReader.h"
77 #include "llvm/CodeGen/CallBrPrepare.h"
78 #include "llvm/CodeGen/CodeGenPrepare.h"
79 #include "llvm/CodeGen/DwarfEHPrepare.h"
80 #include "llvm/CodeGen/ExpandLargeDivRem.h"
81 #include "llvm/CodeGen/ExpandLargeFpConvert.h"
82 #include "llvm/CodeGen/ExpandMemCmp.h"
83 #include "llvm/CodeGen/GCMetadata.h"
84 #include "llvm/CodeGen/GlobalMerge.h"
85 #include "llvm/CodeGen/HardwareLoops.h"
86 #include "llvm/CodeGen/IndirectBrExpand.h"
87 #include "llvm/CodeGen/InterleavedAccess.h"
88 #include "llvm/CodeGen/InterleavedLoadCombine.h"
89 #include "llvm/CodeGen/JMCInstrumenter.h"
90 #include "llvm/CodeGen/LowerEmuTLS.h"
91 #include "llvm/CodeGen/SafeStack.h"
92 #include "llvm/CodeGen/SelectOptimize.h"
93 #include "llvm/CodeGen/ShadowStackGCLowering.h"
94 #include "llvm/CodeGen/SjLjEHPrepare.h"
95 #include "llvm/CodeGen/StackProtector.h"
96 #include "llvm/CodeGen/TargetPassConfig.h"
97 #include "llvm/CodeGen/TypePromotion.h"
98 #include "llvm/CodeGen/WasmEHPrepare.h"
99 #include "llvm/CodeGen/WinEHPrepare.h"
100 #include "llvm/IR/DebugInfo.h"
101 #include "llvm/IR/Dominators.h"
102 #include "llvm/IR/PassManager.h"
103 #include "llvm/IR/PrintPasses.h"
104 #include "llvm/IR/SafepointIRVerifier.h"
105 #include "llvm/IR/Verifier.h"
106 #include "llvm/IRPrinter/IRPrintingPasses.h"
107 #include "llvm/Passes/OptimizationLevel.h"
108 #include "llvm/Support/CommandLine.h"
109 #include "llvm/Support/Debug.h"
110 #include "llvm/Support/ErrorHandling.h"
111 #include "llvm/Support/FormatVariadic.h"
112 #include "llvm/Support/Regex.h"
113 #include "llvm/Target/TargetMachine.h"
114 #include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
115 #include "llvm/Transforms/CFGuard.h"
116 #include "llvm/Transforms/Coroutines/CoroCleanup.h"
117 #include "llvm/Transforms/Coroutines/CoroConditionalWrapper.h"
118 #include "llvm/Transforms/Coroutines/CoroEarly.h"
119 #include "llvm/Transforms/Coroutines/CoroElide.h"
120 #include "llvm/Transforms/Coroutines/CoroSplit.h"
121 #include "llvm/Transforms/HipStdPar/HipStdPar.h"
122 #include "llvm/Transforms/IPO/AlwaysInliner.h"
123 #include "llvm/Transforms/IPO/Annotation2Metadata.h"
124 #include "llvm/Transforms/IPO/ArgumentPromotion.h"
125 #include "llvm/Transforms/IPO/Attributor.h"
126 #include "llvm/Transforms/IPO/BlockExtractor.h"
127 #include "llvm/Transforms/IPO/CalledValuePropagation.h"
128 #include "llvm/Transforms/IPO/ConstantMerge.h"
129 #include "llvm/Transforms/IPO/CrossDSOCFI.h"
130 #include "llvm/Transforms/IPO/DeadArgumentElimination.h"
131 #include "llvm/Transforms/IPO/ElimAvailExtern.h"
132 #include "llvm/Transforms/IPO/EmbedBitcodePass.h"
133 #include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
134 #include "llvm/Transforms/IPO/FunctionAttrs.h"
135 #include "llvm/Transforms/IPO/FunctionImport.h"
136 #include "llvm/Transforms/IPO/GlobalDCE.h"
137 #include "llvm/Transforms/IPO/GlobalOpt.h"
138 #include "llvm/Transforms/IPO/GlobalSplit.h"
139 #include "llvm/Transforms/IPO/HotColdSplitting.h"
140 #include "llvm/Transforms/IPO/IROutliner.h"
141 #include "llvm/Transforms/IPO/InferFunctionAttrs.h"
142 #include "llvm/Transforms/IPO/Inliner.h"
143 #include "llvm/Transforms/IPO/Internalize.h"
144 #include "llvm/Transforms/IPO/LoopExtractor.h"
145 #include "llvm/Transforms/IPO/LowerTypeTests.h"
146 #include "llvm/Transforms/IPO/MemProfContextDisambiguation.h"
147 #include "llvm/Transforms/IPO/MergeFunctions.h"
148 #include "llvm/Transforms/IPO/ModuleInliner.h"
149 #include "llvm/Transforms/IPO/OpenMPOpt.h"
150 #include "llvm/Transforms/IPO/PartialInlining.h"
151 #include "llvm/Transforms/IPO/SCCP.h"
152 #include "llvm/Transforms/IPO/SampleProfile.h"
153 #include "llvm/Transforms/IPO/SampleProfileProbe.h"
154 #include "llvm/Transforms/IPO/StripDeadPrototypes.h"
155 #include "llvm/Transforms/IPO/StripSymbols.h"
156 #include "llvm/Transforms/IPO/SyntheticCountsPropagation.h"
157 #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
158 #include "llvm/Transforms/InstCombine/InstCombine.h"
159 #include "llvm/Transforms/Instrumentation.h"
160 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
161 #include "llvm/Transforms/Instrumentation/BoundsChecking.h"
162 #include "llvm/Transforms/Instrumentation/CGProfile.h"
163 #include "llvm/Transforms/Instrumentation/ControlHeightReduction.h"
164 #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
165 #include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
166 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
167 #include "llvm/Transforms/Instrumentation/InstrOrderFile.h"
168 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
169 #include "llvm/Transforms/Instrumentation/KCFI.h"
170 #include "llvm/Transforms/Instrumentation/MemProfiler.h"
171 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
172 #include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
173 #include "llvm/Transforms/Instrumentation/PoisonChecking.h"
174 #include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
175 #include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
176 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
177 #include "llvm/Transforms/ObjCARC.h"
178 #include "llvm/Transforms/Scalar/ADCE.h"
179 #include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
180 #include "llvm/Transforms/Scalar/AnnotationRemarks.h"
181 #include "llvm/Transforms/Scalar/BDCE.h"
182 #include "llvm/Transforms/Scalar/CallSiteSplitting.h"
183 #include "llvm/Transforms/Scalar/ConstantHoisting.h"
184 #include "llvm/Transforms/Scalar/ConstraintElimination.h"
185 #include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
186 #include "llvm/Transforms/Scalar/DCE.h"
187 #include "llvm/Transforms/Scalar/DFAJumpThreading.h"
188 #include "llvm/Transforms/Scalar/DeadStoreElimination.h"
189 #include "llvm/Transforms/Scalar/DivRemPairs.h"
190 #include "llvm/Transforms/Scalar/EarlyCSE.h"
191 #include "llvm/Transforms/Scalar/FlattenCFG.h"
192 #include "llvm/Transforms/Scalar/Float2Int.h"
193 #include "llvm/Transforms/Scalar/GVN.h"
194 #include "llvm/Transforms/Scalar/GuardWidening.h"
195 #include "llvm/Transforms/Scalar/IVUsersPrinter.h"
196 #include "llvm/Transforms/Scalar/IndVarSimplify.h"
197 #include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h"
198 #include "llvm/Transforms/Scalar/InferAddressSpaces.h"
199 #include "llvm/Transforms/Scalar/InferAlignment.h"
200 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
201 #include "llvm/Transforms/Scalar/JumpThreading.h"
202 #include "llvm/Transforms/Scalar/LICM.h"
203 #include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h"
204 #include "llvm/Transforms/Scalar/LoopBoundSplit.h"
205 #include "llvm/Transforms/Scalar/LoopDataPrefetch.h"
206 #include "llvm/Transforms/Scalar/LoopDeletion.h"
207 #include "llvm/Transforms/Scalar/LoopDistribute.h"
208 #include "llvm/Transforms/Scalar/LoopFlatten.h"
209 #include "llvm/Transforms/Scalar/LoopFuse.h"
210 #include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
211 #include "llvm/Transforms/Scalar/LoopInstSimplify.h"
212 #include "llvm/Transforms/Scalar/LoopInterchange.h"
213 #include "llvm/Transforms/Scalar/LoopLoadElimination.h"
214 #include "llvm/Transforms/Scalar/LoopPassManager.h"
215 #include "llvm/Transforms/Scalar/LoopPredication.h"
216 #include "llvm/Transforms/Scalar/LoopReroll.h"
217 #include "llvm/Transforms/Scalar/LoopRotation.h"
218 #include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
219 #include "llvm/Transforms/Scalar/LoopSink.h"
220 #include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
221 #include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
222 #include "llvm/Transforms/Scalar/LoopUnrollPass.h"
223 #include "llvm/Transforms/Scalar/LoopVersioningLICM.h"
224 #include "llvm/Transforms/Scalar/LowerAtomicPass.h"
225 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
226 #include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
227 #include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
228 #include "llvm/Transforms/Scalar/LowerMatrixIntrinsics.h"
229 #include "llvm/Transforms/Scalar/LowerWidenableCondition.h"
230 #include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
231 #include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
232 #include "llvm/Transforms/Scalar/MergeICmps.h"
233 #include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
234 #include "llvm/Transforms/Scalar/NaryReassociate.h"
235 #include "llvm/Transforms/Scalar/NewGVN.h"
236 #include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
237 #include "llvm/Transforms/Scalar/PlaceSafepoints.h"
238 #include "llvm/Transforms/Scalar/Reassociate.h"
239 #include "llvm/Transforms/Scalar/Reg2Mem.h"
240 #include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
241 #include "llvm/Transforms/Scalar/SCCP.h"
242 #include "llvm/Transforms/Scalar/SROA.h"
243 #include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h"
244 #include "llvm/Transforms/Scalar/Scalarizer.h"
245 #include "llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h"
246 #include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
247 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
248 #include "llvm/Transforms/Scalar/Sink.h"
249 #include "llvm/Transforms/Scalar/SpeculativeExecution.h"
250 #include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
251 #include "llvm/Transforms/Scalar/StructurizeCFG.h"
252 #include "llvm/Transforms/Scalar/TLSVariableHoist.h"
253 #include "llvm/Transforms/Scalar/TailRecursionElimination.h"
254 #include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
255 #include "llvm/Transforms/Utils/AddDiscriminators.h"
256 #include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
257 #include "llvm/Transforms/Utils/BreakCriticalEdges.h"
258 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
259 #include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h"
260 #include "llvm/Transforms/Utils/CountVisits.h"
261 #include "llvm/Transforms/Utils/DXILUpgrade.h"
262 #include "llvm/Transforms/Utils/Debugify.h"
263 #include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
264 #include "llvm/Transforms/Utils/FixIrreducible.h"
265 #include "llvm/Transforms/Utils/HelloWorld.h"
266 #include "llvm/Transforms/Utils/InjectTLIMappings.h"
267 #include "llvm/Transforms/Utils/InstructionNamer.h"
268 #include "llvm/Transforms/Utils/LCSSA.h"
269 #include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
270 #include "llvm/Transforms/Utils/LoopSimplify.h"
271 #include "llvm/Transforms/Utils/LoopVersioning.h"
272 #include "llvm/Transforms/Utils/LowerGlobalDtors.h"
273 #include "llvm/Transforms/Utils/LowerIFunc.h"
274 #include "llvm/Transforms/Utils/LowerInvoke.h"
275 #include "llvm/Transforms/Utils/LowerSwitch.h"
276 #include "llvm/Transforms/Utils/Mem2Reg.h"
277 #include "llvm/Transforms/Utils/MetaRenamer.h"
278 #include "llvm/Transforms/Utils/MoveAutoInit.h"
279 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
280 #include "llvm/Transforms/Utils/PredicateInfo.h"
281 #include "llvm/Transforms/Utils/RelLookupTableConverter.h"
282 #include "llvm/Transforms/Utils/StripGCRelocates.h"
283 #include "llvm/Transforms/Utils/StripNonLineTableDebugInfo.h"
284 #include "llvm/Transforms/Utils/SymbolRewriter.h"
285 #include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
286 #include "llvm/Transforms/Utils/UnifyLoopExits.h"
287 #include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h"
288 #include "llvm/Transforms/Vectorize/LoopVectorize.h"
289 #include "llvm/Transforms/Vectorize/SLPVectorizer.h"
290 #include "llvm/Transforms/Vectorize/VectorCombine.h"
291 #include <optional>
292
293 using namespace llvm;
294
295 static const Regex DefaultAliasRegex(
296 "^(default|thinlto-pre-link|thinlto|lto-pre-link|lto)<(O[0123sz])>$");
297
298 namespace llvm {
299 cl::opt<bool> PrintPipelinePasses(
300 "print-pipeline-passes",
301 cl::desc("Print a '-passes' compatible string describing the pipeline "
302 "(best-effort only)."));
303 } // namespace llvm
304
305 AnalysisKey NoOpModuleAnalysis::Key;
306 AnalysisKey NoOpCGSCCAnalysis::Key;
307 AnalysisKey NoOpFunctionAnalysis::Key;
308 AnalysisKey NoOpLoopAnalysis::Key;
309
310 namespace {
311
312 /// Whether or not we should populate a PassInstrumentationCallbacks's class to
313 /// pass name map.
314 ///
315 /// This is for optimization purposes so we don't populate it if we never use
316 /// it. This should be updated if new pass instrumentation wants to use the map.
317 /// We currently only use this for --print-before/after.
shouldPopulateClassToPassNames()318 bool shouldPopulateClassToPassNames() {
319 return PrintPipelinePasses || !printBeforePasses().empty() ||
320 !printAfterPasses().empty() || !isFilterPassesEmpty() ||
321 TargetPassConfig::hasLimitedCodeGenPipeline();
322 }
323
324 // A pass for testing -print-on-crash.
325 // DO NOT USE THIS EXCEPT FOR TESTING!
326 class TriggerCrashPass : public PassInfoMixin<TriggerCrashPass> {
327 public:
run(Module &,ModuleAnalysisManager &)328 PreservedAnalyses run(Module &, ModuleAnalysisManager &) {
329 abort();
330 return PreservedAnalyses::all();
331 }
name()332 static StringRef name() { return "TriggerCrashPass"; }
333 };
334
335 // A pass for testing message reporting of -verify-each failures.
336 // DO NOT USE THIS EXCEPT FOR TESTING!
337 class TriggerVerifierErrorPass
338 : public PassInfoMixin<TriggerVerifierErrorPass> {
339 public:
run(Module & M,ModuleAnalysisManager &)340 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
341 // Intentionally break the Module by creating an alias without setting the
342 // aliasee.
343 auto *PtrTy = llvm::PointerType::getUnqual(M.getContext());
344 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
345 GlobalValue::LinkageTypes::InternalLinkage,
346 "__bad_alias", nullptr, &M);
347 return PreservedAnalyses::none();
348 }
349
run(Function & F,FunctionAnalysisManager &)350 PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
351 // Intentionally break the Function by inserting a terminator
352 // instruction in the middle of a basic block.
353 BasicBlock &BB = F.getEntryBlock();
354 new UnreachableInst(F.getContext(), BB.getTerminator());
355 return PreservedAnalyses::none();
356 }
357
name()358 static StringRef name() { return "TriggerVerifierErrorPass"; }
359 };
360
361 } // namespace
362
PassBuilder(TargetMachine * TM,PipelineTuningOptions PTO,std::optional<PGOOptions> PGOOpt,PassInstrumentationCallbacks * PIC)363 PassBuilder::PassBuilder(TargetMachine *TM, PipelineTuningOptions PTO,
364 std::optional<PGOOptions> PGOOpt,
365 PassInstrumentationCallbacks *PIC)
366 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC) {
367 bool ShouldPopulateClassToPassNames = PIC && shouldPopulateClassToPassNames();
368 if (TM)
369 TM->registerPassBuilderCallbacks(*this, ShouldPopulateClassToPassNames);
370 if (ShouldPopulateClassToPassNames) {
371 #define MODULE_PASS(NAME, CREATE_PASS) \
372 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
373 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
374 PIC->addClassToPassName(CLASS, NAME);
375 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \
376 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
377 #define FUNCTION_PASS(NAME, CREATE_PASS) \
378 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
379 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
380 PIC->addClassToPassName(CLASS, NAME);
381 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
382 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
383 #define LOOPNEST_PASS(NAME, CREATE_PASS) \
384 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
385 #define LOOP_PASS(NAME, CREATE_PASS) \
386 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
387 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
388 PIC->addClassToPassName(CLASS, NAME);
389 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \
390 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
391 #define CGSCC_PASS(NAME, CREATE_PASS) \
392 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
393 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
394 PIC->addClassToPassName(CLASS, NAME);
395 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
396 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
397 #include "PassRegistry.def"
398
399 #define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
400 PIC->addClassToPassName(PASS_NAME::name(), NAME);
401 #define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
402 PIC->addClassToPassName(PASS_NAME::name(), NAME);
403 #include "llvm/CodeGen/MachinePassRegistry.def"
404 }
405 }
406
registerModuleAnalyses(ModuleAnalysisManager & MAM)407 void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
408 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \
409 MAM.registerPass([&] { return CREATE_PASS; });
410 #include "PassRegistry.def"
411
412 for (auto &C : ModuleAnalysisRegistrationCallbacks)
413 C(MAM);
414 }
415
registerCGSCCAnalyses(CGSCCAnalysisManager & CGAM)416 void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) {
417 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
418 CGAM.registerPass([&] { return CREATE_PASS; });
419 #include "PassRegistry.def"
420
421 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
422 C(CGAM);
423 }
424
registerFunctionAnalyses(FunctionAnalysisManager & FAM)425 void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
426 // We almost always want the default alias analysis pipeline.
427 // If a user wants a different one, they can register their own before calling
428 // registerFunctionAnalyses().
429 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
430
431 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
432 FAM.registerPass([&] { return CREATE_PASS; });
433 #include "PassRegistry.def"
434
435 for (auto &C : FunctionAnalysisRegistrationCallbacks)
436 C(FAM);
437 }
438
registerMachineFunctionAnalyses(MachineFunctionAnalysisManager & MFAM)439 void PassBuilder::registerMachineFunctionAnalyses(
440 MachineFunctionAnalysisManager &MFAM) {
441
442 #define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
443 MFAM.registerPass([&] { return PASS_NAME(); });
444 #include "llvm/CodeGen/MachinePassRegistry.def"
445
446 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
447 C(MFAM);
448 }
449
registerLoopAnalyses(LoopAnalysisManager & LAM)450 void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
451 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \
452 LAM.registerPass([&] { return CREATE_PASS; });
453 #include "PassRegistry.def"
454
455 for (auto &C : LoopAnalysisRegistrationCallbacks)
456 C(LAM);
457 }
458
parseRepeatPassName(StringRef Name)459 static std::optional<int> parseRepeatPassName(StringRef Name) {
460 if (!Name.consume_front("repeat<") || !Name.consume_back(">"))
461 return std::nullopt;
462 int Count;
463 if (Name.getAsInteger(0, Count) || Count <= 0)
464 return std::nullopt;
465 return Count;
466 }
467
468 static std::optional<std::pair<bool, bool>>
parseFunctionPipelineName(StringRef Name)469 parseFunctionPipelineName(StringRef Name) {
470 std::pair<bool, bool> Params;
471 if (!Name.consume_front("function"))
472 return std::nullopt;
473 if (Name.empty())
474 return Params;
475 if (!Name.consume_front("<") || !Name.consume_back(">"))
476 return std::nullopt;
477 while (!Name.empty()) {
478 auto [Front, Back] = Name.split(';');
479 Name = Back;
480 if (Front == "eager-inv")
481 Params.first = true;
482 else if (Front == "no-rerun")
483 Params.second = true;
484 else
485 return std::nullopt;
486 }
487 return Params;
488 }
489
parseDevirtPassName(StringRef Name)490 static std::optional<int> parseDevirtPassName(StringRef Name) {
491 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
492 return std::nullopt;
493 int Count;
494 if (Name.getAsInteger(0, Count) || Count < 0)
495 return std::nullopt;
496 return Count;
497 }
498
checkParametrizedPassName(StringRef Name,StringRef PassName)499 static bool checkParametrizedPassName(StringRef Name, StringRef PassName) {
500 if (!Name.consume_front(PassName))
501 return false;
502 // normal pass name w/o parameters == default parameters
503 if (Name.empty())
504 return true;
505 return Name.starts_with("<") && Name.ends_with(">");
506 }
507
parseOptLevel(StringRef S)508 static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
509 return StringSwitch<std::optional<OptimizationLevel>>(S)
510 .Case("O0", OptimizationLevel::O0)
511 .Case("O1", OptimizationLevel::O1)
512 .Case("O2", OptimizationLevel::O2)
513 .Case("O3", OptimizationLevel::O3)
514 .Case("Os", OptimizationLevel::Os)
515 .Case("Oz", OptimizationLevel::Oz)
516 .Default(std::nullopt);
517 }
518
519 namespace {
520
521 /// This performs customized parsing of pass name with parameters.
522 ///
523 /// We do not need parametrization of passes in textual pipeline very often,
524 /// yet on a rare occasion ability to specify parameters right there can be
525 /// useful.
526 ///
527 /// \p Name - parameterized specification of a pass from a textual pipeline
528 /// is a string in a form of :
529 /// PassName '<' parameter-list '>'
530 ///
531 /// Parameter list is being parsed by the parser callable argument, \p Parser,
532 /// It takes a string-ref of parameters and returns either StringError or a
533 /// parameter list in a form of a custom parameters type, all wrapped into
534 /// Expected<> template class.
535 ///
536 template <typename ParametersParseCallableT>
parsePassParameters(ParametersParseCallableT && Parser,StringRef Name,StringRef PassName)537 auto parsePassParameters(ParametersParseCallableT &&Parser, StringRef Name,
538 StringRef PassName) -> decltype(Parser(StringRef{})) {
539 using ParametersT = typename decltype(Parser(StringRef{}))::value_type;
540
541 StringRef Params = Name;
542 if (!Params.consume_front(PassName)) {
543 assert(false &&
544 "unable to strip pass name from parametrized pass specification");
545 }
546 if (!Params.empty() &&
547 (!Params.consume_front("<") || !Params.consume_back(">"))) {
548 assert(false && "invalid format for parametrized pass name");
549 }
550
551 Expected<ParametersT> Result = Parser(Params);
552 assert((Result || Result.template errorIsA<StringError>()) &&
553 "Pass parameter parser can only return StringErrors.");
554 return Result;
555 }
556
557 /// Parser of parameters for HardwareLoops pass.
parseHardwareLoopOptions(StringRef Params)558 Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
559 HardwareLoopOptions HardwareLoopOpts;
560
561 while (!Params.empty()) {
562 StringRef ParamName;
563 std::tie(ParamName, Params) = Params.split(';');
564 if (ParamName.consume_front("hardware-loop-decrement=")) {
565 int Count;
566 if (ParamName.getAsInteger(0, Count))
567 return make_error<StringError>(
568 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
569 inconvertibleErrorCode());
570 HardwareLoopOpts.setDecrement(Count);
571 continue;
572 }
573 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
574 int Count;
575 if (ParamName.getAsInteger(0, Count))
576 return make_error<StringError>(
577 formatv("invalid HardwareLoopPass parameter '{0}' ", ParamName).str(),
578 inconvertibleErrorCode());
579 HardwareLoopOpts.setCounterBitwidth(Count);
580 continue;
581 }
582 if (ParamName == "force-hardware-loops") {
583 HardwareLoopOpts.setForce(true);
584 } else if (ParamName == "force-hardware-loop-phi") {
585 HardwareLoopOpts.setForcePhi(true);
586 } else if (ParamName == "force-nested-hardware-loop") {
587 HardwareLoopOpts.setForceNested(true);
588 } else if (ParamName == "force-hardware-loop-guard") {
589 HardwareLoopOpts.setForceGuard(true);
590 } else {
591 return make_error<StringError>(
592 formatv("invalid HardwarePass parameter '{0}' ", ParamName).str(),
593 inconvertibleErrorCode());
594 }
595 }
596 return HardwareLoopOpts;
597 }
598
599 /// Parser of parameters for LoopUnroll pass.
parseLoopUnrollOptions(StringRef Params)600 Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
601 LoopUnrollOptions UnrollOpts;
602 while (!Params.empty()) {
603 StringRef ParamName;
604 std::tie(ParamName, Params) = Params.split(';');
605 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
606 // Don't accept -Os/-Oz.
607 if (OptLevel && !OptLevel->isOptimizingForSize()) {
608 UnrollOpts.setOptLevel(OptLevel->getSpeedupLevel());
609 continue;
610 }
611 if (ParamName.consume_front("full-unroll-max=")) {
612 int Count;
613 if (ParamName.getAsInteger(0, Count))
614 return make_error<StringError>(
615 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
616 inconvertibleErrorCode());
617 UnrollOpts.setFullUnrollMaxCount(Count);
618 continue;
619 }
620
621 bool Enable = !ParamName.consume_front("no-");
622 if (ParamName == "partial") {
623 UnrollOpts.setPartial(Enable);
624 } else if (ParamName == "peeling") {
625 UnrollOpts.setPeeling(Enable);
626 } else if (ParamName == "profile-peeling") {
627 UnrollOpts.setProfileBasedPeeling(Enable);
628 } else if (ParamName == "runtime") {
629 UnrollOpts.setRuntime(Enable);
630 } else if (ParamName == "upperbound") {
631 UnrollOpts.setUpperBound(Enable);
632 } else {
633 return make_error<StringError>(
634 formatv("invalid LoopUnrollPass parameter '{0}' ", ParamName).str(),
635 inconvertibleErrorCode());
636 }
637 }
638 return UnrollOpts;
639 }
640
parseSinglePassOption(StringRef Params,StringRef OptionName,StringRef PassName)641 Expected<bool> parseSinglePassOption(StringRef Params, StringRef OptionName,
642 StringRef PassName) {
643 bool Result = false;
644 while (!Params.empty()) {
645 StringRef ParamName;
646 std::tie(ParamName, Params) = Params.split(';');
647
648 if (ParamName == OptionName) {
649 Result = true;
650 } else {
651 return make_error<StringError>(
652 formatv("invalid {1} pass parameter '{0}' ", ParamName, PassName)
653 .str(),
654 inconvertibleErrorCode());
655 }
656 }
657 return Result;
658 }
659
parseGlobalDCEPassOptions(StringRef Params)660 Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
661 return parseSinglePassOption(Params, "vfe-linkage-unit-visibility", "GlobalDCE");
662 }
663
parseCGProfilePassOptions(StringRef Params)664 Expected<bool> parseCGProfilePassOptions(StringRef Params) {
665 return parseSinglePassOption(Params, "in-lto-post-link", "CGProfile");
666 }
667
parseInlinerPassOptions(StringRef Params)668 Expected<bool> parseInlinerPassOptions(StringRef Params) {
669 return parseSinglePassOption(Params, "only-mandatory", "InlinerPass");
670 }
671
parseCoroSplitPassOptions(StringRef Params)672 Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
673 return parseSinglePassOption(Params, "reuse-storage", "CoroSplitPass");
674 }
675
parsePostOrderFunctionAttrsPassOptions(StringRef Params)676 Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
677 return parseSinglePassOption(Params, "skip-non-recursive-function-attrs",
678 "PostOrderFunctionAttrs");
679 }
680
parseCFGuardPassOptions(StringRef Params)681 Expected<CFGuardPass::Mechanism> parseCFGuardPassOptions(StringRef Params) {
682 if (Params.empty())
683 return CFGuardPass::Mechanism::Check;
684
685 auto [Param, RHS] = Params.split(';');
686 if (!RHS.empty())
687 return make_error<StringError>(
688 formatv("too many CFGuardPass parameters '{0}' ", Params).str(),
689 inconvertibleErrorCode());
690
691 if (Param == "check")
692 return CFGuardPass::Mechanism::Check;
693 if (Param == "dispatch")
694 return CFGuardPass::Mechanism::Dispatch;
695
696 return make_error<StringError>(
697 formatv("invalid CFGuardPass mechanism: '{0}' ", Param).str(),
698 inconvertibleErrorCode());
699 }
700
parseEarlyCSEPassOptions(StringRef Params)701 Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
702 return parseSinglePassOption(Params, "memssa", "EarlyCSE");
703 }
704
parseEntryExitInstrumenterPassOptions(StringRef Params)705 Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
706 return parseSinglePassOption(Params, "post-inline", "EntryExitInstrumenter");
707 }
708
parseLoopExtractorPassOptions(StringRef Params)709 Expected<bool> parseLoopExtractorPassOptions(StringRef Params) {
710 return parseSinglePassOption(Params, "single", "LoopExtractor");
711 }
712
parseLowerMatrixIntrinsicsPassOptions(StringRef Params)713 Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
714 return parseSinglePassOption(Params, "minimal", "LowerMatrixIntrinsics");
715 }
716
parseASanPassOptions(StringRef Params)717 Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
718 AddressSanitizerOptions Result;
719 while (!Params.empty()) {
720 StringRef ParamName;
721 std::tie(ParamName, Params) = Params.split(';');
722
723 if (ParamName == "kernel") {
724 Result.CompileKernel = true;
725 } else {
726 return make_error<StringError>(
727 formatv("invalid AddressSanitizer pass parameter '{0}' ", ParamName)
728 .str(),
729 inconvertibleErrorCode());
730 }
731 }
732 return Result;
733 }
734
parseHWASanPassOptions(StringRef Params)735 Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
736 HWAddressSanitizerOptions Result;
737 while (!Params.empty()) {
738 StringRef ParamName;
739 std::tie(ParamName, Params) = Params.split(';');
740
741 if (ParamName == "recover") {
742 Result.Recover = true;
743 } else if (ParamName == "kernel") {
744 Result.CompileKernel = true;
745 } else {
746 return make_error<StringError>(
747 formatv("invalid HWAddressSanitizer pass parameter '{0}' ", ParamName)
748 .str(),
749 inconvertibleErrorCode());
750 }
751 }
752 return Result;
753 }
754
parseEmbedBitcodePassOptions(StringRef Params)755 Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
756 EmbedBitcodeOptions Result;
757 while (!Params.empty()) {
758 StringRef ParamName;
759 std::tie(ParamName, Params) = Params.split(';');
760
761 if (ParamName == "thinlto") {
762 Result.IsThinLTO = true;
763 } else if (ParamName == "emit-summary") {
764 Result.EmitLTOSummary = true;
765 } else {
766 return make_error<StringError>(
767 formatv("invalid EmbedBitcode pass parameter '{0}' ", ParamName)
768 .str(),
769 inconvertibleErrorCode());
770 }
771 }
772 return Result;
773 }
774
parseMSanPassOptions(StringRef Params)775 Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
776 MemorySanitizerOptions Result;
777 while (!Params.empty()) {
778 StringRef ParamName;
779 std::tie(ParamName, Params) = Params.split(';');
780
781 if (ParamName == "recover") {
782 Result.Recover = true;
783 } else if (ParamName == "kernel") {
784 Result.Kernel = true;
785 } else if (ParamName.consume_front("track-origins=")) {
786 if (ParamName.getAsInteger(0, Result.TrackOrigins))
787 return make_error<StringError>(
788 formatv("invalid argument to MemorySanitizer pass track-origins "
789 "parameter: '{0}' ",
790 ParamName)
791 .str(),
792 inconvertibleErrorCode());
793 } else if (ParamName == "eager-checks") {
794 Result.EagerChecks = true;
795 } else {
796 return make_error<StringError>(
797 formatv("invalid MemorySanitizer pass parameter '{0}' ", ParamName)
798 .str(),
799 inconvertibleErrorCode());
800 }
801 }
802 return Result;
803 }
804
805 /// Parser of parameters for SimplifyCFG pass.
parseSimplifyCFGOptions(StringRef Params)806 Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
807 SimplifyCFGOptions Result;
808 while (!Params.empty()) {
809 StringRef ParamName;
810 std::tie(ParamName, Params) = Params.split(';');
811
812 bool Enable = !ParamName.consume_front("no-");
813 if (ParamName == "speculate-blocks") {
814 Result.speculateBlocks(Enable);
815 } else if (ParamName == "simplify-cond-branch") {
816 Result.setSimplifyCondBranch(Enable);
817 } else if (ParamName == "forward-switch-cond") {
818 Result.forwardSwitchCondToPhi(Enable);
819 } else if (ParamName == "switch-range-to-icmp") {
820 Result.convertSwitchRangeToICmp(Enable);
821 } else if (ParamName == "switch-to-lookup") {
822 Result.convertSwitchToLookupTable(Enable);
823 } else if (ParamName == "keep-loops") {
824 Result.needCanonicalLoops(Enable);
825 } else if (ParamName == "hoist-common-insts") {
826 Result.hoistCommonInsts(Enable);
827 } else if (ParamName == "sink-common-insts") {
828 Result.sinkCommonInsts(Enable);
829 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
830 APInt BonusInstThreshold;
831 if (ParamName.getAsInteger(0, BonusInstThreshold))
832 return make_error<StringError>(
833 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
834 "parameter: '{0}' ",
835 ParamName).str(),
836 inconvertibleErrorCode());
837 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
838 } else {
839 return make_error<StringError>(
840 formatv("invalid SimplifyCFG pass parameter '{0}' ", ParamName).str(),
841 inconvertibleErrorCode());
842 }
843 }
844 return Result;
845 }
846
parseInstCombineOptions(StringRef Params)847 Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
848 InstCombineOptions Result;
849 // When specifying "instcombine" in -passes enable fix-point verification by
850 // default, as this is what most tests should use.
851 Result.setVerifyFixpoint(true);
852 while (!Params.empty()) {
853 StringRef ParamName;
854 std::tie(ParamName, Params) = Params.split(';');
855
856 bool Enable = !ParamName.consume_front("no-");
857 if (ParamName == "use-loop-info") {
858 Result.setUseLoopInfo(Enable);
859 } else if (ParamName == "verify-fixpoint") {
860 Result.setVerifyFixpoint(Enable);
861 } else if (Enable && ParamName.consume_front("max-iterations=")) {
862 APInt MaxIterations;
863 if (ParamName.getAsInteger(0, MaxIterations))
864 return make_error<StringError>(
865 formatv("invalid argument to InstCombine pass max-iterations "
866 "parameter: '{0}' ",
867 ParamName).str(),
868 inconvertibleErrorCode());
869 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
870 } else {
871 return make_error<StringError>(
872 formatv("invalid InstCombine pass parameter '{0}' ", ParamName).str(),
873 inconvertibleErrorCode());
874 }
875 }
876 return Result;
877 }
878
879 /// Parser of parameters for LoopVectorize pass.
parseLoopVectorizeOptions(StringRef Params)880 Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
881 LoopVectorizeOptions Opts;
882 while (!Params.empty()) {
883 StringRef ParamName;
884 std::tie(ParamName, Params) = Params.split(';');
885
886 bool Enable = !ParamName.consume_front("no-");
887 if (ParamName == "interleave-forced-only") {
888 Opts.setInterleaveOnlyWhenForced(Enable);
889 } else if (ParamName == "vectorize-forced-only") {
890 Opts.setVectorizeOnlyWhenForced(Enable);
891 } else {
892 return make_error<StringError>(
893 formatv("invalid LoopVectorize parameter '{0}' ", ParamName).str(),
894 inconvertibleErrorCode());
895 }
896 }
897 return Opts;
898 }
899
parseLoopUnswitchOptions(StringRef Params)900 Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
901 std::pair<bool, bool> Result = {false, true};
902 while (!Params.empty()) {
903 StringRef ParamName;
904 std::tie(ParamName, Params) = Params.split(';');
905
906 bool Enable = !ParamName.consume_front("no-");
907 if (ParamName == "nontrivial") {
908 Result.first = Enable;
909 } else if (ParamName == "trivial") {
910 Result.second = Enable;
911 } else {
912 return make_error<StringError>(
913 formatv("invalid LoopUnswitch pass parameter '{0}' ", ParamName)
914 .str(),
915 inconvertibleErrorCode());
916 }
917 }
918 return Result;
919 }
920
parseLICMOptions(StringRef Params)921 Expected<LICMOptions> parseLICMOptions(StringRef Params) {
922 LICMOptions Result;
923 while (!Params.empty()) {
924 StringRef ParamName;
925 std::tie(ParamName, Params) = Params.split(';');
926
927 bool Enable = !ParamName.consume_front("no-");
928 if (ParamName == "allowspeculation") {
929 Result.AllowSpeculation = Enable;
930 } else {
931 return make_error<StringError>(
932 formatv("invalid LICM pass parameter '{0}' ", ParamName).str(),
933 inconvertibleErrorCode());
934 }
935 }
936 return Result;
937 }
938
parseLoopRotateOptions(StringRef Params)939 Expected<std::pair<bool, bool>> parseLoopRotateOptions(StringRef Params) {
940 std::pair<bool, bool> Result = {true, false};
941 while (!Params.empty()) {
942 StringRef ParamName;
943 std::tie(ParamName, Params) = Params.split(';');
944
945 bool Enable = !ParamName.consume_front("no-");
946 if (ParamName == "header-duplication") {
947 Result.first = Enable;
948 } else if (ParamName == "prepare-for-lto") {
949 Result.second = Enable;
950 } else {
951 return make_error<StringError>(
952 formatv("invalid LoopRotate pass parameter '{0}' ", ParamName).str(),
953 inconvertibleErrorCode());
954 }
955 }
956 return Result;
957 }
958
parseMergedLoadStoreMotionOptions(StringRef Params)959 Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
960 bool Result = false;
961 while (!Params.empty()) {
962 StringRef ParamName;
963 std::tie(ParamName, Params) = Params.split(';');
964
965 bool Enable = !ParamName.consume_front("no-");
966 if (ParamName == "split-footer-bb") {
967 Result = Enable;
968 } else {
969 return make_error<StringError>(
970 formatv("invalid MergedLoadStoreMotion pass parameter '{0}' ",
971 ParamName)
972 .str(),
973 inconvertibleErrorCode());
974 }
975 }
976 return Result;
977 }
978
parseGVNOptions(StringRef Params)979 Expected<GVNOptions> parseGVNOptions(StringRef Params) {
980 GVNOptions Result;
981 while (!Params.empty()) {
982 StringRef ParamName;
983 std::tie(ParamName, Params) = Params.split(';');
984
985 bool Enable = !ParamName.consume_front("no-");
986 if (ParamName == "pre") {
987 Result.setPRE(Enable);
988 } else if (ParamName == "load-pre") {
989 Result.setLoadPRE(Enable);
990 } else if (ParamName == "split-backedge-load-pre") {
991 Result.setLoadPRESplitBackedge(Enable);
992 } else if (ParamName == "memdep") {
993 Result.setMemDep(Enable);
994 } else {
995 return make_error<StringError>(
996 formatv("invalid GVN pass parameter '{0}' ", ParamName).str(),
997 inconvertibleErrorCode());
998 }
999 }
1000 return Result;
1001 }
1002
parseIPSCCPOptions(StringRef Params)1003 Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
1004 IPSCCPOptions Result;
1005 while (!Params.empty()) {
1006 StringRef ParamName;
1007 std::tie(ParamName, Params) = Params.split(';');
1008
1009 bool Enable = !ParamName.consume_front("no-");
1010 if (ParamName == "func-spec")
1011 Result.setFuncSpec(Enable);
1012 else
1013 return make_error<StringError>(
1014 formatv("invalid IPSCCP pass parameter '{0}' ", ParamName).str(),
1015 inconvertibleErrorCode());
1016 }
1017 return Result;
1018 }
1019
parseSROAOptions(StringRef Params)1020 Expected<SROAOptions> parseSROAOptions(StringRef Params) {
1021 if (Params.empty() || Params == "modify-cfg")
1022 return SROAOptions::ModifyCFG;
1023 if (Params == "preserve-cfg")
1024 return SROAOptions::PreserveCFG;
1025 return make_error<StringError>(
1026 formatv("invalid SROA pass parameter '{0}' (either preserve-cfg or "
1027 "modify-cfg can be specified)",
1028 Params)
1029 .str(),
1030 inconvertibleErrorCode());
1031 }
1032
1033 Expected<StackLifetime::LivenessType>
parseStackLifetimeOptions(StringRef Params)1034 parseStackLifetimeOptions(StringRef Params) {
1035 StackLifetime::LivenessType Result = StackLifetime::LivenessType::May;
1036 while (!Params.empty()) {
1037 StringRef ParamName;
1038 std::tie(ParamName, Params) = Params.split(';');
1039
1040 if (ParamName == "may") {
1041 Result = StackLifetime::LivenessType::May;
1042 } else if (ParamName == "must") {
1043 Result = StackLifetime::LivenessType::Must;
1044 } else {
1045 return make_error<StringError>(
1046 formatv("invalid StackLifetime parameter '{0}' ", ParamName).str(),
1047 inconvertibleErrorCode());
1048 }
1049 }
1050 return Result;
1051 }
1052
parseDependenceAnalysisPrinterOptions(StringRef Params)1053 Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1054 return parseSinglePassOption(Params, "normalized-results",
1055 "DependenceAnalysisPrinter");
1056 }
1057
parseSeparateConstOffsetFromGEPPassOptions(StringRef Params)1058 Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1059 return parseSinglePassOption(Params, "lower-gep",
1060 "SeparateConstOffsetFromGEP");
1061 }
1062
1063 Expected<OptimizationLevel>
parseFunctionSimplificationPipelineOptions(StringRef Params)1064 parseFunctionSimplificationPipelineOptions(StringRef Params) {
1065 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1066 if (!L || *L == OptimizationLevel::O0) {
1067 return make_error<StringError>(
1068 formatv("invalid function-simplification parameter '{0}' ", Params)
1069 .str(),
1070 inconvertibleErrorCode());
1071 };
1072 return *L;
1073 }
1074
parseMemorySSAPrinterPassOptions(StringRef Params)1075 Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1076 return parseSinglePassOption(Params, "no-ensure-optimized-uses",
1077 "MemorySSAPrinterPass");
1078 }
1079
parseSpeculativeExecutionPassOptions(StringRef Params)1080 Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1081 return parseSinglePassOption(Params, "only-if-divergent-target",
1082 "SpeculativeExecutionPass");
1083 }
1084
parseMemProfUsePassOptions(StringRef Params)1085 Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1086 std::string Result;
1087 while (!Params.empty()) {
1088 StringRef ParamName;
1089 std::tie(ParamName, Params) = Params.split(';');
1090
1091 if (ParamName.consume_front("profile-filename=")) {
1092 Result = ParamName.str();
1093 } else {
1094 return make_error<StringError>(
1095 formatv("invalid MemProfUse pass parameter '{0}' ", ParamName).str(),
1096 inconvertibleErrorCode());
1097 }
1098 }
1099 return Result;
1100 }
1101
parseStructuralHashPrinterPassOptions(StringRef Params)1102 Expected<bool> parseStructuralHashPrinterPassOptions(StringRef Params) {
1103 return parseSinglePassOption(Params, "detailed",
1104 "StructuralHashPrinterPass");
1105 }
1106
parseWinEHPrepareOptions(StringRef Params)1107 Expected<bool> parseWinEHPrepareOptions(StringRef Params) {
1108 return parseSinglePassOption(Params, "demote-catchswitch-only",
1109 "WinEHPreparePass");
1110 }
1111
parseGlobalMergeOptions(StringRef Params)1112 Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1113 GlobalMergeOptions Result;
1114 while (!Params.empty()) {
1115 StringRef ParamName;
1116 std::tie(ParamName, Params) = Params.split(';');
1117
1118 bool Enable = !ParamName.consume_front("no-");
1119 if (ParamName == "group-by-use")
1120 Result.GroupByUse = Enable;
1121 else if (ParamName == "ignore-single-use")
1122 Result.IgnoreSingleUse = Enable;
1123 else if (ParamName == "merge-const")
1124 Result.MergeConst = Enable;
1125 else if (ParamName == "merge-external")
1126 Result.MergeExternal = Enable;
1127 else if (ParamName.consume_front("max-offset=")) {
1128 if (ParamName.getAsInteger(0, Result.MaxOffset))
1129 return make_error<StringError>(
1130 formatv("invalid GlobalMergePass parameter '{0}' ", ParamName)
1131 .str(),
1132 inconvertibleErrorCode());
1133 }
1134 }
1135 return Result;
1136 }
1137
1138 } // namespace
1139
1140 /// Tests whether a pass name starts with a valid prefix for a default pipeline
1141 /// alias.
startsWithDefaultPipelineAliasPrefix(StringRef Name)1142 static bool startsWithDefaultPipelineAliasPrefix(StringRef Name) {
1143 return Name.starts_with("default") || Name.starts_with("thinlto") ||
1144 Name.starts_with("lto");
1145 }
1146
1147 /// Tests whether registered callbacks will accept a given pass name.
1148 ///
1149 /// When parsing a pipeline text, the type of the outermost pipeline may be
1150 /// omitted, in which case the type is automatically determined from the first
1151 /// pass name in the text. This may be a name that is handled through one of the
1152 /// callbacks. We check this through the oridinary parsing callbacks by setting
1153 /// up a dummy PassManager in order to not force the client to also handle this
1154 /// type of query.
1155 template <typename PassManagerT, typename CallbacksT>
callbacksAcceptPassName(StringRef Name,CallbacksT & Callbacks)1156 static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1157 if (!Callbacks.empty()) {
1158 PassManagerT DummyPM;
1159 for (auto &CB : Callbacks)
1160 if (CB(Name, DummyPM, {}))
1161 return true;
1162 }
1163 return false;
1164 }
1165
1166 template <typename CallbacksT>
isModulePassName(StringRef Name,CallbacksT & Callbacks)1167 static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1168 // Manually handle aliases for pre-configured pipeline fragments.
1169 if (startsWithDefaultPipelineAliasPrefix(Name))
1170 return DefaultAliasRegex.match(Name);
1171
1172 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1173
1174 // Explicitly handle pass manager names.
1175 if (Name == "module")
1176 return true;
1177 if (Name == "cgscc")
1178 return true;
1179 if (NameNoBracket == "function")
1180 return true;
1181 if (Name == "coro-cond")
1182 return true;
1183
1184 // Explicitly handle custom-parsed pass names.
1185 if (parseRepeatPassName(Name))
1186 return true;
1187
1188 #define MODULE_PASS(NAME, CREATE_PASS) \
1189 if (Name == NAME) \
1190 return true;
1191 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1192 if (checkParametrizedPassName(Name, NAME)) \
1193 return true;
1194 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1195 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1196 return true;
1197 #include "PassRegistry.def"
1198
1199 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1200 }
1201
1202 template <typename CallbacksT>
isCGSCCPassName(StringRef Name,CallbacksT & Callbacks)1203 static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1204 // Explicitly handle pass manager names.
1205 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1206 if (Name == "cgscc")
1207 return true;
1208 if (NameNoBracket == "function")
1209 return true;
1210
1211 // Explicitly handle custom-parsed pass names.
1212 if (parseRepeatPassName(Name))
1213 return true;
1214 if (parseDevirtPassName(Name))
1215 return true;
1216
1217 #define CGSCC_PASS(NAME, CREATE_PASS) \
1218 if (Name == NAME) \
1219 return true;
1220 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1221 if (checkParametrizedPassName(Name, NAME)) \
1222 return true;
1223 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1224 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1225 return true;
1226 #include "PassRegistry.def"
1227
1228 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1229 }
1230
1231 template <typename CallbacksT>
isFunctionPassName(StringRef Name,CallbacksT & Callbacks)1232 static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1233 // Explicitly handle pass manager names.
1234 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1235 if (NameNoBracket == "function")
1236 return true;
1237 if (Name == "loop" || Name == "loop-mssa")
1238 return true;
1239
1240 // Explicitly handle custom-parsed pass names.
1241 if (parseRepeatPassName(Name))
1242 return true;
1243
1244 #define FUNCTION_PASS(NAME, CREATE_PASS) \
1245 if (Name == NAME) \
1246 return true;
1247 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1248 if (checkParametrizedPassName(Name, NAME)) \
1249 return true;
1250 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1251 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1252 return true;
1253 #include "PassRegistry.def"
1254
1255 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1256 }
1257
1258 template <typename CallbacksT>
isLoopNestPassName(StringRef Name,CallbacksT & Callbacks,bool & UseMemorySSA)1259 static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1260 bool &UseMemorySSA) {
1261 UseMemorySSA = false;
1262
1263 // Explicitly handle custom-parsed pass names.
1264 if (parseRepeatPassName(Name))
1265 return true;
1266
1267 if (checkParametrizedPassName(Name, "lnicm")) {
1268 UseMemorySSA = true;
1269 return true;
1270 }
1271
1272 #define LOOPNEST_PASS(NAME, CREATE_PASS) \
1273 if (Name == NAME) \
1274 return true;
1275 #include "PassRegistry.def"
1276
1277 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1278 }
1279
1280 template <typename CallbacksT>
isLoopPassName(StringRef Name,CallbacksT & Callbacks,bool & UseMemorySSA)1281 static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1282 bool &UseMemorySSA) {
1283 UseMemorySSA = false;
1284
1285 // Explicitly handle custom-parsed pass names.
1286 if (parseRepeatPassName(Name))
1287 return true;
1288
1289 if (checkParametrizedPassName(Name, "licm")) {
1290 UseMemorySSA = true;
1291 return true;
1292 }
1293
1294 #define LOOP_PASS(NAME, CREATE_PASS) \
1295 if (Name == NAME) \
1296 return true;
1297 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1298 if (checkParametrizedPassName(Name, NAME)) \
1299 return true;
1300 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1301 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1302 return true;
1303 #include "PassRegistry.def"
1304
1305 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1306 }
1307
1308 std::optional<std::vector<PassBuilder::PipelineElement>>
parsePipelineText(StringRef Text)1309 PassBuilder::parsePipelineText(StringRef Text) {
1310 std::vector<PipelineElement> ResultPipeline;
1311
1312 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
1313 &ResultPipeline};
1314 for (;;) {
1315 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
1316 size_t Pos = Text.find_first_of(",()");
1317 Pipeline.push_back({Text.substr(0, Pos), {}});
1318
1319 // If we have a single terminating name, we're done.
1320 if (Pos == Text.npos)
1321 break;
1322
1323 char Sep = Text[Pos];
1324 Text = Text.substr(Pos + 1);
1325 if (Sep == ',')
1326 // Just a name ending in a comma, continue.
1327 continue;
1328
1329 if (Sep == '(') {
1330 // Push the inner pipeline onto the stack to continue processing.
1331 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
1332 continue;
1333 }
1334
1335 assert(Sep == ')' && "Bogus separator!");
1336 // When handling the close parenthesis, we greedily consume them to avoid
1337 // empty strings in the pipeline.
1338 do {
1339 // If we try to pop the outer pipeline we have unbalanced parentheses.
1340 if (PipelineStack.size() == 1)
1341 return std::nullopt;
1342
1343 PipelineStack.pop_back();
1344 } while (Text.consume_front(")"));
1345
1346 // Check if we've finished parsing.
1347 if (Text.empty())
1348 break;
1349
1350 // Otherwise, the end of an inner pipeline always has to be followed by
1351 // a comma, and then we can continue.
1352 if (!Text.consume_front(","))
1353 return std::nullopt;
1354 }
1355
1356 if (PipelineStack.size() > 1)
1357 // Unbalanced paretheses.
1358 return std::nullopt;
1359
1360 assert(PipelineStack.back() == &ResultPipeline &&
1361 "Wrong pipeline at the bottom of the stack!");
1362 return {std::move(ResultPipeline)};
1363 }
1364
parseModulePass(ModulePassManager & MPM,const PipelineElement & E)1365 Error PassBuilder::parseModulePass(ModulePassManager &MPM,
1366 const PipelineElement &E) {
1367 auto &Name = E.Name;
1368 auto &InnerPipeline = E.InnerPipeline;
1369
1370 // First handle complex passes like the pass managers which carry pipelines.
1371 if (!InnerPipeline.empty()) {
1372 if (Name == "module") {
1373 ModulePassManager NestedMPM;
1374 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1375 return Err;
1376 MPM.addPass(std::move(NestedMPM));
1377 return Error::success();
1378 }
1379 if (Name == "coro-cond") {
1380 ModulePassManager NestedMPM;
1381 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1382 return Err;
1383 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
1384 return Error::success();
1385 }
1386 if (Name == "cgscc") {
1387 CGSCCPassManager CGPM;
1388 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
1389 return Err;
1390 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
1391 return Error::success();
1392 }
1393 if (auto Params = parseFunctionPipelineName(Name)) {
1394 if (Params->second)
1395 return make_error<StringError>(
1396 "cannot have a no-rerun module to function adaptor",
1397 inconvertibleErrorCode());
1398 FunctionPassManager FPM;
1399 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1400 return Err;
1401 MPM.addPass(
1402 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
1403 return Error::success();
1404 }
1405 if (auto Count = parseRepeatPassName(Name)) {
1406 ModulePassManager NestedMPM;
1407 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
1408 return Err;
1409 MPM.addPass(createRepeatedPass(*Count, std::move(NestedMPM)));
1410 return Error::success();
1411 }
1412
1413 for (auto &C : ModulePipelineParsingCallbacks)
1414 if (C(Name, MPM, InnerPipeline))
1415 return Error::success();
1416
1417 // Normal passes can't have pipelines.
1418 return make_error<StringError>(
1419 formatv("invalid use of '{0}' pass as module pipeline", Name).str(),
1420 inconvertibleErrorCode());
1421 ;
1422 }
1423
1424 // Manually handle aliases for pre-configured pipeline fragments.
1425 if (startsWithDefaultPipelineAliasPrefix(Name)) {
1426 SmallVector<StringRef, 3> Matches;
1427 if (!DefaultAliasRegex.match(Name, &Matches))
1428 return make_error<StringError>(
1429 formatv("unknown default pipeline alias '{0}'", Name).str(),
1430 inconvertibleErrorCode());
1431
1432 assert(Matches.size() == 3 && "Must capture two matched strings!");
1433
1434 OptimizationLevel L = *parseOptLevel(Matches[2]);
1435
1436 // This is consistent with old pass manager invoked via opt, but
1437 // inconsistent with clang. Clang doesn't enable loop vectorization
1438 // but does enable slp vectorization at Oz.
1439 PTO.LoopVectorization =
1440 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1441 PTO.SLPVectorization =
1442 L.getSpeedupLevel() > 1 && L != OptimizationLevel::Oz;
1443
1444 if (Matches[1] == "default") {
1445 MPM.addPass(buildPerModuleDefaultPipeline(L));
1446 } else if (Matches[1] == "thinlto-pre-link") {
1447 MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L));
1448 } else if (Matches[1] == "thinlto") {
1449 MPM.addPass(buildThinLTODefaultPipeline(L, nullptr));
1450 } else if (Matches[1] == "lto-pre-link") {
1451 if (PTO.UnifiedLTO)
1452 // When UnifiedLTO is enabled, use the ThinLTO pre-link pipeline. This
1453 // avoids compile-time performance regressions and keeps the pre-link
1454 // LTO pipeline "unified" for both LTO modes.
1455 MPM.addPass(buildThinLTOPreLinkDefaultPipeline(L));
1456 else
1457 MPM.addPass(buildLTOPreLinkDefaultPipeline(L));
1458 } else {
1459 assert(Matches[1] == "lto" && "Not one of the matched options!");
1460 MPM.addPass(buildLTODefaultPipeline(L, nullptr));
1461 }
1462 return Error::success();
1463 }
1464
1465 // Finally expand the basic registered passes from the .inc file.
1466 #define MODULE_PASS(NAME, CREATE_PASS) \
1467 if (Name == NAME) { \
1468 MPM.addPass(CREATE_PASS); \
1469 return Error::success(); \
1470 }
1471 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1472 if (checkParametrizedPassName(Name, NAME)) { \
1473 auto Params = parsePassParameters(PARSER, Name, NAME); \
1474 if (!Params) \
1475 return Params.takeError(); \
1476 MPM.addPass(CREATE_PASS(Params.get())); \
1477 return Error::success(); \
1478 }
1479 #define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1480 if (Name == "require<" NAME ">") { \
1481 MPM.addPass( \
1482 RequireAnalysisPass< \
1483 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
1484 return Error::success(); \
1485 } \
1486 if (Name == "invalidate<" NAME ">") { \
1487 MPM.addPass(InvalidateAnalysisPass< \
1488 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1489 return Error::success(); \
1490 }
1491 #define CGSCC_PASS(NAME, CREATE_PASS) \
1492 if (Name == NAME) { \
1493 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
1494 return Error::success(); \
1495 }
1496 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1497 if (checkParametrizedPassName(Name, NAME)) { \
1498 auto Params = parsePassParameters(PARSER, Name, NAME); \
1499 if (!Params) \
1500 return Params.takeError(); \
1501 MPM.addPass( \
1502 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
1503 return Error::success(); \
1504 }
1505 #define FUNCTION_PASS(NAME, CREATE_PASS) \
1506 if (Name == NAME) { \
1507 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
1508 return Error::success(); \
1509 }
1510 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1511 if (checkParametrizedPassName(Name, NAME)) { \
1512 auto Params = parsePassParameters(PARSER, Name, NAME); \
1513 if (!Params) \
1514 return Params.takeError(); \
1515 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1516 return Error::success(); \
1517 }
1518 #define LOOPNEST_PASS(NAME, CREATE_PASS) \
1519 if (Name == NAME) { \
1520 MPM.addPass(createModuleToFunctionPassAdaptor( \
1521 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1522 return Error::success(); \
1523 }
1524 #define LOOP_PASS(NAME, CREATE_PASS) \
1525 if (Name == NAME) { \
1526 MPM.addPass(createModuleToFunctionPassAdaptor( \
1527 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1528 return Error::success(); \
1529 }
1530 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1531 if (checkParametrizedPassName(Name, NAME)) { \
1532 auto Params = parsePassParameters(PARSER, Name, NAME); \
1533 if (!Params) \
1534 return Params.takeError(); \
1535 MPM.addPass( \
1536 createModuleToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1537 CREATE_PASS(Params.get()), false, false))); \
1538 return Error::success(); \
1539 }
1540 #include "PassRegistry.def"
1541
1542 for (auto &C : ModulePipelineParsingCallbacks)
1543 if (C(Name, MPM, InnerPipeline))
1544 return Error::success();
1545 return make_error<StringError>(
1546 formatv("unknown module pass '{0}'", Name).str(),
1547 inconvertibleErrorCode());
1548 }
1549
parseCGSCCPass(CGSCCPassManager & CGPM,const PipelineElement & E)1550 Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
1551 const PipelineElement &E) {
1552 auto &Name = E.Name;
1553 auto &InnerPipeline = E.InnerPipeline;
1554
1555 // First handle complex passes like the pass managers which carry pipelines.
1556 if (!InnerPipeline.empty()) {
1557 if (Name == "cgscc") {
1558 CGSCCPassManager NestedCGPM;
1559 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1560 return Err;
1561 // Add the nested pass manager with the appropriate adaptor.
1562 CGPM.addPass(std::move(NestedCGPM));
1563 return Error::success();
1564 }
1565 if (auto Params = parseFunctionPipelineName(Name)) {
1566 FunctionPassManager FPM;
1567 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
1568 return Err;
1569 // Add the nested pass manager with the appropriate adaptor.
1570 CGPM.addPass(createCGSCCToFunctionPassAdaptor(
1571 std::move(FPM), Params->first, Params->second));
1572 return Error::success();
1573 }
1574 if (auto Count = parseRepeatPassName(Name)) {
1575 CGSCCPassManager NestedCGPM;
1576 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1577 return Err;
1578 CGPM.addPass(createRepeatedPass(*Count, std::move(NestedCGPM)));
1579 return Error::success();
1580 }
1581 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
1582 CGSCCPassManager NestedCGPM;
1583 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
1584 return Err;
1585 CGPM.addPass(
1586 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
1587 return Error::success();
1588 }
1589
1590 for (auto &C : CGSCCPipelineParsingCallbacks)
1591 if (C(Name, CGPM, InnerPipeline))
1592 return Error::success();
1593
1594 // Normal passes can't have pipelines.
1595 return make_error<StringError>(
1596 formatv("invalid use of '{0}' pass as cgscc pipeline", Name).str(),
1597 inconvertibleErrorCode());
1598 }
1599
1600 // Now expand the basic registered passes from the .inc file.
1601 #define CGSCC_PASS(NAME, CREATE_PASS) \
1602 if (Name == NAME) { \
1603 CGPM.addPass(CREATE_PASS); \
1604 return Error::success(); \
1605 }
1606 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1607 if (checkParametrizedPassName(Name, NAME)) { \
1608 auto Params = parsePassParameters(PARSER, Name, NAME); \
1609 if (!Params) \
1610 return Params.takeError(); \
1611 CGPM.addPass(CREATE_PASS(Params.get())); \
1612 return Error::success(); \
1613 }
1614 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1615 if (Name == "require<" NAME ">") { \
1616 CGPM.addPass(RequireAnalysisPass< \
1617 std::remove_reference_t<decltype(CREATE_PASS)>, \
1618 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
1619 CGSCCUpdateResult &>()); \
1620 return Error::success(); \
1621 } \
1622 if (Name == "invalidate<" NAME ">") { \
1623 CGPM.addPass(InvalidateAnalysisPass< \
1624 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1625 return Error::success(); \
1626 }
1627 #define FUNCTION_PASS(NAME, CREATE_PASS) \
1628 if (Name == NAME) { \
1629 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
1630 return Error::success(); \
1631 }
1632 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1633 if (checkParametrizedPassName(Name, NAME)) { \
1634 auto Params = parsePassParameters(PARSER, Name, NAME); \
1635 if (!Params) \
1636 return Params.takeError(); \
1637 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
1638 return Error::success(); \
1639 }
1640 #define LOOPNEST_PASS(NAME, CREATE_PASS) \
1641 if (Name == NAME) { \
1642 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1643 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1644 return Error::success(); \
1645 }
1646 #define LOOP_PASS(NAME, CREATE_PASS) \
1647 if (Name == NAME) { \
1648 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
1649 createFunctionToLoopPassAdaptor(CREATE_PASS, false, false))); \
1650 return Error::success(); \
1651 }
1652 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1653 if (checkParametrizedPassName(Name, NAME)) { \
1654 auto Params = parsePassParameters(PARSER, Name, NAME); \
1655 if (!Params) \
1656 return Params.takeError(); \
1657 CGPM.addPass( \
1658 createCGSCCToFunctionPassAdaptor(createFunctionToLoopPassAdaptor( \
1659 CREATE_PASS(Params.get()), false, false))); \
1660 return Error::success(); \
1661 }
1662 #include "PassRegistry.def"
1663
1664 for (auto &C : CGSCCPipelineParsingCallbacks)
1665 if (C(Name, CGPM, InnerPipeline))
1666 return Error::success();
1667 return make_error<StringError>(
1668 formatv("unknown cgscc pass '{0}'", Name).str(),
1669 inconvertibleErrorCode());
1670 }
1671
parseFunctionPass(FunctionPassManager & FPM,const PipelineElement & E)1672 Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
1673 const PipelineElement &E) {
1674 auto &Name = E.Name;
1675 auto &InnerPipeline = E.InnerPipeline;
1676
1677 // First handle complex passes like the pass managers which carry pipelines.
1678 if (!InnerPipeline.empty()) {
1679 if (Name == "function") {
1680 FunctionPassManager NestedFPM;
1681 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1682 return Err;
1683 // Add the nested pass manager with the appropriate adaptor.
1684 FPM.addPass(std::move(NestedFPM));
1685 return Error::success();
1686 }
1687 if (Name == "loop" || Name == "loop-mssa") {
1688 LoopPassManager LPM;
1689 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
1690 return Err;
1691 // Add the nested pass manager with the appropriate adaptor.
1692 bool UseMemorySSA = (Name == "loop-mssa");
1693 bool UseBFI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1694 return Pipeline.Name.contains("simple-loop-unswitch");
1695 });
1696 bool UseBPI = llvm::any_of(InnerPipeline, [](auto Pipeline) {
1697 return Pipeline.Name == "loop-predication";
1698 });
1699 FPM.addPass(createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA,
1700 UseBFI, UseBPI));
1701 return Error::success();
1702 }
1703 if (auto Count = parseRepeatPassName(Name)) {
1704 FunctionPassManager NestedFPM;
1705 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
1706 return Err;
1707 FPM.addPass(createRepeatedPass(*Count, std::move(NestedFPM)));
1708 return Error::success();
1709 }
1710
1711 for (auto &C : FunctionPipelineParsingCallbacks)
1712 if (C(Name, FPM, InnerPipeline))
1713 return Error::success();
1714
1715 // Normal passes can't have pipelines.
1716 return make_error<StringError>(
1717 formatv("invalid use of '{0}' pass as function pipeline", Name).str(),
1718 inconvertibleErrorCode());
1719 }
1720
1721 // Now expand the basic registered passes from the .inc file.
1722 #define FUNCTION_PASS(NAME, CREATE_PASS) \
1723 if (Name == NAME) { \
1724 FPM.addPass(CREATE_PASS); \
1725 return Error::success(); \
1726 }
1727 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1728 if (checkParametrizedPassName(Name, NAME)) { \
1729 auto Params = parsePassParameters(PARSER, Name, NAME); \
1730 if (!Params) \
1731 return Params.takeError(); \
1732 FPM.addPass(CREATE_PASS(Params.get())); \
1733 return Error::success(); \
1734 }
1735 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1736 if (Name == "require<" NAME ">") { \
1737 FPM.addPass( \
1738 RequireAnalysisPass< \
1739 std::remove_reference_t<decltype(CREATE_PASS)>, Function>()); \
1740 return Error::success(); \
1741 } \
1742 if (Name == "invalidate<" NAME ">") { \
1743 FPM.addPass(InvalidateAnalysisPass< \
1744 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1745 return Error::success(); \
1746 }
1747 // FIXME: UseMemorySSA is set to false. Maybe we could do things like:
1748 // bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
1749 // "guard-widening");
1750 // The risk is that it may become obsolete if we're not careful.
1751 #define LOOPNEST_PASS(NAME, CREATE_PASS) \
1752 if (Name == NAME) { \
1753 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1754 return Error::success(); \
1755 }
1756 #define LOOP_PASS(NAME, CREATE_PASS) \
1757 if (Name == NAME) { \
1758 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false, false)); \
1759 return Error::success(); \
1760 }
1761 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1762 if (checkParametrizedPassName(Name, NAME)) { \
1763 auto Params = parsePassParameters(PARSER, Name, NAME); \
1764 if (!Params) \
1765 return Params.takeError(); \
1766 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), \
1767 false, false)); \
1768 return Error::success(); \
1769 }
1770 #include "PassRegistry.def"
1771
1772 for (auto &C : FunctionPipelineParsingCallbacks)
1773 if (C(Name, FPM, InnerPipeline))
1774 return Error::success();
1775 return make_error<StringError>(
1776 formatv("unknown function pass '{0}'", Name).str(),
1777 inconvertibleErrorCode());
1778 }
1779
parseLoopPass(LoopPassManager & LPM,const PipelineElement & E)1780 Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
1781 const PipelineElement &E) {
1782 StringRef Name = E.Name;
1783 auto &InnerPipeline = E.InnerPipeline;
1784
1785 // First handle complex passes like the pass managers which carry pipelines.
1786 if (!InnerPipeline.empty()) {
1787 if (Name == "loop") {
1788 LoopPassManager NestedLPM;
1789 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1790 return Err;
1791 // Add the nested pass manager with the appropriate adaptor.
1792 LPM.addPass(std::move(NestedLPM));
1793 return Error::success();
1794 }
1795 if (auto Count = parseRepeatPassName(Name)) {
1796 LoopPassManager NestedLPM;
1797 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
1798 return Err;
1799 LPM.addPass(createRepeatedPass(*Count, std::move(NestedLPM)));
1800 return Error::success();
1801 }
1802
1803 for (auto &C : LoopPipelineParsingCallbacks)
1804 if (C(Name, LPM, InnerPipeline))
1805 return Error::success();
1806
1807 // Normal passes can't have pipelines.
1808 return make_error<StringError>(
1809 formatv("invalid use of '{0}' pass as loop pipeline", Name).str(),
1810 inconvertibleErrorCode());
1811 }
1812
1813 // Now expand the basic registered passes from the .inc file.
1814 #define LOOPNEST_PASS(NAME, CREATE_PASS) \
1815 if (Name == NAME) { \
1816 LPM.addPass(CREATE_PASS); \
1817 return Error::success(); \
1818 }
1819 #define LOOP_PASS(NAME, CREATE_PASS) \
1820 if (Name == NAME) { \
1821 LPM.addPass(CREATE_PASS); \
1822 return Error::success(); \
1823 }
1824 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1825 if (checkParametrizedPassName(Name, NAME)) { \
1826 auto Params = parsePassParameters(PARSER, Name, NAME); \
1827 if (!Params) \
1828 return Params.takeError(); \
1829 LPM.addPass(CREATE_PASS(Params.get())); \
1830 return Error::success(); \
1831 }
1832 #define LOOP_ANALYSIS(NAME, CREATE_PASS) \
1833 if (Name == "require<" NAME ">") { \
1834 LPM.addPass(RequireAnalysisPass< \
1835 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
1836 LoopAnalysisManager, LoopStandardAnalysisResults &, \
1837 LPMUpdater &>()); \
1838 return Error::success(); \
1839 } \
1840 if (Name == "invalidate<" NAME ">") { \
1841 LPM.addPass(InvalidateAnalysisPass< \
1842 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
1843 return Error::success(); \
1844 }
1845 #include "PassRegistry.def"
1846
1847 for (auto &C : LoopPipelineParsingCallbacks)
1848 if (C(Name, LPM, InnerPipeline))
1849 return Error::success();
1850 return make_error<StringError>(formatv("unknown loop pass '{0}'", Name).str(),
1851 inconvertibleErrorCode());
1852 }
1853
parseMachinePass(MachineFunctionPassManager & MFPM,const PipelineElement & E)1854 Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
1855 const PipelineElement &E) {
1856 StringRef Name = E.Name;
1857 if (!E.InnerPipeline.empty())
1858 return make_error<StringError>("invalid pipeline",
1859 inconvertibleErrorCode());
1860
1861 #define MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
1862 if (Name == NAME) { \
1863 MFPM.addPass(PASS_NAME()); \
1864 return Error::success(); \
1865 }
1866 #define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
1867 if (Name == NAME) { \
1868 MFPM.addPass(PASS_NAME()); \
1869 return Error::success(); \
1870 }
1871 #include "llvm/CodeGen/MachinePassRegistry.def"
1872
1873 for (auto &C : MachinePipelineParsingCallbacks)
1874 if (C(Name, MFPM))
1875 return Error::success();
1876 return make_error<StringError>(
1877 formatv("unknown machine pass '{0}'", Name).str(),
1878 inconvertibleErrorCode());
1879 }
1880
parseAAPassName(AAManager & AA,StringRef Name)1881 bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
1882 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1883 if (Name == NAME) { \
1884 AA.registerModuleAnalysis< \
1885 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1886 return true; \
1887 }
1888 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
1889 if (Name == NAME) { \
1890 AA.registerFunctionAnalysis< \
1891 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
1892 return true; \
1893 }
1894 #include "PassRegistry.def"
1895
1896 for (auto &C : AAParsingCallbacks)
1897 if (C(Name, AA))
1898 return true;
1899 return false;
1900 }
1901
parseMachinePassPipeline(MachineFunctionPassManager & MFPM,ArrayRef<PipelineElement> Pipeline)1902 Error PassBuilder::parseMachinePassPipeline(
1903 MachineFunctionPassManager &MFPM, ArrayRef<PipelineElement> Pipeline) {
1904 for (const auto &Element : Pipeline) {
1905 if (auto Err = parseMachinePass(MFPM, Element))
1906 return Err;
1907 }
1908 return Error::success();
1909 }
1910
parseLoopPassPipeline(LoopPassManager & LPM,ArrayRef<PipelineElement> Pipeline)1911 Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
1912 ArrayRef<PipelineElement> Pipeline) {
1913 for (const auto &Element : Pipeline) {
1914 if (auto Err = parseLoopPass(LPM, Element))
1915 return Err;
1916 }
1917 return Error::success();
1918 }
1919
parseFunctionPassPipeline(FunctionPassManager & FPM,ArrayRef<PipelineElement> Pipeline)1920 Error PassBuilder::parseFunctionPassPipeline(
1921 FunctionPassManager &FPM, ArrayRef<PipelineElement> Pipeline) {
1922 for (const auto &Element : Pipeline) {
1923 if (auto Err = parseFunctionPass(FPM, Element))
1924 return Err;
1925 }
1926 return Error::success();
1927 }
1928
parseCGSCCPassPipeline(CGSCCPassManager & CGPM,ArrayRef<PipelineElement> Pipeline)1929 Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
1930 ArrayRef<PipelineElement> Pipeline) {
1931 for (const auto &Element : Pipeline) {
1932 if (auto Err = parseCGSCCPass(CGPM, Element))
1933 return Err;
1934 }
1935 return Error::success();
1936 }
1937
crossRegisterProxies(LoopAnalysisManager & LAM,FunctionAnalysisManager & FAM,CGSCCAnalysisManager & CGAM,ModuleAnalysisManager & MAM)1938 void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
1939 FunctionAnalysisManager &FAM,
1940 CGSCCAnalysisManager &CGAM,
1941 ModuleAnalysisManager &MAM) {
1942 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
1943 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
1944 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
1945 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
1946 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
1947 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
1948 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
1949 }
1950
parseModulePassPipeline(ModulePassManager & MPM,ArrayRef<PipelineElement> Pipeline)1951 Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
1952 ArrayRef<PipelineElement> Pipeline) {
1953 for (const auto &Element : Pipeline) {
1954 if (auto Err = parseModulePass(MPM, Element))
1955 return Err;
1956 }
1957 return Error::success();
1958 }
1959
1960 // Primary pass pipeline description parsing routine for a \c ModulePassManager
1961 // FIXME: Should this routine accept a TargetMachine or require the caller to
1962 // pre-populate the analysis managers with target-specific stuff?
parsePassPipeline(ModulePassManager & MPM,StringRef PipelineText)1963 Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
1964 StringRef PipelineText) {
1965 auto Pipeline = parsePipelineText(PipelineText);
1966 if (!Pipeline || Pipeline->empty())
1967 return make_error<StringError>(
1968 formatv("invalid pipeline '{0}'", PipelineText).str(),
1969 inconvertibleErrorCode());
1970
1971 // If the first name isn't at the module layer, wrap the pipeline up
1972 // automatically.
1973 StringRef FirstName = Pipeline->front().Name;
1974
1975 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
1976 bool UseMemorySSA;
1977 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
1978 Pipeline = {{"cgscc", std::move(*Pipeline)}};
1979 } else if (isFunctionPassName(FirstName,
1980 FunctionPipelineParsingCallbacks)) {
1981 Pipeline = {{"function", std::move(*Pipeline)}};
1982 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
1983 UseMemorySSA)) {
1984 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
1985 std::move(*Pipeline)}}}};
1986 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
1987 UseMemorySSA)) {
1988 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
1989 std::move(*Pipeline)}}}};
1990 } else {
1991 for (auto &C : TopLevelPipelineParsingCallbacks)
1992 if (C(MPM, *Pipeline))
1993 return Error::success();
1994
1995 // Unknown pass or pipeline name!
1996 auto &InnerPipeline = Pipeline->front().InnerPipeline;
1997 return make_error<StringError>(
1998 formatv("unknown {0} name '{1}'",
1999 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2000 .str(),
2001 inconvertibleErrorCode());
2002 }
2003 }
2004
2005 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2006 return Err;
2007 return Error::success();
2008 }
2009
2010 // Primary pass pipeline description parsing routine for a \c CGSCCPassManager
parsePassPipeline(CGSCCPassManager & CGPM,StringRef PipelineText)2011 Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
2012 StringRef PipelineText) {
2013 auto Pipeline = parsePipelineText(PipelineText);
2014 if (!Pipeline || Pipeline->empty())
2015 return make_error<StringError>(
2016 formatv("invalid pipeline '{0}'", PipelineText).str(),
2017 inconvertibleErrorCode());
2018
2019 StringRef FirstName = Pipeline->front().Name;
2020 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2021 return make_error<StringError>(
2022 formatv("unknown cgscc pass '{0}' in pipeline '{1}'", FirstName,
2023 PipelineText)
2024 .str(),
2025 inconvertibleErrorCode());
2026
2027 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2028 return Err;
2029 return Error::success();
2030 }
2031
2032 // Primary pass pipeline description parsing routine for a \c
2033 // FunctionPassManager
parsePassPipeline(FunctionPassManager & FPM,StringRef PipelineText)2034 Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
2035 StringRef PipelineText) {
2036 auto Pipeline = parsePipelineText(PipelineText);
2037 if (!Pipeline || Pipeline->empty())
2038 return make_error<StringError>(
2039 formatv("invalid pipeline '{0}'", PipelineText).str(),
2040 inconvertibleErrorCode());
2041
2042 StringRef FirstName = Pipeline->front().Name;
2043 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2044 return make_error<StringError>(
2045 formatv("unknown function pass '{0}' in pipeline '{1}'", FirstName,
2046 PipelineText)
2047 .str(),
2048 inconvertibleErrorCode());
2049
2050 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2051 return Err;
2052 return Error::success();
2053 }
2054
2055 // Primary pass pipeline description parsing routine for a \c LoopPassManager
parsePassPipeline(LoopPassManager & CGPM,StringRef PipelineText)2056 Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM,
2057 StringRef PipelineText) {
2058 auto Pipeline = parsePipelineText(PipelineText);
2059 if (!Pipeline || Pipeline->empty())
2060 return make_error<StringError>(
2061 formatv("invalid pipeline '{0}'", PipelineText).str(),
2062 inconvertibleErrorCode());
2063
2064 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2065 return Err;
2066
2067 return Error::success();
2068 }
2069
parsePassPipeline(MachineFunctionPassManager & MFPM,StringRef PipelineText)2070 Error PassBuilder::parsePassPipeline(MachineFunctionPassManager &MFPM,
2071 StringRef PipelineText) {
2072 auto Pipeline = parsePipelineText(PipelineText);
2073 if (!Pipeline || Pipeline->empty())
2074 return make_error<StringError>(
2075 formatv("invalid machine pass pipeline '{0}'", PipelineText).str(),
2076 inconvertibleErrorCode());
2077
2078 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2079 return Err;
2080
2081 return Error::success();
2082 }
2083
parseAAPipeline(AAManager & AA,StringRef PipelineText)2084 Error PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) {
2085 // If the pipeline just consists of the word 'default' just replace the AA
2086 // manager with our default one.
2087 if (PipelineText == "default") {
2088 AA = buildDefaultAAPipeline();
2089 return Error::success();
2090 }
2091
2092 while (!PipelineText.empty()) {
2093 StringRef Name;
2094 std::tie(Name, PipelineText) = PipelineText.split(',');
2095 if (!parseAAPassName(AA, Name))
2096 return make_error<StringError>(
2097 formatv("unknown alias analysis name '{0}'", Name).str(),
2098 inconvertibleErrorCode());
2099 }
2100
2101 return Error::success();
2102 }
2103
printPassName(StringRef PassName,raw_ostream & OS)2104 static void printPassName(StringRef PassName, raw_ostream &OS) {
2105 OS << " " << PassName << "\n";
2106 }
printPassName(StringRef PassName,StringRef Params,raw_ostream & OS)2107 static void printPassName(StringRef PassName, StringRef Params,
2108 raw_ostream &OS) {
2109 OS << " " << PassName << "<" << Params << ">\n";
2110 }
2111
printPassNames(raw_ostream & OS)2112 void PassBuilder::printPassNames(raw_ostream &OS) {
2113 // TODO: print pass descriptions when they are available
2114
2115 OS << "Module passes:\n";
2116 #define MODULE_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2117 #include "PassRegistry.def"
2118
2119 OS << "Module passes with params:\n";
2120 #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2121 printPassName(NAME, PARAMS, OS);
2122 #include "PassRegistry.def"
2123
2124 OS << "Module analyses:\n";
2125 #define MODULE_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2126 #include "PassRegistry.def"
2127
2128 OS << "Module alias analyses:\n";
2129 #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2130 #include "PassRegistry.def"
2131
2132 OS << "CGSCC passes:\n";
2133 #define CGSCC_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2134 #include "PassRegistry.def"
2135
2136 OS << "CGSCC passes with params:\n";
2137 #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2138 printPassName(NAME, PARAMS, OS);
2139 #include "PassRegistry.def"
2140
2141 OS << "CGSCC analyses:\n";
2142 #define CGSCC_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2143 #include "PassRegistry.def"
2144
2145 OS << "Function passes:\n";
2146 #define FUNCTION_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2147 #include "PassRegistry.def"
2148
2149 OS << "Function passes with params:\n";
2150 #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2151 printPassName(NAME, PARAMS, OS);
2152 #include "PassRegistry.def"
2153
2154 OS << "Function analyses:\n";
2155 #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2156 #include "PassRegistry.def"
2157
2158 OS << "Function alias analyses:\n";
2159 #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2160 #include "PassRegistry.def"
2161
2162 OS << "LoopNest passes:\n";
2163 #define LOOPNEST_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2164 #include "PassRegistry.def"
2165
2166 OS << "Loop passes:\n";
2167 #define LOOP_PASS(NAME, CREATE_PASS) printPassName(NAME, OS);
2168 #include "PassRegistry.def"
2169
2170 OS << "Loop passes with params:\n";
2171 #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2172 printPassName(NAME, PARAMS, OS);
2173 #include "PassRegistry.def"
2174
2175 OS << "Loop analyses:\n";
2176 #define LOOP_ANALYSIS(NAME, CREATE_PASS) printPassName(NAME, OS);
2177 #include "PassRegistry.def"
2178
2179 OS << "Machine module passes (WIP):\n";
2180 #define MACHINE_MODULE_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
2181 printPassName(NAME, OS);
2182 #include "llvm/CodeGen/MachinePassRegistry.def"
2183
2184 OS << "Machine function passes (WIP):\n";
2185 #define MACHINE_FUNCTION_PASS(NAME, PASS_NAME, CONSTRUCTOR) \
2186 printPassName(NAME, OS);
2187 #include "llvm/CodeGen/MachinePassRegistry.def"
2188
2189 OS << "Machine function analyses (WIP):\n";
2190 #define MACHINE_FUNCTION_ANALYSIS(NAME, PASS_NAME, CONSTRUCTOR) \
2191 printPassName(NAME, OS);
2192 #include "llvm/CodeGen/MachinePassRegistry.def"
2193 }
2194
registerParseTopLevelPipelineCallback(const std::function<bool (ModulePassManager &,ArrayRef<PipelineElement>)> & C)2195 void PassBuilder::registerParseTopLevelPipelineCallback(
2196 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
2197 &C) {
2198 TopLevelPipelineParsingCallbacks.push_back(C);
2199 }
2200