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