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