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