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
17 #include "llvm-c/Transforms/PassManagerBuilder.h"
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 {
31 class FunctionPassManager;
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 /// ...
59 class PassManagerBuilder {
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,
64 legacy::PassManagerBase &PM)>
65 ExtensionFn;
66 typedef int GlobalExtensionID;
67
68 enum ExtensionPointTy {
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.
72 EP_EarlyAsPossible,
73
74 /// EP_ModuleOptimizerEarly - This extension point allows adding passes
75 /// just before the main module-level optimization passes.
76 EP_ModuleOptimizerEarly,
77
78 /// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
79 /// the end of the loop optimizer.
80 EP_LoopOptimizerEnd,
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.
85 EP_ScalarOptimizerLate,
86
87 /// EP_OptimizerLast -- This extension point allows adding passes that
88 /// run after everything else.
89 EP_OptimizerLast,
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.
94 EP_VectorizerStart,
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.
99 EP_EnabledOnOptLevel0,
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.
104 EP_Peephole,
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.
112 EP_LateLoopOptimizations,
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.
117 EP_CGSCCOptimizerLate,
118
119 /// EP_FullLinkTimeOptimizationEarly - This extensions point allow adding
120 /// passes that
121 /// run at Link Time, before Full Link Time Optimization.
122 EP_FullLinkTimeOptimizationEarly,
123
124 /// EP_FullLinkTimeOptimizationLast - This extensions point allow adding
125 /// passes that
126 /// run at Link Time, after Full Link Time Optimization.
127 EP_FullLinkTimeOptimizationLast,
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.
141 TargetLibraryInfoImpl *LibraryInfo;
142
143 /// Inliner - Specifies the inliner to use. If this is non-null, it is
144 /// added to the per-module passes.
145 Pass *Inliner;
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
157 bool DisableUnrollLoops;
158 bool CallGraphProfile;
159 bool SLPVectorize;
160 bool LoopVectorize;
161 bool LoopsInterleaved;
162 bool RerollLoops;
163 bool NewGVN;
164 bool DisableGVNLoadPRE;
165 bool ForgetAllSCEVInLoopUnroll;
166 bool VerifyInput;
167 bool VerifyOutput;
168 bool MergeFunctions;
169 bool PrepareForLTO;
170 bool PrepareForThinLTO;
171 bool PerformThinLTO;
172 bool DivergentTarget;
173 unsigned LicmMssaOptCap;
174 unsigned LicmMssaNoAccForPromotionCap;
175
176 /// Enable profile instrumentation pass.
177 bool EnablePGOInstrGen;
178 /// Enable profile context sensitive instrumentation pass.
179 bool EnablePGOCSInstrGen;
180 /// Enable profile context sensitive profile use pass.
181 bool EnablePGOCSInstrUse;
182 /// Profile data file name that the instrumentation will be written to.
183 std::string PGOInstrGen;
184 /// Path of the profile data file.
185 std::string PGOInstrUse;
186 /// Path of the sample Profile data file.
187 std::string PGOSampleUse;
188
189 private:
190 /// ExtensionList - This is list of all of the extensions that are registered.
191 std::vector<std::pair<ExtensionPointTy, ExtensionFn>> Extensions;
192
193 public:
194 PassManagerBuilder();
195 ~PassManagerBuilder();
196 /// Adds an extension that will be used by all PassManagerBuilder instances.
197 /// This is intended to be used by plugins, to register a set of
198 /// optimisations to run automatically.
199 ///
200 /// \returns A global extension identifier that can be used to remove the
201 /// extension.
202 static GlobalExtensionID addGlobalExtension(ExtensionPointTy Ty,
203 ExtensionFn Fn);
204 /// Removes an extension that was previously added using addGlobalExtension.
205 /// This is also intended to be used by plugins, to remove any extension that
206 /// was previously registered before being unloaded.
207 ///
208 /// \param ExtensionID Identifier of the extension to be removed.
209 static void removeGlobalExtension(GlobalExtensionID ExtensionID);
210 void addExtension(ExtensionPointTy Ty, ExtensionFn Fn);
211
212 private:
213 void addExtensionsToPM(ExtensionPointTy ETy,
214 legacy::PassManagerBase &PM) const;
215 void addInitialAliasAnalysisPasses(legacy::PassManagerBase &PM) const;
216 void addLTOOptimizationPasses(legacy::PassManagerBase &PM);
217 void addLateLTOOptimizationPasses(legacy::PassManagerBase &PM);
218 void addPGOInstrPasses(legacy::PassManagerBase &MPM, bool IsCS);
219 void addFunctionSimplificationPasses(legacy::PassManagerBase &MPM);
220 void addVectorPasses(legacy::PassManagerBase &PM, bool IsFullLTO);
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.
238 class RegisterStandardPasses {
239 PassManagerBuilder::GlobalExtensionID ExtensionID;
240
241 public:
RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty,PassManagerBuilder::ExtensionFn Fn)242 RegisterStandardPasses(PassManagerBuilder::ExtensionPointTy Ty,
243 PassManagerBuilder::ExtensionFn Fn) {
244 ExtensionID = PassManagerBuilder::addGlobalExtension(Ty, std::move(Fn));
245 }
246
~RegisterStandardPasses()247 ~RegisterStandardPasses() {
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.
251 PassManagerBuilder::removeGlobalExtension(ExtensionID);
252 }
253 };
254
unwrap(LLVMPassManagerBuilderRef P)255 inline PassManagerBuilder *unwrap(LLVMPassManagerBuilderRef P) {
256 return reinterpret_cast<PassManagerBuilder*>(P);
257 }
258
wrap(PassManagerBuilder * P)259 inline LLVMPassManagerBuilderRef wrap(PassManagerBuilder *P) {
260 return reinterpret_cast<LLVMPassManagerBuilderRef>(P);
261 }
262
263 } // end namespace llvm
264 #endif
265