Home | History | Annotate | Download | only in IPO 
      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 
     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 
     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 
     63 void PassManagerBuilder::addGlobalExtension(
     64     PassManagerBuilder::ExtensionPointTy Ty,
     65     PassManagerBuilder::ExtensionFn Fn) {
     66   GlobalExtensions->push_back(std::make_pair(Ty, Fn));
     67 }
     68 
     69 void PassManagerBuilder::addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
     70   Extensions.push_back(std::make_pair(Ty, Fn));
     71 }
     72 
     73 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
     84 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 
     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 
    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 
    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 
    292 LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate(void) {
    293   PassManagerBuilder *PMB = new PassManagerBuilder();
    294   return wrap(PMB);
    295 }
    296 
    297 void LLVMPassManagerBuilderDispose(LLVMPassManagerBuilderRef PMB) {
    298   PassManagerBuilder *Builder = unwrap(PMB);
    299   delete Builder;
    300 }
    301 
    302 void
    303 LLVMPassManagerBuilderSetOptLevel(LLVMPassManagerBuilderRef PMB,
    304                                   unsigned OptLevel) {
    305   PassManagerBuilder *Builder = unwrap(PMB);
    306   Builder->OptLevel = OptLevel;
    307 }
    308 
    309 void
    310 LLVMPassManagerBuilderSetSizeLevel(LLVMPassManagerBuilderRef PMB,
    311                                    unsigned SizeLevel) {
    312   PassManagerBuilder *Builder = unwrap(PMB);
    313   Builder->SizeLevel = SizeLevel;
    314 }
    315 
    316 void
    317 LLVMPassManagerBuilderSetDisableUnitAtATime(LLVMPassManagerBuilderRef PMB,
    318                                             LLVMBool Value) {
    319   PassManagerBuilder *Builder = unwrap(PMB);
    320   Builder->DisableUnitAtATime = Value;
    321 }
    322 
    323 void
    324 LLVMPassManagerBuilderSetDisableUnrollLoops(LLVMPassManagerBuilderRef PMB,
    325                                             LLVMBool Value) {
    326   PassManagerBuilder *Builder = unwrap(PMB);
    327   Builder->DisableUnrollLoops = Value;
    328 }
    329 
    330 void
    331 LLVMPassManagerBuilderSetDisableSimplifyLibCalls(LLVMPassManagerBuilderRef PMB,
    332                                                  LLVMBool Value) {
    333   PassManagerBuilder *Builder = unwrap(PMB);
    334   Builder->DisableSimplifyLibCalls = Value;
    335 }
    336 
    337 void
    338 LLVMPassManagerBuilderUseInlinerWithThreshold(LLVMPassManagerBuilderRef PMB,
    339                                               unsigned Threshold) {
    340   PassManagerBuilder *Builder = unwrap(PMB);
    341   Builder->Inliner = createFunctionInliningPass(Threshold);
    342 }
    343 
    344 void
    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
    353 LLVMPassManagerBuilderPopulateModulePassManager(LLVMPassManagerBuilderRef PMB,
    354                                                 LLVMPassManagerRef PM) {
    355   PassManagerBuilder *Builder = unwrap(PMB);
    356   PassManagerBase *MPM = unwrap(PM);
    357   Builder->populateModulePassManager(*MPM);
    358 }
    359 
    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