• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- PassManagerBuilder.cpp - Build Standard Pass -----------------------===//
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 
16 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
17 
18 #include "llvm-c/Transforms/PassManagerBuilder.h"
19 
20 #include "llvm/PassManager.h"
21 #include "llvm/DefaultPasses.h"
22 #include "llvm/PassManager.h"
23 #include "llvm/Analysis/Passes.h"
24 #include "llvm/Analysis/Verifier.h"
25 #include "llvm/Support/CommandLine.h"
26 #include "llvm/Target/TargetLibraryInfo.h"
27 #include "llvm/Transforms/Scalar.h"
28 #include "llvm/Transforms/Vectorize.h"
29 #include "llvm/Transforms/IPO.h"
30 #include "llvm/ADT/SmallVector.h"
31 #include "llvm/Support/ManagedStatic.h"
32 
33 using namespace llvm;
34 
35 static cl::opt<bool>
36 RunVectorization("vectorize", cl::desc("Run vectorization passes"));
37 
38 static cl::opt<bool>
39 UseGVNAfterVectorization("use-gvn-after-vectorization",
40   cl::init(false), cl::Hidden,
41   cl::desc("Run GVN instead of Early CSE after vectorization passes"));
42 
PassManagerBuilder()43 PassManagerBuilder::PassManagerBuilder() {
44     OptLevel = 2;
45     SizeLevel = 0;
46     LibraryInfo = 0;
47     Inliner = 0;
48     DisableSimplifyLibCalls = false;
49     DisableUnitAtATime = false;
50     DisableUnrollLoops = false;
51     Vectorize = RunVectorization;
52 }
53 
~PassManagerBuilder()54 PassManagerBuilder::~PassManagerBuilder() {
55   delete LibraryInfo;
56   delete Inliner;
57 }
58 
59 /// Set of global extensions, automatically added as part of the standard set.
60 static ManagedStatic<SmallVector<std::pair<PassManagerBuilder::ExtensionPointTy,
61    PassManagerBuilder::ExtensionFn>, 8> > GlobalExtensions;
62 
addGlobalExtension(PassManagerBuilder::ExtensionPointTy Ty,PassManagerBuilder::ExtensionFn Fn)63 void PassManagerBuilder::addGlobalExtension(
64     PassManagerBuilder::ExtensionPointTy Ty,
65     PassManagerBuilder::ExtensionFn Fn) {
66   GlobalExtensions->push_back(std::make_pair(Ty, Fn));
67 }
68 
addExtension(ExtensionPointTy Ty,ExtensionFn Fn)69 void PassManagerBuilder::addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
70   Extensions.push_back(std::make_pair(Ty, Fn));
71 }
72 
addExtensionsToPM(ExtensionPointTy ETy,PassManagerBase & PM) const73 void PassManagerBuilder::addExtensionsToPM(ExtensionPointTy ETy,
74                                            PassManagerBase &PM) const {
75   for (unsigned i = 0, e = GlobalExtensions->size(); i != e; ++i)
76     if ((*GlobalExtensions)[i].first == ETy)
77       (*GlobalExtensions)[i].second(*this, PM);
78   for (unsigned i = 0, e = Extensions.size(); i != e; ++i)
79     if (Extensions[i].first == ETy)
80       Extensions[i].second(*this, PM);
81 }
82 
83 void
addInitialAliasAnalysisPasses(PassManagerBase & PM) const84 PassManagerBuilder::addInitialAliasAnalysisPasses(PassManagerBase &PM) const {
85   // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
86   // BasicAliasAnalysis wins if they disagree. This is intended to help
87   // support "obvious" type-punning idioms.
88   PM.add(createTypeBasedAliasAnalysisPass());
89   PM.add(createBasicAliasAnalysisPass());
90 }
91 
populateFunctionPassManager(FunctionPassManager & FPM)92 void PassManagerBuilder::populateFunctionPassManager(FunctionPassManager &FPM) {
93   addExtensionsToPM(EP_EarlyAsPossible, FPM);
94 
95   // Add LibraryInfo if we have some.
96   if (LibraryInfo) FPM.add(new TargetLibraryInfo(*LibraryInfo));
97 
98   if (OptLevel == 0) return;
99 
100   addInitialAliasAnalysisPasses(FPM);
101 
102   FPM.add(createCFGSimplificationPass());
103   FPM.add(createScalarReplAggregatesPass());
104   FPM.add(createEarlyCSEPass());
105   FPM.add(createLowerExpectIntrinsicPass());
106 }
107 
populateModulePassManager(PassManagerBase & MPM)108 void PassManagerBuilder::populateModulePassManager(PassManagerBase &MPM) {
109   // If all optimizations are disabled, just run the always-inline pass.
110   if (OptLevel == 0) {
111     if (Inliner) {
112       MPM.add(Inliner);
113       Inliner = 0;
114     }
115     addExtensionsToPM(EP_EnabledOnOptLevel0, MPM);
116     return;
117   }
118 
119   // Add LibraryInfo if we have some.
120   if (LibraryInfo) MPM.add(new TargetLibraryInfo(*LibraryInfo));
121 
122   addInitialAliasAnalysisPasses(MPM);
123 
124   if (!DisableUnitAtATime) {
125     addExtensionsToPM(EP_ModuleOptimizerEarly, MPM);
126 
127     MPM.add(createGlobalOptimizerPass());     // Optimize out global vars
128 
129     MPM.add(createIPSCCPPass());              // IP SCCP
130     MPM.add(createDeadArgEliminationPass());  // Dead argument elimination
131 
132     MPM.add(createInstructionCombiningPass());// Clean up after IPCP & DAE
133     MPM.add(createCFGSimplificationPass());   // Clean up after IPCP & DAE
134   }
135 
136   // Start of CallGraph SCC passes.
137   if (!DisableUnitAtATime)
138     MPM.add(createPruneEHPass());             // Remove dead EH info
139   if (Inliner) {
140     MPM.add(Inliner);
141     Inliner = 0;
142   }
143   if (!DisableUnitAtATime)
144     MPM.add(createFunctionAttrsPass());       // Set readonly/readnone attrs
145   if (OptLevel > 2)
146     MPM.add(createArgumentPromotionPass());   // Scalarize uninlined fn args
147 
148   // Start of function pass.
149   // Break up aggregate allocas, using SSAUpdater.
150   MPM.add(createScalarReplAggregatesPass(-1, false));
151   MPM.add(createEarlyCSEPass());              // Catch trivial redundancies
152   if (!DisableSimplifyLibCalls)
153     MPM.add(createSimplifyLibCallsPass());    // Library Call Optimizations
154   MPM.add(createJumpThreadingPass());         // Thread jumps.
155   MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
156   MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
157   MPM.add(createInstructionCombiningPass());  // Combine silly seq's
158 
159   MPM.add(createTailCallEliminationPass());   // Eliminate tail calls
160   MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
161   MPM.add(createReassociatePass());           // Reassociate expressions
162   MPM.add(createLoopRotatePass());            // Rotate Loop
163   MPM.add(createLICMPass());                  // Hoist loop invariants
164   MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
165   MPM.add(createInstructionCombiningPass());
166   MPM.add(createIndVarSimplifyPass());        // Canonicalize indvars
167   MPM.add(createLoopIdiomPass());             // Recognize idioms like memset.
168   MPM.add(createLoopDeletionPass());          // Delete dead loops
169   if (!DisableUnrollLoops)
170     MPM.add(createLoopUnrollPass());          // Unroll small loops
171   addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
172 
173   if (OptLevel > 1)
174     MPM.add(createGVNPass());                 // Remove redundancies
175   MPM.add(createMemCpyOptPass());             // Remove memcpy / form memset
176   MPM.add(createSCCPPass());                  // Constant prop with SCCP
177 
178   // Run instcombine after redundancy elimination to exploit opportunities
179   // opened up by them.
180   MPM.add(createInstructionCombiningPass());
181   MPM.add(createJumpThreadingPass());         // Thread jumps
182   MPM.add(createCorrelatedValuePropagationPass());
183   MPM.add(createDeadStoreEliminationPass());  // Delete dead stores
184 
185   addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
186 
187   if (Vectorize) {
188     MPM.add(createBBVectorizePass());
189     MPM.add(createInstructionCombiningPass());
190     if (OptLevel > 1 && UseGVNAfterVectorization)
191       MPM.add(createGVNPass());                   // Remove redundancies
192     else
193       MPM.add(createEarlyCSEPass());              // Catch trivial redundancies
194   }
195 
196   MPM.add(createAggressiveDCEPass());         // Delete dead instructions
197   MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
198   MPM.add(createInstructionCombiningPass());  // Clean up after everything.
199 
200   if (!DisableUnitAtATime) {
201     // FIXME: We shouldn't bother with this anymore.
202     MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
203 
204     // GlobalOpt already deletes dead functions and globals, at -O3 try a
205     // late pass of GlobalDCE.  It is capable of deleting dead cycles.
206     if (OptLevel > 2)
207       MPM.add(createGlobalDCEPass());         // Remove dead fns and globals.
208 
209     if (OptLevel > 1)
210       MPM.add(createConstantMergePass());     // Merge dup global constants
211   }
212   addExtensionsToPM(EP_OptimizerLast, MPM);
213 }
214 
populateLTOPassManager(PassManagerBase & PM,bool Internalize,bool RunInliner,bool DisableGVNLoadPRE)215 void PassManagerBuilder::populateLTOPassManager(PassManagerBase &PM,
216                                                 bool Internalize,
217                                                 bool RunInliner,
218                                                 bool DisableGVNLoadPRE) {
219   // Provide AliasAnalysis services for optimizations.
220   addInitialAliasAnalysisPasses(PM);
221 
222   // Now that composite has been compiled, scan through the module, looking
223   // for a main function.  If main is defined, mark all other functions
224   // internal.
225   if (Internalize)
226     PM.add(createInternalizePass(true));
227 
228   // Propagate constants at call sites into the functions they call.  This
229   // opens opportunities for globalopt (and inlining) by substituting function
230   // pointers passed as arguments to direct uses of functions.
231   PM.add(createIPSCCPPass());
232 
233   // Now that we internalized some globals, see if we can hack on them!
234   PM.add(createGlobalOptimizerPass());
235 
236   // Linking modules together can lead to duplicated global constants, only
237   // keep one copy of each constant.
238   PM.add(createConstantMergePass());
239 
240   // Remove unused arguments from functions.
241   PM.add(createDeadArgEliminationPass());
242 
243   // Reduce the code after globalopt and ipsccp.  Both can open up significant
244   // simplification opportunities, and both can propagate functions through
245   // function pointers.  When this happens, we often have to resolve varargs
246   // calls, etc, so let instcombine do this.
247   PM.add(createInstructionCombiningPass());
248 
249   // Inline small functions
250   if (RunInliner)
251     PM.add(createFunctionInliningPass());
252 
253   PM.add(createPruneEHPass());   // Remove dead EH info.
254 
255   // Optimize globals again if we ran the inliner.
256   if (RunInliner)
257     PM.add(createGlobalOptimizerPass());
258   PM.add(createGlobalDCEPass()); // Remove dead functions.
259 
260   // If we didn't decide to inline a function, check to see if we can
261   // transform it to pass arguments by value instead of by reference.
262   PM.add(createArgumentPromotionPass());
263 
264   // The IPO passes may leave cruft around.  Clean up after them.
265   PM.add(createInstructionCombiningPass());
266   PM.add(createJumpThreadingPass());
267   // Break up allocas
268   PM.add(createScalarReplAggregatesPass());
269 
270   // Run a few AA driven optimizations here and now, to cleanup the code.
271   PM.add(createFunctionAttrsPass()); // Add nocapture.
272   PM.add(createGlobalsModRefPass()); // IP alias analysis.
273 
274   PM.add(createLICMPass());                 // Hoist loop invariants.
275   PM.add(createGVNPass(DisableGVNLoadPRE)); // Remove redundancies.
276   PM.add(createMemCpyOptPass());            // Remove dead memcpys.
277   // Nuke dead stores.
278   PM.add(createDeadStoreEliminationPass());
279 
280   // Cleanup and simplify the code after the scalar optimizations.
281   PM.add(createInstructionCombiningPass());
282 
283   PM.add(createJumpThreadingPass());
284 
285   // Delete basic blocks, which optimization passes may have killed.
286   PM.add(createCFGSimplificationPass());
287 
288   // Now that we have optimized the program, discard unreachable functions.
289   PM.add(createGlobalDCEPass());
290 }
291 
LLVMPassManagerBuilderCreate(void)292 LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate(void) {
293   PassManagerBuilder *PMB = new PassManagerBuilder();
294   return wrap(PMB);
295 }
296 
LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB)297 void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB) {
298   PassManagerBuilder *Builder = unwrap(PMB);
299   delete Builder;
300 }
301 
302 void
LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB,unsigned OptLevel)303 LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB,
304                                   unsigned OptLevel) {
305   PassManagerBuilder *Builder = unwrap(PMB);
306   Builder->OptLevel = OptLevel;
307 }
308 
309 void
LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB,unsigned SizeLevel)310 LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB,
311                                    unsigned SizeLevel) {
312   PassManagerBuilder *Builder = unwrap(PMB);
313   Builder->SizeLevel = SizeLevel;
314 }
315 
316 void
LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB,LLVMBool Value)317 LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB,
318                                             LLVMBool Value) {
319   PassManagerBuilder *Builder = unwrap(PMB);
320   Builder->DisableUnitAtATime = Value;
321 }
322 
323 void
LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB,LLVMBool Value)324 LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB,
325                                             LLVMBool Value) {
326   PassManagerBuilder *Builder = unwrap(PMB);
327   Builder->DisableUnrollLoops = Value;
328 }
329 
330 void
LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB,LLVMBool Value)331 LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB,
332                                                  LLVMBool Value) {
333   PassManagerBuilder *Builder = unwrap(PMB);
334   Builder->DisableSimplifyLibCalls = Value;
335 }
336 
337 void
LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,unsigned Threshold)338 LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,
339                                               unsigned Threshold) {
340   PassManagerBuilder *Builder = unwrap(PMB);
341   Builder->Inliner = createFunctionInliningPass(Threshold);
342 }
343 
344 void
LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,LLVMPassManagerRef PM)345 LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
346                                                   LLVMPassManagerRef PM) {
347   PassManagerBuilder *Builder = unwrap(PMB);
348   FunctionPassManager *FPM = unwrap<FunctionPassManager>(PM);
349   Builder->populateFunctionPassManager(*FPM);
350 }
351 
352 void
LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,LLVMPassManagerRef PM)353 LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
354                                                 LLVMPassManagerRef PM) {
355   PassManagerBuilder *Builder = unwrap(PMB);
356   PassManagerBase *MPM = unwrap(PM);
357   Builder->populateModulePassManager(*MPM);
358 }
359 
LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,LLVMPassManagerRef PM,bool Internalize,bool RunInliner)360 void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,
361                                                   LLVMPassManagerRef PM,
362                                                   bool Internalize,
363                                                   bool RunInliner) {
364   PassManagerBuilder *Builder = unwrap(PMB);
365   PassManagerBase *LPM = unwrap(PM);
366   Builder->populateLTOPassManager(*LPM, Internalize, RunInliner);
367 }
368