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