LLVM 19.0.0git
PassBuilder.h
Go to the documentation of this file.
1//===- Parsing, selection, and construction of pass pipelines --*- 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/// \file
9///
10/// Interfaces for registering analysis passes, producing common pass manager
11/// configurations, and parsing of pass pipelines.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_PASSES_PASSBUILDER_H
16#define LLVM_PASSES_PASSBUILDER_H
17
20#include "llvm/IR/PassManager.h"
22#include "llvm/Support/Error.h"
29#include <vector>
30
31namespace llvm {
32class StringRef;
33class AAManager;
34class TargetMachine;
35class ModuleSummaryIndex;
36template <typename T> class IntrusiveRefCntPtr;
37namespace vfs {
38class FileSystem;
39} // namespace vfs
40
41/// Tunable parameters for passes in the default pipelines.
43public:
44 /// Constructor sets pipeline tuning defaults based on cl::opts. Each option
45 /// can be set in the PassBuilder when using a LLVM as a library.
47
48 /// Tuning option to set loop interleaving on/off, set based on opt level.
50
51 /// Tuning option to enable/disable loop vectorization, set based on opt
52 /// level.
54
55 /// Tuning option to enable/disable slp loop vectorization, set based on opt
56 /// level.
58
59 /// Tuning option to enable/disable loop unrolling. Its default value is true.
61
62 /// Tuning option to forget all SCEV loops in LoopUnroll. Its default value
63 /// is that of the flag: `-forget-scev-loop-unroll`.
65
66 /// Tuning option to cap the number of calls to retrive clobbering accesses in
67 /// MemorySSA, in LICM.
69
70 /// Tuning option to disable promotion to scalars in LICM with MemorySSA, if
71 /// the number of access is too large.
73
74 /// Tuning option to enable/disable call graph profile. Its default value is
75 /// that of the flag: `-enable-npm-call-graph-profile`.
77
78 // Add LTO pipeline tuning option to enable the unified LTO pipeline.
80
81 /// Tuning option to enable/disable function merging. Its default value is
82 /// false.
84
85 /// Tuning option to override the default inliner threshold.
87
88 // Experimental option to eagerly invalidate more analyses. This has the
89 // potential to decrease max memory usage in exchange for more compile time.
90 // This may affect codegen due to either passes using analyses only when
91 // cached, or invalidating and recalculating an analysis that was
92 // stale/imprecise but still valid. Currently this invalidates all function
93 // analyses after various module->function or cgscc->function adaptors in the
94 // default pipelines.
96};
97
98/// This class provides access to building LLVM's passes.
99///
100/// Its members provide the baseline state available to passes during their
101/// construction. The \c PassRegistry.def file specifies how to construct all
102/// of the built-in passes, and those may reference these members during
103/// construction.
105 TargetMachine *TM;
107 std::optional<PGOOptions> PGOOpt;
109
110public:
111 /// A struct to capture parsed pass pipeline names.
112 ///
113 /// A pipeline is defined as a series of names, each of which may in itself
114 /// recursively contain a nested pipeline. A name is either the name of a pass
115 /// (e.g. "instcombine") or the name of a pipeline type (e.g. "cgscc"). If the
116 /// name is the name of a pass, the InnerPipeline is empty, since passes
117 /// cannot contain inner pipelines. See parsePassPipeline() for a more
118 /// detailed description of the textual pipeline format.
121 std::vector<PipelineElement> InnerPipeline;
122 };
123
124 explicit PassBuilder(TargetMachine *TM = nullptr,
126 std::optional<PGOOptions> PGOOpt = std::nullopt,
127 PassInstrumentationCallbacks *PIC = nullptr);
128
129 /// Cross register the analysis managers through their proxies.
130 ///
131 /// This is an interface that can be used to cross register each
132 /// AnalysisManager with all the others analysis managers.
137 MachineFunctionAnalysisManager *MFAM = nullptr);
138
139 /// Registers all available module analysis passes.
140 ///
141 /// This is an interface that can be used to populate a \c
142 /// ModuleAnalysisManager with all registered module analyses. Callers can
143 /// still manually register any additional analyses. Callers can also
144 /// pre-register analyses and this will not override those.
146
147 /// Registers all available CGSCC analysis passes.
148 ///
149 /// This is an interface that can be used to populate a \c CGSCCAnalysisManager
150 /// with all registered CGSCC analyses. Callers can still manually register any
151 /// additional analyses. Callers can also pre-register analyses and this will
152 /// not override those.
154
155 /// Registers all available function analysis passes.
156 ///
157 /// This is an interface that can be used to populate a \c
158 /// FunctionAnalysisManager with all registered function analyses. Callers can
159 /// still manually register any additional analyses. Callers can also
160 /// pre-register analyses and this will not override those.
162
163 /// Registers all available loop analysis passes.
164 ///
165 /// This is an interface that can be used to populate a \c LoopAnalysisManager
166 /// with all registered loop analyses. Callers can still manually register any
167 /// additional analyses.
169
170 /// Registers all available machine function analysis passes.
171 ///
172 /// This is an interface that can be used to populate a \c
173 /// MachineFunctionAnalysisManager with all registered function analyses.
174 /// Callers can still manually register any additional analyses. Callers can
175 /// also pre-register analyses and this will not override those.
177
178 /// Construct the core LLVM function canonicalization and simplification
179 /// pipeline.
180 ///
181 /// This is a long pipeline and uses most of the per-function optimization
182 /// passes in LLVM to canonicalize and simplify the IR. It is suitable to run
183 /// repeatedly over the IR and is not expected to destroy important
184 /// information about the semantics of the IR.
185 ///
186 /// Note that \p Level cannot be `O0` here. The pipelines produced are
187 /// only intended for use when attempting to optimize code. If frontends
188 /// require some transformations for semantic reasons, they should explicitly
189 /// build them.
190 ///
191 /// \p Phase indicates the current ThinLTO phase.
195
196 /// Construct the core LLVM module canonicalization and simplification
197 /// pipeline.
198 ///
199 /// This pipeline focuses on canonicalizing and simplifying the entire module
200 /// of IR. Much like the function simplification pipeline above, it is
201 /// suitable to run repeatedly over the IR and is not expected to destroy
202 /// important information. It does, however, perform inlining and other
203 /// heuristic based simplifications that are not strictly reversible.
204 ///
205 /// Note that \p Level cannot be `O0` here. The pipelines produced are
206 /// only intended for use when attempting to optimize code. If frontends
207 /// require some transformations for semantic reasons, they should explicitly
208 /// build them.
209 ///
210 /// \p Phase indicates the current ThinLTO phase.
213
214 /// Construct the module pipeline that performs inlining as well as
215 /// the inlining-driven cleanups.
218
219 /// Construct the module pipeline that performs inlining with
220 /// module inliner pass.
223
224 /// Construct the core LLVM module optimization pipeline.
225 ///
226 /// This pipeline focuses on optimizing the execution speed of the IR. It
227 /// uses cost modeling and thresholds to balance code growth against runtime
228 /// improvements. It includes vectorization and other information destroying
229 /// transformations. It also cannot generally be run repeatedly on a module
230 /// without potentially seriously regressing either runtime performance of
231 /// the code or serious code size growth.
232 ///
233 /// Note that \p Level cannot be `O0` here. The pipelines produced are
234 /// only intended for use when attempting to optimize code. If frontends
235 /// require some transformations for semantic reasons, they should explicitly
236 /// build them.
239 ThinOrFullLTOPhase LTOPhase);
240
241 /// Build a per-module default optimization pipeline.
242 ///
243 /// This provides a good default optimization pipeline for per-module
244 /// optimization and code generation without any link-time optimization. It
245 /// typically correspond to frontend "-O[123]" options for optimization
246 /// levels \c O1, \c O2 and \c O3 resp.
248 bool LTOPreLink = false);
249
250 /// Build a fat object default optimization pipeline.
251 ///
252 /// This builds a pipeline that runs the LTO/ThinLTO pre-link pipeline, and
253 /// emits a section containing the pre-link bitcode along side the object code
254 /// generated in non-LTO compilation.
256 bool ThinLTO, bool EmitSummary);
257
258 /// Build a pre-link, ThinLTO-targeting default optimization pipeline to
259 /// a pass manager.
260 ///
261 /// This adds the pre-link optimizations tuned to prepare a module for
262 /// a ThinLTO run. It works to minimize the IR which needs to be analyzed
263 /// without making irreversible decisions which could be made better during
264 /// the LTO run.
266
267 /// Build an ThinLTO default optimization pipeline to a pass manager.
268 ///
269 /// This provides a good default optimization pipeline for link-time
270 /// optimization and code generation. It is particularly tuned to fit well
271 /// when IR coming into the LTO phase was first run through \c
272 /// addPreLinkLTODefaultPipeline, and the two coordinate closely.
275 const ModuleSummaryIndex *ImportSummary);
276
277 /// Build a pre-link, LTO-targeting default optimization pipeline to a pass
278 /// manager.
279 ///
280 /// This adds the pre-link optimizations tuned to work well with a later LTO
281 /// run. It works to minimize the IR which needs to be analyzed without
282 /// making irreversible decisions which could be made better during the LTO
283 /// run.
285
286 /// Build an LTO default optimization pipeline to a pass manager.
287 ///
288 /// This provides a good default optimization pipeline for link-time
289 /// optimization and code generation. It is particularly tuned to fit well
290 /// when IR coming into the LTO phase was first run through \c
291 /// addPreLinkLTODefaultPipeline, and the two coordinate closely.
293 ModuleSummaryIndex *ExportSummary);
294
295 /// Build an O0 pipeline with the minimal semantically required passes.
296 ///
297 /// This should only be used for non-LTO and LTO pre-link pipelines.
299 bool LTOPreLink = false);
300
301 /// Build the default `AAManager` with the default alias analysis pipeline
302 /// registered.
303 ///
304 /// This also adds target-specific alias analyses registered via
305 /// TargetMachine::registerDefaultAliasAnalyses().
307
308 /// Parse a textual pass pipeline description into a \c
309 /// ModulePassManager.
310 ///
311 /// The format of the textual pass pipeline description looks something like:
312 ///
313 /// module(function(instcombine,sroa),dce,cgscc(inliner,function(...)),...)
314 ///
315 /// Pass managers have ()s describing the nest structure of passes. All passes
316 /// are comma separated. As a special shortcut, if the very first pass is not
317 /// a module pass (as a module pass manager is), this will automatically form
318 /// the shortest stack of pass managers that allow inserting that first pass.
319 /// So, assuming function passes 'fpassN', CGSCC passes 'cgpassN', and loop
320 /// passes 'lpassN', all of these are valid:
321 ///
322 /// fpass1,fpass2,fpass3
323 /// cgpass1,cgpass2,cgpass3
324 /// lpass1,lpass2,lpass3
325 ///
326 /// And they are equivalent to the following (resp.):
327 ///
328 /// module(function(fpass1,fpass2,fpass3))
329 /// module(cgscc(cgpass1,cgpass2,cgpass3))
330 /// module(function(loop(lpass1,lpass2,lpass3)))
331 ///
332 /// This shortcut is especially useful for debugging and testing small pass
333 /// combinations.
334 ///
335 /// The sequence of passes aren't necessarily the exact same kind of pass.
336 /// You can mix different levels implicitly if adaptor passes are defined to
337 /// make them work. For example,
338 ///
339 /// mpass1,fpass1,fpass2,mpass2,lpass1
340 ///
341 /// This pipeline uses only one pass manager: the top-level module manager.
342 /// fpass1,fpass2 and lpass1 are added into the top-level module manager
343 /// using only adaptor passes. No nested function/loop pass managers are
344 /// added. The purpose is to allow easy pass testing when the user
345 /// specifically want the pass to run under a adaptor directly. This is
346 /// preferred when a pipeline is largely of one type, but one or just a few
347 /// passes are of different types(See PassBuilder.cpp for examples).
349
350 /// {{@ Parse a textual pass pipeline description into a specific PassManager
351 ///
352 /// Automatic deduction of an appropriate pass manager stack is not supported.
353 /// For example, to insert a loop pass 'lpass' into a FunctionPassManager,
354 /// this is the valid pipeline text:
355 ///
356 /// function(lpass)
360 /// @}}
361
362 /// Parse a textual MIR pipeline into the provided \c MachineFunctionPass
363 /// manager.
364 /// The format of the textual machine pipeline is a comma separated list of
365 /// machine pass names:
366 ///
367 /// machine-funciton-pass,machine-module-pass,...
368 ///
369 /// There is no need to specify the pass nesting, and this function
370 /// currently cannot handle the pass nesting.
372 StringRef PipelineText);
373
374 /// Parse a textual alias analysis pipeline into the provided AA manager.
375 ///
376 /// The format of the textual AA pipeline is a comma separated list of AA
377 /// pass names:
378 ///
379 /// basic-aa,globals-aa,...
380 ///
381 /// The AA manager is set up such that the provided alias analyses are tried
382 /// in the order specified. See the \c AAManaager documentation for details
383 /// about the logic used. This routine just provides the textual mapping
384 /// between AA names and the analyses to register with the manager.
385 ///
386 /// Returns false if the text cannot be parsed cleanly. The specific state of
387 /// the \p AA manager is unspecified if such an error is encountered and this
388 /// returns false.
389 Error parseAAPipeline(AAManager &AA, StringRef PipelineText);
390
391 /// Print pass names.
393
394 /// Register a callback for a default optimizer pipeline extension
395 /// point
396 ///
397 /// This extension point allows adding passes that perform peephole
398 /// optimizations similar to the instruction combiner. These passes will be
399 /// inserted after each instance of the instruction combiner pass.
401 const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
402 PeepholeEPCallbacks.push_back(C);
403 }
404
405 /// Register a callback for a default optimizer pipeline extension
406 /// point
407 ///
408 /// This extension point allows adding late loop canonicalization and
409 /// simplification passes. This is the last point in the loop optimization
410 /// pipeline before loop deletion. Each pass added
411 /// here must be an instance of LoopPass.
412 /// This is the place to add passes that can remove loops, such as target-
413 /// specific loop idiom recognition.
415 const std::function<void(LoopPassManager &, OptimizationLevel)> &C) {
416 LateLoopOptimizationsEPCallbacks.push_back(C);
417 }
418
419 /// Register a callback for a default optimizer pipeline extension
420 /// point
421 ///
422 /// This extension point allows adding loop passes to the end of the loop
423 /// optimizer.
425 const std::function<void(LoopPassManager &, OptimizationLevel)> &C) {
426 LoopOptimizerEndEPCallbacks.push_back(C);
427 }
428
429 /// Register a callback for a default optimizer pipeline extension
430 /// point
431 ///
432 /// This extension point allows adding optimization passes after most of the
433 /// main optimizations, but before the last cleanup-ish optimizations.
435 const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
436 ScalarOptimizerLateEPCallbacks.push_back(C);
437 }
438
439 /// Register a callback for a default optimizer pipeline extension
440 /// point
441 ///
442 /// This extension point allows adding CallGraphSCC passes at the end of the
443 /// main CallGraphSCC passes and before any function simplification passes run
444 /// by CGPassManager.
446 const std::function<void(CGSCCPassManager &, OptimizationLevel)> &C) {
447 CGSCCOptimizerLateEPCallbacks.push_back(C);
448 }
449
450 /// Register a callback for a default optimizer pipeline extension
451 /// point
452 ///
453 /// This extension point allows adding optimization passes before the
454 /// vectorizer and other highly target specific optimization passes are
455 /// executed.
457 const std::function<void(FunctionPassManager &, OptimizationLevel)> &C) {
458 VectorizerStartEPCallbacks.push_back(C);
459 }
460
461 /// Register a callback for a default optimizer pipeline extension point.
462 ///
463 /// This extension point allows adding optimization once at the start of the
464 /// pipeline. This does not apply to 'backend' compiles (LTO and ThinLTO
465 /// link-time pipelines).
467 const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
468 PipelineStartEPCallbacks.push_back(C);
469 }
470
471 /// Register a callback for a default optimizer pipeline extension point.
472 ///
473 /// This extension point allows adding optimization right after passes that do
474 /// basic simplification of the input IR.
476 const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
477 PipelineEarlySimplificationEPCallbacks.push_back(C);
478 }
479
480 /// Register a callback for a default optimizer pipeline extension point
481 ///
482 /// This extension point allows adding optimizations before the function
483 /// optimization pipeline.
485 const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
486 OptimizerEarlyEPCallbacks.push_back(C);
487 }
488
489 /// Register a callback for a default optimizer pipeline extension point
490 ///
491 /// This extension point allows adding optimizations at the very end of the
492 /// function optimization pipeline.
494 const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
495 OptimizerLastEPCallbacks.push_back(C);
496 }
497
498 /// Register a callback for a default optimizer pipeline extension point
499 ///
500 /// This extension point allows adding optimizations at the start of the full
501 /// LTO pipeline.
503 const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
504 FullLinkTimeOptimizationEarlyEPCallbacks.push_back(C);
505 }
506
507 /// Register a callback for a default optimizer pipeline extension point
508 ///
509 /// This extension point allows adding optimizations at the end of the full
510 /// LTO pipeline.
512 const std::function<void(ModulePassManager &, OptimizationLevel)> &C) {
513 FullLinkTimeOptimizationLastEPCallbacks.push_back(C);
514 }
515
516 /// Register a callback for parsing an AliasAnalysis Name to populate
517 /// the given AAManager \p AA
519 const std::function<bool(StringRef Name, AAManager &AA)> &C) {
520 AAParsingCallbacks.push_back(C);
521 }
522
523 /// {{@ Register callbacks for analysis registration with this PassBuilder
524 /// instance.
525 /// Callees register their analyses with the given AnalysisManager objects.
527 const std::function<void(CGSCCAnalysisManager &)> &C) {
528 CGSCCAnalysisRegistrationCallbacks.push_back(C);
529 }
531 const std::function<void(FunctionAnalysisManager &)> &C) {
532 FunctionAnalysisRegistrationCallbacks.push_back(C);
533 }
535 const std::function<void(LoopAnalysisManager &)> &C) {
536 LoopAnalysisRegistrationCallbacks.push_back(C);
537 }
539 const std::function<void(ModuleAnalysisManager &)> &C) {
540 ModuleAnalysisRegistrationCallbacks.push_back(C);
541 }
543 const std::function<void(MachineFunctionAnalysisManager &)> &C) {
544 MachineFunctionAnalysisRegistrationCallbacks.push_back(C);
545 }
546 /// @}}
547
548 /// {{@ Register pipeline parsing callbacks with this pass builder instance.
549 /// Using these callbacks, callers can parse both a single pass name, as well
550 /// as entire sub-pipelines, and populate the PassManager instance
551 /// accordingly.
553 const std::function<bool(StringRef Name, CGSCCPassManager &,
555 CGSCCPipelineParsingCallbacks.push_back(C);
556 }
558 const std::function<bool(StringRef Name, FunctionPassManager &,
560 FunctionPipelineParsingCallbacks.push_back(C);
561 }
563 const std::function<bool(StringRef Name, LoopPassManager &,
565 LoopPipelineParsingCallbacks.push_back(C);
566 }
568 const std::function<bool(StringRef Name, ModulePassManager &,
570 ModulePipelineParsingCallbacks.push_back(C);
571 }
573 const std::function<bool(StringRef Name, MachineFunctionPassManager &,
575 MachineFunctionPipelineParsingCallbacks.push_back(C);
576 }
577 /// @}}
578
579 /// Register a callback for a top-level pipeline entry.
580 ///
581 /// If the PassManager type is not given at the top level of the pipeline
582 /// text, this Callback should be used to determine the appropriate stack of
583 /// PassManagers and populate the passed ModulePassManager.
585 const std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>
586 &C);
587
588 /// Add PGOInstrumenation passes for O0 only.
589 void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen,
590 bool IsCS, bool AtomicCounterUpdate,
591 std::string ProfileFile,
592 std::string ProfileRemappingFile,
594
595 /// Returns PIC. External libraries can use this to register pass
596 /// instrumentation callbacks.
598 return PIC;
599 }
600
601 // Invoke the callbacks registered for the various extension points.
602 // Custom pipelines should use these to invoke the callbacks registered
603 // by TargetMachines and other clients.
605 OptimizationLevel Level);
607 OptimizationLevel Level);
609 OptimizationLevel Level);
611 OptimizationLevel Level);
613 OptimizationLevel Level);
615 OptimizationLevel Level);
617 OptimizationLevel Level);
619 OptimizationLevel Level);
621 OptimizationLevel Level);
623 OptimizationLevel Level);
625 OptimizationLevel Level);
627 OptimizationLevel Level);
628
630 if (!Name.consume_front(PassName))
631 return false;
632 // normal pass name w/o parameters == default parameters
633 if (Name.empty())
634 return true;
635 return Name.starts_with("<") && Name.ends_with(">");
636 }
637
638 /// This performs customized parsing of pass name with parameters.
639 ///
640 /// We do not need parametrization of passes in textual pipeline very often,
641 /// yet on a rare occasion ability to specify parameters right there can be
642 /// useful.
643 ///
644 /// \p Name - parameterized specification of a pass from a textual pipeline
645 /// is a string in a form of :
646 /// PassName '<' parameter-list '>'
647 ///
648 /// Parameter list is being parsed by the parser callable argument, \p Parser,
649 /// It takes a string-ref of parameters and returns either StringError or a
650 /// parameter list in a form of a custom parameters type, all wrapped into
651 /// Expected<> template class.
652 ///
653 template <typename ParametersParseCallableT>
654 static auto parsePassParameters(ParametersParseCallableT &&Parser,
656 -> decltype(Parser(StringRef{})) {
657 using ParametersT = typename decltype(Parser(StringRef{}))::value_type;
658
659 StringRef Params = Name;
660 if (!Params.consume_front(PassName)) {
662 "unable to strip pass name from parametrized pass specification");
663 }
664 if (!Params.empty() &&
665 (!Params.consume_front("<") || !Params.consume_back(">"))) {
666 llvm_unreachable("invalid format for parametrized pass name");
667 }
668
669 Expected<ParametersT> Result = Parser(Params);
670 assert((Result || Result.template errorIsA<StringError>()) &&
671 "Pass parameter parser can only return StringErrors.");
672 return Result;
673 }
674
675 /// Handle passes only accept one bool-valued parameter.
676 ///
677 /// \return false when Params is empty.
678 static Expected<bool> parseSinglePassOption(StringRef Params,
679 StringRef OptionName,
680 StringRef PassName);
681
682private:
683 // O1 pass pipeline
685 buildO1FunctionSimplificationPipeline(OptimizationLevel Level,
687
688 void addRequiredLTOPreLinkPasses(ModulePassManager &MPM);
689
690 void addVectorPasses(OptimizationLevel Level, FunctionPassManager &FPM,
691 bool IsFullLTO);
692
693 static std::optional<std::vector<PipelineElement>>
694 parsePipelineText(StringRef Text);
695
696 Error parseModulePass(ModulePassManager &MPM, const PipelineElement &E);
697 Error parseCGSCCPass(CGSCCPassManager &CGPM, const PipelineElement &E);
698 Error parseFunctionPass(FunctionPassManager &FPM, const PipelineElement &E);
699 Error parseLoopPass(LoopPassManager &LPM, const PipelineElement &E);
700 Error parseMachinePass(MachineFunctionPassManager &MFPM,
701 const PipelineElement &E);
702 bool parseAAPassName(AAManager &AA, StringRef Name);
703
704 Error parseMachinePassPipeline(MachineFunctionPassManager &MFPM,
705 ArrayRef<PipelineElement> Pipeline);
706 Error parseLoopPassPipeline(LoopPassManager &LPM,
707 ArrayRef<PipelineElement> Pipeline);
708 Error parseFunctionPassPipeline(FunctionPassManager &FPM,
709 ArrayRef<PipelineElement> Pipeline);
710 Error parseCGSCCPassPipeline(CGSCCPassManager &CGPM,
711 ArrayRef<PipelineElement> Pipeline);
712 Error parseModulePassPipeline(ModulePassManager &MPM,
713 ArrayRef<PipelineElement> Pipeline);
714
715 // Adds passes to do pre-inlining and related cleanup passes before
716 // profile instrumentation/matching (to enable better context sensitivity),
717 // and for memprof to enable better matching with missing debug frames.
718 void addPreInlinerPasses(ModulePassManager &MPM, OptimizationLevel Level,
719 ThinOrFullLTOPhase LTOPhase);
720
721 void addPGOInstrPasses(ModulePassManager &MPM, OptimizationLevel Level,
722 bool RunProfileGen, bool IsCS,
723 bool AtomicCounterUpdate, std::string ProfileFile,
724 std::string ProfileRemappingFile,
725 IntrusiveRefCntPtr<vfs::FileSystem> FS);
726
727 // Extension Point callbacks
728 SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
729 PeepholeEPCallbacks;
730 SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
731 LateLoopOptimizationsEPCallbacks;
732 SmallVector<std::function<void(LoopPassManager &, OptimizationLevel)>, 2>
733 LoopOptimizerEndEPCallbacks;
734 SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
735 ScalarOptimizerLateEPCallbacks;
736 SmallVector<std::function<void(CGSCCPassManager &, OptimizationLevel)>, 2>
737 CGSCCOptimizerLateEPCallbacks;
738 SmallVector<std::function<void(FunctionPassManager &, OptimizationLevel)>, 2>
739 VectorizerStartEPCallbacks;
740 // Module callbacks
741 SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
742 OptimizerEarlyEPCallbacks;
743 SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
744 OptimizerLastEPCallbacks;
745 SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
746 FullLinkTimeOptimizationEarlyEPCallbacks;
747 SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
748 FullLinkTimeOptimizationLastEPCallbacks;
749 SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
750 PipelineStartEPCallbacks;
751 SmallVector<std::function<void(ModulePassManager &, OptimizationLevel)>, 2>
752 PipelineEarlySimplificationEPCallbacks;
753
754 SmallVector<std::function<void(ModuleAnalysisManager &)>, 2>
755 ModuleAnalysisRegistrationCallbacks;
756 SmallVector<std::function<bool(StringRef, ModulePassManager &,
757 ArrayRef<PipelineElement>)>,
758 2>
759 ModulePipelineParsingCallbacks;
761 std::function<bool(ModulePassManager &, ArrayRef<PipelineElement>)>, 2>
762 TopLevelPipelineParsingCallbacks;
763 // CGSCC callbacks
764 SmallVector<std::function<void(CGSCCAnalysisManager &)>, 2>
765 CGSCCAnalysisRegistrationCallbacks;
766 SmallVector<std::function<bool(StringRef, CGSCCPassManager &,
767 ArrayRef<PipelineElement>)>,
768 2>
769 CGSCCPipelineParsingCallbacks;
770 // Function callbacks
771 SmallVector<std::function<void(FunctionAnalysisManager &)>, 2>
772 FunctionAnalysisRegistrationCallbacks;
773 SmallVector<std::function<bool(StringRef, FunctionPassManager &,
774 ArrayRef<PipelineElement>)>,
775 2>
776 FunctionPipelineParsingCallbacks;
777 // Loop callbacks
778 SmallVector<std::function<void(LoopAnalysisManager &)>, 2>
779 LoopAnalysisRegistrationCallbacks;
780 SmallVector<std::function<bool(StringRef, LoopPassManager &,
781 ArrayRef<PipelineElement>)>,
782 2>
783 LoopPipelineParsingCallbacks;
784 // AA callbacks
785 SmallVector<std::function<bool(StringRef Name, AAManager &AA)>, 2>
786 AAParsingCallbacks;
787 // Machine pass callbackcs
788 SmallVector<std::function<void(MachineFunctionAnalysisManager &)>, 2>
789 MachineFunctionAnalysisRegistrationCallbacks;
790 SmallVector<std::function<bool(StringRef, MachineFunctionPassManager &,
791 ArrayRef<PipelineElement>)>,
792 2>
793 MachineFunctionPipelineParsingCallbacks;
794};
795
796/// This utility template takes care of adding require<> and invalidate<>
797/// passes for an analysis to a given \c PassManager. It is intended to be used
798/// during parsing of a pass pipeline when parsing a single PipelineName.
799/// When registering a new function analysis FancyAnalysis with the pass
800/// pipeline name "fancy-analysis", a matching ParsePipelineCallback could look
801/// like this:
802///
803/// static bool parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
804/// ArrayRef<PipelineElement> P) {
805/// if (parseAnalysisUtilityPasses<FancyAnalysis>("fancy-analysis", Name,
806/// FPM))
807/// return true;
808/// return false;
809/// }
810template <typename AnalysisT, typename IRUnitT, typename AnalysisManagerT,
811 typename... ExtraArgTs>
813 StringRef AnalysisName, StringRef PipelineName,
815 if (!PipelineName.ends_with(">"))
816 return false;
817 // See if this is an invalidate<> pass name
818 if (PipelineName.starts_with("invalidate<")) {
819 PipelineName = PipelineName.substr(11, PipelineName.size() - 12);
820 if (PipelineName != AnalysisName)
821 return false;
823 return true;
824 }
825
826 // See if this is a require<> pass name
827 if (PipelineName.starts_with("require<")) {
828 PipelineName = PipelineName.substr(8, PipelineName.size() - 9);
829 if (PipelineName != AnalysisName)
830 return false;
831 PM.addPass(RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
832 ExtraArgTs...>());
833 return true;
834 }
835
836 return false;
837}
838
839// These are special since they are only for testing purposes.
840
841/// No-op module pass which does nothing.
842struct NoOpModulePass : PassInfoMixin<NoOpModulePass> {
844 return PreservedAnalyses::all();
845 }
846};
847
848/// No-op module analysis.
849class NoOpModuleAnalysis : public AnalysisInfoMixin<NoOpModuleAnalysis> {
851 static AnalysisKey Key;
852
853public:
854 struct Result {};
856};
857
858/// No-op CGSCC pass which does nothing.
859struct NoOpCGSCCPass : PassInfoMixin<NoOpCGSCCPass> {
862 return PreservedAnalyses::all();
863 }
864};
865
866/// No-op CGSCC analysis.
867class NoOpCGSCCAnalysis : public AnalysisInfoMixin<NoOpCGSCCAnalysis> {
869 static AnalysisKey Key;
870
871public:
872 struct Result {};
874 return Result();
875 }
876};
877
878/// No-op function pass which does nothing.
879struct NoOpFunctionPass : PassInfoMixin<NoOpFunctionPass> {
881 return PreservedAnalyses::all();
882 }
883};
884
885/// No-op function analysis.
886class NoOpFunctionAnalysis : public AnalysisInfoMixin<NoOpFunctionAnalysis> {
888 static AnalysisKey Key;
889
890public:
891 struct Result {};
893};
894
895/// No-op loop nest pass which does nothing.
896struct NoOpLoopNestPass : PassInfoMixin<NoOpLoopNestPass> {
899 return PreservedAnalyses::all();
900 }
901};
902
903/// No-op loop pass which does nothing.
904struct NoOpLoopPass : PassInfoMixin<NoOpLoopPass> {
907 return PreservedAnalyses::all();
908 }
909};
910
911/// No-op machine function pass which does nothing.
913 : public MachinePassInfoMixin<NoOpMachineFunctionPass> {
915 return PreservedAnalyses::all();
916 }
917};
918
919/// No-op loop analysis.
920class NoOpLoopAnalysis : public AnalysisInfoMixin<NoOpLoopAnalysis> {
922 static AnalysisKey Key;
923
924public:
925 struct Result {};
927 return Result();
928 }
929};
930}
931
932#endif
aarch64 falkor hwpf fix Falkor HW Prefetch Fix Late Phase
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This header provides classes for managing passes over SCCs of the call graph.
std::string Name
This header provides classes for managing a pipeline of passes over loops in LLVM IR.
#define F(x, y, z)
Definition: MD5.cpp:55
#define G(x, y, z)
Definition: MD5.cpp:56
This header enumerates the LLVM-provided high-level optimization levels.
Define option tunables for PGO.
CGSCCAnalysisManager CGAM
ModulePassManager MPM
LoopAnalysisManager LAM
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
PassInstrumentationCallbacks PIC
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
static const char PassName[]
A manager for alias analyses.
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:348
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
A smart pointer to a reference-counted object that inherits from RefCountedBase or ThreadSafeRefCount...
This class provides an interface for updating the loop pass manager based on mutations to the loop ne...
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
This class represents a loop nest and can be used to query its properties.
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:44
Module pass, wrapping the inliner pass.
Definition: Inliner.h:62
Class to hold module path string table and global value map, and encapsulate methods for operating on...
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
No-op CGSCC analysis.
Definition: PassBuilder.h:867
Result run(LazyCallGraph::SCC &, CGSCCAnalysisManager &, LazyCallGraph &G)
Definition: PassBuilder.h:873
No-op function analysis.
Definition: PassBuilder.h:886
Result run(Function &, FunctionAnalysisManager &)
Definition: PassBuilder.h:892
No-op loop analysis.
Definition: PassBuilder.h:920
Result run(Loop &, LoopAnalysisManager &, LoopStandardAnalysisResults &)
Definition: PassBuilder.h:926
No-op module analysis.
Definition: PassBuilder.h:849
Result run(Module &, ModuleAnalysisManager &)
Definition: PassBuilder.h:855
This class provides access to building LLVM's passes.
Definition: PassBuilder.h:104
ModulePassManager buildO0DefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build an O0 pipeline with the minimal semantically required passes.
void invokeFullLinkTimeOptimizationLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
ModuleInlinerWrapperPass buildInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the module pipeline that performs inlining as well as the inlining-driven cleanups.
void registerAnalysisRegistrationCallback(const std::function< void(MachineFunctionAnalysisManager &)> &C)
Definition: PassBuilder.h:542
void printPassNames(raw_ostream &OS)
Print pass names.
static bool checkParametrizedPassName(StringRef Name, StringRef PassName)
Definition: PassBuilder.h:629
void invokeOptimizerLastEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
void registerPipelineEarlySimplificationEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:475
void invokeVectorizerStartEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Definition: PassBuilder.h:567
AAManager buildDefaultAAPipeline()
Build the default AAManager with the default alias analysis pipeline registered.
Error parseAAPipeline(AAManager &AA, StringRef PipelineText)
Parse a textual alias analysis pipeline into the provided AA manager.
void invokeCGSCCOptimizerLateEPCallbacks(CGSCCPassManager &CGPM, OptimizationLevel Level)
ModulePassManager buildThinLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, ThinLTO-targeting default optimization pipeline to a pass manager.
void registerAnalysisRegistrationCallback(const std::function< void(ModuleAnalysisManager &)> &C)
Definition: PassBuilder.h:538
void registerPipelineStartEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:466
void invokeScalarOptimizerLateEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, LoopPassManager &, ArrayRef< PipelineElement >)> &C)
Definition: PassBuilder.h:562
void registerLoopAnalyses(LoopAnalysisManager &LAM)
Registers all available loop analysis passes.
PassInstrumentationCallbacks * getPassInstrumentationCallbacks() const
Returns PIC.
Definition: PassBuilder.h:597
void registerLateLoopOptimizationsEPCallback(const std::function< void(LoopPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:414
void crossRegisterProxies(LoopAnalysisManager &LAM, FunctionAnalysisManager &FAM, CGSCCAnalysisManager &CGAM, ModuleAnalysisManager &MAM, MachineFunctionAnalysisManager *MFAM=nullptr)
Cross register the analysis managers through their proxies.
void registerLoopOptimizerEndEPCallback(const std::function< void(LoopPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:424
void registerParseAACallback(const std::function< bool(StringRef Name, AAManager &AA)> &C)
Register a callback for parsing an AliasAnalysis Name to populate the given AAManager AA.
Definition: PassBuilder.h:518
void registerOptimizerLastEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:493
void registerVectorizerStartEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:456
void registerAnalysisRegistrationCallback(const std::function< void(LoopAnalysisManager &)> &C)
Definition: PassBuilder.h:534
void registerPeepholeEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:400
void registerAnalysisRegistrationCallback(const std::function< void(FunctionAnalysisManager &)> &C)
Definition: PassBuilder.h:530
void registerScalarOptimizerLateEPCallback(const std::function< void(FunctionPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:434
ModulePassManager buildPerModuleDefaultPipeline(OptimizationLevel Level, bool LTOPreLink=false)
Build a per-module default optimization pipeline.
void registerAnalysisRegistrationCallback(const std::function< void(CGSCCAnalysisManager &)> &C)
{{@ Register callbacks for analysis registration with this PassBuilder instance.
Definition: PassBuilder.h:526
void invokePipelineStartEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
FunctionPassManager buildFunctionSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the core LLVM function canonicalization and simplification pipeline.
void registerCGSCCOptimizerLateEPCallback(const std::function< void(CGSCCPassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:445
void invokePeepholeEPCallbacks(FunctionPassManager &FPM, OptimizationLevel Level)
Error parsePassPipeline(ModulePassManager &MPM, StringRef PipelineText)
Parse a textual pass pipeline description into a ModulePassManager.
void invokeLoopOptimizerEndEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)
void registerOptimizerEarlyEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:484
ModulePassManager buildLTODefaultPipeline(OptimizationLevel Level, ModuleSummaryIndex *ExportSummary)
Build an LTO default optimization pipeline to a pass manager.
ModulePassManager buildModuleInlinerPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the module pipeline that performs inlining with module inliner pass.
ModulePassManager buildThinLTODefaultPipeline(OptimizationLevel Level, const ModuleSummaryIndex *ImportSummary)
Build an ThinLTO default optimization pipeline to a pass manager.
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, CGSCCPassManager &, ArrayRef< PipelineElement >)> &C)
{{@ Register pipeline parsing callbacks with this pass builder instance.
Definition: PassBuilder.h:552
void registerFullLinkTimeOptimizationEarlyEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:502
void invokeLateLoopOptimizationsEPCallbacks(LoopPassManager &LPM, OptimizationLevel Level)
void invokeOptimizerEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, FunctionPassManager &, ArrayRef< PipelineElement >)> &C)
Definition: PassBuilder.h:557
void registerModuleAnalyses(ModuleAnalysisManager &MAM)
Registers all available module analysis passes.
void invokePipelineEarlySimplificationEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
void registerFullLinkTimeOptimizationLastEPCallback(const std::function< void(ModulePassManager &, OptimizationLevel)> &C)
Register a callback for a default optimizer pipeline extension point.
Definition: PassBuilder.h:511
void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM)
Registers all available CGSCC analysis passes.
void invokeFullLinkTimeOptimizationEarlyEPCallbacks(ModulePassManager &MPM, OptimizationLevel Level)
ModulePassManager buildFatLTODefaultPipeline(OptimizationLevel Level, bool ThinLTO, bool EmitSummary)
Build a fat object default optimization pipeline.
static auto parsePassParameters(ParametersParseCallableT &&Parser, StringRef Name, StringRef PassName) -> decltype(Parser(StringRef{}))
This performs customized parsing of pass name with parameters.
Definition: PassBuilder.h:654
ModulePassManager buildModuleSimplificationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase Phase)
Construct the core LLVM module canonicalization and simplification pipeline.
void registerPipelineParsingCallback(const std::function< bool(StringRef Name, MachineFunctionPassManager &, ArrayRef< PipelineElement >)> &C)
Definition: PassBuilder.h:572
static Expected< bool > parseSinglePassOption(StringRef Params, StringRef OptionName, StringRef PassName)
Handle passes only accept one bool-valued parameter.
void registerMachineFunctionAnalyses(MachineFunctionAnalysisManager &MFAM)
Registers all available machine function analysis passes.
ModulePassManager buildModuleOptimizationPipeline(OptimizationLevel Level, ThinOrFullLTOPhase LTOPhase)
Construct the core LLVM module optimization pipeline.
void registerParseTopLevelPipelineCallback(const std::function< bool(ModulePassManager &, ArrayRef< PipelineElement >)> &C)
Register a callback for a top-level pipeline entry.
void addPGOInstrPassesForO0(ModulePassManager &MPM, bool RunProfileGen, bool IsCS, bool AtomicCounterUpdate, std::string ProfileFile, std::string ProfileRemappingFile, IntrusiveRefCntPtr< vfs::FileSystem > FS)
Add PGOInstrumenation passes for O0 only.
ModulePassManager buildLTOPreLinkDefaultPipeline(OptimizationLevel Level)
Build a pre-link, LTO-targeting default optimization pipeline to a pass manager.
void registerFunctionAnalyses(FunctionAnalysisManager &FAM)
Registers all available function analysis passes.
This class manages callbacks registration, as well as provides a way for PassInstrumentation to pass ...
LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same< PassT, PassManager >::value > addPass(PassT &&Pass)
Definition: PassManager.h:273
Tunable parameters for passes in the default pipelines.
Definition: PassBuilder.h:42
unsigned LicmMssaNoAccForPromotionCap
Tuning option to disable promotion to scalars in LICM with MemorySSA, if the number of access is too ...
Definition: PassBuilder.h:72
bool SLPVectorization
Tuning option to enable/disable slp loop vectorization, set based on opt level.
Definition: PassBuilder.h:57
int InlinerThreshold
Tuning option to override the default inliner threshold.
Definition: PassBuilder.h:86
bool CallGraphProfile
Tuning option to enable/disable call graph profile.
Definition: PassBuilder.h:76
bool MergeFunctions
Tuning option to enable/disable function merging.
Definition: PassBuilder.h:83
bool ForgetAllSCEVInLoopUnroll
Tuning option to forget all SCEV loops in LoopUnroll.
Definition: PassBuilder.h:64
unsigned LicmMssaOptCap
Tuning option to cap the number of calls to retrive clobbering accesses in MemorySSA,...
Definition: PassBuilder.h:68
bool LoopInterleaving
Tuning option to set loop interleaving on/off, set based on opt level.
Definition: PassBuilder.h:49
PipelineTuningOptions()
Constructor sets pipeline tuning defaults based on cl::opts.
bool LoopUnrolling
Tuning option to enable/disable loop unrolling. Its default value is true.
Definition: PassBuilder.h:60
bool LoopVectorization
Tuning option to enable/disable loop vectorization, set based on opt level.
Definition: PassBuilder.h:53
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:115
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
constexpr StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:567
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:257
constexpr size_t size() const
size - Get the string size.
Definition: StringRef.h:137
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition: StringRef.h:271
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:76
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
PassManager< Module > ModulePassManager
Convenience typedef for a pass manager over modules.
Definition: PassManager.h:310
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
Definition: PassManager.h:315
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
bool parseAnalysisUtilityPasses(StringRef AnalysisName, StringRef PipelineName, PassManager< IRUnitT, AnalysisManagerT, ExtraArgTs... > &PM)
This utility template takes care of adding require<> and invalidate<> passes for an analysis to a giv...
Definition: PassBuilder.h:812
PassManager< MachineFunction > MachineFunctionPassManager
Convenience typedef for a pass manager over functions.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition: PassManager.h:632
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
Definition: PassManager.h:637
AnalysisManager< Loop, LoopStandardAnalysisResults & > LoopAnalysisManager
The loop analysis manager.
ThinOrFullLTOPhase
This enumerates the LLVM full LTO or ThinLTO optimization phases.
Definition: Pass.h:76
PassManager< Loop, LoopAnalysisManager, LoopStandardAnalysisResults &, LPMUpdater & > LoopPassManager
The Loop pass manager.
PassManager< LazyCallGraph::SCC, CGSCCAnalysisManager, LazyCallGraph &, CGSCCUpdateResult & > CGSCCPassManager
The CGSCC pass manager.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition: SmallVector.h:1135
AnalysisManager< LazyCallGraph::SCC, LazyCallGraph & > CGSCCAnalysisManager
The CGSCC analysis manager.
A CRTP mix-in that provides informational APIs needed for analysis passes.
Definition: PassManager.h:114
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:26
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
A no-op pass template which simply forces a specific analysis result to be invalidated.
Definition: PassManager.h:996
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
A CRTP mix-in that provides informational APIs needed for machine passes.
No-op CGSCC pass which does nothing.
Definition: PassBuilder.h:859
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &, LazyCallGraph &, CGSCCUpdateResult &UR)
Definition: PassBuilder.h:860
No-op function pass which does nothing.
Definition: PassBuilder.h:879
PreservedAnalyses run(Function &F, FunctionAnalysisManager &)
Definition: PassBuilder.h:880
No-op loop nest pass which does nothing.
Definition: PassBuilder.h:896
PreservedAnalyses run(LoopNest &L, LoopAnalysisManager &, LoopStandardAnalysisResults &, LPMUpdater &)
Definition: PassBuilder.h:897
No-op loop pass which does nothing.
Definition: PassBuilder.h:904
PreservedAnalyses run(Loop &L, LoopAnalysisManager &, LoopStandardAnalysisResults &, LPMUpdater &)
Definition: PassBuilder.h:905
No-op machine function pass which does nothing.
Definition: PassBuilder.h:913
PreservedAnalyses run(MachineFunction &, MachineFunctionAnalysisManager &)
Definition: PassBuilder.h:914
No-op module pass which does nothing.
Definition: PassBuilder.h:842
PreservedAnalyses run(Module &M, ModuleAnalysisManager &)
Definition: PassBuilder.h:843
A struct to capture parsed pass pipeline names.
Definition: PassBuilder.h:119
std::vector< PipelineElement > InnerPipeline
Definition: PassBuilder.h:121
A CRTP mix-in to automatically provide informational APIs needed for passes.
Definition: PassManager.h:91
A utility pass template to force an analysis result to be available.
Definition: PassManager.h:969