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