LLVM 24.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/ADT/StringTable.h"
20#include "llvm/Analysis/AliasAnalysisEvaluator.h"
21#include "llvm/Analysis/AliasSetTracker.h"
22#include "llvm/Analysis/AssumptionCache.h"
23#include "llvm/Analysis/BasicAliasAnalysis.h"
24#include "llvm/Analysis/BlockFrequencyInfo.h"
25#include "llvm/Analysis/BranchProbabilityInfo.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/EphemeralValuesCache.h"
43#include "llvm/Analysis/FunctionPropertiesAnalysis.h"
44#include "llvm/Analysis/GlobalsModRef.h"
45#include "llvm/Analysis/HashRecognize.h"
46#include "llvm/Analysis/IR2Vec.h"
47#include "llvm/Analysis/IVUsers.h"
48#include "llvm/Analysis/InlineAdvisor.h"
49#include "llvm/Analysis/InstCount.h"
50#include "llvm/Analysis/KernelInfo.h"
51#include "llvm/Analysis/LastRunTrackingAnalysis.h"
52#include "llvm/Analysis/LazyCallGraph.h"
53#include "llvm/Analysis/LazyValueInfo.h"
54#include "llvm/Analysis/LibcallLoweringInfo.h"
55#include "llvm/Analysis/Lint.h"
56#include "llvm/Analysis/LoopAccessAnalysis.h"
57#include "llvm/Analysis/LoopCacheAnalysis.h"
58#include "llvm/Analysis/LoopInfo.h"
59#include "llvm/Analysis/LoopNestAnalysis.h"
60#include "llvm/Analysis/MemDerefPrinter.h"
61#include "llvm/Analysis/MemoryDependenceAnalysis.h"
62#include "llvm/Analysis/MemorySSA.h"
63#include "llvm/Analysis/ModuleDebugInfoPrinter.h"
64#include "llvm/Analysis/ModuleSummaryAnalysis.h"
65#include "llvm/Analysis/MustExecute.h"
66#include "llvm/Analysis/ObjCARCAliasAnalysis.h"
67#include "llvm/Analysis/PhiValues.h"
68#include "llvm/Analysis/PostDominators.h"
69#include "llvm/Analysis/ProfileSummaryInfo.h"
70#include "llvm/Analysis/RegionInfo.h"
71#include "llvm/Analysis/RuntimeLibcallInfo.h"
72#include "llvm/Analysis/ScalarEvolution.h"
73#include "llvm/Analysis/ScalarEvolutionAliasAnalysis.h"
74#include "llvm/Analysis/ScalarEvolutionDivision.h"
75#include "llvm/Analysis/ScopedNoAliasAA.h"
76#include "llvm/Analysis/StackLifetime.h"
77#include "llvm/Analysis/StackSafetyAnalysis.h"
78#include "llvm/Analysis/StaticDataProfileInfo.h"
79#include "llvm/Analysis/StructuralHash.h"
80#include "llvm/Analysis/TargetLibraryInfo.h"
81#include "llvm/Analysis/TargetTransformInfo.h"
82#include "llvm/Analysis/TypeBasedAliasAnalysis.h"
83#include "llvm/Analysis/UniformityAnalysis.h"
84#include "llvm/CodeGen/AssignmentTrackingAnalysis.h"
85#include "llvm/CodeGen/AtomicExpand.h"
86#include "llvm/CodeGen/BasicBlockSectionsProfileReader.h"
87#include "llvm/CodeGen/BranchFoldingPass.h"
88#include "llvm/CodeGen/BranchRelaxation.h"
89#include "llvm/CodeGen/BreakFalseDeps.h"
90#include "llvm/CodeGen/CFIFixup.h"
91#include "llvm/CodeGen/CFIInstrInserter.h"
92#include "llvm/CodeGen/CodeGenPrepare.h"
93#include "llvm/CodeGen/ComplexDeinterleavingPass.h"
94#include "llvm/CodeGen/DeadMachineInstructionElim.h"
95#include "llvm/CodeGen/DetectDeadLanes.h"
96#include "llvm/CodeGen/DwarfEHPrepare.h"
97#include "llvm/CodeGen/EHContGuardTargets.h"
98#include "llvm/CodeGen/EarlyIfConversion.h"
99#include "llvm/CodeGen/EdgeBundles.h"
100#include "llvm/CodeGen/ExpandIRInsts.h"
101#include "llvm/CodeGen/ExpandPostRAPseudos.h"
102#include "llvm/CodeGen/ExpandReductions.h"
103#include "llvm/CodeGen/FEntryInserter.h"
104#include "llvm/CodeGen/FinalizeISel.h"
105#include "llvm/CodeGen/FixupStatepointCallerSaved.h"
106#include "llvm/CodeGen/FuncletLayout.h"
107#include "llvm/CodeGen/GCEmptyBasicBlocks.h"
108#include "llvm/CodeGen/GCMetadata.h"
109#include "llvm/CodeGen/GlobalISel/CSEInfo.h"
110#include "llvm/CodeGen/GlobalISel/GISelValueTracking.h"
111#include "llvm/CodeGen/GlobalISel/IRTranslator.h"
112#include "llvm/CodeGen/GlobalISel/InstructionSelect.h"
113#include "llvm/CodeGen/GlobalISel/Legalizer.h"
114#include "llvm/CodeGen/GlobalISel/LoadStoreOpt.h"
115#include "llvm/CodeGen/GlobalISel/Localizer.h"
116#include "llvm/CodeGen/GlobalISel/RegBankSelect.h"
117#include "llvm/CodeGen/GlobalMerge.h"
118#include "llvm/CodeGen/GlobalMergeFunctions.h"
119#include "llvm/CodeGen/HardwareLoops.h"
120#include "llvm/CodeGen/ImplicitNullChecks.h"
121#include "llvm/CodeGen/IndirectBrExpand.h"
122#include "llvm/CodeGen/InitUndef.h"
123#include "llvm/CodeGen/InlineAsmPrepare.h"
124#include "llvm/CodeGen/InterleavedAccess.h"
125#include "llvm/CodeGen/InterleavedLoadCombine.h"
126#include "llvm/CodeGen/JMCInstrumenter.h"
127#include "llvm/CodeGen/KCFI.h"
128#include "llvm/CodeGen/LiveDebugValuesPass.h"
129#include "llvm/CodeGen/LiveDebugVariables.h"
130#include "llvm/CodeGen/LiveIntervals.h"
131#include "llvm/CodeGen/LiveRegMatrix.h"
132#include "llvm/CodeGen/LiveStacks.h"
133#include "llvm/CodeGen/LiveVariables.h"
134#include "llvm/CodeGen/LocalStackSlotAllocation.h"
135#include "llvm/CodeGen/LowerEmuTLS.h"
136#include "llvm/CodeGen/MIRPrinter.h"
137#include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
138#include "llvm/CodeGen/MachineBlockHashInfo.h"
139#include "llvm/CodeGen/MachineBlockPlacement.h"
140#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
141#include "llvm/CodeGen/MachineCFGPrinter.h"
142#include "llvm/CodeGen/MachineCSE.h"
143#include "llvm/CodeGen/MachineCheckDebugify.h"
144#include "llvm/CodeGen/MachineCombiner.h"
145#include "llvm/CodeGen/MachineCopyPropagation.h"
146#include "llvm/CodeGen/MachineDebugify.h"
147#include "llvm/CodeGen/MachineDominanceFrontier.h"
148#include "llvm/CodeGen/MachineDominators.h"
149#include "llvm/CodeGen/MachineFunctionAnalysis.h"
150#include "llvm/CodeGen/MachineInstrBundle.h"
151#include "llvm/CodeGen/MachineLICM.h"
152#include "llvm/CodeGen/MachineLateInstrsCleanup.h"
153#include "llvm/CodeGen/MachinePassManager.h"
154#include "llvm/CodeGen/MachinePipeliner.h"
155#include "llvm/CodeGen/MachinePostDominators.h"
156#include "llvm/CodeGen/MachineRegionInfo.h"
157#include "llvm/CodeGen/MachineRegisterInfo.h"
158#include "llvm/CodeGen/MachineScheduler.h"
159#include "llvm/CodeGen/MachineSink.h"
160#include "llvm/CodeGen/MachineStripDebug.h"
161#include "llvm/CodeGen/MachineTraceMetrics.h"
162#include "llvm/CodeGen/MachineUniformityAnalysis.h"
163#include "llvm/CodeGen/MachineVerifier.h"
164#include "llvm/CodeGen/OptimizePHIs.h"
165#include "llvm/CodeGen/PEI.h"
166#include "llvm/CodeGen/PHIElimination.h"
167#include "llvm/CodeGen/PatchableFunction.h"
168#include "llvm/CodeGen/PeepholeOptimizer.h"
169#include "llvm/CodeGen/PostRAHazardRecognizer.h"
170#include "llvm/CodeGen/PostRAMachineSink.h"
171#include "llvm/CodeGen/PostRASchedulerList.h"
172#include "llvm/CodeGen/PreISelIntrinsicLowering.h"
173#include "llvm/CodeGen/ProcessImplicitDefs.h"
174#include "llvm/CodeGen/ReachingDefAnalysis.h"
175#include "llvm/CodeGen/RegAllocEvictionAdvisor.h"
176#include "llvm/CodeGen/RegAllocFast.h"
177#include "llvm/CodeGen/RegAllocGreedyPass.h"
178#include "llvm/CodeGen/RegAllocPriorityAdvisor.h"
179#include "llvm/CodeGen/RegUsageInfoCollector.h"
180#include "llvm/CodeGen/RegUsageInfoPropagate.h"
181#include "llvm/CodeGen/RegisterClassInfo.h"
182#include "llvm/CodeGen/RegisterCoalescerPass.h"
183#include "llvm/CodeGen/RegisterUsageInfo.h"
184#include "llvm/CodeGen/RemoveLoadsIntoFakeUses.h"
185#include "llvm/CodeGen/RemoveRedundantDebugValues.h"
186#include "llvm/CodeGen/RenameIndependentSubregs.h"
187#include "llvm/CodeGen/ReplaceWithVeclib.h"
188#include "llvm/CodeGen/SafeStack.h"
189#include "llvm/CodeGen/SanitizerBinaryMetadata.h"
190#include "llvm/CodeGen/SelectOptimize.h"
191#include "llvm/CodeGen/ShadowStackGCLowering.h"
192#include "llvm/CodeGen/ShrinkWrap.h"
193#include "llvm/CodeGen/SjLjEHPrepare.h"
194#include "llvm/CodeGen/SlotIndexes.h"
195#include "llvm/CodeGen/SpillPlacement.h"
196#include "llvm/CodeGen/StackColoring.h"
197#include "llvm/CodeGen/StackFrameLayoutAnalysisPass.h"
198#include "llvm/CodeGen/StackProtector.h"
199#include "llvm/CodeGen/StackSlotColoring.h"
200#include "llvm/CodeGen/StaticDataAnnotator.h"
201#include "llvm/CodeGen/StaticDataSplitter.h"
202#include "llvm/CodeGen/TailDuplication.h"
203#include "llvm/CodeGen/TargetPassConfig.h"
204#include "llvm/CodeGen/TwoAddressInstructionPass.h"
205#include "llvm/CodeGen/TypePromotion.h"
206#include "llvm/CodeGen/UnreachableBlockElim.h"
207#include "llvm/CodeGen/VirtRegMap.h"
208#include "llvm/CodeGen/WasmEHPrepare.h"
209#include "llvm/CodeGen/WinEHPrepare.h"
210#include "llvm/CodeGen/XRayInstrumentation.h"
211#include "llvm/IR/DebugInfo.h"
212#include "llvm/IR/Dominators.h"
213#include "llvm/IR/PassManager.h"
214#include "llvm/IR/SafepointIRVerifier.h"
215#include "llvm/IR/Verifier.h"
216#include "llvm/IRPrinter/IRPrintingPasses.h"
217#include "llvm/Passes/OptimizationLevel.h"
218#include "llvm/Passes/TriggerCrashPasses.h"
219#include "llvm/Support/CodeGen.h"
220#include "llvm/Support/CommandLine.h"
221#include "llvm/Support/Debug.h"
222#include "llvm/Support/Error.h"
223#include "llvm/Support/ErrorHandling.h"
224#include "llvm/Support/FormatAdapters.h"
225#include "llvm/Support/FormatVariadic.h"
226#include "llvm/Support/Regex.h"
227#include "llvm/Target/TargetMachine.h"
228#include "llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h"
229#include "llvm/Transforms/CFGuard.h"
230#include "llvm/Transforms/Coroutines/CoroAnnotationElide.h"
231#include "llvm/Transforms/Coroutines/CoroCleanup.h"
232#include "llvm/Transforms/Coroutines/CoroConditionalWrapper.h"
233#include "llvm/Transforms/Coroutines/CoroEarly.h"
234#include "llvm/Transforms/Coroutines/CoroElide.h"
235#include "llvm/Transforms/Coroutines/CoroSplit.h"
236#include "llvm/Transforms/HipStdPar/HipStdPar.h"
237#include "llvm/Transforms/IPO/AlwaysInliner.h"
238#include "llvm/Transforms/IPO/Annotation2Metadata.h"
239#include "llvm/Transforms/IPO/ArgumentPromotion.h"
240#include "llvm/Transforms/IPO/Attributor.h"
241#include "llvm/Transforms/IPO/BlockExtractor.h"
242#include "llvm/Transforms/IPO/CalledValuePropagation.h"
243#include "llvm/Transforms/IPO/ConstantMerge.h"
244#include "llvm/Transforms/IPO/CrossDSOCFI.h"
245#include "llvm/Transforms/IPO/DeadArgumentElimination.h"
246#include "llvm/Transforms/IPO/ElimAvailExtern.h"
247#include "llvm/Transforms/IPO/EmbedBitcodePass.h"
248#include "llvm/Transforms/IPO/ExpandVariadics.h"
249#include "llvm/Transforms/IPO/FatLTOCleanup.h"
250#include "llvm/Transforms/IPO/ForceFunctionAttrs.h"
251#include "llvm/Transforms/IPO/FunctionAttrs.h"
252#include "llvm/Transforms/IPO/FunctionImport.h"
253#include "llvm/Transforms/IPO/GlobalDCE.h"
254#include "llvm/Transforms/IPO/GlobalOpt.h"
255#include "llvm/Transforms/IPO/GlobalSplit.h"
256#include "llvm/Transforms/IPO/HotColdSplitting.h"
257#include "llvm/Transforms/IPO/InferFunctionAttrs.h"
258#include "llvm/Transforms/IPO/Instrumentor.h"
259#include "llvm/Transforms/IPO/Internalize.h"
260#include "llvm/Transforms/IPO/LowerTypeTests.h"
261#include "llvm/Transforms/IPO/MemProfContextDisambiguation.h"
262#include "llvm/Transforms/IPO/MergeFunctions.h"
263#include "llvm/Transforms/IPO/OpenMPOpt.h"
264#include "llvm/Transforms/IPO/PartialInlining.h"
265#include "llvm/Transforms/IPO/SCCP.h"
266#include "llvm/Transforms/IPO/SampleProfile.h"
267#include "llvm/Transforms/IPO/SampleProfileProbe.h"
268#include "llvm/Transforms/IPO/StripDeadPrototypes.h"
269#include "llvm/Transforms/IPO/StripSymbols.h"
270#include "llvm/Transforms/IPO/WholeProgramDevirt.h"
271#include "llvm/Transforms/InstCombine/InstCombine.h"
272#include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
273#include "llvm/Transforms/Instrumentation/AllocToken.h"
274#include "llvm/Transforms/Instrumentation/BoundsChecking.h"
275#include "llvm/Transforms/Instrumentation/CGProfile.h"
276#include "llvm/Transforms/Instrumentation/ControlHeightReduction.h"
277#include "llvm/Transforms/Instrumentation/CopyProf.h"
278#include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
279#include "llvm/Transforms/Instrumentation/GCOVProfiler.h"
280#include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
281#include "llvm/Transforms/Instrumentation/InstrProfiling.h"
282#include "llvm/Transforms/Instrumentation/KCFI.h"
283#include "llvm/Transforms/Instrumentation/LowerAllowCheckPass.h"
284#include "llvm/Transforms/Instrumentation/MemProfInstrumentation.h"
285#include "llvm/Transforms/Instrumentation/MemProfUse.h"
286#include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
287#include "llvm/Transforms/Instrumentation/NumericalStabilitySanitizer.h"
288#include "llvm/Transforms/Instrumentation/PGOCtxProfFlattening.h"
289#include "llvm/Transforms/Instrumentation/PGOCtxProfLowering.h"
290#include "llvm/Transforms/Instrumentation/PGOForceFunctionAttrs.h"
291#include "llvm/Transforms/Instrumentation/PGOInstrumentation.h"
292#include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
293#include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
294#include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
295#include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
296#include "llvm/Transforms/Instrumentation/TypeSanitizer.h"
297#include "llvm/Transforms/ObjCARC.h"
298#include "llvm/Transforms/Scalar/ADCE.h"
299#include "llvm/Transforms/Scalar/AlignmentFromAssumptions.h"
300#include "llvm/Transforms/Scalar/AnnotationRemarks.h"
301#include "llvm/Transforms/Scalar/BDCE.h"
302#include "llvm/Transforms/Scalar/CallSiteSplitting.h"
303#include "llvm/Transforms/Scalar/ConstantHoisting.h"
304#include "llvm/Transforms/Scalar/ConstraintElimination.h"
305#include "llvm/Transforms/Scalar/CorrelatedValuePropagation.h"
306#include "llvm/Transforms/Scalar/DCE.h"
307#include "llvm/Transforms/Scalar/DFAJumpThreading.h"
308#include "llvm/Transforms/Scalar/DeadStoreElimination.h"
309#include "llvm/Transforms/Scalar/DivRemPairs.h"
310#include "llvm/Transforms/Scalar/DropUnnecessaryAssumes.h"
311#include "llvm/Transforms/Scalar/EarlyCSE.h"
312#include "llvm/Transforms/Scalar/ExpandMemCmp.h"
313#include "llvm/Transforms/Scalar/FlattenCFG.h"
314#include "llvm/Transforms/Scalar/Float2Int.h"
315#include "llvm/Transforms/Scalar/GVN.h"
316#include "llvm/Transforms/Scalar/GuardWidening.h"
317#include "llvm/Transforms/Scalar/IVUsersPrinter.h"
318#include "llvm/Transforms/Scalar/IndVarSimplify.h"
319#include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h"
320#include "llvm/Transforms/Scalar/InferAddressSpaces.h"
321#include "llvm/Transforms/Scalar/InferAlignment.h"
322#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
323#include "llvm/Transforms/Scalar/JumpTableToSwitch.h"
324#include "llvm/Transforms/Scalar/JumpThreading.h"
325#include "llvm/Transforms/Scalar/LICM.h"
326#include "llvm/Transforms/Scalar/LogicalSROA.h"
327#include "llvm/Transforms/Scalar/LoopAccessAnalysisPrinter.h"
328#include "llvm/Transforms/Scalar/LoopBoundSplit.h"
329#include "llvm/Transforms/Scalar/LoopDataPrefetch.h"
330#include "llvm/Transforms/Scalar/LoopDeletion.h"
331#include "llvm/Transforms/Scalar/LoopDistribute.h"
332#include "llvm/Transforms/Scalar/LoopFlatten.h"
333#include "llvm/Transforms/Scalar/LoopFuse.h"
334#include "llvm/Transforms/Scalar/LoopIdiomRecognize.h"
335#include "llvm/Transforms/Scalar/LoopInstSimplify.h"
336#include "llvm/Transforms/Scalar/LoopInterchange.h"
337#include "llvm/Transforms/Scalar/LoopLoadElimination.h"
338#include "llvm/Transforms/Scalar/LoopPassManager.h"
339#include "llvm/Transforms/Scalar/LoopPredication.h"
340#include "llvm/Transforms/Scalar/LoopRotation.h"
341#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
342#include "llvm/Transforms/Scalar/LoopSink.h"
343#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
344#include "llvm/Transforms/Scalar/LoopTermFold.h"
345#include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
346#include "llvm/Transforms/Scalar/LoopUnrollPass.h"
347#include "llvm/Transforms/Scalar/LoopVersioningLICM.h"
348#include "llvm/Transforms/Scalar/LowerAtomicPass.h"
349#include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
350#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
351#include "llvm/Transforms/Scalar/LowerGuardIntrinsic.h"
352#include "llvm/Transforms/Scalar/LowerMatrixIntrinsics.h"
353#include "llvm/Transforms/Scalar/LowerWidenableCondition.h"
354#include "llvm/Transforms/Scalar/MakeGuardsExplicit.h"
355#include "llvm/Transforms/Scalar/MemCpyOptimizer.h"
356#include "llvm/Transforms/Scalar/MergeICmps.h"
357#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
358#include "llvm/Transforms/Scalar/NaryReassociate.h"
359#include "llvm/Transforms/Scalar/NewGVN.h"
360#include "llvm/Transforms/Scalar/PartiallyInlineLibCalls.h"
361#include "llvm/Transforms/Scalar/PlaceSafepoints.h"
362#include "llvm/Transforms/Scalar/Reassociate.h"
363#include "llvm/Transforms/Scalar/Reg2Mem.h"
364#include "llvm/Transforms/Scalar/RewriteStatepointsForGC.h"
365#include "llvm/Transforms/Scalar/SCCP.h"
366#include "llvm/Transforms/Scalar/SROA.h"
367#include "llvm/Transforms/Scalar/ScalarizeMaskedMemIntrin.h"
368#include "llvm/Transforms/Scalar/Scalarizer.h"
369#include "llvm/Transforms/Scalar/SeparateConstOffsetFromGEP.h"
370#include "llvm/Transforms/Scalar/SimpleLoopUnswitch.h"
371#include "llvm/Transforms/Scalar/SimplifyCFG.h"
372#include "llvm/Transforms/Scalar/Sink.h"
373#include "llvm/Transforms/Scalar/SpeculativeExecution.h"
374#include "llvm/Transforms/Scalar/StraightLineStrengthReduce.h"
375#include "llvm/Transforms/Scalar/StructurizeCFG.h"
376#include "llvm/Transforms/Scalar/TailRecursionElimination.h"
377#include "llvm/Transforms/Scalar/WarnMissedTransforms.h"
378#include "llvm/Transforms/Utils/AddDiscriminators.h"
379#include "llvm/Transforms/Utils/AssignGUID.h"
380#include "llvm/Transforms/Utils/AssumeBundleBuilder.h"
381#include "llvm/Transforms/Utils/BreakCriticalEdges.h"
382#include "llvm/Transforms/Utils/CanonicalizeAliases.h"
383#include "llvm/Transforms/Utils/CanonicalizeFreezeInLoops.h"
384#include "llvm/Transforms/Utils/CountVisits.h"
385#include "llvm/Transforms/Utils/DXILUpgrade.h"
386#include "llvm/Transforms/Utils/Debugify.h"
387#include "llvm/Transforms/Utils/DeclareRuntimeLibcalls.h"
388#include "llvm/Transforms/Utils/EntryExitInstrumenter.h"
389#include "llvm/Transforms/Utils/FixIrreducible.h"
390#include "llvm/Transforms/Utils/HelloWorld.h"
391#include "llvm/Transforms/Utils/IRNormalizer.h"
392#include "llvm/Transforms/Utils/InjectTLIMappings.h"
393#include "llvm/Transforms/Utils/InstructionNamer.h"
394#include "llvm/Transforms/Utils/LibCallsShrinkWrap.h"
395#include "llvm/Transforms/Utils/LoopSimplify.h"
396#include "llvm/Transforms/Utils/LoopVersioning.h"
397#include "llvm/Transforms/Utils/LowerCommentStringPass.h"
398#include "llvm/Transforms/Utils/LowerGlobalDtors.h"
399#include "llvm/Transforms/Utils/LowerIFunc.h"
400#include "llvm/Transforms/Utils/LowerInvoke.h"
401#include "llvm/Transforms/Utils/LowerSwitch.h"
402#include "llvm/Transforms/Utils/Mem2Reg.h"
403#include "llvm/Transforms/Utils/MetaRenamer.h"
404#include "llvm/Transforms/Utils/MoveAutoInit.h"
405#include "llvm/Transforms/Utils/NameAnonGlobals.h"
406#include "llvm/Transforms/Utils/PredicateInfo.h"
407#include "llvm/Transforms/Utils/ProfileVerify.h"
408#include "llvm/Transforms/Utils/RelLookupTableConverter.h"
409#include "llvm/Transforms/Utils/StripConvergenceIntrinsics.h"
410#include "llvm/Transforms/Utils/StripGCRelocates.h"
411#include "llvm/Transforms/Utils/StripNonLineTableDebugInfo.h"
412#include "llvm/Transforms/Utils/SymbolRewriter.h"
413#include "llvm/Transforms/Utils/UnifyLoopExits.h"
414#include "llvm/Transforms/Vectorize/LoadStoreVectorizer.h"
415#include "llvm/Transforms/Vectorize/LoopIdiomVectorize.h"
416#include "llvm/Transforms/Vectorize/LoopVectorize.h"
417#include "llvm/Transforms/Vectorize/SLPVectorizer.h"
418#include "llvm/Transforms/Vectorize/SandboxVectorizer/SandboxVectorizer.h"
419#include "llvm/Transforms/Vectorize/VectorCombine.h"
420#include <optional>
421
422using namespace llvm;
423
424cl::opt<std::optional<PrintPipelinePassesFormat>, false,
425 PrintPipelinePassesFormatParser>
426 llvm::PrintPipelinePasses(
427 "print-pipeline-passes", cl::ValueOptional,
428 cl::desc(
429 "Print string describing the pipeline (best-effort only).\n"
430 " - =text\tPrint a '-passes' compatible string describing the "
431 "pipeline.\n"
432 " - =tree\tPrint a tree-like structure describing the pipeline."));
433
434bool PrintPipelinePassesFormatParser::parse(
435 cl::Option &O, StringRef ArgName, StringRef Arg,
436 std::optional<PrintPipelinePassesFormat> &Val) {
437 std::optional<PrintPipelinePassesFormat> Format =
438 StringSwitch<std::optional<PrintPipelinePassesFormat>>(Arg)
439 .Case("text", PrintPipelinePassesFormat::Text)
440 .Case("", PrintPipelinePassesFormat::Text)
441 .Case("tree", PrintPipelinePassesFormat::Tree)
442 .Default(std::nullopt);
443
444 if (!Format)
445 return O.error(formatv(
446 "'{0}' value invalid for print-pipeline-passes argument!", Arg));
447
448 Val = Format;
449 return false;
450}
451
452void llvm::printFormattedPipelinePasses(raw_ostream &OS, StringRef Pipeline,
453 PrintPipelinePassesFormat Format) {
454 switch (Format) {
455 case PrintPipelinePassesFormat::Text:
456 OS << Pipeline;
457 break;
458 case PrintPipelinePassesFormat::Tree: {
459 int IndentLevel = 0;
460 for (char C : Pipeline) {
461 switch (C) {
462 case '(':
463 ++IndentLevel;
464 OS << formatv("\n{0}", fmt_repeat(" ", IndentLevel));
465 break;
466 case ')':
467 --IndentLevel;
468 assert(IndentLevel >= 0 && "Invalid pipeline string!");
469 break;
470 case ',':
471 OS << formatv("\n{0}", fmt_repeat(" ", IndentLevel));
472 break;
473 default:
474 OS << C;
475 }
476 }
477 break;
478 }
479 }
480}
481
482AnalysisKey NoOpModuleAnalysis::Key;
483AnalysisKey NoOpCGSCCAnalysis::Key;
484AnalysisKey NoOpFunctionAnalysis::Key;
485AnalysisKey NoOpLoopAnalysis::Key;
486
487namespace {
488
489bool applyMIRDebugify(DIBuilder &DIB, Function &F, ModuleAnalysisManager &AM) {
490 FunctionAnalysisManager &FAM =
491 AM.getResult<FunctionAnalysisManagerModuleProxy>(*F.getParent())
492 .getManager();
493
494 return applyDebugifyMetadataToMachineFunction(
495 DIB, F, [&](Function &Func) -> MachineFunction * {
496 MachineFunctionAnalysis::Result *MFA =
497 FAM.getCachedResult<MachineFunctionAnalysis>(Func);
498 return MFA ? &MFA->getMF() : nullptr;
499 });
500}
501
502// A pass for testing message reporting of -verify-each failures.
503// DO NOT USE THIS EXCEPT FOR TESTING!
504class TriggerVerifierErrorPass
505 : public OptionalPassInfoMixin<TriggerVerifierErrorPass> {
506public:
507 PreservedAnalyses run(Module &M, ModuleAnalysisManager &) {
508 // Intentionally break the Module by creating an alias without setting the
509 // aliasee.
510 auto *PtrTy = PointerType::getUnqual(M.getContext());
511 GlobalAlias::create(PtrTy, PtrTy->getAddressSpace(),
512 GlobalValue::LinkageTypes::InternalLinkage,
513 "__bad_alias", nullptr, &M);
514 return PreservedAnalyses::none();
515 }
516
517 PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
518 // Intentionally break the Function by inserting a terminator
519 // instruction in the middle of a basic block.
520 BasicBlock &BB = F.getEntryBlock();
521 new UnreachableInst(F.getContext(), BB.getTerminator()->getIterator());
522 return PreservedAnalyses::none();
523 }
524
525 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
526 // Intentionally create a virtual register and set NoVRegs property.
527 auto &MRI = MF.getRegInfo();
528 MRI.createGenericVirtualRegister(LLT::scalar(8));
529 MF.getProperties().setNoVRegs();
530 return PreservedAnalyses::all();
531 }
532
533 static StringRef name() { return "TriggerVerifierErrorPass"; }
534};
535
536// A pass requires all MachineFunctionProperties.
537// DO NOT USE THIS EXCEPT FOR TESTING!
538class RequireAllMachineFunctionPropertiesPass
539 : public OptionalPassInfoMixin<RequireAllMachineFunctionPropertiesPass> {
540public:
541 PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &) {
542 MFPropsModifier _(*this, MF);
543 return PreservedAnalyses::none();
544 }
545
546 static MachineFunctionProperties getRequiredProperties() {
547 return MachineFunctionProperties()
548 .setFailedISel()
549 .setFailsVerification()
550 .setIsSSA()
551 .setLegalized()
552 .setNoPHIs()
553 .setNoVRegs()
554 .setRegBankSelected()
555 .setSelected()
556 .setTiedOpsRewritten()
557 .setTracksDebugUserValues()
558 .setTracksLiveness();
559 }
560 static StringRef name() { return "RequireAllMachineFunctionPropertiesPass"; }
561};
562
563} // namespace
564
565static std::optional<OptimizationLevel> parseOptLevel(StringRef S) {
566 if (S == "Os" || S == "Oz")
567 reportFatalUsageError(
568 Twine("The optimization level \"") + S +
569 "\" is no longer supported. Use O2 in conjunction with the " +
570 (S == "Os" ? "optsize" : "minsize") + " attribute instead.");
571
572 return StringSwitch<std::optional<OptimizationLevel>>(S)
573 .Case("O0", OptimizationLevel::O0)
574 .Case("O1", OptimizationLevel::O1)
575 .Case("O2", OptimizationLevel::O2)
576 .Case("O3", OptimizationLevel::O3)
577 .Default(std::nullopt);
578}
579
580static Expected<OptimizationLevel> parseOptLevelParam(StringRef S) {
581 std::optional<OptimizationLevel> OptLevel = parseOptLevel(S);
582 if (OptLevel)
583 return *OptLevel;
584 return make_error<StringError>(
585 formatv("invalid optimization level '{}'", S).str(),
586 inconvertibleErrorCode());
587}
588
589PassBuilder::PassBuilder(TargetMachine *TM, PipelineTuningOptions PTO,
590 std::optional<PGOOptions> PGOOpt,
591 PassInstrumentationCallbacks *PIC,
592 IntrusiveRefCntPtr<vfs::FileSystem> FS)
593 : TM(TM), PTO(PTO), PGOOpt(PGOOpt), PIC(PIC), FS(std::move(FS)) {
594 if (TM)
595 TM->registerPassBuilderCallbacks(*this);
596 if (PIC) {
597 PIC->registerClassToPassNameCallback([this, PIC]() {
598 // MSVC requires this to be captured if it's used inside decltype.
599 // Other compilers consider it an unused lambda capture.
600 (void)this;
601#define MODULE_PASS(NAME, CREATE_PASS) \
602 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
603#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
604 PIC->addClassToPassName(CLASS, NAME);
605#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
606 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
607#define FUNCTION_PASS(NAME, CREATE_PASS) \
608 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
609#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
610 PIC->addClassToPassName(CLASS, NAME);
611#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
612 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
613#define LOOPNEST_PASS(NAME, CREATE_PASS) \
614 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
615#define LOOP_PASS(NAME, CREATE_PASS) \
616 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
617#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
618 PIC->addClassToPassName(CLASS, NAME);
619#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
620 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
621#define CGSCC_PASS(NAME, CREATE_PASS) \
622 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
623#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
624 PIC->addClassToPassName(CLASS, NAME);
625#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
626 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
627#include "PassRegistry.def"
628
629#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
630 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
631#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
632 PIC->addClassToPassName(decltype(CREATE_PASS)::name(), NAME);
633#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
634 PARAMS) \
635 PIC->addClassToPassName(CLASS, NAME);
636#include "llvm/Passes/MachinePassRegistry.def"
637 });
638 }
639
640 // Module-level callbacks without LTO phase
641 registerPipelineParsingCallback(
642 [this](StringRef Name, ModulePassManager &PM,
643 ArrayRef<PassBuilder::PipelineElement>) {
644#define MODULE_CALLBACK(NAME, INVOKE) \
645 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
646 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
647 if (!L) { \
648 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
649 return false; \
650 } \
651 INVOKE(PM, L.get()); \
652 return true; \
653 }
654#include "PassRegistry.def"
655 return false;
656 });
657
658 // Module-level callbacks with LTO phase (use Phase::None for string API)
659 registerPipelineParsingCallback(
660 [this](StringRef Name, ModulePassManager &PM,
661 ArrayRef<PassBuilder::PipelineElement>) {
662#define MODULE_LTO_CALLBACK(NAME, INVOKE) \
663 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
664 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
665 if (!L) { \
666 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
667 return false; \
668 } \
669 INVOKE(PM, L.get(), ThinOrFullLTOPhase::None); \
670 return true; \
671 }
672#include "PassRegistry.def"
673 return false;
674 });
675
676 // Function-level callbacks
677 registerPipelineParsingCallback(
678 [this](StringRef Name, FunctionPassManager &PM,
679 ArrayRef<PassBuilder::PipelineElement>) {
680#define FUNCTION_CALLBACK(NAME, INVOKE) \
681 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
682 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
683 if (!L) { \
684 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
685 return false; \
686 } \
687 INVOKE(PM, L.get()); \
688 return true; \
689 }
690#include "PassRegistry.def"
691 return false;
692 });
693
694 // CGSCC-level callbacks
695 registerPipelineParsingCallback(
696 [this](StringRef Name, CGSCCPassManager &PM,
697 ArrayRef<PassBuilder::PipelineElement>) {
698#define CGSCC_CALLBACK(NAME, INVOKE) \
699 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
700 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
701 if (!L) { \
702 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
703 return false; \
704 } \
705 INVOKE(PM, L.get()); \
706 return true; \
707 }
708#include "PassRegistry.def"
709 return false;
710 });
711
712 // Loop-level callbacks
713 registerPipelineParsingCallback(
714 [this](StringRef Name, LoopPassManager &PM,
715 ArrayRef<PassBuilder::PipelineElement>) {
716#define LOOP_CALLBACK(NAME, INVOKE) \
717 if (PassBuilder::checkParametrizedPassName(Name, NAME)) { \
718 auto L = PassBuilder::parsePassParameters(parseOptLevelParam, Name, NAME); \
719 if (!L) { \
720 errs() << NAME ": " << toString(L.takeError()) << '\n'; \
721 return false; \
722 } \
723 INVOKE(PM, L.get()); \
724 return true; \
725 }
726#include "PassRegistry.def"
727 return false;
728 });
729}
730
731void PassBuilder::registerModuleAnalyses(ModuleAnalysisManager &MAM) {
732#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
733 MAM.registerPass([&] { return CREATE_PASS; });
734#include "PassRegistry.def"
735
736 for (auto &C : ModuleAnalysisRegistrationCallbacks)
737 C(MAM);
738}
739
740void PassBuilder::registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM) {
741#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
742 CGAM.registerPass([&] { return CREATE_PASS; });
743#include "PassRegistry.def"
744
745 for (auto &C : CGSCCAnalysisRegistrationCallbacks)
746 C(CGAM);
747}
748
749void PassBuilder::registerFunctionAnalyses(FunctionAnalysisManager &FAM) {
750 // We almost always want the default alias analysis pipeline.
751 // If a user wants a different one, they can register their own before calling
752 // registerFunctionAnalyses().
753 FAM.registerPass([&] { return buildDefaultAAPipeline(); });
754
755#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
756 if constexpr (std::is_constructible_v< \
757 std::remove_reference_t<decltype(CREATE_PASS)>, \
758 const TargetMachine &>) { \
759 if (TM) \
760 FAM.registerPass([&] { return CREATE_PASS; }); \
761 } else { \
762 FAM.registerPass([&] { return CREATE_PASS; }); \
763 }
764#include "PassRegistry.def"
765
766 for (auto &C : FunctionAnalysisRegistrationCallbacks)
767 C(FAM);
768}
769
770void PassBuilder::registerMachineFunctionAnalyses(
771 MachineFunctionAnalysisManager &MFAM) {
772
773#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
774 MFAM.registerPass([&] { return CREATE_PASS; });
775#include "llvm/Passes/MachinePassRegistry.def"
776
777 for (auto &C : MachineFunctionAnalysisRegistrationCallbacks)
778 C(MFAM);
779}
780
781void PassBuilder::registerLoopAnalyses(LoopAnalysisManager &LAM) {
782#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
783 LAM.registerPass([&] { return CREATE_PASS; });
784#include "PassRegistry.def"
785
786 for (auto &C : LoopAnalysisRegistrationCallbacks)
787 C(LAM);
788}
789
790static std::optional<std::pair<bool, bool>>
791parseFunctionPipelineName(StringRef Name) {
792 std::pair<bool, bool> Params;
793 if (!Name.consume_front("function"))
794 return std::nullopt;
795 if (Name.empty())
796 return Params;
797 if (!Name.consume_front("<") || !Name.consume_back(">"))
798 return std::nullopt;
799 while (!Name.empty()) {
800 auto [Front, Back] = Name.split(';');
801 Name = Back;
802 if (Front == "eager-inv")
803 Params.first = true;
804 else if (Front == "no-rerun")
805 Params.second = true;
806 else
807 return std::nullopt;
808 }
809 return Params;
810}
811
812static std::optional<int> parseDevirtPassName(StringRef Name) {
813 if (!Name.consume_front("devirt<") || !Name.consume_back(">"))
814 return std::nullopt;
815 int Count;
816 if (Name.getAsInteger(0, Count) || Count < 0)
817 return std::nullopt;
818 return Count;
819}
820
821Expected<bool> PassBuilder::parseSinglePassOption(StringRef Params,
822 StringRef OptionName,
823 StringRef PassName) {
824 bool Result = false;
825 while (!Params.empty()) {
826 StringRef ParamName;
827 std::tie(ParamName, Params) = Params.split(';');
828
829 if (ParamName == OptionName) {
830 Result = true;
831 } else {
832 return make_error<StringError>(
833 formatv("invalid {} pass parameter '{}'", PassName, ParamName).str(),
834 inconvertibleErrorCode());
835 }
836 }
837 return Result;
838}
839
840namespace {
841
842/// Parser of parameters for HardwareLoops pass.
843Expected<HardwareLoopOptions> parseHardwareLoopOptions(StringRef Params) {
844 HardwareLoopOptions HardwareLoopOpts;
845
846 while (!Params.empty()) {
847 StringRef ParamName;
848 std::tie(ParamName, Params) = Params.split(';');
849 if (ParamName.consume_front("hardware-loop-decrement=")) {
850 int Count;
851 if (ParamName.getAsInteger(0, Count))
852 return make_error<StringError>(
853 formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
854 inconvertibleErrorCode());
855 HardwareLoopOpts.setDecrement(Count);
856 continue;
857 }
858 if (ParamName.consume_front("hardware-loop-counter-bitwidth=")) {
859 int Count;
860 if (ParamName.getAsInteger(0, Count))
861 return make_error<StringError>(
862 formatv("invalid HardwareLoopPass parameter '{}'", ParamName).str(),
863 inconvertibleErrorCode());
864 HardwareLoopOpts.setCounterBitwidth(Count);
865 continue;
866 }
867 if (ParamName == "force-hardware-loops") {
868 HardwareLoopOpts.setForce(true);
869 } else if (ParamName == "force-hardware-loop-phi") {
870 HardwareLoopOpts.setForcePhi(true);
871 } else if (ParamName == "force-nested-hardware-loop") {
872 HardwareLoopOpts.setForceNested(true);
873 } else if (ParamName == "force-hardware-loop-guard") {
874 HardwareLoopOpts.setForceGuard(true);
875 } else {
876 return make_error<StringError>(
877 formatv("invalid HardwarePass parameter '{}'", ParamName).str(),
878 inconvertibleErrorCode());
879 }
880 }
881 return HardwareLoopOpts;
882}
883
884/// Parser of parameters for Lint pass.
885Expected<bool> parseLintOptions(StringRef Params) {
886 return PassBuilder::parseSinglePassOption(Params, "abort-on-error",
887 "LintPass");
888}
889
890/// Parser of parameters for FunctionPropertiesStatistics pass.
891Expected<bool> parseFunctionPropertiesStatisticsOptions(StringRef Params) {
892 return PassBuilder::parseSinglePassOption(Params, "pre-opt",
893 "FunctionPropertiesStatisticsPass");
894}
895
896/// Parser of parameters for InstCount pass.
897Expected<bool> parseInstCountOptions(StringRef Params) {
898 return PassBuilder::parseSinglePassOption(Params, "pre-opt", "InstCountPass");
899}
900
901/// Parser of parameters for LoopUnroll pass.
902Expected<LoopUnrollOptions> parseLoopUnrollOptions(StringRef Params) {
903 LoopUnrollOptions UnrollOpts;
904 while (!Params.empty()) {
905 StringRef ParamName;
906 std::tie(ParamName, Params) = Params.split(';');
907 std::optional<OptimizationLevel> OptLevel = parseOptLevel(ParamName);
908 if (OptLevel) {
909 UnrollOpts.setOptLevel(static_cast<int>(*OptLevel));
910 continue;
911 }
912 if (ParamName.consume_front("full-unroll-max=")) {
913 int Count;
914 if (ParamName.getAsInteger(0, Count))
915 return make_error<StringError>(
916 formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
917 inconvertibleErrorCode());
918 UnrollOpts.setFullUnrollMaxCount(Count);
919 continue;
920 }
921
922 bool Enable = !ParamName.consume_front("no-");
923 if (ParamName == "partial") {
924 UnrollOpts.setPartial(Enable);
925 } else if (ParamName == "peeling") {
926 UnrollOpts.setPeeling(Enable);
927 } else if (ParamName == "profile-peeling") {
928 UnrollOpts.setProfileBasedPeeling(Enable);
929 } else if (ParamName == "runtime") {
930 UnrollOpts.setRuntime(Enable);
931 } else if (ParamName == "upperbound") {
932 UnrollOpts.setUpperBound(Enable);
933 } else if (ParamName == "prepare-for-lto") {
934 UnrollOpts.setPrepareForLTO(Enable);
935 } else {
936 return make_error<StringError>(
937 formatv("invalid LoopUnrollPass parameter '{}'", ParamName).str(),
938 inconvertibleErrorCode());
939 }
940 }
941 return UnrollOpts;
942}
943
944Expected<bool> parseGlobalDCEPassOptions(StringRef Params) {
945 return PassBuilder::parseSinglePassOption(
946 Params, "vfe-linkage-unit-visibility", "GlobalDCE");
947}
948
949Expected<bool> parseCGProfilePassOptions(StringRef Params) {
950 return PassBuilder::parseSinglePassOption(Params, "in-lto-post-link",
951 "CGProfile");
952}
953
954Expected<bool> parseInlinerPassOptions(StringRef Params) {
955 return PassBuilder::parseSinglePassOption(Params, "only-mandatory",
956 "InlinerPass");
957}
958
959Expected<bool> parseCoroSplitPassOptions(StringRef Params) {
960 return PassBuilder::parseSinglePassOption(Params, "reuse-storage",
961 "CoroSplitPass");
962}
963
964Expected<bool> parsePostOrderFunctionAttrsPassOptions(StringRef Params) {
965 return PassBuilder::parseSinglePassOption(
966 Params, "skip-non-recursive-function-attrs", "PostOrderFunctionAttrs");
967}
968
969Expected<bool> parseEarlyCSEPassOptions(StringRef Params) {
970 return PassBuilder::parseSinglePassOption(Params, "memssa", "EarlyCSE");
971}
972
973Expected<bool> parseEntryExitInstrumenterPassOptions(StringRef Params) {
974 return PassBuilder::parseSinglePassOption(Params, "post-inline",
975 "EntryExitInstrumenter");
976}
977
978Expected<bool> parseDropUnnecessaryAssumesPassOptions(StringRef Params) {
979 return PassBuilder::parseSinglePassOption(Params, "drop-deref",
980 "DropUnnecessaryAssumes");
981}
982
983Expected<bool> parseLowerMatrixIntrinsicsPassOptions(StringRef Params) {
984 return PassBuilder::parseSinglePassOption(Params, "minimal",
985 "LowerMatrixIntrinsics");
986}
987
988Expected<IRNormalizerOptions> parseIRNormalizerPassOptions(StringRef Params) {
989 IRNormalizerOptions Result;
990 while (!Params.empty()) {
991 StringRef ParamName;
992 std::tie(ParamName, Params) = Params.split(';');
993
994 bool Enable = !ParamName.consume_front("no-");
995 if (ParamName == "preserve-order")
996 Result.PreserveOrder = Enable;
997 else if (ParamName == "rename-all")
998 Result.RenameAll = Enable;
999 else if (ParamName == "fold-all") // FIXME: Name mismatch
1000 Result.FoldPreOutputs = Enable;
1001 else if (ParamName == "reorder-operands")
1002 Result.ReorderOperands = Enable;
1003 else {
1004 return make_error<StringError>(
1005 formatv("invalid normalize pass parameter '{}'", ParamName).str(),
1006 inconvertibleErrorCode());
1007 }
1008 }
1009
1010 return Result;
1011}
1012
1013Expected<AddressSanitizerOptions> parseASanPassOptions(StringRef Params) {
1014 AddressSanitizerOptions Result;
1015 while (!Params.empty()) {
1016 StringRef ParamName;
1017 std::tie(ParamName, Params) = Params.split(';');
1018
1019 if (ParamName == "kernel") {
1020 Result.CompileKernel = true;
1021 } else if (ParamName == "use-after-scope") {
1022 Result.UseAfterScope = true;
1023 } else {
1024 return make_error<StringError>(
1025 formatv("invalid AddressSanitizer pass parameter '{}'", ParamName)
1026 .str(),
1027 inconvertibleErrorCode());
1028 }
1029 }
1030 return Result;
1031}
1032
1033Expected<HWAddressSanitizerOptions> parseHWASanPassOptions(StringRef Params) {
1034 HWAddressSanitizerOptions Result;
1035 while (!Params.empty()) {
1036 StringRef ParamName;
1037 std::tie(ParamName, Params) = Params.split(';');
1038
1039 if (ParamName == "recover") {
1040 Result.Recover = true;
1041 } else if (ParamName == "kernel") {
1042 Result.CompileKernel = true;
1043 } else {
1044 return make_error<StringError>(
1045 formatv("invalid HWAddressSanitizer pass parameter '{}'", ParamName)
1046 .str(),
1047 inconvertibleErrorCode());
1048 }
1049 }
1050 return Result;
1051}
1052
1053Expected<lowertypetests::DropTestKind>
1054parseDropTypeTestsPassOptions(StringRef Params) {
1055 lowertypetests::DropTestKind Result = lowertypetests::DropTestKind::Assume;
1056 while (!Params.empty()) {
1057 StringRef ParamName;
1058 std::tie(ParamName, Params) = Params.split(';');
1059
1060 if (ParamName == "all") {
1061 Result = lowertypetests::DropTestKind::All;
1062 } else if (ParamName == "assume") {
1063 Result = lowertypetests::DropTestKind::Assume;
1064 } else {
1065 return make_error<StringError>(
1066 formatv("invalid DropTypeTestsPass parameter '{}'", ParamName).str(),
1067 inconvertibleErrorCode());
1068 }
1069 }
1070 return Result;
1071}
1072
1073Expected<EmbedBitcodeOptions> parseEmbedBitcodePassOptions(StringRef Params) {
1074 EmbedBitcodeOptions Result;
1075 while (!Params.empty()) {
1076 StringRef ParamName;
1077 std::tie(ParamName, Params) = Params.split(';');
1078
1079 if (ParamName == "thinlto") {
1080 Result.IsThinLTO = true;
1081 } else if (ParamName == "emit-summary") {
1082 Result.EmitLTOSummary = true;
1083 } else {
1084 return make_error<StringError>(
1085 formatv("invalid EmbedBitcode pass parameter '{}'", ParamName).str(),
1086 inconvertibleErrorCode());
1087 }
1088 }
1089 return Result;
1090}
1091
1092Expected<LowerAllowCheckPass::Options>
1093parseLowerAllowCheckPassOptions(StringRef Params) {
1094 LowerAllowCheckPass::Options Result;
1095 while (!Params.empty()) {
1096 StringRef ParamName;
1097 std::tie(ParamName, Params) = Params.split(';');
1098
1099 // Format is <cutoffs[1,2,3]=70000;cutoffs[5,6,8]=90000>
1100 //
1101 // Parsing allows duplicate indices (last one takes precedence).
1102 // It would technically be in spec to specify
1103 // cutoffs[0]=70000,cutoffs[1]=90000,cutoffs[0]=80000,...
1104 if (ParamName.starts_with("cutoffs[")) {
1105 StringRef IndicesStr;
1106 StringRef CutoffStr;
1107
1108 std::tie(IndicesStr, CutoffStr) = ParamName.split("]=");
1109 // cutoffs[1,2,3
1110 // 70000
1111
1112 int cutoff;
1113 if (CutoffStr.getAsInteger(0, cutoff))
1114 return make_error<StringError>(
1115 formatv("invalid LowerAllowCheck pass cutoffs parameter '{}' ({})",
1116 CutoffStr, Params)
1117 .str(),
1118 inconvertibleErrorCode());
1119
1120 if (!IndicesStr.consume_front("cutoffs[") || IndicesStr == "")
1121 return make_error<StringError>(
1122 formatv("invalid LowerAllowCheck pass index parameter '{}' ({})",
1123 IndicesStr, CutoffStr)
1124 .str(),
1125 inconvertibleErrorCode());
1126
1127 while (IndicesStr != "") {
1128 StringRef firstIndexStr;
1129 std::tie(firstIndexStr, IndicesStr) = IndicesStr.split('|');
1130
1131 unsigned int index;
1132 if (firstIndexStr.getAsInteger(0, index))
1133 return make_error<StringError>(
1134 formatv(
1135 "invalid LowerAllowCheck pass index parameter '{}' ({}) {}",
1136 firstIndexStr, IndicesStr)
1137 .str(),
1138 inconvertibleErrorCode());
1139
1140 // In the common case (sequentially increasing indices), we will issue
1141 // O(n) resize requests. We assume the underlying data structure has
1142 // O(1) runtime for each added element.
1143 if (index >= Result.cutoffs.size())
1144 Result.cutoffs.resize(index + 1, 0);
1145
1146 Result.cutoffs[index] = cutoff;
1147 }
1148 } else if (ParamName.starts_with("runtime_check")) {
1149 StringRef ValueString;
1150 std::tie(std::ignore, ValueString) = ParamName.split("=");
1151 int runtime_check;
1152 if (ValueString.getAsInteger(0, runtime_check)) {
1153 return make_error<StringError>(
1154 formatv("invalid LowerAllowCheck pass runtime_check parameter '{}' "
1155 "({})",
1156 ValueString, Params)
1157 .str(),
1158 inconvertibleErrorCode());
1159 }
1160 Result.runtime_check = runtime_check;
1161 } else {
1162 return make_error<StringError>(
1163 formatv("invalid LowerAllowCheck pass parameter '{}'", ParamName)
1164 .str(),
1165 inconvertibleErrorCode());
1166 }
1167 }
1168
1169 return Result;
1170}
1171
1172Expected<MemorySanitizerOptions> parseMSanPassOptions(StringRef Params) {
1173 MemorySanitizerOptions Result;
1174 while (!Params.empty()) {
1175 StringRef ParamName;
1176 std::tie(ParamName, Params) = Params.split(';');
1177
1178 if (ParamName == "recover") {
1179 Result.Recover = true;
1180 } else if (ParamName == "kernel") {
1181 Result.Kernel = true;
1182 } else if (ParamName.consume_front("track-origins=")) {
1183 if (ParamName.getAsInteger(0, Result.TrackOrigins))
1184 return make_error<StringError>(
1185 formatv("invalid argument to MemorySanitizer pass track-origins "
1186 "parameter: '{}'",
1187 ParamName)
1188 .str(),
1189 inconvertibleErrorCode());
1190 } else if (ParamName == "eager-checks") {
1191 Result.EagerChecks = true;
1192 } else {
1193 return make_error<StringError>(
1194 formatv("invalid MemorySanitizer pass parameter '{}'", ParamName)
1195 .str(),
1196 inconvertibleErrorCode());
1197 }
1198 }
1199 return Result;
1200}
1201
1202Expected<AllocTokenOptions> parseAllocTokenPassOptions(StringRef Params) {
1203 AllocTokenOptions Result;
1204 while (!Params.empty()) {
1205 StringRef ParamName;
1206 std::tie(ParamName, Params) = Params.split(';');
1207
1208 if (ParamName.consume_front("mode=")) {
1209 if (auto Mode = getAllocTokenModeFromString(ParamName))
1210 Result.Mode = *Mode;
1211 else
1212 return make_error<StringError>(
1213 formatv("invalid argument to AllocToken pass mode "
1214 "parameter: '{}'",
1215 ParamName)
1216 .str(),
1217 inconvertibleErrorCode());
1218 } else {
1219 return make_error<StringError>(
1220 formatv("invalid AllocToken pass parameter '{}'", ParamName).str(),
1221 inconvertibleErrorCode());
1222 }
1223 }
1224 return Result;
1225}
1226
1227/// Parser of parameters for SimplifyCFG pass.
1228Expected<SimplifyCFGOptions> parseSimplifyCFGOptions(StringRef Params) {
1229 SimplifyCFGOptions Result;
1230 while (!Params.empty()) {
1231 StringRef ParamName;
1232 std::tie(ParamName, Params) = Params.split(';');
1233
1234 bool Enable = !ParamName.consume_front("no-");
1235 if (ParamName == "speculate-blocks") {
1236 Result.speculateBlocks(Enable);
1237 } else if (ParamName == "simplify-cond-branch") {
1238 Result.setSimplifyCondBranch(Enable);
1239 } else if (ParamName == "forward-switch-cond") {
1240 Result.forwardSwitchCondToPhi(Enable);
1241 } else if (ParamName == "switch-range-to-icmp") {
1242 Result.convertSwitchRangeToICmp(Enable);
1243 } else if (ParamName == "switch-to-arithmetic") {
1244 Result.convertSwitchToArithmetic(Enable);
1245 } else if (ParamName == "switch-to-lookup") {
1246 Result.convertSwitchToLookupTable(Enable);
1247 } else if (ParamName == "keep-loops") {
1248 Result.needCanonicalLoops(Enable);
1249 } else if (ParamName == "hoist-common-insts") {
1250 Result.hoistCommonInsts(Enable);
1251 } else if (ParamName == "hoist-loads-stores-with-cond-faulting") {
1252 Result.hoistLoadsStoresWithCondFaulting(Enable);
1253 } else if (ParamName == "sink-common-insts") {
1254 Result.sinkCommonInsts(Enable);
1255 } else if (ParamName == "speculate-unpredictables") {
1256 Result.speculateUnpredictables(Enable);
1257 } else if (Enable && ParamName.consume_front("bonus-inst-threshold=")) {
1258 APInt BonusInstThreshold;
1259 if (ParamName.getAsInteger(0, BonusInstThreshold))
1260 return make_error<StringError>(
1261 formatv("invalid argument to SimplifyCFG pass bonus-threshold "
1262 "parameter: '{}'",
1263 ParamName)
1264 .str(),
1265 inconvertibleErrorCode());
1266 Result.bonusInstThreshold(BonusInstThreshold.getSExtValue());
1267 } else {
1268 return make_error<StringError>(
1269 formatv("invalid SimplifyCFG pass parameter '{}'", ParamName).str(),
1270 inconvertibleErrorCode());
1271 }
1272 }
1273 return Result;
1274}
1275
1276Expected<InstCombineOptions> parseInstCombineOptions(StringRef Params) {
1277 InstCombineOptions Result;
1278 // When specifying "instcombine" in -passes enable fix-point verification by
1279 // default, as this is what most tests should use.
1280 Result.setVerifyFixpoint(true);
1281 while (!Params.empty()) {
1282 StringRef ParamName;
1283 std::tie(ParamName, Params) = Params.split(';');
1284
1285 bool Enable = !ParamName.consume_front("no-");
1286 if (ParamName == "verify-fixpoint") {
1287 Result.setVerifyFixpoint(Enable);
1288 } else if (Enable && ParamName.consume_front("max-iterations=")) {
1289 APInt MaxIterations;
1290 if (ParamName.getAsInteger(0, MaxIterations))
1291 return make_error<StringError>(
1292 formatv("invalid argument to InstCombine pass max-iterations "
1293 "parameter: '{}'",
1294 ParamName)
1295 .str(),
1296 inconvertibleErrorCode());
1297 Result.setMaxIterations((unsigned)MaxIterations.getZExtValue());
1298 } else {
1299 return make_error<StringError>(
1300 formatv("invalid InstCombine pass parameter '{}'", ParamName).str(),
1301 inconvertibleErrorCode());
1302 }
1303 }
1304 return Result;
1305}
1306
1307/// Parser of parameters for LoopVectorize pass.
1308Expected<LoopVectorizeOptions> parseLoopVectorizeOptions(StringRef Params) {
1309 LoopVectorizeOptions Opts;
1310 while (!Params.empty()) {
1311 StringRef ParamName;
1312 std::tie(ParamName, Params) = Params.split(';');
1313
1314 bool Enable = !ParamName.consume_front("no-");
1315 if (ParamName == "interleave-forced-only") {
1316 Opts.setInterleaveOnlyWhenForced(Enable);
1317 } else if (ParamName == "vectorize-forced-only") {
1318 Opts.setVectorizeOnlyWhenForced(Enable);
1319 } else {
1320 return make_error<StringError>(
1321 formatv("invalid LoopVectorize parameter '{}'", ParamName).str(),
1322 inconvertibleErrorCode());
1323 }
1324 }
1325 return Opts;
1326}
1327
1328Expected<std::pair<bool, bool>> parseLoopUnswitchOptions(StringRef Params) {
1329 std::pair<bool, bool> Result = {false, true};
1330 while (!Params.empty()) {
1331 StringRef ParamName;
1332 std::tie(ParamName, Params) = Params.split(';');
1333
1334 bool Enable = !ParamName.consume_front("no-");
1335 if (ParamName == "nontrivial") {
1336 Result.first = Enable;
1337 } else if (ParamName == "trivial") {
1338 Result.second = Enable;
1339 } else {
1340 return make_error<StringError>(
1341 formatv("invalid LoopUnswitch pass parameter '{}'", ParamName).str(),
1342 inconvertibleErrorCode());
1343 }
1344 }
1345 return Result;
1346}
1347
1348Expected<LICMOptions> parseLICMOptions(StringRef Params) {
1349 LICMOptions Result;
1350 while (!Params.empty()) {
1351 StringRef ParamName;
1352 std::tie(ParamName, Params) = Params.split(';');
1353
1354 bool Enable = !ParamName.consume_front("no-");
1355 if (ParamName == "allowspeculation") {
1356 Result.AllowSpeculation = Enable;
1357 } else {
1358 return make_error<StringError>(
1359 formatv("invalid LICM pass parameter '{}'", ParamName).str(),
1360 inconvertibleErrorCode());
1361 }
1362 }
1363 return Result;
1364}
1365
1366struct LoopRotateOptions {
1367 bool EnableHeaderDuplication = true;
1368 bool PrepareForLTO = false;
1369 bool CheckExitCount = false;
1370};
1371
1372Expected<LoopRotateOptions> parseLoopRotateOptions(StringRef Params) {
1373 LoopRotateOptions Result;
1374 while (!Params.empty()) {
1375 StringRef ParamName;
1376 std::tie(ParamName, Params) = Params.split(';');
1377
1378 bool Enable = !ParamName.consume_front("no-");
1379 if (ParamName == "header-duplication") {
1380 Result.EnableHeaderDuplication = Enable;
1381 } else if (ParamName == "prepare-for-lto") {
1382 Result.PrepareForLTO = Enable;
1383 } else if (ParamName == "check-exit-count") {
1384 Result.CheckExitCount = Enable;
1385 } else {
1386 return make_error<StringError>(
1387 formatv("invalid LoopRotate pass parameter '{}'", ParamName).str(),
1388 inconvertibleErrorCode());
1389 }
1390 }
1391 return Result;
1392}
1393
1394Expected<bool> parseMergedLoadStoreMotionOptions(StringRef Params) {
1395 bool Result = false;
1396 while (!Params.empty()) {
1397 StringRef ParamName;
1398 std::tie(ParamName, Params) = Params.split(';');
1399
1400 bool Enable = !ParamName.consume_front("no-");
1401 if (ParamName == "split-footer-bb") {
1402 Result = Enable;
1403 } else {
1404 return make_error<StringError>(
1405 formatv("invalid MergedLoadStoreMotion pass parameter '{}'",
1406 ParamName)
1407 .str(),
1408 inconvertibleErrorCode());
1409 }
1410 }
1411 return Result;
1412}
1413
1414Expected<GVNOptions> parseGVNOptions(StringRef Params) {
1415 GVNOptions Result;
1416 while (!Params.empty()) {
1417 StringRef ParamName;
1418 std::tie(ParamName, Params) = Params.split(';');
1419
1420 bool Enable = !ParamName.consume_front("no-");
1421 if (ParamName == "scalar-pre") {
1422 Result.setScalarPRE(Enable);
1423 } else if (ParamName == "load-pre") {
1424 Result.setLoadPRE(Enable);
1425 } else if (ParamName == "split-backedge-load-pre") {
1426 Result.setLoadPRESplitBackedge(Enable);
1427 } else if (ParamName == "memdep") {
1428 // MemDep and MemorySSA are mutually exclusive.
1429 Result.setMemDep(Enable);
1430 Result.setMemorySSA(!Enable);
1431 } else if (ParamName == "memoryssa") {
1432 // MemDep and MemorySSA are mutually exclusive.
1433 Result.setMemorySSA(Enable);
1434 Result.setMemDep(!Enable);
1435 } else {
1436 return make_error<StringError>(
1437 formatv("invalid GVN pass parameter '{}'", ParamName).str(),
1438 inconvertibleErrorCode());
1439 }
1440 }
1441 return Result;
1442}
1443
1444Expected<IPSCCPOptions> parseIPSCCPOptions(StringRef Params) {
1445 IPSCCPOptions Result;
1446 while (!Params.empty()) {
1447 StringRef ParamName;
1448 std::tie(ParamName, Params) = Params.split(';');
1449
1450 bool Enable = !ParamName.consume_front("no-");
1451 if (ParamName == "func-spec")
1452 Result.setFuncSpec(Enable);
1453 else
1454 return make_error<StringError>(
1455 formatv("invalid IPSCCP pass parameter '{}'", ParamName).str(),
1456 inconvertibleErrorCode());
1457 }
1458 return Result;
1459}
1460
1461Expected<ScalarizerPassOptions> parseScalarizerOptions(StringRef Params) {
1462 ScalarizerPassOptions Result;
1463 while (!Params.empty()) {
1464 StringRef ParamName;
1465 std::tie(ParamName, Params) = Params.split(';');
1466
1467 if (ParamName.consume_front("min-bits=")) {
1468 if (ParamName.getAsInteger(0, Result.ScalarizeMinBits)) {
1469 return make_error<StringError>(
1470 formatv("invalid argument to Scalarizer pass min-bits "
1471 "parameter: '{}'",
1472 ParamName)
1473 .str(),
1474 inconvertibleErrorCode());
1475 }
1476
1477 continue;
1478 }
1479
1480 bool Enable = !ParamName.consume_front("no-");
1481 if (ParamName == "load-store")
1482 Result.ScalarizeLoadStore = Enable;
1483 else if (ParamName == "variable-insert-extract")
1484 Result.ScalarizeVariableInsertExtract = Enable;
1485 else {
1486 return make_error<StringError>(
1487 formatv("invalid Scalarizer pass parameter '{}'", ParamName).str(),
1488 inconvertibleErrorCode());
1489 }
1490 }
1491
1492 return Result;
1493}
1494
1495Expected<SROAOptions> parseSROAOptions(StringRef Params) {
1496 SROAOptions Result(SROAOptions::ModifyCFG);
1497 bool SawCFGOption = false;
1498 while (!Params.empty()) {
1499 StringRef ParamName;
1500 std::tie(ParamName, Params) = Params.split(';');
1501
1502 if (ParamName == "modify-cfg") {
1503 if (SawCFGOption)
1504 return make_error<StringError>("multiple SROA CFG options specified",
1505 inconvertibleErrorCode());
1506 Result.CFG = SROAOptions::ModifyCFG;
1507 SawCFGOption = true;
1508 } else if (ParamName == "preserve-cfg") {
1509 if (SawCFGOption)
1510 return make_error<StringError>("multiple SROA CFG options specified",
1511 inconvertibleErrorCode());
1512 Result.CFG = SROAOptions::PreserveCFG;
1513 SawCFGOption = true;
1514 } else if (ParamName == "aggregate-to-vector") {
1515 Result.AggregateToVector = true;
1516 } else {
1517 return make_error<StringError>(
1518 formatv("invalid SROA pass parameter '{}' (expected preserve-cfg, "
1519 "modify-cfg, or aggregate-to-vector)",
1520 ParamName)
1521 .str(),
1522 inconvertibleErrorCode());
1523 }
1524 }
1525 return Result;
1526}
1527
1528Expected<StackLifetime::LivenessType>
1529parseStackLifetimeOptions(StringRef Params) {
1530 StackLifetime::LivenessType Result = StackLifetime::LivenessType::May;
1531 while (!Params.empty()) {
1532 StringRef ParamName;
1533 std::tie(ParamName, Params) = Params.split(';');
1534
1535 if (ParamName == "may") {
1536 Result = StackLifetime::LivenessType::May;
1537 } else if (ParamName == "must") {
1538 Result = StackLifetime::LivenessType::Must;
1539 } else {
1540 return make_error<StringError>(
1541 formatv("invalid StackLifetime parameter '{}'", ParamName).str(),
1542 inconvertibleErrorCode());
1543 }
1544 }
1545 return Result;
1546}
1547
1548Expected<bool> parseDependenceAnalysisPrinterOptions(StringRef Params) {
1549 return PassBuilder::parseSinglePassOption(Params, "normalized-results",
1550 "DependenceAnalysisPrinter");
1551}
1552
1553Expected<bool> parseSeparateConstOffsetFromGEPPassOptions(StringRef Params) {
1554 return PassBuilder::parseSinglePassOption(Params, "lower-gep",
1555 "SeparateConstOffsetFromGEP");
1556}
1557
1558Expected<bool> parseStructurizeCFGPassOptions(StringRef Params) {
1559 return PassBuilder::parseSinglePassOption(Params, "skip-uniform-regions",
1560 "StructurizeCFG");
1561}
1562
1563Expected<OptimizationLevel>
1564parseFunctionSimplificationPipelineOptions(StringRef Params) {
1565 std::optional<OptimizationLevel> L = parseOptLevel(Params);
1566 if (!L || *L == OptimizationLevel::O0) {
1567 return make_error<StringError>(
1568 formatv("invalid function-simplification parameter '{}'", Params).str(),
1569 inconvertibleErrorCode());
1570 };
1571 return *L;
1572}
1573
1574Expected<bool> parseMemorySSAPrinterPassOptions(StringRef Params) {
1575 return PassBuilder::parseSinglePassOption(Params, "no-ensure-optimized-uses",
1576 "MemorySSAPrinterPass");
1577}
1578
1579Expected<bool> parseSpeculativeExecutionPassOptions(StringRef Params) {
1580 return PassBuilder::parseSinglePassOption(Params, "only-if-divergent-target",
1581 "SpeculativeExecutionPass");
1582}
1583
1584Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
1585 std::string Result;
1586 while (!Params.empty()) {
1587 StringRef ParamName;
1588 std::tie(ParamName, Params) = Params.split(';');
1589
1590 if (ParamName.consume_front("profile-filename=")) {
1591 Result = ParamName.str();
1592 } else {
1593 return make_error<StringError>(
1594 formatv("invalid MemProfUse pass parameter '{}'", ParamName).str(),
1595 inconvertibleErrorCode());
1596 }
1597 }
1598 return Result;
1599}
1600
1601Expected<StructuralHashOptions>
1602parseStructuralHashPrinterPassOptions(StringRef Params) {
1603 if (Params.empty())
1604 return StructuralHashOptions::None;
1605 if (Params == "detailed")
1606 return StructuralHashOptions::Detailed;
1607 if (Params == "call-target-ignored")
1608 return StructuralHashOptions::CallTargetIgnored;
1609 return make_error<StringError>(
1610 formatv("invalid structural hash printer parameter '{}'", Params).str(),
1611 inconvertibleErrorCode());
1612}
1613
1614Expected<bool> parseWinEHPrepareOptions(StringRef Params) {
1615 return PassBuilder::parseSinglePassOption(Params, "demote-catchswitch-only",
1616 "WinEHPreparePass");
1617}
1618
1619Expected<GlobalMergeOptions> parseGlobalMergeOptions(StringRef Params) {
1620 GlobalMergeOptions Result;
1621 while (!Params.empty()) {
1622 StringRef ParamName;
1623 std::tie(ParamName, Params) = Params.split(';');
1624
1625 bool Enable = !ParamName.consume_front("no-");
1626 if (ParamName == "group-by-use")
1627 Result.GroupByUse = Enable;
1628 else if (ParamName == "ignore-single-use")
1629 Result.IgnoreSingleUse = Enable;
1630 else if (ParamName == "merge-const")
1631 Result.MergeConstantGlobals = Enable;
1632 else if (ParamName == "merge-const-aggressive")
1633 Result.MergeConstAggressive = Enable;
1634 else if (ParamName == "merge-external")
1635 Result.MergeExternal = Enable;
1636 else if (ParamName.consume_front("max-offset=")) {
1637 if (ParamName.getAsInteger(0, Result.MaxOffset))
1638 return make_error<StringError>(
1639 formatv("invalid GlobalMergePass parameter '{}'", ParamName).str(),
1640 inconvertibleErrorCode());
1641 } else {
1642 return make_error<StringError>(
1643 formatv("invalid global-merge pass parameter '{}'", Params).str(),
1644 inconvertibleErrorCode());
1645 }
1646 }
1647 return Result;
1648}
1649
1650Expected<SmallVector<std::string, 0>> parseInternalizeGVs(StringRef Params) {
1651 SmallVector<std::string, 1> PreservedGVs;
1652 while (!Params.empty()) {
1653 StringRef ParamName;
1654 std::tie(ParamName, Params) = Params.split(';');
1655
1656 if (ParamName.consume_front("preserve-gv=")) {
1657 PreservedGVs.push_back(ParamName.str());
1658 } else {
1659 return make_error<StringError>(
1660 formatv("invalid Internalize pass parameter '{}'", ParamName).str(),
1661 inconvertibleErrorCode());
1662 }
1663 }
1664
1665 return Expected<SmallVector<std::string, 0>>(std::move(PreservedGVs));
1666}
1667
1668Expected<RegAllocFastPass::Options>
1669parseRegAllocFastPassOptions(PassBuilder &PB, StringRef Params) {
1670 RegAllocFastPass::Options Opts;
1671 while (!Params.empty()) {
1672 StringRef ParamName;
1673 std::tie(ParamName, Params) = Params.split(';');
1674
1675 if (ParamName.consume_front("filter=")) {
1676 std::optional<RegAllocFilterFunc> Filter =
1677 PB.parseRegAllocFilter(ParamName);
1678 if (!Filter) {
1679 return make_error<StringError>(
1680 formatv("invalid regallocfast register filter '{}'", ParamName)
1681 .str(),
1682 inconvertibleErrorCode());
1683 }
1684 Opts.Filter = *Filter;
1685 Opts.FilterName = ParamName;
1686 continue;
1687 }
1688
1689 if (ParamName == "no-clear-vregs") {
1690 Opts.ClearVRegs = false;
1691 continue;
1692 }
1693
1694 return make_error<StringError>(
1695 formatv("invalid regallocfast pass parameter '{}'", ParamName).str(),
1696 inconvertibleErrorCode());
1697 }
1698 return Opts;
1699}
1700
1701Expected<BoundsCheckingPass::Options>
1702parseBoundsCheckingOptions(StringRef Params) {
1703 BoundsCheckingPass::Options Options;
1704 while (!Params.empty()) {
1705 StringRef ParamName;
1706 std::tie(ParamName, Params) = Params.split(';');
1707 if (ParamName == "trap") {
1708 Options.Rt = std::nullopt;
1709 } else if (ParamName == "rt") {
1710 Options.Rt = {
1711 /*MinRuntime=*/false,
1712 /*MayReturn=*/true,
1713 /*HandlerPreserveAllRegs=*/false,
1714 };
1715 } else if (ParamName == "rt-abort") {
1716 Options.Rt = {
1717 /*MinRuntime=*/false,
1718 /*MayReturn=*/false,
1719 /*HandlerPreserveAllRegs=*/false,
1720 };
1721 } else if (ParamName == "min-rt") {
1722 Options.Rt = {
1723 /*MinRuntime=*/true,
1724 /*MayReturn=*/true,
1725 /*HandlerPreserveAllRegs=*/false,
1726 };
1727 } else if (ParamName == "min-rt-abort") {
1728 Options.Rt = {
1729 /*MinRuntime=*/true,
1730 /*MayReturn=*/false,
1731 /*HandlerPreserveAllRegs=*/false,
1732 };
1733 } else if (ParamName == "merge") {
1734 Options.Merge = true;
1735 } else if (ParamName == "handler-preserve-all-regs") {
1736 if (Options.Rt)
1737 Options.Rt->HandlerPreserveAllRegs = true;
1738 } else {
1739 StringRef ParamEQ;
1740 StringRef Val;
1741 std::tie(ParamEQ, Val) = ParamName.split('=');
1742 int8_t Id;
1743 if (ParamEQ == "guard" && !Val.getAsInteger(0, Id)) {
1744 Options.GuardKind = Id;
1745 } else {
1746 return make_error<StringError>(
1747 formatv("invalid BoundsChecking pass parameter '{}'", ParamName)
1748 .str(),
1749 inconvertibleErrorCode());
1750 }
1751 }
1752 }
1753 return Options;
1754}
1755
1756Expected<CodeGenOptLevel> parseExpandIRInstsOptions(StringRef Param) {
1757 if (Param.empty())
1758 return CodeGenOptLevel::None;
1759
1760 // Parse a CodeGenOptLevel, e.g. "O1", "O2", "O3".
1761 auto [Prefix, Digit] = Param.split('O');
1762
1763 uint8_t N;
1764 if (!Prefix.empty() || Digit.getAsInteger(10, N))
1765 return createStringError("invalid expand-ir-insts pass parameter '%s'",
1766 Param.str().c_str());
1767
1768 std::optional<CodeGenOptLevel> Level = CodeGenOpt::getLevel(N);
1769 if (!Level.has_value())
1770 return createStringError(
1771 "invalid optimization level for expand-ir-insts pass: %s",
1772 Digit.str().c_str());
1773
1774 return *Level;
1775}
1776
1777Expected<RAGreedyPass::Options>
1778parseRegAllocGreedyFilterFunc(PassBuilder &PB, StringRef Params) {
1779 if (Params.empty() || Params == "all")
1780 return RAGreedyPass::Options();
1781
1782 std::optional<RegAllocFilterFunc> Filter = PB.parseRegAllocFilter(Params);
1783 if (Filter)
1784 return RAGreedyPass::Options{*Filter, Params};
1785
1786 return make_error<StringError>(
1787 formatv("invalid regallocgreedy register filter '{}'", Params).str(),
1788 inconvertibleErrorCode());
1789}
1790
1791Expected<bool> parseMachineSinkingPassOptions(StringRef Params) {
1792 return PassBuilder::parseSinglePassOption(Params, "enable-sink-fold",
1793 "MachineSinkingPass");
1794}
1795
1796Expected<bool> parseMachineBlockPlacementPassOptions(StringRef Params) {
1797 bool AllowTailMerge = true;
1798 if (!Params.empty()) {
1799 AllowTailMerge = !Params.consume_front("no-");
1800 if (Params != "tail-merge")
1801 return make_error<StringError>(
1802 formatv("invalid MachineBlockPlacementPass parameter '{}'", Params)
1803 .str(),
1804 inconvertibleErrorCode());
1805 }
1806 return AllowTailMerge;
1807}
1808
1809Expected<bool> parseVirtRegRewriterPassOptions(StringRef Params) {
1810 bool ClearVirtRegs = true;
1811 if (!Params.empty()) {
1812 ClearVirtRegs = !Params.consume_front("no-");
1813 if (Params != "clear-vregs")
1814 return make_error<StringError>(
1815 formatv("invalid VirtRegRewriter pass parameter '{}'", Params).str(),
1816 inconvertibleErrorCode());
1817 }
1818 return ClearVirtRegs;
1819}
1820
1821struct FatLTOOptions {
1822 OptimizationLevel OptLevel;
1823 bool ThinLTO = false;
1824 bool EmitSummary = false;
1825};
1826
1827Expected<FatLTOOptions> parseFatLTOOptions(StringRef Params) {
1828 FatLTOOptions Result;
1829 bool HaveOptLevel = false;
1830 while (!Params.empty()) {
1831 StringRef ParamName;
1832 std::tie(ParamName, Params) = Params.split(';');
1833
1834 if (ParamName == "thinlto") {
1835 Result.ThinLTO = true;
1836 } else if (ParamName == "emit-summary") {
1837 Result.EmitSummary = true;
1838 } else if (std::optional<OptimizationLevel> OptLevel =
1839 parseOptLevel(ParamName)) {
1840 Result.OptLevel = *OptLevel;
1841 HaveOptLevel = true;
1842 } else {
1843 return make_error<StringError>(
1844 formatv("invalid fatlto-pre-link pass parameter '{}'", ParamName)
1845 .str(),
1846 inconvertibleErrorCode());
1847 }
1848 }
1849 if (!HaveOptLevel)
1850 return make_error<StringError>(
1851 "missing optimization level for fatlto-pre-link pipeline",
1852 inconvertibleErrorCode());
1853 return Result;
1854}
1855
1856} // namespace
1857
1858/// Tests whether registered callbacks will accept a given pass name.
1859///
1860/// When parsing a pipeline text, the type of the outermost pipeline may be
1861/// omitted, in which case the type is automatically determined from the first
1862/// pass name in the text. This may be a name that is handled through one of the
1863/// callbacks. We check this through the oridinary parsing callbacks by setting
1864/// up a dummy PassManager in order to not force the client to also handle this
1865/// type of query.
1866template <typename PassManagerT, typename CallbacksT>
1867static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks) {
1868 if (!Callbacks.empty()) {
1869 PassManagerT DummyPM;
1870 for (auto &CB : Callbacks)
1871 if (CB(Name, DummyPM, {}))
1872 return true;
1873 }
1874 return false;
1875}
1876
1877template <typename CallbacksT>
1878static bool isModulePassName(StringRef Name, CallbacksT &Callbacks) {
1879 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1880
1881 // Explicitly handle pass manager names.
1882 if (Name == "module")
1883 return true;
1884 if (Name == "cgscc")
1885 return true;
1886 if (NameNoBracket == "function")
1887 return true;
1888 if (Name == "coro-cond")
1889 return true;
1890
1891#define MODULE_PASS(NAME, CREATE_PASS) \
1892 if (Name == NAME) \
1893 return true;
1894#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1895 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1896 return true;
1897#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
1898 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1899 return true;
1900#include "PassRegistry.def"
1901
1902 return callbacksAcceptPassName<ModulePassManager>(Name, Callbacks);
1903}
1904
1905template <typename CallbacksT>
1906static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks) {
1907 // Explicitly handle pass manager names.
1908 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1909 if (Name == "cgscc")
1910 return true;
1911 if (NameNoBracket == "function")
1912 return true;
1913
1914 // Explicitly handle custom-parsed pass names.
1915 if (parseDevirtPassName(Name))
1916 return true;
1917
1918#define CGSCC_PASS(NAME, CREATE_PASS) \
1919 if (Name == NAME) \
1920 return true;
1921#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1922 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1923 return true;
1924#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
1925 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1926 return true;
1927#include "PassRegistry.def"
1928
1929 return callbacksAcceptPassName<CGSCCPassManager>(Name, Callbacks);
1930}
1931
1932template <typename CallbacksT>
1933static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1934 // Explicitly handle pass manager names.
1935 StringRef NameNoBracket = Name.take_until([](char C) { return C == '<'; });
1936 if (NameNoBracket == "function")
1937 return true;
1938 if (Name == "loop" || Name == "loop-mssa" || Name == "machine-function")
1939 return true;
1940
1941#define FUNCTION_PASS(NAME, CREATE_PASS) \
1942 if (Name == NAME) \
1943 return true;
1944#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
1945 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1946 return true;
1947#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1948 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1949 return true;
1950#include "PassRegistry.def"
1951
1952 return callbacksAcceptPassName<FunctionPassManager>(Name, Callbacks);
1953}
1954
1955template <typename CallbacksT>
1956static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks) {
1957 // Explicitly handle pass manager names.
1958 if (Name == "machine-function")
1959 return true;
1960
1961#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
1962 if (Name == NAME) \
1963 return true;
1964#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
1965 PARAMS) \
1966 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
1967 return true;
1968
1969#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
1970 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
1971 return true;
1972
1973#include "llvm/Passes/MachinePassRegistry.def"
1974
1975 return callbacksAcceptPassName<MachineFunctionPassManager>(Name, Callbacks);
1976}
1977
1978template <typename CallbacksT>
1979static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks,
1980 bool &UseMemorySSA) {
1981 UseMemorySSA = false;
1982
1983 if (PassBuilder::checkParametrizedPassName(Name, "lnicm")) {
1984 UseMemorySSA = true;
1985 return true;
1986 }
1987
1988#define LOOPNEST_PASS(NAME, CREATE_PASS) \
1989 if (Name == NAME) \
1990 return true;
1991#include "PassRegistry.def"
1992
1993 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
1994}
1995
1996template <typename CallbacksT>
1997static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks,
1998 bool &UseMemorySSA) {
1999 UseMemorySSA = false;
2000
2001 if (PassBuilder::checkParametrizedPassName(Name, "licm")) {
2002 UseMemorySSA = true;
2003 return true;
2004 }
2005
2006#define LOOP_PASS(NAME, CREATE_PASS) \
2007 if (Name == NAME) \
2008 return true;
2009#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2010 if (PassBuilder::checkParametrizedPassName(Name, NAME)) \
2011 return true;
2012#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2013 if (Name == "require<" NAME ">" || Name == "invalidate<" NAME ">") \
2014 return true;
2015#include "PassRegistry.def"
2016
2017 return callbacksAcceptPassName<LoopPassManager>(Name, Callbacks);
2018}
2019
2020std::optional<std::vector<PassBuilder::PipelineElement>>
2021PassBuilder::parsePipelineText(StringRef Text) {
2022 std::vector<PipelineElement> ResultPipeline;
2023
2024 SmallVector<std::vector<PipelineElement> *, 4> PipelineStack = {
2025 &ResultPipeline};
2026 for (;;) {
2027 std::vector<PipelineElement> &Pipeline = *PipelineStack.back();
2028 size_t Pos = Text.find_first_of(",()");
2029 Pipeline.push_back({Text.substr(0, Pos), {}});
2030
2031 // If we have a single terminating name, we're done.
2032 if (Pos == Text.npos)
2033 break;
2034
2035 char Sep = Text[Pos];
2036 Text = Text.substr(Pos + 1);
2037 if (Sep == ',')
2038 // Just a name ending in a comma, continue.
2039 continue;
2040
2041 if (Sep == '(') {
2042 // Push the inner pipeline onto the stack to continue processing.
2043 PipelineStack.push_back(&Pipeline.back().InnerPipeline);
2044 continue;
2045 }
2046
2047 assert(Sep == ')' && "Bogus separator!");
2048 // When handling the close parenthesis, we greedily consume them to avoid
2049 // empty strings in the pipeline.
2050 do {
2051 // If we try to pop the outer pipeline we have unbalanced parentheses.
2052 if (PipelineStack.size() == 1)
2053 return std::nullopt;
2054
2055 PipelineStack.pop_back();
2056 } while (Text.consume_front(")"));
2057
2058 // Check if we've finished parsing.
2059 if (Text.empty())
2060 break;
2061
2062 // Otherwise, the end of an inner pipeline always has to be followed by
2063 // a comma, and then we can continue.
2064 if (!Text.consume_front(","))
2065 return std::nullopt;
2066 }
2067
2068 if (PipelineStack.size() > 1)
2069 // Unbalanced paretheses.
2070 return std::nullopt;
2071
2072 assert(PipelineStack.back() == &ResultPipeline &&
2073 "Wrong pipeline at the bottom of the stack!");
2074 return {std::move(ResultPipeline)};
2075}
2076
2082
2083Error PassBuilder::parseModulePass(ModulePassManager &MPM,
2084 const PipelineElement &E) {
2085 auto &Name = E.Name;
2086 auto &InnerPipeline = E.InnerPipeline;
2087
2088 // First handle complex passes like the pass managers which carry pipelines.
2089 if (!InnerPipeline.empty()) {
2090 if (Name == "module") {
2091 ModulePassManager NestedMPM;
2092 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
2093 return Err;
2094 MPM.addPass(std::move(NestedMPM));
2095 return Error::success();
2096 }
2097 if (Name == "coro-cond") {
2098 ModulePassManager NestedMPM;
2099 if (auto Err = parseModulePassPipeline(NestedMPM, InnerPipeline))
2100 return Err;
2101 MPM.addPass(CoroConditionalWrapper(std::move(NestedMPM)));
2102 return Error::success();
2103 }
2104 if (Name == "cgscc") {
2105 CGSCCPassManager CGPM;
2106 if (auto Err = parseCGSCCPassPipeline(CGPM, InnerPipeline))
2107 return Err;
2108 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
2109 return Error::success();
2110 }
2111 if (auto Params = parseFunctionPipelineName(Name)) {
2112 if (Params->second)
2113 return make_error<StringError>(
2114 "cannot have a no-rerun module to function adaptor",
2115 inconvertibleErrorCode());
2116 FunctionPassManager FPM;
2117 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2118 return Err;
2119 MPM.addPass(
2120 createModuleToFunctionPassAdaptor(std::move(FPM), Params->first));
2121 return Error::success();
2122 }
2123
2124 for (auto &C : ModulePipelineParsingCallbacks)
2125 if (C(Name, MPM, InnerPipeline))
2126 return Error::success();
2127
2128 // Normal passes can't have pipelines.
2129 return make_error<StringError>(
2130 formatv("invalid use of '{}' pass as module pipeline", Name).str(),
2131 inconvertibleErrorCode());
2132 ;
2133 }
2134
2135 // Finally expand the basic registered passes from the .inc file.
2136#define MODULE_PASS(NAME, CREATE_PASS) \
2137 if (Name == NAME) { \
2138 MPM.addPass(CREATE_PASS); \
2139 return Error::success(); \
2140 }
2141#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2142 if (checkParametrizedPassName(Name, NAME)) { \
2143 auto Params = parsePassParameters(PARSER, Name, NAME); \
2144 if (!Params) \
2145 return Params.takeError(); \
2146 MPM.addPass(CREATE_PASS(Params.get())); \
2147 return Error::success(); \
2148 }
2149#define MODULE_ANALYSIS(NAME, CREATE_PASS) \
2150 if (Name == "require<" NAME ">") { \
2151 MPM.addPass( \
2152 RequireAnalysisPass< \
2153 std::remove_reference_t<decltype(CREATE_PASS)>, Module>()); \
2154 return Error::success(); \
2155 } \
2156 if (Name == "invalidate<" NAME ">") { \
2157 MPM.addPass(InvalidateAnalysisPass< \
2158 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2159 return Error::success(); \
2160 }
2161#define CGSCC_PASS(NAME, CREATE_PASS) \
2162 if (Name == NAME) { \
2163 MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS)); \
2164 return Error::success(); \
2165 }
2166#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2167 if (checkParametrizedPassName(Name, NAME)) { \
2168 auto Params = parsePassParameters(PARSER, Name, NAME); \
2169 if (!Params) \
2170 return Params.takeError(); \
2171 MPM.addPass( \
2172 createModuleToPostOrderCGSCCPassAdaptor(CREATE_PASS(Params.get()))); \
2173 return Error::success(); \
2174 }
2175#define FUNCTION_PASS(NAME, CREATE_PASS) \
2176 if (Name == NAME) { \
2177 if constexpr (std::is_constructible_v< \
2178 std::remove_reference_t<decltype(CREATE_PASS)>, \
2179 const TargetMachine &>) { \
2180 if (!TM) \
2181 return make_error<StringError>( \
2182 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2183 inconvertibleErrorCode()); \
2184 } \
2185 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS)); \
2186 return Error::success(); \
2187 }
2188#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2189 if (checkParametrizedPassName(Name, NAME)) { \
2190 auto Params = parsePassParameters(PARSER, Name, NAME); \
2191 if (!Params) \
2192 return Params.takeError(); \
2193 auto CreatePass = CREATE_PASS; \
2194 if constexpr (std::is_constructible_v< \
2195 std::remove_reference_t<decltype(CreatePass( \
2196 Params.get()))>, \
2197 const TargetMachine &, \
2198 std::remove_reference_t<decltype(Params.get())>>) { \
2199 if (!TM) { \
2200 return make_error<StringError>( \
2201 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2202 inconvertibleErrorCode()); \
2203 } \
2204 } \
2205 MPM.addPass(createModuleToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2206 return Error::success(); \
2207 }
2208#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2209 if (Name == NAME) { \
2210 MPM.addPass(createModuleToFunctionPassAdaptor( \
2211 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2212 return Error::success(); \
2213 }
2214#define LOOP_PASS(NAME, CREATE_PASS) \
2215 if (Name == NAME) { \
2216 MPM.addPass(createModuleToFunctionPassAdaptor( \
2217 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2218 return Error::success(); \
2219 }
2220#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2221 if (checkParametrizedPassName(Name, NAME)) { \
2222 auto Params = parsePassParameters(PARSER, Name, NAME); \
2223 if (!Params) \
2224 return Params.takeError(); \
2225 MPM.addPass(createModuleToFunctionPassAdaptor( \
2226 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2227 return Error::success(); \
2228 }
2229#include "PassRegistry.def"
2230
2231 for (auto &C : ModulePipelineParsingCallbacks)
2232 if (C(Name, MPM, InnerPipeline))
2233 return Error::success();
2234 return make_error<StringError>(
2235 formatv("unknown module pass '{}'", Name).str(),
2236 inconvertibleErrorCode());
2237}
2238
2239Error PassBuilder::parseCGSCCPass(CGSCCPassManager &CGPM,
2240 const PipelineElement &E) {
2241 auto &Name = E.Name;
2242 auto &InnerPipeline = E.InnerPipeline;
2243
2244 // First handle complex passes like the pass managers which carry pipelines.
2245 if (!InnerPipeline.empty()) {
2246 if (Name == "cgscc") {
2247 CGSCCPassManager NestedCGPM;
2248 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2249 return Err;
2250 // Add the nested pass manager with the appropriate adaptor.
2251 CGPM.addPass(std::move(NestedCGPM));
2252 return Error::success();
2253 }
2254 if (auto Params = parseFunctionPipelineName(Name)) {
2255 FunctionPassManager FPM;
2256 if (auto Err = parseFunctionPassPipeline(FPM, InnerPipeline))
2257 return Err;
2258 // Add the nested pass manager with the appropriate adaptor.
2259 CGPM.addPass(createCGSCCToFunctionPassAdaptor(
2260 std::move(FPM), Params->first, Params->second));
2261 return Error::success();
2262 }
2263 if (auto MaxRepetitions = parseDevirtPassName(Name)) {
2264 CGSCCPassManager NestedCGPM;
2265 if (auto Err = parseCGSCCPassPipeline(NestedCGPM, InnerPipeline))
2266 return Err;
2267 CGPM.addPass(
2268 createDevirtSCCRepeatedPass(std::move(NestedCGPM), *MaxRepetitions));
2269 return Error::success();
2270 }
2271
2272 for (auto &C : CGSCCPipelineParsingCallbacks)
2273 if (C(Name, CGPM, InnerPipeline))
2274 return Error::success();
2275
2276 // Normal passes can't have pipelines.
2277 return make_error<StringError>(
2278 formatv("invalid use of '{}' pass as cgscc pipeline", Name).str(),
2279 inconvertibleErrorCode());
2280 }
2281
2282// Now expand the basic registered passes from the .inc file.
2283#define CGSCC_PASS(NAME, CREATE_PASS) \
2284 if (Name == NAME) { \
2285 CGPM.addPass(CREATE_PASS); \
2286 return Error::success(); \
2287 }
2288#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2289 if (checkParametrizedPassName(Name, NAME)) { \
2290 auto Params = parsePassParameters(PARSER, Name, NAME); \
2291 if (!Params) \
2292 return Params.takeError(); \
2293 CGPM.addPass(CREATE_PASS(Params.get())); \
2294 return Error::success(); \
2295 }
2296#define CGSCC_ANALYSIS(NAME, CREATE_PASS) \
2297 if (Name == "require<" NAME ">") { \
2298 CGPM.addPass(RequireAnalysisPass< \
2299 std::remove_reference_t<decltype(CREATE_PASS)>, \
2300 LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, \
2301 CGSCCUpdateResult &>()); \
2302 return Error::success(); \
2303 } \
2304 if (Name == "invalidate<" NAME ">") { \
2305 CGPM.addPass(InvalidateAnalysisPass< \
2306 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2307 return Error::success(); \
2308 }
2309#define FUNCTION_PASS(NAME, CREATE_PASS) \
2310 if (Name == NAME) { \
2311 if constexpr (std::is_constructible_v< \
2312 std::remove_reference_t<decltype(CREATE_PASS)>, \
2313 const TargetMachine &>) { \
2314 if (!TM) \
2315 return make_error<StringError>( \
2316 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2317 inconvertibleErrorCode()); \
2318 } \
2319 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS)); \
2320 return Error::success(); \
2321 }
2322#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2323 if (checkParametrizedPassName(Name, NAME)) { \
2324 auto Params = parsePassParameters(PARSER, Name, NAME); \
2325 if (!Params) \
2326 return Params.takeError(); \
2327 auto CreatePass = CREATE_PASS; \
2328 if constexpr (std::is_constructible_v< \
2329 std::remove_reference_t<decltype(CreatePass( \
2330 Params.get()))>, \
2331 const TargetMachine &, \
2332 std::remove_reference_t<decltype(Params.get())>>) { \
2333 if (!TM) { \
2334 return make_error<StringError>( \
2335 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2336 inconvertibleErrorCode()); \
2337 } \
2338 } \
2339 CGPM.addPass(createCGSCCToFunctionPassAdaptor(CREATE_PASS(Params.get()))); \
2340 return Error::success(); \
2341 }
2342#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2343 if (Name == NAME) { \
2344 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2345 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2346 return Error::success(); \
2347 }
2348#define LOOP_PASS(NAME, CREATE_PASS) \
2349 if (Name == NAME) { \
2350 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2351 createFunctionToLoopPassAdaptor(CREATE_PASS, false))); \
2352 return Error::success(); \
2353 }
2354#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2355 if (checkParametrizedPassName(Name, NAME)) { \
2356 auto Params = parsePassParameters(PARSER, Name, NAME); \
2357 if (!Params) \
2358 return Params.takeError(); \
2359 CGPM.addPass(createCGSCCToFunctionPassAdaptor( \
2360 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false))); \
2361 return Error::success(); \
2362 }
2363#include "PassRegistry.def"
2364
2365 for (auto &C : CGSCCPipelineParsingCallbacks)
2366 if (C(Name, CGPM, InnerPipeline))
2367 return Error::success();
2368 return make_error<StringError>(formatv("unknown cgscc pass '{}'", Name).str(),
2369 inconvertibleErrorCode());
2370}
2371
2372Error PassBuilder::parseFunctionPass(FunctionPassManager &FPM,
2373 const PipelineElement &E) {
2374 auto &Name = E.Name;
2375 auto &InnerPipeline = E.InnerPipeline;
2376
2377 // First handle complex passes like the pass managers which carry pipelines.
2378 if (!InnerPipeline.empty()) {
2379 if (Name == "function") {
2380 FunctionPassManager NestedFPM;
2381 if (auto Err = parseFunctionPassPipeline(NestedFPM, InnerPipeline))
2382 return Err;
2383 // Add the nested pass manager with the appropriate adaptor.
2384 FPM.addPass(std::move(NestedFPM));
2385 return Error::success();
2386 }
2387 if (Name == "loop" || Name == "loop-mssa") {
2388 LoopPassManager LPM;
2389 if (auto Err = parseLoopPassPipeline(LPM, InnerPipeline))
2390 return Err;
2391 // Add the nested pass manager with the appropriate adaptor.
2392 bool UseMemorySSA = (Name == "loop-mssa");
2393 FPM.addPass(
2394 createFunctionToLoopPassAdaptor(std::move(LPM), UseMemorySSA));
2395 return Error::success();
2396 }
2397 if (Name == "machine-function") {
2398 MachineFunctionPassManager MFPM;
2399 if (auto Err = parseMachinePassPipeline(MFPM, InnerPipeline))
2400 return Err;
2401 FPM.addPass(createFunctionToMachineFunctionPassAdaptor(std::move(MFPM)));
2402 return Error::success();
2403 }
2404
2405 for (auto &C : FunctionPipelineParsingCallbacks)
2406 if (C(Name, FPM, InnerPipeline))
2407 return Error::success();
2408
2409 // Normal passes can't have pipelines.
2410 return make_error<StringError>(
2411 formatv("invalid use of '{}' pass as function pipeline", Name).str(),
2412 inconvertibleErrorCode());
2413 }
2414
2415// Now expand the basic registered passes from the .inc file.
2416#define FUNCTION_PASS(NAME, CREATE_PASS) \
2417 if (Name == NAME) { \
2418 if constexpr (std::is_constructible_v< \
2419 std::remove_reference_t<decltype(CREATE_PASS)>, \
2420 const TargetMachine &>) { \
2421 if (!TM) \
2422 return make_error<StringError>( \
2423 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2424 inconvertibleErrorCode()); \
2425 } \
2426 FPM.addPass(CREATE_PASS); \
2427 return Error::success(); \
2428 }
2429#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2430 if (checkParametrizedPassName(Name, NAME)) { \
2431 auto Params = parsePassParameters(PARSER, Name, NAME); \
2432 if (!Params) \
2433 return Params.takeError(); \
2434 auto CreatePass = CREATE_PASS; \
2435 if constexpr (std::is_constructible_v< \
2436 std::remove_reference_t<decltype(CreatePass( \
2437 Params.get()))>, \
2438 const TargetMachine &, \
2439 std::remove_reference_t<decltype(Params.get())>>) { \
2440 if (!TM) { \
2441 return make_error<StringError>( \
2442 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2443 inconvertibleErrorCode()); \
2444 } \
2445 } \
2446 FPM.addPass(CREATE_PASS(Params.get())); \
2447 return Error::success(); \
2448 }
2449#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2450 if (Name == "require<" NAME ">") { \
2451 if constexpr (std::is_constructible_v< \
2452 std::remove_reference_t<decltype(CREATE_PASS)>, \
2453 const TargetMachine &>) { \
2454 if (!TM) \
2455 return make_error<StringError>( \
2456 formatv("pass '{0}' requires TargetMachine", Name).str(), \
2457 inconvertibleErrorCode()); \
2458 } \
2459 FPM.addPass( \
2460 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2461 Function>()); \
2462 return Error::success(); \
2463 } \
2464 if (Name == "invalidate<" NAME ">") { \
2465 FPM.addPass(InvalidateAnalysisPass< \
2466 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2467 return Error::success(); \
2468 }
2469// FIXME: UseMemorySSA is set to false. Maybe we could do things like:
2470// bool UseMemorySSA = !("canon-freeze" || "loop-predication" ||
2471// "guard-widening");
2472// The risk is that it may become obsolete if we're not careful.
2473#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2474 if (Name == NAME) { \
2475 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2476 return Error::success(); \
2477 }
2478#define LOOP_PASS(NAME, CREATE_PASS) \
2479 if (Name == NAME) { \
2480 FPM.addPass(createFunctionToLoopPassAdaptor(CREATE_PASS, false)); \
2481 return Error::success(); \
2482 }
2483#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2484 if (checkParametrizedPassName(Name, NAME)) { \
2485 auto Params = parsePassParameters(PARSER, Name, NAME); \
2486 if (!Params) \
2487 return Params.takeError(); \
2488 FPM.addPass( \
2489 createFunctionToLoopPassAdaptor(CREATE_PASS(Params.get()), false)); \
2490 return Error::success(); \
2491 }
2492#include "PassRegistry.def"
2493
2494 for (auto &C : FunctionPipelineParsingCallbacks)
2495 if (C(Name, FPM, InnerPipeline))
2496 return Error::success();
2497 return make_error<StringError>(
2498 formatv("unknown function pass '{}'", Name).str(),
2499 inconvertibleErrorCode());
2500}
2501
2502Error PassBuilder::parseLoopPass(LoopPassManager &LPM,
2503 const PipelineElement &E) {
2504 StringRef Name = E.Name;
2505 auto &InnerPipeline = E.InnerPipeline;
2506
2507 // First handle complex passes like the pass managers which carry pipelines.
2508 if (!InnerPipeline.empty()) {
2509 if (Name == "loop") {
2510 LoopPassManager NestedLPM;
2511 if (auto Err = parseLoopPassPipeline(NestedLPM, InnerPipeline))
2512 return Err;
2513 // Add the nested pass manager with the appropriate adaptor.
2514 LPM.addPass(std::move(NestedLPM));
2515 return Error::success();
2516 }
2517
2518 for (auto &C : LoopPipelineParsingCallbacks)
2519 if (C(Name, LPM, InnerPipeline))
2520 return Error::success();
2521
2522 // Normal passes can't have pipelines.
2523 return make_error<StringError>(
2524 formatv("invalid use of '{}' pass as loop pipeline", Name).str(),
2525 inconvertibleErrorCode());
2526 }
2527
2528// Now expand the basic registered passes from the .inc file.
2529#define LOOPNEST_PASS(NAME, CREATE_PASS) \
2530 if (Name == NAME) { \
2531 LPM.addPass(CREATE_PASS); \
2532 return Error::success(); \
2533 }
2534#define LOOP_PASS(NAME, CREATE_PASS) \
2535 if (Name == NAME) { \
2536 LPM.addPass(CREATE_PASS); \
2537 return Error::success(); \
2538 }
2539#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2540 if (checkParametrizedPassName(Name, NAME)) { \
2541 auto Params = parsePassParameters(PARSER, Name, NAME); \
2542 if (!Params) \
2543 return Params.takeError(); \
2544 LPM.addPass(CREATE_PASS(Params.get())); \
2545 return Error::success(); \
2546 }
2547#define LOOP_ANALYSIS(NAME, CREATE_PASS) \
2548 if (Name == "require<" NAME ">") { \
2549 LPM.addPass(RequireAnalysisPass< \
2550 std::remove_reference_t<decltype(CREATE_PASS)>, Loop, \
2551 LoopAnalysisManager, LoopStandardAnalysisResults &, \
2552 LPMUpdater &>()); \
2553 return Error::success(); \
2554 } \
2555 if (Name == "invalidate<" NAME ">") { \
2556 LPM.addPass(InvalidateAnalysisPass< \
2557 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2558 return Error::success(); \
2559 }
2560#include "PassRegistry.def"
2561
2562 for (auto &C : LoopPipelineParsingCallbacks)
2563 if (C(Name, LPM, InnerPipeline))
2564 return Error::success();
2565 return make_error<StringError>(formatv("unknown loop pass '{}'", Name).str(),
2566 inconvertibleErrorCode());
2567}
2568
2569Error PassBuilder::parseMachinePass(MachineFunctionPassManager &MFPM,
2570 const PipelineElement &E) {
2571 StringRef Name = E.Name;
2572 // Handle any nested pass managers.
2573 if (!E.InnerPipeline.empty()) {
2574 if (E.Name == "machine-function") {
2575 MachineFunctionPassManager NestedPM;
2576 if (auto Err = parseMachinePassPipeline(NestedPM, E.InnerPipeline))
2577 return Err;
2578 MFPM.addPass(std::move(NestedPM));
2579 return Error::success();
2580 }
2581 return make_error<StringError>("invalid pipeline",
2582 inconvertibleErrorCode());
2583 }
2584
2585#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) \
2586 if (Name == NAME) { \
2587 MFPM.addPass(CREATE_PASS); \
2588 return Error::success(); \
2589 }
2590#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) \
2591 if (Name == NAME) { \
2592 MFPM.addPass(CREATE_PASS); \
2593 return Error::success(); \
2594 }
2595#define MACHINE_FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, \
2596 PARAMS) \
2597 if (checkParametrizedPassName(Name, NAME)) { \
2598 auto Params = parsePassParameters(PARSER, Name, NAME); \
2599 if (!Params) \
2600 return Params.takeError(); \
2601 MFPM.addPass(CREATE_PASS(Params.get())); \
2602 return Error::success(); \
2603 }
2604#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) \
2605 if (Name == "require<" NAME ">") { \
2606 MFPM.addPass( \
2607 RequireAnalysisPass<std::remove_reference_t<decltype(CREATE_PASS)>, \
2608 MachineFunction>()); \
2609 return Error::success(); \
2610 } \
2611 if (Name == "invalidate<" NAME ">") { \
2612 MFPM.addPass(InvalidateAnalysisPass< \
2613 std::remove_reference_t<decltype(CREATE_PASS)>>()); \
2614 return Error::success(); \
2615 }
2616#include "llvm/Passes/MachinePassRegistry.def"
2617
2618 for (auto &C : MachineFunctionPipelineParsingCallbacks)
2619 if (C(Name, MFPM, E.InnerPipeline))
2620 return Error::success();
2621 return make_error<StringError>(
2622 formatv("unknown machine pass '{}'", Name).str(),
2623 inconvertibleErrorCode());
2624}
2625
2626bool PassBuilder::parseAAPassName(AAManager &AA, StringRef Name) {
2627#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2628 if (Name == NAME) { \
2629 AA.registerModuleAnalysis< \
2630 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2631 return true; \
2632 }
2633#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \
2634 if (Name == NAME) { \
2635 AA.registerFunctionAnalysis< \
2636 std::remove_reference_t<decltype(CREATE_PASS)>>(); \
2637 return true; \
2638 }
2639#include "PassRegistry.def"
2640
2641 for (auto &C : AAParsingCallbacks)
2642 if (C(Name, AA))
2643 return true;
2644 return false;
2645}
2646
2647Error PassBuilder::parseMachinePassPipeline(
2648 MachineFunctionPassManager &MFPM, ArrayRef<PipelineElement> Pipeline) {
2649 for (const auto &Element : Pipeline) {
2650 if (auto Err = parseMachinePass(MFPM, Element))
2651 return Err;
2652 }
2653 return Error::success();
2654}
2655
2656Error PassBuilder::parseLoopPassPipeline(LoopPassManager &LPM,
2657 ArrayRef<PipelineElement> Pipeline) {
2658 for (const auto &Element : Pipeline) {
2659 if (auto Err = parseLoopPass(LPM, Element))
2660 return Err;
2661 }
2662 return Error::success();
2663}
2664
2665Error PassBuilder::parseFunctionPassPipeline(
2666 FunctionPassManager &FPM, ArrayRef<PipelineElement> Pipeline) {
2667 for (const auto &Element : Pipeline) {
2668 if (auto Err = parseFunctionPass(FPM, Element))
2669 return Err;
2670 }
2671 return Error::success();
2672}
2673
2674Error PassBuilder::parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
2675 ArrayRef<PipelineElement> Pipeline) {
2676 for (const auto &Element : Pipeline) {
2677 if (auto Err = parseCGSCCPass(CGPM, Element))
2678 return Err;
2679 }
2680 return Error::success();
2681}
2682
2683void PassBuilder::crossRegisterProxies(LoopAnalysisManager &LAM,
2684 FunctionAnalysisManager &FAM,
2685 CGSCCAnalysisManager &CGAM,
2686 ModuleAnalysisManager &MAM,
2687 MachineFunctionAnalysisManager *MFAM) {
2688 MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
2689 MAM.registerPass([&] { return CGSCCAnalysisManagerModuleProxy(CGAM); });
2690 CGAM.registerPass([&] { return ModuleAnalysisManagerCGSCCProxy(MAM); });
2691 FAM.registerPass([&] { return CGSCCAnalysisManagerFunctionProxy(CGAM); });
2692 FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
2693 FAM.registerPass([&] { return LoopAnalysisManagerFunctionProxy(LAM); });
2694 LAM.registerPass([&] { return FunctionAnalysisManagerLoopProxy(FAM); });
2695 if (MFAM) {
2696 MAM.registerPass(
2697 [&] { return MachineFunctionAnalysisManagerModuleProxy(*MFAM); });
2698 FAM.registerPass(
2699 [&] { return MachineFunctionAnalysisManagerFunctionProxy(*MFAM); });
2700 MFAM->registerPass(
2701 [&] { return ModuleAnalysisManagerMachineFunctionProxy(MAM); });
2702 MFAM->registerPass(
2703 [&] { return FunctionAnalysisManagerMachineFunctionProxy(FAM); });
2704 }
2705}
2706
2707Error PassBuilder::parseModulePassPipeline(ModulePassManager &MPM,
2708 ArrayRef<PipelineElement> Pipeline) {
2709 for (const auto &Element : Pipeline) {
2710 if (auto Err = parseModulePass(MPM, Element))
2711 return Err;
2712 }
2713 return Error::success();
2714}
2715
2716// Primary pass pipeline description parsing routine for a \c ModulePassManager
2717// FIXME: Should this routine accept a TargetMachine or require the caller to
2718// pre-populate the analysis managers with target-specific stuff?
2719Error PassBuilder::parsePassPipeline(ModulePassManager &MPM,
2720 StringRef PipelineText) {
2721 auto Pipeline = parsePipelineText(PipelineText);
2722 if (!Pipeline || Pipeline->empty())
2723 return make_error<StringError>(
2724 formatv("invalid pipeline '{}'", PipelineText).str(),
2725 inconvertibleErrorCode());
2726
2727 // If the first name isn't at the module layer, wrap the pipeline up
2728 // automatically.
2729 StringRef FirstName = Pipeline->front().Name;
2730
2731 if (!isModulePassName(FirstName, ModulePipelineParsingCallbacks)) {
2732 bool UseMemorySSA;
2733 if (isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks)) {
2734 Pipeline = {{"cgscc", std::move(*Pipeline)}};
2735 } else if (isFunctionPassName(FirstName,
2736 FunctionPipelineParsingCallbacks)) {
2737 Pipeline = {{"function", std::move(*Pipeline)}};
2738 } else if (isLoopNestPassName(FirstName, LoopPipelineParsingCallbacks,
2739 UseMemorySSA)) {
2740 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2741 std::move(*Pipeline)}}}};
2742 } else if (isLoopPassName(FirstName, LoopPipelineParsingCallbacks,
2743 UseMemorySSA)) {
2744 Pipeline = {{"function", {{UseMemorySSA ? "loop-mssa" : "loop",
2745 std::move(*Pipeline)}}}};
2746 } else if (isMachineFunctionPassName(
2747 FirstName, MachineFunctionPipelineParsingCallbacks)) {
2748 Pipeline = {{"function", {{"machine-function", std::move(*Pipeline)}}}};
2749 } else {
2750 for (auto &C : TopLevelPipelineParsingCallbacks)
2751 if (C(MPM, *Pipeline))
2752 return Error::success();
2753
2754 // Unknown pass or pipeline name!
2755 auto &InnerPipeline = Pipeline->front().InnerPipeline;
2756 return make_error<StringError>(
2757 formatv("unknown {} name '{}'",
2758 (InnerPipeline.empty() ? "pass" : "pipeline"), FirstName)
2759 .str(),
2760 inconvertibleErrorCode());
2761 }
2762 }
2763
2764 if (auto Err = parseModulePassPipeline(MPM, *Pipeline))
2765 return Err;
2766 return Error::success();
2767}
2768
2769// Primary pass pipeline description parsing routine for a \c CGSCCPassManager
2770Error PassBuilder::parsePassPipeline(CGSCCPassManager &CGPM,
2771 StringRef PipelineText) {
2772 auto Pipeline = parsePipelineText(PipelineText);
2773 if (!Pipeline || Pipeline->empty())
2774 return make_error<StringError>(
2775 formatv("invalid pipeline '{}'", PipelineText).str(),
2776 inconvertibleErrorCode());
2777
2778 StringRef FirstName = Pipeline->front().Name;
2779 if (!isCGSCCPassName(FirstName, CGSCCPipelineParsingCallbacks))
2780 return make_error<StringError>(
2781 formatv("unknown cgscc pass '{}' in pipeline '{}'", FirstName,
2782 PipelineText)
2783 .str(),
2784 inconvertibleErrorCode());
2785
2786 if (auto Err = parseCGSCCPassPipeline(CGPM, *Pipeline))
2787 return Err;
2788 return Error::success();
2789}
2790
2791// Primary pass pipeline description parsing routine for a \c
2792// FunctionPassManager
2793Error PassBuilder::parsePassPipeline(FunctionPassManager &FPM,
2794 StringRef PipelineText) {
2795 auto Pipeline = parsePipelineText(PipelineText);
2796 if (!Pipeline || Pipeline->empty())
2797 return make_error<StringError>(
2798 formatv("invalid pipeline '{}'", PipelineText).str(),
2799 inconvertibleErrorCode());
2800
2801 StringRef FirstName = Pipeline->front().Name;
2802 if (!isFunctionPassName(FirstName, FunctionPipelineParsingCallbacks))
2803 return make_error<StringError>(
2804 formatv("unknown function pass '{}' in pipeline '{}'", FirstName,
2805 PipelineText)
2806 .str(),
2807 inconvertibleErrorCode());
2808
2809 if (auto Err = parseFunctionPassPipeline(FPM, *Pipeline))
2810 return Err;
2811 return Error::success();
2812}
2813
2814// Primary pass pipeline description parsing routine for a \c LoopPassManager
2815Error PassBuilder::parsePassPipeline(LoopPassManager &CGPM,
2816 StringRef PipelineText) {
2817 auto Pipeline = parsePipelineText(PipelineText);
2818 if (!Pipeline || Pipeline->empty())
2819 return make_error<StringError>(
2820 formatv("invalid pipeline '{}'", PipelineText).str(),
2821 inconvertibleErrorCode());
2822
2823 if (auto Err = parseLoopPassPipeline(CGPM, *Pipeline))
2824 return Err;
2825
2826 return Error::success();
2827}
2828
2829Error PassBuilder::parsePassPipeline(MachineFunctionPassManager &MFPM,
2830 StringRef PipelineText) {
2831 auto Pipeline = parsePipelineText(PipelineText);
2832 if (!Pipeline || Pipeline->empty())
2833 return make_error<StringError>(
2834 formatv("invalid machine pass pipeline '{}'", PipelineText).str(),
2835 inconvertibleErrorCode());
2836
2837 if (auto Err = parseMachinePassPipeline(MFPM, *Pipeline))
2838 return Err;
2839
2840 return Error::success();
2841}
2842
2843Error PassBuilder::parseAAPipeline(AAManager &AA, StringRef PipelineText) {
2844 // If the pipeline just consists of the word 'default' just replace the AA
2845 // manager with our default one.
2846 if (PipelineText == "default") {
2847 AA = buildDefaultAAPipeline();
2848 return Error::success();
2849 }
2850
2851 while (!PipelineText.empty()) {
2852 StringRef Name;
2853 std::tie(Name, PipelineText) = PipelineText.split(',');
2854 if (!parseAAPassName(AA, Name))
2855 return make_error<StringError>(
2856 formatv("unknown alias analysis name '{}'", Name).str(),
2857 inconvertibleErrorCode());
2858 }
2859
2860 return Error::success();
2861}
2862
2863std::optional<RegAllocFilterFunc>
2864PassBuilder::parseRegAllocFilter(StringRef FilterName) {
2865 if (FilterName == "all")
2866 return nullptr;
2867 for (auto &C : RegClassFilterParsingCallbacks)
2868 if (auto F = C(FilterName))
2869 return F;
2870 return std::nullopt;
2871}
2872
2873LLVM_ATTRIBUTE_NOINLINE static void printPassNameList(StringTable PassNames,
2874 raw_ostream &OS) {
2875 for (StringRef PassName : PassNames)
2876 OS << " " << PassName << '\n';
2877}
2878
2879LLVM_ATTRIBUTE_NOINLINE static void
2880printPassNameListWithParams(StringTable PassNames, raw_ostream &OS) {
2881 auto I = PassNames.begin();
2882 auto End = PassNames.end();
2883 while (I != End) {
2884 StringRef Name = *I;
2885 ++I;
2886 assert(I != End);
2887 StringRef Params = *I;
2888 ++I;
2889 OS << " " << Name << '<' << Params << ">\n";
2890 }
2891}
2892
2893void PassBuilder::printPassNames(raw_ostream &OS) {
2894 // TODO: print pass descriptions when they are available
2895
2896 OS << "Module passes:\n";
2897 static constexpr char ModulePassNames[] = {"\0"
2898#define MODULE_PASS(NAME, CREATE_PASS) NAME "\0"
2899#include "PassRegistry.def"
2900 };
2901 printPassNameList(StringTable(ModulePassNames), OS);
2902
2903 OS << "Module passes with params:\n";
2904 static constexpr char ModulePassNamesWithParams[] = {"\0"
2905#define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2906 NAME "\0" PARAMS "\0"
2907#include "PassRegistry.def"
2908 };
2909 printPassNameListWithParams(StringTable(ModulePassNamesWithParams), OS);
2910
2911 OS << "Module analyses:\n";
2912 static constexpr char ModuleAnalysisNames[] = {"\0"
2913#define MODULE_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2914#include "PassRegistry.def"
2915 };
2916 printPassNameList(StringTable(ModuleAnalysisNames), OS);
2917
2918 OS << "Module alias analyses:\n";
2919 static constexpr char ModuleAliasAnalysisNames[] = {"\0"
2920#define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2921#include "PassRegistry.def"
2922 };
2923 printPassNameList(StringTable(ModuleAliasAnalysisNames), OS);
2924
2925 OS << "CGSCC passes:\n";
2926 static constexpr char CGSCCPassNames[] = {"\0"
2927#define CGSCC_PASS(NAME, CREATE_PASS) NAME "\0"
2928#include "PassRegistry.def"
2929 };
2930 printPassNameList(StringTable(CGSCCPassNames), OS);
2931
2932 OS << "CGSCC passes with params:\n";
2933 static constexpr char CGSCCPassNamesWithParams[] = {"\0"
2934#define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2935 NAME "\0" PARAMS "\0"
2936#include "PassRegistry.def"
2937 };
2938 printPassNameListWithParams(StringTable(CGSCCPassNamesWithParams), OS);
2939
2940 OS << "CGSCC analyses:\n";
2941 static constexpr char CGSCCAnalysisNames[] = {"\0"
2942#define CGSCC_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2943#include "PassRegistry.def"
2944 };
2945 printPassNameList(StringTable(CGSCCAnalysisNames), OS);
2946
2947 OS << "Function passes:\n";
2948 static constexpr char FunctionPassNames[] = {"\0"
2949#define FUNCTION_PASS(NAME, CREATE_PASS) NAME "\0"
2950#include "PassRegistry.def"
2951 };
2952 printPassNameList(StringTable(FunctionPassNames), OS);
2953
2954 OS << "Function passes with params:\n";
2955 static constexpr char FunctionPassNamesWithParams[] = {"\0"
2956#define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2957 NAME "\0" PARAMS "\0"
2958#include "PassRegistry.def"
2959 };
2960 printPassNameListWithParams(StringTable(FunctionPassNamesWithParams), OS);
2961
2962 OS << "Function analyses:\n";
2963 static constexpr char FunctionAnalysisNames[] = {"\0"
2964#define FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2965#include "PassRegistry.def"
2966 };
2967 printPassNameList(StringTable(FunctionAnalysisNames), OS);
2968
2969 OS << "Function alias analyses:\n";
2970 static constexpr char FunctionAliasAnalysisNames[] = {"\0"
2971#define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
2972#include "PassRegistry.def"
2973 };
2974 printPassNameList(StringTable(FunctionAliasAnalysisNames), OS);
2975
2976 OS << "LoopNest passes:\n";
2977 static constexpr char LoopNestPassNames[] = {"\0"
2978#define LOOPNEST_PASS(NAME, CREATE_PASS) NAME "\0"
2979#include "PassRegistry.def"
2980 };
2981 printPassNameList(StringTable(LoopNestPassNames), OS);
2982
2983 OS << "Loop passes:\n";
2984 static constexpr char LoopPassNames[] = {"\0"
2985#define LOOP_PASS(NAME, CREATE_PASS) NAME "\0"
2986#include "PassRegistry.def"
2987 };
2988 printPassNameList(StringTable(LoopPassNames), OS);
2989
2990 OS << "Loop passes with params:\n";
2991 static constexpr char LoopPassNamesWithParams[] = {"\0"
2992#define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) \
2993 NAME "\0" PARAMS "\0"
2994#include "PassRegistry.def"
2995 };
2996 printPassNameListWithParams(StringTable(LoopPassNamesWithParams), OS);
2997
2998 OS << "Loop analyses:\n";
2999 static constexpr char LoopAnalysisNames[] = {"\0"
3000#define LOOP_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
3001#include "PassRegistry.def"
3002 };
3003 printPassNameList(StringTable(LoopAnalysisNames), OS);
3004
3005 OS << "Machine module passes (WIP):\n";
3006 static constexpr char MachineModulePassNames[] = {"\0"
3007#define MACHINE_MODULE_PASS(NAME, CREATE_PASS) NAME "\0"
3008#include "llvm/Passes/MachinePassRegistry.def"
3009 };
3010 printPassNameList(StringTable(MachineModulePassNames), OS);
3011
3012 OS << "Machine function passes (WIP):\n";
3013 static constexpr char MachineFunctionPassNames[] = {"\0"
3014#define MACHINE_FUNCTION_PASS(NAME, CREATE_PASS) NAME "\0"
3015#include "llvm/Passes/MachinePassRegistry.def"
3016 };
3017 printPassNameList(StringTable(MachineFunctionPassNames), OS);
3018
3019 OS << "Machine function analyses (WIP):\n";
3020 static constexpr char MachineFunctionAnalysisNames[] = {"\0"
3021#define MACHINE_FUNCTION_ANALYSIS(NAME, CREATE_PASS) NAME "\0"
3022#include "llvm/Passes/MachinePassRegistry.def"
3023 };
3024 printPassNameList(StringTable(MachineFunctionAnalysisNames), OS);
3025}
3026
3027void PassBuilder::registerParseTopLevelPipelineCallback(
3028 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
3029 &C) {
3030 TopLevelPipelineParsingCallbacks.push_back(C);
3031}
assert
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
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.
BreakFalseDeps.h
This file contains the declaration of the BreakFalseDepsPass class, used to identify and avoid false ...
C
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
CFIFixup.h
Contains definition of the base CFIFixup pass.
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.
CSEInfo.h
Provides analysis for continuously CSEing during GISel passes.
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.
KCFI.h
This file contains the declaration of the MachineKCFI class, which is a Machine Pass that implements ...
LLVM_ATTRIBUTE_NOINLINE
#define LLVM_ATTRIBUTE_NOINLINE
LLVM_ATTRIBUTE_NOINLINE - On compilers where we have a directive to do so, mark a method "not for inl...
Definition Compiler.h:354
CycleAnalysis.h
This file declares an analysis pass that computes CycleInfo for LLVM IR, specialized from GenericCycl...
DetectDeadLanes.h
Analysis that tracks defined/used subregister lanes across COPY instructions and instructions that ge...
EarlyCSE.h
This file provides the interface for a simple, fast CSE pass.
EmbedBitcodePass.h
This file provides a pass which clones the current module and runs the provided pass pipeline on the ...
ForceFunctionAttrs.h
Super simple passes to force specific function attrs from the commandline into the IR for debugging p...
FunctionAttrs.h
Provides passes for computing function attributes based on interprocedural analyses.
GCOVProfiler.h
This file provides the interface for the GCOV style profiler pass.
GISelValueTracking.h
Provides analysis for querying information about KnownBits during GISel passes.
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...
IR2Vec.h
This file defines the IR2Vec vocabulary analysis(IR2VecVocabAnalysis), the core ir2vec::Embedder inte...
IRPrintingPasses.h
This file defines passes to print out IR in various granularities.
IRTranslator.h
This file declares the IRTranslator pass.
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.
LogicalSROA.h
This file provides the interface for LLVM's Logical Scalar Replacement of Aggregates pass.
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:54
I
#define I(x, y, z)
Definition MD5.cpp:57
Module
Machine Check Debug Module
Definition MachineCheckDebugify.cpp:133
MachineCheckDebugify.h
This file contains the declaration of the CheckDebugMachineModulePass class, used by the new pass man...
MachineUniformityAnalysis.h
Machine IR instance of the generic uniformity analysis.
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
if
if(PassOpts->AAPipeline)
Definition PassBuilderBindings.cpp:64
PB
PassBuilder PB(Machine, PassOpts->PTO, std::nullopt, &PIC)
isModulePassName
static bool isModulePassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1878
callbacksAcceptPassName
static bool callbacksAcceptPassName(StringRef Name, CallbacksT &Callbacks)
Tests whether registered callbacks will accept a given pass name.
Definition PassBuilder.cpp:1867
parseDevirtPassName
static std::optional< int > parseDevirtPassName(StringRef Name)
Definition PassBuilder.cpp:812
printPassNameList
static LLVM_ATTRIBUTE_NOINLINE void printPassNameList(StringTable PassNames, raw_ostream &OS)
Definition PassBuilder.cpp:2873
isLoopNestPassName
static bool isLoopNestPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
Definition PassBuilder.cpp:1979
isMachineFunctionPassName
static bool isMachineFunctionPassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1956
parseOptLevelParam
static Expected< OptimizationLevel > parseOptLevelParam(StringRef S)
Definition PassBuilder.cpp:580
parseOptLevel
static std::optional< OptimizationLevel > parseOptLevel(StringRef S)
Definition PassBuilder.cpp:565
isLoopPassName
static bool isLoopPassName(StringRef Name, CallbacksT &Callbacks, bool &UseMemorySSA)
Definition PassBuilder.cpp:1997
parseFunctionPipelineName
static std::optional< std::pair< bool, bool > > parseFunctionPipelineName(StringRef Name)
Definition PassBuilder.cpp:791
isCGSCCPassName
static bool isCGSCCPassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1906
printPassNameListWithParams
static LLVM_ATTRIBUTE_NOINLINE void printPassNameListWithParams(StringTable PassNames, raw_ostream &OS)
Definition PassBuilder.cpp:2880
isFunctionPassName
static bool isFunctionPassName(StringRef Name, CallbacksT &Callbacks)
Definition PassBuilder.cpp:1933
setupOptionsForPipelineAlias
static void setupOptionsForPipelineAlias(PipelineTuningOptions &PTO, OptimizationLevel L)
Definition PassBuilder.cpp:2077
PredicateInfo.h
This file implements the PredicateInfo analysis, which creates an Extended SSA form for operations us...
Mode
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
RegBankSelect.h
This file describes the interface of the MachineFunctionPass responsible for assigning the generic vi...
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...
SROA.h
This file provides the interface for LLVM's Scalar Replacement of Aggregates pass.
name
static const char * name
Definition SVEShuffleOpts.cpp:268
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...
StripConvergenceIntrinsics.h
This pass strips convergence intrinsics and operand bundles as those are only useful when modifying t...
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:709
llvm::AAManager
A manager for alias analyses.
Definition AliasAnalysis.h:967
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:1561
llvm::APInt::getSExtValue
int64_t getSExtValue() const
Get sign extended value.
Definition APInt.h:1583
llvm::AnalysisManager::registerPass
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
Definition PassManager.h:491
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition PassManager.h:430
llvm::ArrayRef
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
llvm::BasicBlock::getTerminator
const Instruction * getTerminator() const LLVM_READONLY
Returns the terminator instruction; assumes that the block is well-formed.
Definition BasicBlock.h:237
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
llvm::Error::success
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
llvm::Expected
Tagged union holding either a T or a Error.
Definition Error.h:485
llvm::GlobalAlias::create
static LLVM_ABI 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:692
llvm::IntrusiveRefCntPtr
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
Definition IntrusiveRefCntPtr.h:174
llvm::LLT::scalar
static constexpr LLT scalar(unsigned SizeInBits)
Get a low-level scalar or aggregate "bag of bits".
Definition LowLevelType.h:89
llvm::MachineFunctionAnalysis
This analysis create MachineFunction for given Function.
Definition MachineFunctionAnalysis.h:27
llvm::MachineFunction::getRegInfo
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Definition MachineFunction.h:799
llvm::MachineFunction::getProperties
const MachineFunctionProperties & getProperties() const
Get the function properties.
Definition MachineFunction.h:886
llvm::MachineRegisterInfo::createGenericVirtualRegister
LLVM_ABI Register createGenericVirtualRegister(LLT Ty, StringRef Name="")
Create and return a new generic virtual register with low-level type Ty.
Definition MachineRegisterInfo.cpp:191
llvm::PassBuilder
This class provides access to building LLVM's passes.
Definition PassBuilder.h:114
llvm::PassBuilder::printPassNames
LLVM_ABI void printPassNames(raw_ostream &OS)
Print pass names.
Definition PassBuilder.cpp:2893
llvm::PassBuilder::checkParametrizedPassName
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition PassBuilder.h:712
llvm::PassBuilder::buildDefaultAAPipeline
LLVM_ABI AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Definition PassBuilderPipelines.cpp:2547
llvm::PassBuilder::parseAAPipeline
LLVM_ABI Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
Definition PassBuilder.cpp:2843
llvm::PassBuilder::registerLoopAnalyses
LLVM_ABI void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
Definition PassBuilder.cpp:781
llvm::PassBuilder::parseRegAllocFilter
LLVM_ABI std::optional< RegAllocFilterFunc > parseRegAllocFilter(StringRef RegAllocFilterName)
Parse RegAllocFilterName to get RegAllocFilterFunc.
Definition PassBuilder.cpp:2864
llvm::PassBuilder::crossRegisterProxies
LLVM_ABI void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
Definition PassBuilder.cpp:2683
llvm::PassBuilder::PassBuilder
LLVM_ABI PassBuilder(TargetMachine *TM=nullptr, PipelineTuningOptions PTO=PipelineTuningOptions(), std::optional< PGOOptions > PGOOpt=std::nullopt, PassInstrumentationCallbacks *PIC=nullptr, IntrusiveRefCntPtr< vfs::FileSystem > FS=vfs::getRealFileSystem())
Definition PassBuilder.cpp:589
llvm::PassBuilder::parsePassPipeline
LLVM_ABI Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
Definition PassBuilder.cpp:2719
llvm::PassBuilder::registerPipelineParsingCallback
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, CGSCCPassManager &, ArrayRef< PipelineElement >)> &C)
{{@ Register pipeline parsing callbacks with this pass builder instance.
Definition PassBuilder.h:608
llvm::PassBuilder::registerModuleAnalyses
LLVM_ABI void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
Definition PassBuilder.cpp:731
llvm::PassBuilder::registerCGSCCAnalyses
LLVM_ABI void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
Definition PassBuilder.cpp:740
llvm::PassBuilder::parseSinglePassOption
static LLVM_ABI Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
Definition PassBuilder.cpp:821
llvm::PassBuilder::registerMachineFunctionAnalyses
LLVM_ABI void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
Definition PassBuilder.cpp:770
llvm::PassBuilder::registerParseTopLevelPipelineCallback
LLVM_ABI void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
Definition PassBuilder.cpp:3027
llvm::PassBuilder::registerFunctionAnalyses
LLVM_ABI void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
Definition PassBuilder.cpp:749
llvm::PassInstrumentationCallbacks
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
Definition PassInstrumentation.h:67
llvm::PassManager::addPass
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v< PassT, PassManager > > addPass(PassT &&Pass)
Definition PassManager.h:219
llvm::PipelineTuningOptions
Tunable parameters for passes in the default pipelines.
Definition PassBuilder.h:41
llvm::PipelineTuningOptions::SLPVectorization
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition PassBuilder.h:56
llvm::PipelineTuningOptions::LoopVectorization
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition PassBuilder.h:52
llvm::PreservedAnalyses::none
static PreservedAnalyses none()
Convenience factory function for the empty preserved set.
Definition Analysis.h:115
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition Analysis.h:118
llvm::SmallVectorTemplateBase::push_back
void push_back(const T &Elt)
Definition SmallVector.h:423
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1252
llvm::StringRef
Represent a constant reference to a string, i.e.
Definition StringRef.h:56
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:736
llvm::StringRef::getAsInteger
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
Definition StringRef.h:490
llvm::StringRef::str
std::string str() const
Get the contents as an std::string.
Definition StringRef.h:222
llvm::StringRef::starts_with
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition StringRef.h:258
llvm::StringRef::empty
constexpr bool empty() const
Check if the string is empty.
Definition StringRef.h:141
llvm::StringRef::front
char front() const
Get the first character in the string.
Definition StringRef.h:147
llvm::StringRef::consume_front
bool consume_front(char Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition StringRef.h:661
llvm::StringSwitch
A switch()-like statement whose cases are string literals.
Definition StringSwitch.h:47
llvm::StringSwitch::Case
StringSwitch & Case(StringLiteral S, T Value)
Definition StringSwitch.h:69
llvm::StringTable
A table of densely packed, null-terminated strings indexed by offset.
Definition StringTable.h:34
llvm::StringTable::begin
constexpr Iterator begin() const
Definition StringTable.h:144
llvm::StringTable::end
constexpr Iterator end() const
Definition StringTable.h:145
llvm::TargetMachine
Primary interface to the complete machine description for the target machine.
Definition TargetMachine.h:84
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition ilist_node.h:123
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
PassBuilder.h
Interfaces for registering analysis passes, producing common pass manager configurations,...
llvm::AA
Abstract Attribute helper functions.
Definition Attributor.h:165
llvm::CodeGenOpt::getLevel
std::optional< CodeGenOptLevel > getLevel(int OL)
Get the Level identified by the integer OL.
Definition CodeGen.h:188
llvm::ISD::BasicBlock
@ BasicBlock
Various leaf nodes.
Definition ISDOpcodes.h:81
llvm::dxil::PointerTypeAnalysis::run
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
Definition PointerTypeAnalysis.cpp:216
llvm::lowertypetests::DropTestKind
DropTestKind
Specifies how to drop type tests.
Definition LowerTypeTests.h:210
llvm::lowertypetests::DropTestKind::All
@ All
Drop only llvm.assumes using type test value.
Definition LowerTypeTests.h:212
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
Definition MicrosoftDemangle.h:132
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition FunctionInfo.h:25
llvm::CGSCCAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< CGSCCAnalysisManager, Function > CGSCCAnalysisManagerFunctionProxy
A proxy from a CGSCCAnalysisManager to a Function.
Definition CGSCCPassManager.h:408
llvm::ModuleAnalysisManagerMachineFunctionProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, MachineFunction > ModuleAnalysisManagerMachineFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition MachinePassManager.h:126
llvm::PrintPipelinePasses
LLVM_ABI cl::opt< std::optional< PrintPipelinePassesFormat >, false, PrintPipelinePassesFormatParser > PrintPipelinePasses
Common option used by multiple tools to print pipeline passes.
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:896
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:567
llvm::ModuleAnalysisManagerFunctionProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, Function > ModuleAnalysisManagerFunctionProxy
Provide the ModuleAnalysisManager to Function proxy.
Definition PassManager.h:846
llvm::inconvertibleErrorCode
LLVM_ABI std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition Error.cpp:94
llvm::FunctionAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
Definition PassManager.h:692
llvm::OptimizationLevel::O1
@ O1
Optimize quickly without destroying debuggability.
Definition OptimizationLevel.h:43
llvm::OptimizationLevel::O0
@ O0
Disable as many optimizations as possible.
Definition OptimizationLevel.h:27
llvm::OptimizationLevel::O3
@ O3
Optimize for fast execution as much as possible.
Definition OptimizationLevel.h:76
llvm::OptimizationLevel::O2
@ O2
Optimize for fast execution as much as possible without triggering significant incremental compile ti...
Definition OptimizationLevel.h:61
llvm::LoopAnalysisManagerFunctionProxy
InnerAnalysisManagerProxy< LoopAnalysisManager, Function > LoopAnalysisManagerFunctionProxy
A proxy from a LoopAnalysisManager to a Function.
Definition LoopAnalysisManager.h:79
llvm::MachineFunctionAnalysisManager
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
Definition MachineFunctionAnalysisManager.h:24
llvm::createStringError
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition Error.h:1321
llvm::CGSCCPassManager
PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager
The CGSCC pass manager.
Definition CGSCCPassManager.h:143
llvm::CGSCCAnalysisManager
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
Definition CGSCCPassManager.h:123
llvm::LoopAnalysisManager
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
Definition LoopAnalysisManager.h:75
llvm::LoopPassManager
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
Definition LoopPassManager.h:173
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:247
llvm::createFunctionToLoopPassAdaptor
FunctionToLoopPassAdaptor createFunctionToLoopPassAdaptor(LoopPassT &&Pass, bool UseMemorySSA=false)
A function to deduce a loop pass type and wrap it in the templated adaptor.
Definition LoopPassManager.h:432
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:498
llvm::createFunctionToMachineFunctionPassAdaptor
FunctionToMachineFunctionPassAdaptor createFunctionToMachineFunctionPassAdaptor(MachineFunctionPassT &&Pass)
Definition MachinePassManager.h:212
llvm::ModulePassManager
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
Definition PassManager.h:257
llvm::SmallVector
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition SmallVector.h:1178
llvm::MachineFunctionAnalysisManagerFunctionProxy
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Function > MachineFunctionAnalysisManagerFunctionProxy
Definition MachinePassManager.h:113
llvm::FunctionAnalysisManagerLoopProxy
OuterAnalysisManagerProxy< FunctionAnalysisManager, Loop, LoopStandardAnalysisResults & > FunctionAnalysisManagerLoopProxy
A proxy from a FunctionAnalysisManager to a Loop.
Definition LoopAnalysisManager.h:156
llvm::make_error
Error make_error(ArgTs &&... Args)
Make a Error instance representing failure using the given error info type.
Definition Error.h:340
llvm::fmt_repeat
support::detail::RepeatAdapter< T > fmt_repeat(T &&Item, size_t Count)
Definition FormatAdapters.h:98
llvm::ModuleAnalysisManagerCGSCCProxy
OuterAnalysisManagerProxy< ModuleAnalysisManager, LazyCallGraph::SCC, LazyCallGraph & > ModuleAnalysisManagerCGSCCProxy
A proxy from a ModuleAnalysisManager to an SCC.
Definition CGSCCPassManager.h:214
llvm::MachineFunctionAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< MachineFunctionAnalysisManager, Module > MachineFunctionAnalysisManagerModuleProxy
Definition MachinePassManager.h:104
llvm::Count
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
Definition InstrProf.h:145
llvm::CGSCCAnalysisManagerModuleProxy
InnerAnalysisManagerProxy< CGSCCAnalysisManager, Module > CGSCCAnalysisManagerModuleProxy
A proxy from a CGSCCAnalysisManager to a Module.
Definition CGSCCPassManager.h:168
llvm::FunctionPassManager
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
Definition PassManager.h:266
llvm::MFPropsModifier
MFPropsModifier(PassT &P, MachineFunction &MF) -> MFPropsModifier< PassT >
llvm::printFormattedPipelinePasses
LLVM_ABI void printFormattedPipelinePasses(raw_ostream &OS, StringRef Pipeline, PrintPipelinePassesFormat Format=PrintPipelinePassesFormat::Text)
Definition PassBuilder.cpp:452
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1917
llvm::MachineFunctionPassManager
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
Definition MachinePassManager.h:225
llvm::applyDebugifyMetadataToMachineFunction
LLVM_ABI bool applyDebugifyMetadataToMachineFunction(DIBuilder &DIB, Function &F, llvm::function_ref< MachineFunction *(Function &)> GetMF)
Definition MachineDebugify.cpp:31
llvm::FunctionAnalysisManager
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition PassManager.h:585
llvm::getAllocTokenModeFromString
LLVM_ABI std::optional< AllocTokenMode > getAllocTokenModeFromString(StringRef Name)
Returns the AllocTokenMode from its canonical string name; if an invalid name was provided returns nu...
Definition AllocToken.cpp:21
llvm::PrintPipelinePassesFormat
PrintPipelinePassesFormat
Definition PassBuilder.h:1031
llvm::StructuralHashOptions::Detailed
@ Detailed
Hash with opcode only.
Definition StructuralHash.h:18
llvm::StructuralHashOptions::CallTargetIgnored
@ CallTargetIgnored
Hash with opcode and operands.
Definition StructuralHash.h:19
llvm::ModuleAnalysisManager
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39
llvm::ColorMode::Enable
@ Enable
Enable colors.
Definition WithColor.h:47
llvm::reportFatalUsageError
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
Definition Error.cpp:177
std
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:878
N
#define N
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition Analysis.h:29
llvm::GVNOptions
A set of parameters to control various transforms performed by GVN pass.
Definition GVN.h:73
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:67
llvm::LoopUnrollOptions::setPeeling
LoopUnrollOptions & setPeeling(bool Peeling)
Enables or disables loop peeling.
Definition LoopUnrollPass.h:109
llvm::LoopUnrollOptions::setOptLevel
LoopUnrollOptions & setOptLevel(int O)
Definition LoopUnrollPass.h:122
llvm::LoopUnrollOptions::setPartial
LoopUnrollOptions & setPartial(bool Partial)
Enables or disables partial unrolling.
Definition LoopUnrollPass.h:97
llvm::LoopUnrollOptions::setFullUnrollMaxCount
LoopUnrollOptions & setFullUnrollMaxCount(unsigned O)
Definition LoopUnrollPass.h:134
llvm::LoopUnrollOptions::setPrepareForLTO
LoopUnrollOptions & setPrepareForLTO(bool V)
Definition LoopUnrollPass.h:139
llvm::LoopUnrollOptions::setUpperBound
LoopUnrollOptions & setUpperBound(bool UpperBound)
Enables or disables the use of trip count upper bound in loop unrolling.
Definition LoopUnrollPass.h:116
llvm::LoopUnrollOptions::setRuntime
LoopUnrollOptions & setRuntime(bool Runtime)
Enables or disables unrolling of loops with runtime trip count.
Definition LoopUnrollPass.h:103
llvm::LoopUnrollOptions::setProfileBasedPeeling
LoopUnrollOptions & setProfileBasedPeeling(int O)
Definition LoopUnrollPass.h:128
llvm::LoopVectorizeOptions::setVectorizeOnlyWhenForced
LoopVectorizeOptions & setVectorizeOnlyWhenForced(bool Value)
Definition LoopVectorize.h:116
llvm::LoopVectorizeOptions::setInterleaveOnlyWhenForced
LoopVectorizeOptions & setInterleaveOnlyWhenForced(bool Value)
Definition LoopVectorize.h:111
llvm::OptionalPassInfoMixin
A CRTP mix-in for passes that can be skipped.
Definition PassManager.h:108
llvm::PrintPipelinePassesFormatParser::parse
LLVM_ABI bool parse(cl::Option &O, StringRef ArgName, StringRef ArgValue, std::optional< PrintPipelinePassesFormat > &Val)
Definition PassBuilder.cpp:434
Generated on for LLVM by doxygen 1.14.0