1 //===-- llvm/Support/StandardPasses.h - Standard pass lists -----*- 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 utility functions for creating a "standard" set of
11 // optimization passes, so that compilers and tools which use optimization
12 // passes use the same set of standard passes.
14 // These are implemented as inline functions so that we do not have to worry
17 //===----------------------------------------------------------------------===//
19 #ifndef LLVM_SUPPORT_STANDARDPASSES_H
20 #define LLVM_SUPPORT_STANDARDPASSES_H
22 #include "llvm/PassManager.h"
23 #include "llvm/Analysis/Dominators.h"
24 #include "llvm/Analysis/Passes.h"
25 #include "llvm/Analysis/Verifier.h"
26 #include "llvm/Transforms/Scalar.h"
27 #include "llvm/Transforms/IPO.h"
30 /// createStandardFunctionPasses - Add the standard list of function passes to
31 /// the provided pass manager.
33 /// \arg OptimizationLevel - The optimization level, corresponding to -O0,
35 static inline void createStandardFunctionPasses(PassManagerBase *PM,
36 unsigned OptimizationLevel);
38 /// createStandardModulePasses - Add the standard list of module passes to the
39 /// provided pass manager.
41 /// \arg OptimizationLevel - The optimization level, corresponding to -O0,
43 /// \arg OptimizeSize - Whether the transformations should optimize for size.
44 /// \arg UnitAtATime - Allow passes which may make global module changes.
45 /// \arg UnrollLoops - Allow loop unrolling.
46 /// \arg SimplifyLibCalls - Allow library calls to be simplified.
47 /// \arg HaveExceptions - Whether the module may have code using exceptions.
48 /// \arg InliningPass - The inlining pass to use, if any, or null. This will
49 /// always be added, even at -O0.a
50 static inline void createStandardModulePasses(PassManagerBase *PM,
51 unsigned OptimizationLevel,
55 bool SimplifyLibCalls,
59 /// createStandardLTOPasses - Add the standard list of module passes suitable
60 /// for link time optimization.
62 /// Internalize - Run the internalize pass.
63 /// RunInliner - Use a function inlining pass.
64 /// VerifyEach - Run the verifier after each pass.
65 static inline void createStandardLTOPasses(PassManagerBase *PM,
72 static inline void createStandardAliasAnalysisPasses(PassManagerBase *PM) {
73 // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
74 // BasicAliasAnalysis wins if they disagree. This is intended to help
75 // support "obvious" type-punning idioms.
76 PM->add(createTypeBasedAliasAnalysisPass());
77 PM->add(createBasicAliasAnalysisPass());
80 static inline void createStandardFunctionPasses(PassManagerBase *PM,
81 unsigned OptimizationLevel) {
82 if (OptimizationLevel > 0) {
83 createStandardAliasAnalysisPasses(PM);
84 PM->add(createCFGSimplificationPass());
85 if (OptimizationLevel == 1)
86 PM->add(createPromoteMemoryToRegisterPass());
88 PM->add(createScalarReplAggregatesPass());
89 PM->add(createInstructionCombiningPass());
93 /// createStandardModulePasses - Add the standard module passes. This is
94 /// expected to be run after the standard function passes.
95 static inline void createStandardModulePasses(PassManagerBase *PM,
96 unsigned OptimizationLevel,
100 bool SimplifyLibCalls,
102 Pass *InliningPass) {
103 createStandardAliasAnalysisPasses(PM);
105 if (OptimizationLevel == 0) {
107 PM->add(InliningPass);
112 PM->add(createGlobalOptimizerPass()); // Optimize out global vars
114 PM->add(createIPSCCPPass()); // IP SCCP
115 PM->add(createDeadArgEliminationPass()); // Dead argument elimination
117 PM->add(createInstructionCombiningPass()); // Clean up after IPCP & DAE
118 PM->add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
120 // Start of CallGraph SCC passes.
121 if (UnitAtATime && HaveExceptions)
122 PM->add(createPruneEHPass()); // Remove dead EH info
124 PM->add(InliningPass);
126 PM->add(createFunctionAttrsPass()); // Set readonly/readnone attrs
127 if (OptimizationLevel > 2)
128 PM->add(createArgumentPromotionPass()); // Scalarize uninlined fn args
130 // Start of function pass.
131 PM->add(createScalarReplAggregatesPass()); // Break up aggregate allocas
132 if (SimplifyLibCalls)
133 PM->add(createSimplifyLibCallsPass()); // Library Call Optimizations
134 PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
135 PM->add(createJumpThreadingPass()); // Thread jumps.
136 PM->add(createCorrelatedValuePropagationPass()); // Propagate conditionals
137 PM->add(createCFGSimplificationPass()); // Merge & remove BBs
138 PM->add(createInstructionCombiningPass()); // Combine silly seq's
140 PM->add(createTailCallEliminationPass()); // Eliminate tail calls
141 PM->add(createCFGSimplificationPass()); // Merge & remove BBs
142 PM->add(createReassociatePass()); // Reassociate expressions
143 PM->add(createLoopRotatePass()); // Rotate Loop
144 PM->add(createLICMPass()); // Hoist loop invariants
145 PM->add(createLoopUnswitchPass(OptimizeSize || OptimizationLevel < 3));
146 PM->add(createInstructionCombiningPass());
147 PM->add(createIndVarSimplifyPass()); // Canonicalize indvars
148 PM->add(createLoopDeletionPass()); // Delete dead loops
150 PM->add(createLoopUnrollPass()); // Unroll small loops
151 PM->add(createInstructionCombiningPass()); // Clean up after the unroller
152 if (OptimizationLevel > 1)
153 PM->add(createGVNPass()); // Remove redundancies
154 PM->add(createMemCpyOptPass()); // Remove memcpy / form memset
155 PM->add(createSCCPPass()); // Constant prop with SCCP
157 // Run instcombine after redundancy elimination to exploit opportunities
158 // opened up by them.
159 PM->add(createInstructionCombiningPass());
160 PM->add(createJumpThreadingPass()); // Thread jumps
161 PM->add(createCorrelatedValuePropagationPass());
162 PM->add(createDeadStoreEliminationPass()); // Delete dead stores
163 PM->add(createAggressiveDCEPass()); // Delete dead instructions
164 PM->add(createCFGSimplificationPass()); // Merge & remove BBs
167 PM->add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
168 PM->add(createDeadTypeEliminationPass()); // Eliminate dead types
170 // GlobalOpt already deletes dead functions and globals, at -O3 try a
171 // late pass of GlobalDCE. It is capable of deleting dead cycles.
172 if (OptimizationLevel > 2)
173 PM->add(createGlobalDCEPass()); // Remove dead fns and globals.
175 if (OptimizationLevel > 1)
176 PM->add(createConstantMergePass()); // Merge dup global constants
180 static inline void addOnePass(PassManagerBase *PM, Pass *P, bool AndVerify) {
184 PM->add(createVerifierPass());
187 static inline void createStandardLTOPasses(PassManagerBase *PM,
191 // Provide AliasAnalysis services for optimizations.
192 createStandardAliasAnalysisPasses(PM);
194 // Now that composite has been compiled, scan through the module, looking
195 // for a main function. If main is defined, mark all other functions
198 addOnePass(PM, createInternalizePass(true), VerifyEach);
200 // Propagate constants at call sites into the functions they call. This
201 // opens opportunities for globalopt (and inlining) by substituting function
202 // pointers passed as arguments to direct uses of functions.
203 addOnePass(PM, createIPSCCPPass(), VerifyEach);
205 // Now that we internalized some globals, see if we can hack on them!
206 addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
208 // Linking modules together can lead to duplicated global constants, only
209 // keep one copy of each constant...
210 addOnePass(PM, createConstantMergePass(), VerifyEach);
212 // Remove unused arguments from functions...
213 addOnePass(PM, createDeadArgEliminationPass(), VerifyEach);
215 // Reduce the code after globalopt and ipsccp. Both can open up significant
216 // simplification opportunities, and both can propagate functions through
217 // function pointers. When this happens, we often have to resolve varargs
218 // calls, etc, so let instcombine do this.
219 addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
221 // Inline small functions
223 addOnePass(PM, createFunctionInliningPass(), VerifyEach);
225 addOnePass(PM, createPruneEHPass(), VerifyEach); // Remove dead EH info.
226 // Optimize globals again if we ran the inliner.
228 addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
229 addOnePass(PM, createGlobalDCEPass(), VerifyEach); // Remove dead functions.
231 // If we didn't decide to inline a function, check to see if we can
232 // transform it to pass arguments by value instead of by reference.
233 addOnePass(PM, createArgumentPromotionPass(), VerifyEach);
235 // The IPO passes may leave cruft around. Clean up after them.
236 addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
237 addOnePass(PM, createJumpThreadingPass(), VerifyEach);
239 addOnePass(PM, createScalarReplAggregatesPass(), VerifyEach);
241 // Run a few AA driven optimizations here and now, to cleanup the code.
242 addOnePass(PM, createFunctionAttrsPass(), VerifyEach); // Add nocapture.
243 addOnePass(PM, createGlobalsModRefPass(), VerifyEach); // IP alias analysis.
245 addOnePass(PM, createLICMPass(), VerifyEach); // Hoist loop invariants.
246 addOnePass(PM, createGVNPass(), VerifyEach); // Remove redundancies.
247 addOnePass(PM, createMemCpyOptPass(), VerifyEach); // Remove dead memcpys.
249 addOnePass(PM, createDeadStoreEliminationPass(), VerifyEach);
251 // Cleanup and simplify the code after the scalar optimizations.
252 addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
254 addOnePass(PM, createJumpThreadingPass(), VerifyEach);
256 // Delete basic blocks, which optimization passes may have killed.
257 addOnePass(PM, createCFGSimplificationPass(), VerifyEach);
259 // Now that we have optimized the program, discard unreachable functions.
260 addOnePass(PM, createGlobalDCEPass(), VerifyEach);