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