1 | //===- PassRegistry.def - Registry of passes --------------------*- C++ -*-===// |
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 | // |
9 | // This file is used as the registry of passes that are part of the core LLVM |
10 | // libraries. This file describes both transformation passes and analyses |
11 | // Analyses are registered while transformation passes have names registered |
12 | // that can be used when providing a textual pass pipeline. |
13 | // |
14 | //===----------------------------------------------------------------------===// |
15 | |
16 | // NOTE: NO INCLUDE GUARD DESIRED! |
17 | |
18 | #ifndef MODULE_ANALYSIS |
19 | #define MODULE_ANALYSIS(NAME, CREATE_PASS) |
20 | #endif |
21 | MODULE_ANALYSIS("callgraph" , CallGraphAnalysis()) |
22 | MODULE_ANALYSIS("collector-metadata" , CollectorMetadataAnalysis()) |
23 | MODULE_ANALYSIS("inline-advisor" , InlineAdvisorAnalysis()) |
24 | MODULE_ANALYSIS("ir-similarity" , IRSimilarityAnalysis()) |
25 | MODULE_ANALYSIS("lcg" , LazyCallGraphAnalysis()) |
26 | MODULE_ANALYSIS("module-summary" , ModuleSummaryIndexAnalysis()) |
27 | MODULE_ANALYSIS("no-op-module" , NoOpModuleAnalysis()) |
28 | MODULE_ANALYSIS("pass-instrumentation" , PassInstrumentationAnalysis(PIC)) |
29 | MODULE_ANALYSIS("profile-summary" , ProfileSummaryAnalysis()) |
30 | MODULE_ANALYSIS("stack-safety" , StackSafetyGlobalAnalysis()) |
31 | MODULE_ANALYSIS("verify" , VerifierAnalysis()) |
32 | |
33 | #ifndef MODULE_ALIAS_ANALYSIS |
34 | #define MODULE_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ |
35 | MODULE_ANALYSIS(NAME, CREATE_PASS) |
36 | #endif |
37 | MODULE_ALIAS_ANALYSIS("globals-aa" , GlobalsAA()) |
38 | #undef MODULE_ALIAS_ANALYSIS |
39 | #undef MODULE_ANALYSIS |
40 | |
41 | #ifndef MODULE_PASS |
42 | #define MODULE_PASS(NAME, CREATE_PASS) |
43 | #endif |
44 | MODULE_PASS("always-inline" , AlwaysInlinerPass()) |
45 | MODULE_PASS("annotation2metadata" , Annotation2MetadataPass()) |
46 | MODULE_PASS("attributor" , AttributorPass()) |
47 | MODULE_PASS("attributor-light" , AttributorLightPass()) |
48 | MODULE_PASS("called-value-propagation" , CalledValuePropagationPass()) |
49 | MODULE_PASS("canonicalize-aliases" , CanonicalizeAliasesPass()) |
50 | MODULE_PASS("check-debugify" , NewPMCheckDebugifyPass()) |
51 | MODULE_PASS("constmerge" , ConstantMergePass()) |
52 | MODULE_PASS("coro-cleanup" , CoroCleanupPass()) |
53 | MODULE_PASS("coro-early" , CoroEarlyPass()) |
54 | MODULE_PASS("cross-dso-cfi" , CrossDSOCFIPass()) |
55 | MODULE_PASS("deadargelim" , DeadArgumentEliminationPass()) |
56 | MODULE_PASS("debugify" , NewPMDebugifyPass()) |
57 | MODULE_PASS("dfsan" , DataFlowSanitizerPass()) |
58 | MODULE_PASS("dot-callgraph" , CallGraphDOTPrinterPass()) |
59 | MODULE_PASS("dxil-upgrade" , DXILUpgradePass()) |
60 | MODULE_PASS("elim-avail-extern" , EliminateAvailableExternallyPass()) |
61 | MODULE_PASS("extract-blocks" , BlockExtractorPass({}, false)) |
62 | MODULE_PASS("forceattrs" , ForceFunctionAttrsPass()) |
63 | MODULE_PASS("function-import" , FunctionImportPass()) |
64 | MODULE_PASS("globalopt" , GlobalOptPass()) |
65 | MODULE_PASS("globalsplit" , GlobalSplitPass()) |
66 | MODULE_PASS("hipstdpar-interpose-alloc" , HipStdParAllocationInterpositionPass()) |
67 | MODULE_PASS("hipstdpar-select-accelerator-code" , |
68 | HipStdParAcceleratorCodeSelectionPass()) |
69 | MODULE_PASS("hotcoldsplit" , HotColdSplittingPass()) |
70 | MODULE_PASS("inferattrs" , InferFunctionAttrsPass()) |
71 | MODULE_PASS("inliner-ml-advisor-release" , |
72 | ModuleInlinerWrapperPass(getInlineParams(), true, {}, |
73 | InliningAdvisorMode::Release, 0)) |
74 | MODULE_PASS("inliner-wrapper" , ModuleInlinerWrapperPass()) |
75 | MODULE_PASS("inliner-wrapper-no-mandatory-first" , |
76 | ModuleInlinerWrapperPass(getInlineParams(), false)) |
77 | MODULE_PASS("insert-gcov-profiling" , GCOVProfilerPass()) |
78 | MODULE_PASS("instrorderfile" , InstrOrderFilePass()) |
79 | MODULE_PASS("instrprof" , InstrProfilingLoweringPass()) |
80 | MODULE_PASS("internalize" , InternalizePass()) |
81 | MODULE_PASS("invalidate<all>" , InvalidateAllAnalysesPass()) |
82 | MODULE_PASS("iroutliner" , IROutlinerPass()) |
83 | MODULE_PASS("jmc-instrumenter" , JMCInstrumenterPass()) |
84 | MODULE_PASS("lower-emutls" , LowerEmuTLSPass()) |
85 | MODULE_PASS("lower-global-dtors" , LowerGlobalDtorsPass()) |
86 | MODULE_PASS("lower-ifunc" , LowerIFuncPass()) |
87 | MODULE_PASS("lowertypetests" , LowerTypeTestsPass()) |
88 | MODULE_PASS("pgo-force-function-attrs" , PGOForceFunctionAttrsPass(PGOOpt ? PGOOpt->ColdOptType : PGOOptions::ColdFuncOpt::Default)) |
89 | MODULE_PASS("memprof-context-disambiguation" , MemProfContextDisambiguation()) |
90 | MODULE_PASS("memprof-module" , ModuleMemProfilerPass()) |
91 | MODULE_PASS("mergefunc" , MergeFunctionsPass()) |
92 | MODULE_PASS("metarenamer" , MetaRenamerPass()) |
93 | MODULE_PASS("module-inline" , ModuleInlinerPass()) |
94 | MODULE_PASS("name-anon-globals" , NameAnonGlobalPass()) |
95 | MODULE_PASS("no-op-module" , NoOpModulePass()) |
96 | MODULE_PASS("objc-arc-apelim" , ObjCARCAPElimPass()) |
97 | MODULE_PASS("openmp-opt" , OpenMPOptPass()) |
98 | MODULE_PASS("openmp-opt-postlink" , |
99 | OpenMPOptPass(ThinOrFullLTOPhase::FullLTOPostLink)) |
100 | MODULE_PASS("partial-inliner" , PartialInlinerPass()) |
101 | MODULE_PASS("pgo-icall-prom" , PGOIndirectCallPromotion()) |
102 | MODULE_PASS("pgo-instr-gen" , PGOInstrumentationGen()) |
103 | MODULE_PASS("pgo-instr-use" , PGOInstrumentationUse()) |
104 | MODULE_PASS("poison-checking" , PoisonCheckingPass()) |
105 | MODULE_PASS("print" , PrintModulePass(dbgs())) |
106 | MODULE_PASS("print-callgraph" , CallGraphPrinterPass(dbgs())) |
107 | MODULE_PASS("print-callgraph-sccs" , CallGraphSCCsPrinterPass(dbgs())) |
108 | MODULE_PASS("print-ir-similarity" , IRSimilarityAnalysisPrinterPass(dbgs())) |
109 | MODULE_PASS("print-lcg" , LazyCallGraphPrinterPass(dbgs())) |
110 | MODULE_PASS("print-lcg-dot" , LazyCallGraphDOTPrinterPass(dbgs())) |
111 | MODULE_PASS("print-must-be-executed-contexts" , |
112 | MustBeExecutedContextPrinterPass(dbgs())) |
113 | MODULE_PASS("print-profile-summary" , ProfileSummaryPrinterPass(dbgs())) |
114 | MODULE_PASS("print-stack-safety" , StackSafetyGlobalPrinterPass(dbgs())) |
115 | MODULE_PASS("print<inline-advisor>" , InlineAdvisorAnalysisPrinterPass(dbgs())) |
116 | MODULE_PASS("print<module-debuginfo>" , ModuleDebugInfoPrinterPass(dbgs())) |
117 | MODULE_PASS("pseudo-probe" , SampleProfileProbePass(TM)) |
118 | MODULE_PASS("pseudo-probe-update" , PseudoProbeUpdatePass()) |
119 | MODULE_PASS("recompute-globalsaa" , RecomputeGlobalsAAPass()) |
120 | MODULE_PASS("rel-lookup-table-converter" , RelLookupTableConverterPass()) |
121 | MODULE_PASS("rewrite-statepoints-for-gc" , RewriteStatepointsForGC()) |
122 | MODULE_PASS("rewrite-symbols" , RewriteSymbolPass()) |
123 | MODULE_PASS("rpo-function-attrs" , ReversePostOrderFunctionAttrsPass()) |
124 | MODULE_PASS("sample-profile" , SampleProfileLoaderPass()) |
125 | MODULE_PASS("sancov-module" , SanitizerCoveragePass()) |
126 | MODULE_PASS("sanmd-module" , SanitizerBinaryMetadataPass()) |
127 | MODULE_PASS("scc-oz-module-inliner" , |
128 | buildInlinerPipeline(OptimizationLevel::Oz, |
129 | ThinOrFullLTOPhase::None)) |
130 | MODULE_PASS("shadow-stack-gc-lowering" , ShadowStackGCLoweringPass()) |
131 | MODULE_PASS("strip" , StripSymbolsPass()) |
132 | MODULE_PASS("strip-dead-debug-info" , StripDeadDebugInfoPass()) |
133 | MODULE_PASS("strip-dead-prototypes" , StripDeadPrototypesPass()) |
134 | MODULE_PASS("strip-debug-declare" , StripDebugDeclarePass()) |
135 | MODULE_PASS("strip-nondebug" , StripNonDebugSymbolsPass()) |
136 | MODULE_PASS("strip-nonlinetable-debuginfo" , StripNonLineTableDebugInfoPass()) |
137 | MODULE_PASS("synthetic-counts-propagation" , SyntheticCountsPropagation()) |
138 | MODULE_PASS("trigger-crash" , TriggerCrashPass()) |
139 | MODULE_PASS("trigger-verifier-error" , TriggerVerifierErrorPass()) |
140 | MODULE_PASS("tsan-module" , ModuleThreadSanitizerPass()) |
141 | MODULE_PASS("verify" , VerifierPass()) |
142 | MODULE_PASS("view-callgraph" , CallGraphViewerPass()) |
143 | MODULE_PASS("wholeprogramdevirt" , WholeProgramDevirtPass()) |
144 | #undef MODULE_PASS |
145 | |
146 | #ifndef MODULE_PASS_WITH_PARAMS |
147 | #define MODULE_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) |
148 | #endif |
149 | MODULE_PASS_WITH_PARAMS( |
150 | "asan" , "AddressSanitizerPass" , |
151 | [](AddressSanitizerOptions Opts) { return AddressSanitizerPass(Opts); }, |
152 | parseASanPassOptions, "kernel" ) |
153 | MODULE_PASS_WITH_PARAMS( |
154 | "cg-profile" , "CGProfilePass" , |
155 | [](bool InLTOPostLink) { return CGProfilePass(InLTOPostLink);}, |
156 | parseCGProfilePassOptions, "in-lto-post-link" ) |
157 | MODULE_PASS_WITH_PARAMS( |
158 | "global-merge" , "GlobalMergePass" , |
159 | [TM = TM](GlobalMergeOptions Opts) { return GlobalMergePass(TM, Opts); }, |
160 | parseGlobalMergeOptions, |
161 | "group-by-use;ignore-single-use;max-offset=N;merge-const;merge-external;" |
162 | "no-group-by-use;no-ignore-single-use;no-merge-const;no-merge-external;" |
163 | "size-only" ) |
164 | MODULE_PASS_WITH_PARAMS( |
165 | "embed-bitcode" , "EmbedBitcodePass" , |
166 | [](EmbedBitcodeOptions Opts) { return EmbedBitcodePass(Opts); }, |
167 | parseEmbedBitcodePassOptions, "thinlto;emit-summary" ) |
168 | MODULE_PASS_WITH_PARAMS( |
169 | "globaldce" , "GlobalDCEPass" , |
170 | [](bool InLTOPostLink) { return GlobalDCEPass(InLTOPostLink); }, |
171 | parseGlobalDCEPassOptions, "in-lto-post-link" ) |
172 | MODULE_PASS_WITH_PARAMS( |
173 | "hwasan" , "HWAddressSanitizerPass" , |
174 | [](HWAddressSanitizerOptions Opts) { return HWAddressSanitizerPass(Opts); }, |
175 | parseHWASanPassOptions, "kernel;recover" ) |
176 | MODULE_PASS_WITH_PARAMS( |
177 | "ipsccp" , "IPSCCPPass" , [](IPSCCPOptions Opts) { return IPSCCPPass(Opts); }, |
178 | parseIPSCCPOptions, "no-func-spec;func-spec" ) |
179 | MODULE_PASS_WITH_PARAMS( |
180 | "loop-extract" , "LoopExtractorPass" , |
181 | [](bool Single) { |
182 | if (Single) |
183 | return LoopExtractorPass(1); |
184 | return LoopExtractorPass(); |
185 | }, |
186 | parseLoopExtractorPassOptions, "single" ) |
187 | MODULE_PASS_WITH_PARAMS( |
188 | "memprof-use" , "MemProfUsePass" , |
189 | [](std::string Opts) { return MemProfUsePass(Opts); }, |
190 | parseMemProfUsePassOptions, "profile-filename=S" ) |
191 | MODULE_PASS_WITH_PARAMS( |
192 | "msan" , "MemorySanitizerPass" , |
193 | [](MemorySanitizerOptions Opts) { return MemorySanitizerPass(Opts); }, |
194 | parseMSanPassOptions, "recover;kernel;eager-checks;track-origins=N" ) |
195 | MODULE_PASS_WITH_PARAMS( |
196 | "print<structural-hash>" , "StructuralHashPrinterPass" , |
197 | [](bool EnableDetailedStructuralHash) { |
198 | return StructuralHashPrinterPass(dbgs(), EnableDetailedStructuralHash); |
199 | }, |
200 | parseStructuralHashPrinterPassOptions, "detailed" ) |
201 | #undef MODULE_PASS_WITH_PARAMS |
202 | |
203 | #ifndef CGSCC_ANALYSIS |
204 | #define CGSCC_ANALYSIS(NAME, CREATE_PASS) |
205 | #endif |
206 | CGSCC_ANALYSIS("no-op-cgscc" , NoOpCGSCCAnalysis()) |
207 | CGSCC_ANALYSIS("fam-proxy" , FunctionAnalysisManagerCGSCCProxy()) |
208 | CGSCC_ANALYSIS("pass-instrumentation" , PassInstrumentationAnalysis(PIC)) |
209 | #undef CGSCC_ANALYSIS |
210 | |
211 | #ifndef CGSCC_PASS |
212 | #define CGSCC_PASS(NAME, CREATE_PASS) |
213 | #endif |
214 | CGSCC_PASS("argpromotion" , ArgumentPromotionPass()) |
215 | CGSCC_PASS("attributor-cgscc" , AttributorCGSCCPass()) |
216 | CGSCC_PASS("attributor-light-cgscc" , AttributorLightCGSCCPass()) |
217 | CGSCC_PASS("invalidate<all>" , InvalidateAllAnalysesPass()) |
218 | CGSCC_PASS("no-op-cgscc" , NoOpCGSCCPass()) |
219 | CGSCC_PASS("openmp-opt-cgscc" , OpenMPOptCGSCCPass()) |
220 | #undef CGSCC_PASS |
221 | |
222 | #ifndef CGSCC_PASS_WITH_PARAMS |
223 | #define CGSCC_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) |
224 | #endif |
225 | CGSCC_PASS_WITH_PARAMS( |
226 | "coro-split" , "CoroSplitPass" , |
227 | [](bool OptimizeFrame) { return CoroSplitPass(OptimizeFrame); }, |
228 | parseCoroSplitPassOptions, "reuse-storage" ) |
229 | CGSCC_PASS_WITH_PARAMS( |
230 | "function-attrs" , "PostOrderFunctionAttrsPass" , |
231 | [](bool SkipNonRecursive) { |
232 | return PostOrderFunctionAttrsPass(SkipNonRecursive); |
233 | }, |
234 | parsePostOrderFunctionAttrsPassOptions, "skip-non-recursive-function-attrs" ) |
235 | CGSCC_PASS_WITH_PARAMS( |
236 | "inline" , "InlinerPass" , |
237 | [](bool OnlyMandatory) { return InlinerPass(OnlyMandatory); }, |
238 | parseInlinerPassOptions, "only-mandatory" ) |
239 | #undef CGSCC_PASS_WITH_PARAMS |
240 | |
241 | #ifndef FUNCTION_ANALYSIS |
242 | #define FUNCTION_ANALYSIS(NAME, CREATE_PASS) |
243 | #endif |
244 | FUNCTION_ANALYSIS("aa" , AAManager()) |
245 | FUNCTION_ANALYSIS("access-info" , LoopAccessAnalysis()) |
246 | FUNCTION_ANALYSIS("assumptions" , AssumptionAnalysis()) |
247 | FUNCTION_ANALYSIS("bb-sections-profile-reader" , BasicBlockSectionsProfileReaderAnalysis(TM)) |
248 | FUNCTION_ANALYSIS("block-freq" , BlockFrequencyAnalysis()) |
249 | FUNCTION_ANALYSIS("branch-prob" , BranchProbabilityAnalysis()) |
250 | FUNCTION_ANALYSIS("cycles" , CycleAnalysis()) |
251 | FUNCTION_ANALYSIS("da" , DependenceAnalysis()) |
252 | FUNCTION_ANALYSIS("debug-ata" , DebugAssignmentTrackingAnalysis()) |
253 | FUNCTION_ANALYSIS("demanded-bits" , DemandedBitsAnalysis()) |
254 | FUNCTION_ANALYSIS("domfrontier" , DominanceFrontierAnalysis()) |
255 | FUNCTION_ANALYSIS("domtree" , DominatorTreeAnalysis()) |
256 | FUNCTION_ANALYSIS("func-properties" , FunctionPropertiesAnalysis()) |
257 | FUNCTION_ANALYSIS("gc-function" , GCFunctionAnalysis()) |
258 | FUNCTION_ANALYSIS("inliner-size-estimator" , InlineSizeEstimatorAnalysis()) |
259 | FUNCTION_ANALYSIS("lazy-value-info" , LazyValueAnalysis()) |
260 | FUNCTION_ANALYSIS("loops" , LoopAnalysis()) |
261 | FUNCTION_ANALYSIS("memdep" , MemoryDependenceAnalysis()) |
262 | FUNCTION_ANALYSIS("memoryssa" , MemorySSAAnalysis()) |
263 | FUNCTION_ANALYSIS("no-op-function" , NoOpFunctionAnalysis()) |
264 | FUNCTION_ANALYSIS("opt-remark-emit" , OptimizationRemarkEmitterAnalysis()) |
265 | FUNCTION_ANALYSIS("pass-instrumentation" , PassInstrumentationAnalysis(PIC)) |
266 | FUNCTION_ANALYSIS("phi-values" , PhiValuesAnalysis()) |
267 | FUNCTION_ANALYSIS("postdomtree" , PostDominatorTreeAnalysis()) |
268 | FUNCTION_ANALYSIS("regions" , RegionInfoAnalysis()) |
269 | FUNCTION_ANALYSIS("scalar-evolution" , ScalarEvolutionAnalysis()) |
270 | FUNCTION_ANALYSIS("should-not-run-function-passes" , |
271 | ShouldNotRunFunctionPassesAnalysis()) |
272 | FUNCTION_ANALYSIS("should-run-extra-vector-passes" , |
273 | ShouldRunExtraVectorPasses()) |
274 | FUNCTION_ANALYSIS("ssp-layout" , SSPLayoutAnalysis()) |
275 | FUNCTION_ANALYSIS("stack-safety-local" , StackSafetyAnalysis()) |
276 | FUNCTION_ANALYSIS("target-ir" , |
277 | TM ? TM->getTargetIRAnalysis() : TargetIRAnalysis()) |
278 | FUNCTION_ANALYSIS("target-lib-info" , TargetLibraryAnalysis()) |
279 | FUNCTION_ANALYSIS("uniformity" , UniformityInfoAnalysis()) |
280 | FUNCTION_ANALYSIS("verify" , VerifierAnalysis()) |
281 | |
282 | #ifndef FUNCTION_ALIAS_ANALYSIS |
283 | #define FUNCTION_ALIAS_ANALYSIS(NAME, CREATE_PASS) \ |
284 | FUNCTION_ANALYSIS(NAME, CREATE_PASS) |
285 | #endif |
286 | FUNCTION_ALIAS_ANALYSIS("basic-aa" , BasicAA()) |
287 | FUNCTION_ALIAS_ANALYSIS("objc-arc-aa" , objcarc::ObjCARCAA()) |
288 | FUNCTION_ALIAS_ANALYSIS("scev-aa" , SCEVAA()) |
289 | FUNCTION_ALIAS_ANALYSIS("scoped-noalias-aa" , ScopedNoAliasAA()) |
290 | FUNCTION_ALIAS_ANALYSIS("tbaa" , TypeBasedAA()) |
291 | #undef FUNCTION_ALIAS_ANALYSIS |
292 | #undef FUNCTION_ANALYSIS |
293 | |
294 | #ifndef FUNCTION_PASS |
295 | #define FUNCTION_PASS(NAME, CREATE_PASS) |
296 | #endif |
297 | FUNCTION_PASS("aa-eval" , AAEvaluator()) |
298 | FUNCTION_PASS("adce" , ADCEPass()) |
299 | FUNCTION_PASS("add-discriminators" , AddDiscriminatorsPass()) |
300 | FUNCTION_PASS("aggressive-instcombine" , AggressiveInstCombinePass()) |
301 | FUNCTION_PASS("alignment-from-assumptions" , AlignmentFromAssumptionsPass()) |
302 | FUNCTION_PASS("annotation-remarks" , AnnotationRemarksPass()) |
303 | FUNCTION_PASS("assume-builder" , AssumeBuilderPass()) |
304 | FUNCTION_PASS("assume-simplify" , AssumeSimplifyPass()) |
305 | FUNCTION_PASS("bdce" , BDCEPass()) |
306 | FUNCTION_PASS("bounds-checking" , BoundsCheckingPass()) |
307 | FUNCTION_PASS("break-crit-edges" , BreakCriticalEdgesPass()) |
308 | FUNCTION_PASS("callbr-prepare" , CallBrPreparePass()) |
309 | FUNCTION_PASS("callsite-splitting" , CallSiteSplittingPass()) |
310 | FUNCTION_PASS("chr" , ControlHeightReductionPass()) |
311 | FUNCTION_PASS("codegenprepare" , CodeGenPreparePass(TM)) |
312 | FUNCTION_PASS("consthoist" , ConstantHoistingPass()) |
313 | FUNCTION_PASS("constraint-elimination" , ConstraintEliminationPass()) |
314 | FUNCTION_PASS("coro-elide" , CoroElidePass()) |
315 | FUNCTION_PASS("correlated-propagation" , CorrelatedValuePropagationPass()) |
316 | FUNCTION_PASS("count-visits" , CountVisitsPass()) |
317 | FUNCTION_PASS("dce" , DCEPass()) |
318 | FUNCTION_PASS("declare-to-assign" , llvm::AssignmentTrackingPass()) |
319 | FUNCTION_PASS("dfa-jump-threading" , DFAJumpThreadingPass()) |
320 | FUNCTION_PASS("div-rem-pairs" , DivRemPairsPass()) |
321 | FUNCTION_PASS("dot-cfg" , CFGPrinterPass()) |
322 | FUNCTION_PASS("dot-cfg-only" , CFGOnlyPrinterPass()) |
323 | FUNCTION_PASS("dot-dom" , DomPrinter()) |
324 | FUNCTION_PASS("dot-dom-only" , DomOnlyPrinter()) |
325 | FUNCTION_PASS("dot-post-dom" , PostDomPrinter()) |
326 | FUNCTION_PASS("dot-post-dom-only" , PostDomOnlyPrinter()) |
327 | FUNCTION_PASS("dse" , DSEPass()) |
328 | FUNCTION_PASS("dwarf-eh-prepare" , DwarfEHPreparePass(TM)) |
329 | FUNCTION_PASS("expand-large-div-rem" , ExpandLargeDivRemPass(TM)) |
330 | FUNCTION_PASS("expand-large-fp-convert" , ExpandLargeFpConvertPass(TM)) |
331 | FUNCTION_PASS("expand-memcmp" , ExpandMemCmpPass(TM)) |
332 | FUNCTION_PASS("fix-irreducible" , FixIrreduciblePass()) |
333 | FUNCTION_PASS("flatten-cfg" , FlattenCFGPass()) |
334 | FUNCTION_PASS("float2int" , Float2IntPass()) |
335 | FUNCTION_PASS("gc-lowering" , GCLoweringPass()) |
336 | FUNCTION_PASS("guard-widening" , GuardWideningPass()) |
337 | FUNCTION_PASS("gvn-hoist" , GVNHoistPass()) |
338 | FUNCTION_PASS("gvn-sink" , GVNSinkPass()) |
339 | FUNCTION_PASS("helloworld" , HelloWorldPass()) |
340 | FUNCTION_PASS("indirectbr-expand" , IndirectBrExpandPass(TM)) |
341 | FUNCTION_PASS("infer-address-spaces" , InferAddressSpacesPass()) |
342 | FUNCTION_PASS("infer-alignment" , InferAlignmentPass()) |
343 | FUNCTION_PASS("inject-tli-mappings" , InjectTLIMappings()) |
344 | FUNCTION_PASS("instcount" , InstCountPass()) |
345 | FUNCTION_PASS("instnamer" , InstructionNamerPass()) |
346 | FUNCTION_PASS("instsimplify" , InstSimplifyPass()) |
347 | FUNCTION_PASS("interleaved-access" , InterleavedAccessPass(TM)) |
348 | FUNCTION_PASS("interleaved-load-combine" , InterleavedLoadCombinePass(TM)) |
349 | FUNCTION_PASS("invalidate<all>" , InvalidateAllAnalysesPass()) |
350 | FUNCTION_PASS("irce" , IRCEPass()) |
351 | FUNCTION_PASS("jump-threading" , JumpThreadingPass()) |
352 | FUNCTION_PASS("jump-table-to-switch" , JumpTableToSwitchPass()); |
353 | FUNCTION_PASS("kcfi" , KCFIPass()) |
354 | FUNCTION_PASS("lcssa" , LCSSAPass()) |
355 | FUNCTION_PASS("libcalls-shrinkwrap" , LibCallsShrinkWrapPass()) |
356 | FUNCTION_PASS("lint" , LintPass()) |
357 | FUNCTION_PASS("load-store-vectorizer" , LoadStoreVectorizerPass()) |
358 | FUNCTION_PASS("loop-data-prefetch" , LoopDataPrefetchPass()) |
359 | FUNCTION_PASS("loop-distribute" , LoopDistributePass()) |
360 | FUNCTION_PASS("loop-fusion" , LoopFusePass()) |
361 | FUNCTION_PASS("loop-load-elim" , LoopLoadEliminationPass()) |
362 | FUNCTION_PASS("loop-simplify" , LoopSimplifyPass()) |
363 | FUNCTION_PASS("loop-sink" , LoopSinkPass()) |
364 | FUNCTION_PASS("loop-versioning" , LoopVersioningPass()) |
365 | FUNCTION_PASS("lower-atomic" , LowerAtomicPass()) |
366 | FUNCTION_PASS("lower-constant-intrinsics" , LowerConstantIntrinsicsPass()) |
367 | FUNCTION_PASS("lower-expect" , LowerExpectIntrinsicPass()) |
368 | FUNCTION_PASS("lower-guard-intrinsic" , LowerGuardIntrinsicPass()) |
369 | FUNCTION_PASS("lower-invoke" , LowerInvokePass()) |
370 | FUNCTION_PASS("lower-switch" , LowerSwitchPass()) |
371 | FUNCTION_PASS("lower-widenable-condition" , LowerWidenableConditionPass()) |
372 | FUNCTION_PASS("make-guards-explicit" , MakeGuardsExplicitPass()) |
373 | FUNCTION_PASS("mem2reg" , PromotePass()) |
374 | FUNCTION_PASS("memcpyopt" , MemCpyOptPass()) |
375 | FUNCTION_PASS("memprof" , MemProfilerPass()) |
376 | FUNCTION_PASS("mergeicmps" , MergeICmpsPass()) |
377 | FUNCTION_PASS("mergereturn" , UnifyFunctionExitNodesPass()) |
378 | FUNCTION_PASS("move-auto-init" , MoveAutoInitPass()) |
379 | FUNCTION_PASS("nary-reassociate" , NaryReassociatePass()) |
380 | FUNCTION_PASS("newgvn" , NewGVNPass()) |
381 | FUNCTION_PASS("no-op-function" , NoOpFunctionPass()) |
382 | FUNCTION_PASS("objc-arc" , ObjCARCOptPass()) |
383 | FUNCTION_PASS("objc-arc-contract" , ObjCARCContractPass()) |
384 | FUNCTION_PASS("objc-arc-expand" , ObjCARCExpandPass()) |
385 | FUNCTION_PASS("pa-eval" , PAEvalPass()) |
386 | FUNCTION_PASS("partially-inline-libcalls" , PartiallyInlineLibCallsPass()) |
387 | FUNCTION_PASS("pgo-memop-opt" , PGOMemOPSizeOpt()) |
388 | FUNCTION_PASS("place-safepoints" , PlaceSafepointsPass()) |
389 | FUNCTION_PASS("print" , PrintFunctionPass(dbgs())) |
390 | // TODO: rename to print<foo> after NPM switch |
391 | FUNCTION_PASS("print-alias-sets" , AliasSetsPrinterPass(dbgs())) |
392 | FUNCTION_PASS("print-cfg-sccs" , CFGSCCPrinterPass(dbgs())) |
393 | FUNCTION_PASS("print-memderefs" , MemDerefPrinterPass(dbgs())) |
394 | FUNCTION_PASS("print-mustexecute" , MustExecutePrinterPass(dbgs())) |
395 | FUNCTION_PASS("print-predicateinfo" , PredicateInfoPrinterPass(dbgs())) |
396 | FUNCTION_PASS("print<access-info>" , LoopAccessInfoPrinterPass(dbgs())) |
397 | FUNCTION_PASS("print<assumptions>" , AssumptionPrinterPass(dbgs())) |
398 | FUNCTION_PASS("print<block-freq>" , BlockFrequencyPrinterPass(dbgs())) |
399 | FUNCTION_PASS("print<branch-prob>" , BranchProbabilityPrinterPass(dbgs())) |
400 | FUNCTION_PASS("print<cost-model>" , CostModelPrinterPass(dbgs())) |
401 | FUNCTION_PASS("print<cycles>" , CycleInfoPrinterPass(dbgs())) |
402 | FUNCTION_PASS("print<da>" , DependenceAnalysisPrinterPass(dbgs())) |
403 | FUNCTION_PASS("print<debug-ata>" , DebugAssignmentTrackingPrinterPass(dbgs())) |
404 | FUNCTION_PASS("print<delinearization>" , DelinearizationPrinterPass(dbgs())) |
405 | FUNCTION_PASS("print<demanded-bits>" , DemandedBitsPrinterPass(dbgs())) |
406 | FUNCTION_PASS("print<domfrontier>" , DominanceFrontierPrinterPass(dbgs())) |
407 | FUNCTION_PASS("print<domtree>" , DominatorTreePrinterPass(dbgs())) |
408 | FUNCTION_PASS("print<func-properties>" , FunctionPropertiesPrinterPass(dbgs())) |
409 | FUNCTION_PASS("print<inline-cost>" , InlineCostAnnotationPrinterPass(dbgs())) |
410 | FUNCTION_PASS("print<inliner-size-estimator>" , |
411 | InlineSizeEstimatorAnalysisPrinterPass(dbgs())) |
412 | FUNCTION_PASS("print<lazy-value-info>" , LazyValueInfoPrinterPass(dbgs())) |
413 | FUNCTION_PASS("print<loops>" , LoopPrinterPass(dbgs())) |
414 | FUNCTION_PASS("print<memoryssa-walker>" , MemorySSAWalkerPrinterPass(dbgs())) |
415 | FUNCTION_PASS("print<phi-values>" , PhiValuesPrinterPass(dbgs())) |
416 | FUNCTION_PASS("print<postdomtree>" , PostDominatorTreePrinterPass(dbgs())) |
417 | FUNCTION_PASS("print<regions>" , RegionInfoPrinterPass(dbgs())) |
418 | FUNCTION_PASS("print<scalar-evolution>" , ScalarEvolutionPrinterPass(dbgs())) |
419 | FUNCTION_PASS("print<stack-safety-local>" , StackSafetyPrinterPass(dbgs())) |
420 | FUNCTION_PASS("print<uniformity>" , UniformityInfoPrinterPass(dbgs())) |
421 | FUNCTION_PASS("reassociate" , ReassociatePass()) |
422 | FUNCTION_PASS("redundant-dbg-inst-elim" , RedundantDbgInstEliminationPass()) |
423 | FUNCTION_PASS("reg2mem" , RegToMemPass()) |
424 | FUNCTION_PASS("safe-stack" , SafeStackPass(TM)) |
425 | FUNCTION_PASS("scalarize-masked-mem-intrin" , ScalarizeMaskedMemIntrinPass()) |
426 | FUNCTION_PASS("scalarizer" , ScalarizerPass()) |
427 | FUNCTION_PASS("sccp" , SCCPPass()) |
428 | FUNCTION_PASS("select-optimize" , SelectOptimizePass(TM)) |
429 | FUNCTION_PASS("separate-const-offset-from-gep" , |
430 | SeparateConstOffsetFromGEPPass()) |
431 | FUNCTION_PASS("sink" , SinkingPass()) |
432 | FUNCTION_PASS("sjlj-eh-prepare" , SjLjEHPreparePass(TM)) |
433 | FUNCTION_PASS("slp-vectorizer" , SLPVectorizerPass()) |
434 | FUNCTION_PASS("slsr" , StraightLineStrengthReducePass()) |
435 | FUNCTION_PASS("stack-protector" , StackProtectorPass(TM)) |
436 | FUNCTION_PASS("strip-gc-relocates" , StripGCRelocates()) |
437 | FUNCTION_PASS("structurizecfg" , StructurizeCFGPass()) |
438 | FUNCTION_PASS("tailcallelim" , TailCallElimPass()) |
439 | FUNCTION_PASS("tlshoist" , TLSVariableHoistPass()) |
440 | FUNCTION_PASS("transform-warning" , WarnMissedTransformationsPass()) |
441 | FUNCTION_PASS("trigger-verifier-error" , TriggerVerifierErrorPass()) |
442 | FUNCTION_PASS("tsan" , ThreadSanitizerPass()) |
443 | FUNCTION_PASS("typepromotion" , TypePromotionPass(TM)) |
444 | FUNCTION_PASS("unify-loop-exits" , UnifyLoopExitsPass()) |
445 | FUNCTION_PASS("vector-combine" , VectorCombinePass()) |
446 | FUNCTION_PASS("verify" , VerifierPass()) |
447 | FUNCTION_PASS("verify<domtree>" , DominatorTreeVerifierPass()) |
448 | FUNCTION_PASS("verify<loops>" , LoopVerifierPass()) |
449 | FUNCTION_PASS("verify<memoryssa>" , MemorySSAVerifierPass()) |
450 | FUNCTION_PASS("verify<regions>" , RegionInfoVerifierPass()) |
451 | FUNCTION_PASS("verify<safepoint-ir>" , SafepointIRVerifierPass()) |
452 | FUNCTION_PASS("verify<scalar-evolution>" , ScalarEvolutionVerifierPass()) |
453 | FUNCTION_PASS("view-cfg" , CFGViewerPass()) |
454 | FUNCTION_PASS("view-cfg-only" , CFGOnlyViewerPass()) |
455 | FUNCTION_PASS("view-dom" , DomViewer()) |
456 | FUNCTION_PASS("view-dom-only" , DomOnlyViewer()) |
457 | FUNCTION_PASS("view-post-dom" , PostDomViewer()) |
458 | FUNCTION_PASS("view-post-dom-only" , PostDomOnlyViewer()) |
459 | FUNCTION_PASS("wasm-eh-prepare" , WasmEHPreparePass()) |
460 | #undef FUNCTION_PASS |
461 | |
462 | #ifndef FUNCTION_PASS_WITH_PARAMS |
463 | #define FUNCTION_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) |
464 | #endif |
465 | FUNCTION_PASS_WITH_PARAMS( |
466 | "cfguard" , "CFGuardPass" , |
467 | [](CFGuardPass::Mechanism M) { return CFGuardPass(M); }, |
468 | parseCFGuardPassOptions, "check;dispatch" ) |
469 | FUNCTION_PASS_WITH_PARAMS( |
470 | "early-cse" , "EarlyCSEPass" , |
471 | [](bool UseMemorySSA) { return EarlyCSEPass(UseMemorySSA); }, |
472 | parseEarlyCSEPassOptions, "memssa" ) |
473 | FUNCTION_PASS_WITH_PARAMS( |
474 | "ee-instrument" , "EntryExitInstrumenterPass" , |
475 | [](bool PostInlining) { return EntryExitInstrumenterPass(PostInlining); }, |
476 | parseEntryExitInstrumenterPassOptions, "post-inline" ) |
477 | FUNCTION_PASS_WITH_PARAMS( |
478 | "function-simplification" , "" , |
479 | [this](OptimizationLevel OL) { |
480 | return buildFunctionSimplificationPipeline(OL, ThinOrFullLTOPhase::None); |
481 | }, |
482 | parseFunctionSimplificationPipelineOptions, "O1;O2;O3;Os;Oz" ) |
483 | FUNCTION_PASS_WITH_PARAMS( |
484 | "gvn" , "GVNPass" , [](GVNOptions Opts) { return GVNPass(Opts); }, |
485 | parseGVNOptions, |
486 | "no-pre;pre;no-load-pre;load-pre;no-split-backedge-load-pre;" |
487 | "split-backedge-load-pre;no-memdep;memdep" ) |
488 | FUNCTION_PASS_WITH_PARAMS( |
489 | "hardware-loops" , "HardwareLoopsPass" , |
490 | [](HardwareLoopOptions Opts) { return HardwareLoopsPass(Opts); }, |
491 | parseHardwareLoopOptions, |
492 | "force-hardware-loops;force-hardware-loop-phi;force-nested-hardware-loop;" |
493 | "force-hardware-loop-guard;hardware-loop-decrement=N;" |
494 | "hardware-loop-counter-bitwidth=N" ) |
495 | FUNCTION_PASS_WITH_PARAMS( |
496 | "instcombine" , "InstCombinePass" , |
497 | [](InstCombineOptions Opts) { return InstCombinePass(Opts); }, |
498 | parseInstCombineOptions, |
499 | "no-use-loop-info;use-loop-info;no-verify-fixpoint;verify-fixpoint;" |
500 | "max-iterations=N" ) |
501 | FUNCTION_PASS_WITH_PARAMS( |
502 | "loop-unroll" , "LoopUnrollPass" , |
503 | [](LoopUnrollOptions Opts) { return LoopUnrollPass(Opts); }, |
504 | parseLoopUnrollOptions, |
505 | "O0;O1;O2;O3;full-unroll-max=N;no-partial;partial;no-peeling;peeling;" |
506 | "no-profile-peeling;profile-peeling;no-runtime;runtime;no-upperbound;" |
507 | "upperbound" ) |
508 | FUNCTION_PASS_WITH_PARAMS( |
509 | "loop-vectorize" , "LoopVectorizePass" , |
510 | [](LoopVectorizeOptions Opts) { return LoopVectorizePass(Opts); }, |
511 | parseLoopVectorizeOptions, |
512 | "no-interleave-forced-only;interleave-forced-only;no-vectorize-forced-only;" |
513 | "vectorize-forced-only" ) |
514 | FUNCTION_PASS_WITH_PARAMS( |
515 | "lower-matrix-intrinsics" , "LowerMatrixIntrinsicsPass" , |
516 | [](bool Minimal) { return LowerMatrixIntrinsicsPass(Minimal); }, |
517 | parseLowerMatrixIntrinsicsPassOptions, "minimal" ) |
518 | FUNCTION_PASS_WITH_PARAMS( |
519 | "mldst-motion" , "MergedLoadStoreMotionPass" , |
520 | [](MergedLoadStoreMotionOptions Opts) { |
521 | return MergedLoadStoreMotionPass(Opts); |
522 | }, |
523 | parseMergedLoadStoreMotionOptions, "no-split-footer-bb;split-footer-bb" ) |
524 | FUNCTION_PASS_WITH_PARAMS( |
525 | "print<da>" , "DependenceAnalysisPrinterPass" , |
526 | [](bool NormalizeResults) { |
527 | return DependenceAnalysisPrinterPass(dbgs(), NormalizeResults); |
528 | }, |
529 | parseDependenceAnalysisPrinterOptions, "normalized-results" ) |
530 | FUNCTION_PASS_WITH_PARAMS( |
531 | "print<memoryssa>" , "MemorySSAPrinterPass" , |
532 | [](bool NoEnsureOptimizedUses) { |
533 | return MemorySSAPrinterPass(dbgs(), !NoEnsureOptimizedUses); |
534 | }, |
535 | parseMemorySSAPrinterPassOptions, "no-ensure-optimized-uses" ) |
536 | FUNCTION_PASS_WITH_PARAMS( |
537 | "print<stack-lifetime>" , "StackLifetimePrinterPass" , |
538 | [](StackLifetime::LivenessType Type) { |
539 | return StackLifetimePrinterPass(dbgs(), Type); |
540 | }, |
541 | parseStackLifetimeOptions, "may;must" ) |
542 | FUNCTION_PASS_WITH_PARAMS( |
543 | "separate-const-offset-from-gep" , "SeparateConstOffsetFromGEPPass" , |
544 | [](bool LowerGEP) { return SeparateConstOffsetFromGEPPass(LowerGEP); }, |
545 | parseSeparateConstOffsetFromGEPPassOptions, "lower-gep" ) |
546 | FUNCTION_PASS_WITH_PARAMS( |
547 | "simplifycfg" , "SimplifyCFGPass" , |
548 | [](SimplifyCFGOptions Opts) { return SimplifyCFGPass(Opts); }, |
549 | parseSimplifyCFGOptions, |
550 | "no-forward-switch-cond;forward-switch-cond;no-switch-range-to-icmp;" |
551 | "switch-range-to-icmp;no-switch-to-lookup;switch-to-lookup;no-keep-loops;" |
552 | "keep-loops;no-hoist-common-insts;hoist-common-insts;no-sink-common-insts;" |
553 | "sink-common-insts;bonus-inst-threshold=N" ) |
554 | FUNCTION_PASS_WITH_PARAMS( |
555 | "speculative-execution" , "SpeculativeExecutionPass" , |
556 | [](bool OnlyIfDivergentTarget) { |
557 | return SpeculativeExecutionPass(OnlyIfDivergentTarget); |
558 | }, |
559 | parseSpeculativeExecutionPassOptions, "only-if-divergent-target" ) |
560 | FUNCTION_PASS_WITH_PARAMS( |
561 | "sroa" , "SROAPass" , |
562 | [](SROAOptions PreserveCFG) { return SROAPass(PreserveCFG); }, |
563 | parseSROAOptions, "preserve-cfg;modify-cfg" ) |
564 | FUNCTION_PASS_WITH_PARAMS( |
565 | "win-eh-prepare" , "WinEHPreparePass" , |
566 | [](bool DemoteCatchSwitchPHIOnly) { |
567 | return WinEHPreparePass(DemoteCatchSwitchPHIOnly); |
568 | }, |
569 | parseWinEHPrepareOptions, "demote-catchswitch-only" ) |
570 | #undef FUNCTION_PASS_WITH_PARAMS |
571 | |
572 | #ifndef LOOPNEST_PASS |
573 | #define LOOPNEST_PASS(NAME, CREATE_PASS) |
574 | #endif |
575 | LOOPNEST_PASS("loop-flatten" , LoopFlattenPass()) |
576 | LOOPNEST_PASS("loop-interchange" , LoopInterchangePass()) |
577 | LOOPNEST_PASS("loop-unroll-and-jam" , LoopUnrollAndJamPass()) |
578 | LOOPNEST_PASS("no-op-loopnest" , NoOpLoopNestPass()) |
579 | #undef LOOPNEST_PASS |
580 | |
581 | #ifndef LOOP_ANALYSIS |
582 | #define LOOP_ANALYSIS(NAME, CREATE_PASS) |
583 | #endif |
584 | LOOP_ANALYSIS("ddg" , DDGAnalysis()) |
585 | LOOP_ANALYSIS("iv-users" , IVUsersAnalysis()) |
586 | LOOP_ANALYSIS("no-op-loop" , NoOpLoopAnalysis()) |
587 | LOOP_ANALYSIS("pass-instrumentation" , PassInstrumentationAnalysis(PIC)) |
588 | #undef LOOP_ANALYSIS |
589 | |
590 | #ifndef LOOP_PASS |
591 | #define LOOP_PASS(NAME, CREATE_PASS) |
592 | #endif |
593 | LOOP_PASS("canon-freeze" , CanonicalizeFreezeInLoopsPass()) |
594 | LOOP_PASS("dot-ddg" , DDGDotPrinterPass()) |
595 | LOOP_PASS("guard-widening" , GuardWideningPass()) |
596 | LOOP_PASS("indvars" , IndVarSimplifyPass()) |
597 | LOOP_PASS("invalidate<all>" , InvalidateAllAnalysesPass()) |
598 | LOOP_PASS("loop-bound-split" , LoopBoundSplitPass()) |
599 | LOOP_PASS("loop-deletion" , LoopDeletionPass()) |
600 | LOOP_PASS("loop-idiom" , LoopIdiomRecognizePass()) |
601 | LOOP_PASS("loop-instsimplify" , LoopInstSimplifyPass()) |
602 | LOOP_PASS("loop-predication" , LoopPredicationPass()) |
603 | LOOP_PASS("loop-reduce" , LoopStrengthReducePass()) |
604 | LOOP_PASS("loop-simplifycfg" , LoopSimplifyCFGPass()) |
605 | LOOP_PASS("loop-unroll-full" , LoopFullUnrollPass()) |
606 | LOOP_PASS("loop-versioning-licm" , LoopVersioningLICMPass()) |
607 | LOOP_PASS("no-op-loop" , NoOpLoopPass()) |
608 | LOOP_PASS("print" , PrintLoopPass(dbgs())) |
609 | LOOP_PASS("print<ddg>" , DDGAnalysisPrinterPass(dbgs())) |
610 | LOOP_PASS("print<iv-users>" , IVUsersPrinterPass(dbgs())) |
611 | LOOP_PASS("print<loop-cache-cost>" , LoopCachePrinterPass(dbgs())) |
612 | LOOP_PASS("print<loopnest>" , LoopNestPrinterPass(dbgs())) |
613 | #undef LOOP_PASS |
614 | |
615 | #ifndef LOOP_PASS_WITH_PARAMS |
616 | #define LOOP_PASS_WITH_PARAMS(NAME, CLASS, CREATE_PASS, PARSER, PARAMS) |
617 | #endif |
618 | LOOP_PASS_WITH_PARAMS( |
619 | "licm" , "LICMPass" , [](LICMOptions Params) { return LICMPass(Params); }, |
620 | parseLICMOptions, "allowspeculation" ) |
621 | LOOP_PASS_WITH_PARAMS( |
622 | "lnicm" , "LNICMPass" , [](LICMOptions Params) { return LNICMPass(Params); }, |
623 | parseLICMOptions, "allowspeculation" ) |
624 | LOOP_PASS_WITH_PARAMS( |
625 | "loop-rotate" , "LoopRotatePass" , |
626 | [](std::pair<bool, bool> Params) { |
627 | return LoopRotatePass(Params.first, Params.second); |
628 | }, |
629 | parseLoopRotateOptions, |
630 | "no-header-duplication;header-duplication;" |
631 | "no-prepare-for-lto;prepare-for-lto" ) |
632 | LOOP_PASS_WITH_PARAMS( |
633 | "simple-loop-unswitch" , "SimpleLoopUnswitchPass" , |
634 | [](std::pair<bool, bool> Params) { |
635 | return SimpleLoopUnswitchPass(Params.first, Params.second); |
636 | }, |
637 | parseLoopUnswitchOptions, "nontrivial;no-nontrivial;trivial;no-trivial" ) |
638 | #undef LOOP_PASS_WITH_PARAMS |
639 | |