LLVM  12.0.0git
PassManagerBuilder.h
Go to the documentation of this file.
1 // llvm/Transforms/IPO/PassManagerBuilder.h - Build Standard Pass -*- 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 defines the PassManagerBuilder class, which is used to set up a
10 // "standard" optimization sequence suitable for languages like C and C++.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
15 #define LLVM_TRANSFORMS_IPO_PASSMANAGERBUILDER_H
16 
18 #include <functional>
19 #include <memory>
20 #include <string>
21 #include <vector>
22 
23 namespace llvm {
24 class ModuleSummaryIndex;
25 class Pass;
26 class TargetLibraryInfoImpl;
27 class TargetMachine;
28 
29 // The old pass manager infrastructure is hidden in a legacy namespace now.
30 namespace legacy {
32 class PassManagerBase;
33 }
34 
35 /// PassManagerBuilder - This class is used to set up a standard optimization
36 /// sequence for languages like C and C++, allowing some APIs to customize the
37 /// pass sequence in various ways. A simple example of using it would be:
38 ///
39 /// PassManagerBuilder Builder;
40 /// Builder.OptLevel = 2;
41 /// Builder.populateFunctionPassManager(FPM);
42 /// Builder.populateModulePassManager(MPM);
43 ///
44 /// In addition to setting up the basic passes, PassManagerBuilder allows
45 /// frontends to vend a plugin API, where plugins are allowed to add extensions
46 /// to the default pass manager. They do this by specifying where in the pass
47 /// pipeline they want to be added, along with a callback function that adds
48 /// the pass(es). For example, a plugin that wanted to add a loop optimization
49 /// could do something like this:
50 ///
51 /// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
52 /// if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
53 /// PM.add(createMyAwesomePass());
54 /// }
55 /// ...
56 /// Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
57 /// addMyLoopPass);
58 /// ...
60 public:
61  /// Extensions are passed to the builder itself (so they can see how it is
62  /// configured) as well as the pass manager to add stuff to.
63  typedef std::function<void(const PassManagerBuilder &Builder,
66  typedef int GlobalExtensionID;
67 
69  /// EP_EarlyAsPossible - This extension point allows adding passes before
70  /// any other transformations, allowing them to see the code as it is coming
71  /// out of the frontend.
73 
74  /// EP_ModuleOptimizerEarly - This extension point allows adding passes
75  /// just before the main module-level optimization passes.
77 
78  /// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
79  /// the end of the loop optimizer.
81 
82  /// EP_ScalarOptimizerLate - This extension point allows adding optimization
83  /// passes after most of the main optimizations, but before the last
84  /// cleanup-ish optimizations.
86 
87  /// EP_OptimizerLast -- This extension point allows adding passes that
88  /// run after everything else.
90 
91  /// EP_VectorizerStart - This extension point allows adding optimization
92  /// passes before the vectorizer and other highly target specific
93  /// optimization passes are executed.
95 
96  /// EP_EnabledOnOptLevel0 - This extension point allows adding passes that
97  /// should not be disabled by O0 optimization level. The passes will be
98  /// inserted after the inlining pass.
100 
101  /// EP_Peephole - This extension point allows adding passes that perform
102  /// peephole optimizations similar to the instruction combiner. These passes
103  /// will be inserted after each instance of the instruction combiner pass.
105 
106  /// EP_LateLoopOptimizations - This extension point allows adding late loop
107  /// canonicalization and simplification passes. This is the last point in
108  /// the loop optimization pipeline before loop deletion. Each pass added
109  /// here must be an instance of LoopPass.
110  /// This is the place to add passes that can remove loops, such as target-
111  /// specific loop idiom recognition.
113 
114  /// EP_CGSCCOptimizerLate - This extension point allows adding CallGraphSCC
115  /// passes at the end of the main CallGraphSCC passes and before any
116  /// function simplification passes run by CGPassManager.
118 
119  /// EP_FullLinkTimeOptimizationEarly - This extensions point allow adding
120  /// passes that
121  /// run at Link Time, before Full Link Time Optimization.
123 
124  /// EP_FullLinkTimeOptimizationLast - This extensions point allow adding
125  /// passes that
126  /// run at Link Time, after Full Link Time Optimization.
128  };
129 
130  /// The Optimization Level - Specify the basic optimization level.
131  /// 0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
132  unsigned OptLevel;
133 
134  /// SizeLevel - How much we're optimizing for size.
135  /// 0 = none, 1 = -Os, 2 = -Oz
136  unsigned SizeLevel;
137 
138  /// LibraryInfo - Specifies information about the runtime library for the
139  /// optimizer. If this is non-null, it is added to both the function and
140  /// per-module pass pipeline.
142 
143  /// Inliner - Specifies the inliner to use. If this is non-null, it is
144  /// added to the per-module passes.
146 
147  /// The module summary index to use for exporting information from the
148  /// regular LTO phase, for example for the CFI and devirtualization type
149  /// tests.
150  ModuleSummaryIndex *ExportSummary = nullptr;
151 
152  /// The module summary index to use for importing information to the
153  /// thin LTO backends, for example for the CFI and devirtualization type
154  /// tests.
155  const ModuleSummaryIndex *ImportSummary = nullptr;
156 
164  bool NewGVN;
174  unsigned LicmMssaOptCap;
176 
177  /// Enable profile instrumentation pass.
179  /// Enable profile context sensitive instrumentation pass.
181  /// Enable profile context sensitive profile use pass.
183  /// Profile data file name that the instrumentation will be written to.
184  std::string PGOInstrGen;
185  /// Path of the profile data file.
186  std::string PGOInstrUse;
187  /// Path of the sample Profile data file.
188  std::string PGOSampleUse;
189 
190 private:
191  /// ExtensionList - This is list of all of the extensions that are registered.
192  std::vector<std::pair<ExtensionPointTy, ExtensionFn>> Extensions;
193 
194 public:
197  /// Adds an extension that will be used by all PassManagerBuilder instances.
198  /// This is intended to be used by plugins, to register a set of
199  /// optimisations to run automatically.
200  ///
201  /// \returns A global extension identifier that can be used to remove the
202  /// extension.
203  static GlobalExtensionID addGlobalExtension(ExtensionPointTy Ty,
204  ExtensionFn Fn);
205  /// Removes an extension that was previously added using addGlobalExtension.
206  /// This is also intended to be used by plugins, to remove any extension that
207  /// was previously registered before being unloaded.
208  ///
209  /// \param ExtensionID Identifier of the extension to be removed.
210  static void removeGlobalExtension(GlobalExtensionID ExtensionID);
211  void addExtension(ExtensionPointTy Ty, ExtensionFn Fn);
212 
213 private:
214  void addExtensionsToPM(ExtensionPointTy ETy,
215  legacy::PassManagerBase &PM) const;
216  void addInitialAliasAnalysisPasses(legacy::PassManagerBase &PM) const;
217  void addLTOOptimizationPasses(legacy::PassManagerBase &PM);
218  void addLateLTOOptimizationPasses(legacy::PassManagerBase &PM);
219  void addPGOInstrPasses(legacy::PassManagerBase &MPM, bool IsCS);
220  void addFunctionSimplificationPasses(legacy::PassManagerBase &MPM);
221 
222 public:
223  /// populateFunctionPassManager - This fills in the function pass manager,
224  /// which is expected to be run on each function immediately as it is
225  /// generated. The idea is to reduce the size of the IR in memory.
226  void populateFunctionPassManager(legacy::FunctionPassManager &FPM);
227 
228  /// populateModulePassManager - This sets up the primary pass manager.
229  void populateModulePassManager(legacy::PassManagerBase &MPM);
230  void populateLTOPassManager(legacy::PassManagerBase &PM);
231  void populateThinLTOPassManager(legacy::PassManagerBase &PM);
232 };
233 
234 /// Registers a function for adding a standard set of passes. This should be
235 /// used by optimizer plugins to allow all front ends to transparently use
236 /// them. Create a static instance of this class in your plugin, providing a
237 /// private function that the PassManagerBuilder can use to add your passes.
240 
241 public:
244  ExtensionID = PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
245  }
246 
248  // If the collection holding the global extensions is destroyed after the
249  // plugin is unloaded, the extension has to be removed here. Indeed, the
250  // destructor of the ExtensionFn may reference code in the plugin.
252  }
253 };
254 
256  return reinterpret_cast<PassManagerBuilder*>(P);
257 }
258 
260  return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
261 }
262 
263 } // end namespace llvm
264 #endif
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:77
RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty, PassManagerBuilder::ExtensionFn Fn)
PassManagerBuilder - This class is used to set up a standard optimization sequence for languages like...
bool EnablePGOInstrGen
Enable profile instrumentation pass.
This class represents lattice values for constants.
Definition: AllocatorList.h:23
bool EnablePGOCSInstrUse
Enable profile context sensitive profile use pass.
static GlobalExtensionID addGlobalExtension(ExtensionPointTy Ty, ExtensionFn Fn)
Adds an extension that will be used by all PassManagerBuilder instances.
EP_ScalarOptimizerLate - This extension point allows adding optimization passes after most of the mai...
Implementation of the target library information.
std::string PGOSampleUse
Path of the sample Profile data file.
Pass * Inliner
Inliner - Specifies the inliner to use.
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:217
EP_ModuleOptimizerEarly - This extension point allows adding passes just before the main module-level...
bool EnablePGOCSInstrGen
Enable profile context sensitive instrumentation pass.
EP_EnabledOnOptLevel0 - This extension point allows adding passes that should not be disabled by O0 o...
std::function< void(const PassManagerBuilder &Builder, legacy::PassManagerBase &PM)> ExtensionFn
Extensions are passed to the builder itself (so they can see how it is configured) as well as the pas...
unsigned OptLevel
The Optimization Level - Specify the basic optimization level.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
std::string PGOInstrUse
Path of the profile data file.
struct LLVMOpaquePassManagerBuilder * LLVMPassManagerBuilderRef
#define P(N)
TargetLibraryInfoImpl * LibraryInfo
LibraryInfo - Specifies information about the runtime library for the optimizer.
assume Assume Builder
FunctionPassManager manages FunctionPasses.
EP_OptimizerLast – This extension point allows adding passes that run after everything else...
EP_EarlyAsPossible - This extension point allows adding passes before any other transformations, allowing them to see the code as it is coming out of the frontend.
EP_CGSCCOptimizerLate - This extension point allows adding CallGraphSCC passes at the end of the main...
EP_VectorizerStart - This extension point allows adding optimization passes before the vectorizer and...
print lazy value Lazy Value Info Printer Pass
PassManagerBase - An abstract interface to allow code to add passes to a pass manager without having ...
EP_FullLinkTimeOptimizationLast - This extensions point allow adding passes that run at Link Time...
EP_Peephole - This extension point allows adding passes that perform peephole optimizations similar t...
std::string PGOInstrGen
Profile data file name that the instrumentation will be written to.
LLVMAttributeRef wrap(Attribute Attr)
Definition: Attributes.h:212
Registers a function for adding a standard set of passes.
unsigned SizeLevel
SizeLevel - How much we&#39;re optimizing for size.
PassManager< Function > FunctionPassManager
Convenience typedef for a pass manager over functions.
Definition: PassManager.h:580
static void removeGlobalExtension(GlobalExtensionID ExtensionID)
Removes an extension that was previously added using addGlobalExtension.
print Print MemDeps of function
EP_FullLinkTimeOptimizationEarly - This extensions point allow adding passes that run at Link Time...
EP_LateLoopOptimizations - This extension point allows adding late loop canonicalization and simplifi...
EP_LoopOptimizerEnd - This extension point allows adding loop passes to the end of the loop optimizer...