1 //===-- llvm/Support/PassManagerBuilder.h - Build Standard Pass -*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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++.
13 // These are implemented as inline functions so that we do not have to worry
16 //===----------------------------------------------------------------------===//
18 #ifndef LLVM_SUPPORT_PASSMANAGERBUILDER_H
19 #define LLVM_SUPPORT_PASSMANAGERBUILDER_H
21 #include "llvm/PassManager.h"
22 #include "llvm/DefaultPasses.h"
23 #include "llvm/Analysis/Passes.h"
24 #include "llvm/Analysis/Verifier.h"
25 #include "llvm/Target/TargetLibraryInfo.h"
26 #include "llvm/Transforms/Scalar.h"
27 #include "llvm/Transforms/IPO.h"
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:
35 /// PassManagerBuilder Builder;
36 /// Builder.OptLevel = 2;
37 /// Builder.populateFunctionPassManager(FPM);
38 /// Builder.populateModulePassManager(MPM);
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:
47 /// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
48 /// if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
49 /// PM.add(createMyAwesomePass());
52 /// Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
55 class PassManagerBuilder {
58 /// Extensions are passed the builder itself (so they can see how it is
59 /// configured) as well as the pass manager to add stuff to.
60 typedef void (*ExtensionFn)(const PassManagerBuilder &Builder,
62 enum ExtensionPointTy {
63 /// EP_EarlyAsPossible - This extension point allows adding passes before
64 /// any other transformations, allowing them to see the code as it is coming
65 /// out of the frontend.
68 /// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
69 /// the end of the loop optimizer.
72 /// EP_ScalarOptimizerLate - This extension point allows adding optimization
73 /// passes after most of the main optimizations, but before the last
74 /// cleanup-ish optimizations.
75 EP_ScalarOptimizerLate
78 /// The Optimization Level - Specify the basic optimization level.
79 /// 0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
82 /// SizeLevel - How much we're optimizing for size.
83 /// 0 = none, 1 = -Os, 2 = -Oz
86 /// LibraryInfo - Specifies information about the runtime library for the
87 /// optimizer. If this is non-null, it is added to both the function and
88 /// per-module pass pipeline.
89 TargetLibraryInfo *LibraryInfo;
91 /// Inliner - Specifies the inliner to use. If this is non-null, it is
92 /// added to the per-module passes.
95 bool DisableSimplifyLibCalls;
96 bool DisableUnitAtATime;
97 bool DisableUnrollLoops;
100 /// ExtensionList - This is list of all of the extensions that are registered.
101 std::vector<std::pair<ExtensionPointTy, ExtensionFn> > Extensions;
104 PassManagerBuilder() {
109 DisableSimplifyLibCalls = false;
110 DisableUnitAtATime = false;
111 DisableUnrollLoops = false;
114 ~PassManagerBuilder() {
119 void addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
120 Extensions.push_back(std::make_pair(Ty, Fn));
124 void addExtensionsToPM(ExtensionPointTy ETy, PassManagerBase &PM) const {
125 for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
126 if (Extensions[i].first == ETy)
127 Extensions[i].second(*this, PM);
130 void addInitialAliasAnalysisPasses(PassManagerBase &PM) const {
131 // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
132 // BasicAliasAnalysis wins if they disagree. This is intended to help
133 // support "obvious" type-punning idioms.
134 PM.add(createTypeBasedAliasAnalysisPass());
135 PM.add(createBasicAliasAnalysisPass());
139 /// populateFunctionPassManager - This fills in the function pass manager,
140 /// which is expected to be run on each function immediately as it is
141 /// generated. The idea is to reduce the size of the IR in memory.
142 void populateFunctionPassManager(FunctionPassManager &FPM) {
143 addExtensionsToPM(EP_EarlyAsPossible, FPM);
145 // Add LibraryInfo if we have some.
146 if (LibraryInfo) FPM.add(new TargetLibraryInfo(*LibraryInfo));
148 if (OptLevel == 0) return;
150 addInitialAliasAnalysisPasses(FPM);
152 FPM.add(createCFGSimplificationPass());
153 FPM.add(createScalarReplAggregatesPass());
154 FPM.add(createEarlyCSEPass());
157 /// populateModulePassManager - This sets up the primary pass manager.
158 void populateModulePassManager(PassManagerBase &MPM) {
159 // If all optimizations are disabled, just run the always-inline pass.
168 // Add LibraryInfo if we have some.
169 if (LibraryInfo) MPM.add(new TargetLibraryInfo(*LibraryInfo));
171 addInitialAliasAnalysisPasses(MPM);
173 if (!DisableUnitAtATime) {
174 MPM.add(createGlobalOptimizerPass()); // Optimize out global vars
176 MPM.add(createIPSCCPPass()); // IP SCCP
177 MPM.add(createDeadArgEliminationPass()); // Dead argument elimination
179 MPM.add(createInstructionCombiningPass());// Clean up after IPCP & DAE
180 MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
183 // Start of CallGraph SCC passes.
184 if (!DisableUnitAtATime)
185 MPM.add(createPruneEHPass()); // Remove dead EH info
190 if (!DisableUnitAtATime)
191 MPM.add(createFunctionAttrsPass()); // Set readonly/readnone attrs
193 MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args
195 // Start of function pass.
196 // Break up aggregate allocas, using SSAUpdater.
197 MPM.add(createScalarReplAggregatesPass(-1, false));
198 MPM.add(createEarlyCSEPass()); // Catch trivial redundancies
199 if (!DisableSimplifyLibCalls)
200 MPM.add(createSimplifyLibCallsPass()); // Library Call Optimizations
201 MPM.add(createJumpThreadingPass()); // Thread jumps.
202 MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
203 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
204 MPM.add(createInstructionCombiningPass()); // Combine silly seq's
206 MPM.add(createTailCallEliminationPass()); // Eliminate tail calls
207 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
208 MPM.add(createReassociatePass()); // Reassociate expressions
209 MPM.add(createLoopRotatePass()); // Rotate Loop
210 MPM.add(createLICMPass()); // Hoist loop invariants
211 MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
212 MPM.add(createInstructionCombiningPass());
213 MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars
214 MPM.add(createLoopIdiomPass()); // Recognize idioms like memset.
215 MPM.add(createLoopDeletionPass()); // Delete dead loops
216 if (!DisableUnrollLoops)
217 MPM.add(createLoopUnrollPass()); // Unroll small loops
218 addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
221 MPM.add(createGVNPass()); // Remove redundancies
222 MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset
223 MPM.add(createSCCPPass()); // Constant prop with SCCP
225 // Run instcombine after redundancy elimination to exploit opportunities
226 // opened up by them.
227 MPM.add(createInstructionCombiningPass());
228 MPM.add(createJumpThreadingPass()); // Thread jumps
229 MPM.add(createCorrelatedValuePropagationPass());
230 MPM.add(createDeadStoreEliminationPass()); // Delete dead stores
232 addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
234 MPM.add(createAggressiveDCEPass()); // Delete dead instructions
235 MPM.add(createCFGSimplificationPass()); // Merge & remove BBs
236 MPM.add(createInstructionCombiningPass()); // Clean up after everything.
238 if (!DisableUnitAtATime) {
239 MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
240 MPM.add(createDeadTypeEliminationPass()); // Eliminate dead types
242 // GlobalOpt already deletes dead functions and globals, at -O3 try a
243 // late pass of GlobalDCE. It is capable of deleting dead cycles.
245 MPM.add(createGlobalDCEPass()); // Remove dead fns and globals.
248 MPM.add(createConstantMergePass()); // Merge dup global constants
252 void populateLTOPassManager(PassManagerBase &PM, bool Internalize,
254 // Provide AliasAnalysis services for optimizations.
255 addInitialAliasAnalysisPasses(PM);
257 // Now that composite has been compiled, scan through the module, looking
258 // for a main function. If main is defined, mark all other functions
261 PM.add(createInternalizePass(true));
263 // Propagate constants at call sites into the functions they call. This
264 // opens opportunities for globalopt (and inlining) by substituting function
265 // pointers passed as arguments to direct uses of functions.
266 PM.add(createIPSCCPPass());
268 // Now that we internalized some globals, see if we can hack on them!
269 PM.add(createGlobalOptimizerPass());
271 // Linking modules together can lead to duplicated global constants, only
272 // keep one copy of each constant.
273 PM.add(createConstantMergePass());
275 // Remove unused arguments from functions.
276 PM.add(createDeadArgEliminationPass());
278 // Reduce the code after globalopt and ipsccp. Both can open up significant
279 // simplification opportunities, and both can propagate functions through
280 // function pointers. When this happens, we often have to resolve varargs
281 // calls, etc, so let instcombine do this.
282 PM.add(createInstructionCombiningPass());
284 // Inline small functions
286 PM.add(createFunctionInliningPass());
288 PM.add(createPruneEHPass()); // Remove dead EH info.
290 // Optimize globals again if we ran the inliner.
292 PM.add(createGlobalOptimizerPass());
293 PM.add(createGlobalDCEPass()); // Remove dead functions.
295 // If we didn't decide to inline a function, check to see if we can
296 // transform it to pass arguments by value instead of by reference.
297 PM.add(createArgumentPromotionPass());
299 // The IPO passes may leave cruft around. Clean up after them.
300 PM.add(createInstructionCombiningPass());
301 PM.add(createJumpThreadingPass());
303 PM.add(createScalarReplAggregatesPass());
305 // Run a few AA driven optimizations here and now, to cleanup the code.
306 PM.add(createFunctionAttrsPass()); // Add nocapture.
307 PM.add(createGlobalsModRefPass()); // IP alias analysis.
309 PM.add(createLICMPass()); // Hoist loop invariants.
310 PM.add(createGVNPass()); // Remove redundancies.
311 PM.add(createMemCpyOptPass()); // Remove dead memcpys.
313 PM.add(createDeadStoreEliminationPass());
315 // Cleanup and simplify the code after the scalar optimizations.
316 PM.add(createInstructionCombiningPass());
318 PM.add(createJumpThreadingPass());
320 // Delete basic blocks, which optimization passes may have killed.
321 PM.add(createCFGSimplificationPass());
323 // Now that we have optimized the program, discard unreachable functions.
324 PM.add(createGlobalDCEPass());
329 } // end namespace llvm