1// llvm/Transforms/IPO/PassManagerBuilder.h - Build Standard Pass -*- C++ -*-=//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the PassManagerBuilder class, which is used to set up a
11// "standard" optimization sequence suitable for languages like C and C++.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
16#define LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
17
18#include <vector>
19
20namespace llvm {
21class TargetLibraryInfo;
22class Pass;
23
24// The old pass manager infrastructure is hidden in a legacy namespace now.
25namespace legacy {
26class PassManagerBase;
27class FunctionPassManager;
28}
29using legacy::PassManagerBase;
30using legacy::FunctionPassManager;
31
32/// PassManagerBuilder - This class is used to set up a standard optimization
33/// sequence for languages like C and C++, allowing some APIs to customize the
34/// pass sequence in various ways. A simple example of using it would be:
35///
36///  PassManagerBuilder Builder;
37///  Builder.OptLevel = 2;
38///  Builder.populateFunctionPassManager(FPM);
39///  Builder.populateModulePassManager(MPM);
40///
41/// In addition to setting up the basic passes, PassManagerBuilder allows
42/// frontends to vend a plugin API, where plugins are allowed to add extensions
43/// to the default pass manager.  They do this by specifying where in the pass
44/// pipeline they want to be added, along with a callback function that adds
45/// the pass(es).  For example, a plugin that wanted to add a loop optimization
46/// could do something like this:
47///
48/// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
49///   if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
50///     PM.add(createMyAwesomePass());
51/// }
52///   ...
53///   Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
54///                        addMyLoopPass);
55///   ...
56class PassManagerBuilder {
57public:
58
59  /// Extensions are passed the builder itself (so they can see how it is
60  /// configured) as well as the pass manager to add stuff to.
61  typedef void (*ExtensionFn)(const PassManagerBuilder &Builder,
62                              PassManagerBase &PM);
63  enum ExtensionPointTy {
64    /// EP_EarlyAsPossible - This extension point allows adding passes before
65    /// any other transformations, allowing them to see the code as it is coming
66    /// out of the frontend.
67    EP_EarlyAsPossible,
68
69    /// EP_ModuleOptimizerEarly - This extension point allows adding passes
70    /// just before the main module-level optimization passes.
71    EP_ModuleOptimizerEarly,
72
73    /// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
74    /// the end of the loop optimizer.
75    EP_LoopOptimizerEnd,
76
77    /// EP_ScalarOptimizerLate - This extension point allows adding optimization
78    /// passes after most of the main optimizations, but before the last
79    /// cleanup-ish optimizations.
80    EP_ScalarOptimizerLate,
81
82    /// EP_OptimizerLast -- This extension point allows adding passes that
83    /// run after everything else.
84    EP_OptimizerLast,
85
86    /// EP_EnabledOnOptLevel0 - This extension point allows adding passes that
87    /// should not be disabled by O0 optimization level. The passes will be
88    /// inserted after the inlining pass.
89    EP_EnabledOnOptLevel0
90  };
91
92  /// The Optimization Level - Specify the basic optimization level.
93  ///    0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
94  unsigned OptLevel;
95
96  /// SizeLevel - How much we're optimizing for size.
97  ///    0 = none, 1 = -Os, 2 = -Oz
98  unsigned SizeLevel;
99
100  /// LibraryInfo - Specifies information about the runtime library for the
101  /// optimizer.  If this is non-null, it is added to both the function and
102  /// per-module pass pipeline.
103  TargetLibraryInfo *LibraryInfo;
104
105  /// Inliner - Specifies the inliner to use.  If this is non-null, it is
106  /// added to the per-module passes.
107  Pass *Inliner;
108
109  bool DisableUnitAtATime;
110  bool DisableUnrollLoops;
111  bool BBVectorize;
112  bool SLPVectorize;
113  bool LoopVectorize;
114  bool LateVectorize;
115  bool RerollLoops;
116
117private:
118  /// ExtensionList - This is list of all of the extensions that are registered.
119  std::vector<std::pair<ExtensionPointTy, ExtensionFn> > Extensions;
120
121public:
122  PassManagerBuilder();
123  ~PassManagerBuilder();
124  /// Adds an extension that will be used by all PassManagerBuilder instances.
125  /// This is intended to be used by plugins, to register a set of
126  /// optimisations to run automatically.
127  static void addGlobalExtension(ExtensionPointTy Ty, ExtensionFn Fn);
128  void addExtension(ExtensionPointTy Ty, ExtensionFn Fn);
129
130private:
131  void addExtensionsToPM(ExtensionPointTy ETy, PassManagerBase &PM) const;
132  void addInitialAliasAnalysisPasses(PassManagerBase &PM) const;
133public:
134
135  /// populateFunctionPassManager - This fills in the function pass manager,
136  /// which is expected to be run on each function immediately as it is
137  /// generated.  The idea is to reduce the size of the IR in memory.
138  void populateFunctionPassManager(FunctionPassManager &FPM);
139
140  /// populateModulePassManager - This sets up the primary pass manager.
141  void populateModulePassManager(PassManagerBase &MPM);
142  void populateLTOPassManager(PassManagerBase &PM, bool Internalize,
143                              bool RunInliner, bool DisableGVNLoadPRE = false);
144};
145
146/// Registers a function for adding a standard set of passes.  This should be
147/// used by optimizer plugins to allow all front ends to transparently use
148/// them.  Create a static instance of this class in your plugin, providing a
149/// private function that the PassManagerBuilder can use to add your passes.
150struct RegisterStandardPasses {
151  RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty,
152                         PassManagerBuilder::ExtensionFn Fn) {
153    PassManagerBuilder::addGlobalExtension(Ty, Fn);
154  }
155};
156
157} // end namespace llvm
158#endif
159