include/llvm/Transforms/IPO/PassManagerBuilder.h

   1 // llvm/Transforms/IPO/PassManagerBuilder.h - Build Standard Pass -*- C++ -*-=//
   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 // These are implemented as inline functions so that we do not have to worry
  14 // about link issues.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #ifndef LLVM_SUPPORT_PASSMANAGERBUILDER_H
  19 #define LLVM_SUPPORT_PASSMANAGERBUILDER_H
  20
  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"
  28
  29 namespace llvm {
  30
  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:
  34 ///
  35 ///  PassManagerBuilder Builder;
  36 ///  Builder.OptLevel = 2;
  37 ///  Builder.populateFunctionPassManager(FPM);
  38 ///  Builder.populateModulePassManager(MPM);
  39 ///
  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:
  46 ///
  47 /// static void addMyLoopPass(const PMBuilder &Builder, PassManagerBase &PM) {
  48 ///   if (Builder.getOptLevel() > 2 && Builder.getOptSizeLevel() == 0)
  49 ///     PM.add(createMyAwesomePass());
  50 /// }
  51 ///   ...
  52 ///   Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
  53 ///                        addMyLoopPass);
  54 ///   ...
  55 class PassManagerBuilder {
  56 public:
  57
  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,
  61                               PassManagerBase &PM);
  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.
  66     EP_EarlyAsPossible,
  67
  68     /// EP_LoopOptimizerEnd - This extension point allows adding loop passes to
  69     /// the end of the loop optimizer.
  70     EP_LoopOptimizerEnd,
  71
  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
  76   };
  77
  78   /// The Optimization Level - Specify the basic optimization level.
  79   ///    0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
  80   unsigned OptLevel;
  81
  82   /// SizeLevel - How much we're optimizing for size.
  83   ///    0 = none, 1 = -Os, 2 = -Oz
  84   unsigned SizeLevel;
  85
  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;
  90
  91   /// Inliner - Specifies the inliner to use.  If this is non-null, it is
  92   /// added to the per-module passes.
  93   Pass *Inliner;
  94
  95   bool DisableSimplifyLibCalls;
  96   bool DisableUnitAtATime;
  97   bool DisableUnrollLoops;
  98
  99 private:
 100   /// ExtensionList - This is list of all of the extensions that are registered.
 101   std::vector<std::pair<ExtensionPointTy, ExtensionFn> > Extensions;
 102
 103 public:
 104   PassManagerBuilder() {
 105     OptLevel = 2;
 106     SizeLevel = 0;
 107     LibraryInfo = 0;
 108     Inliner = 0;
 109     DisableSimplifyLibCalls = false;
 110     DisableUnitAtATime = false;
 111     DisableUnrollLoops = false;
 112   }
 113
 114   ~PassManagerBuilder() {
 115     delete LibraryInfo;
 116     delete Inliner;
 117   }
 118
 119   void addExtension(ExtensionPointTy Ty, ExtensionFn Fn) {
 120     Extensions.push_back(std::make_pair(Ty, Fn));
 121   }
 122
 123 private:
 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);
 128   }
 129
 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());
 136   }
 137 public:
 138
 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);
 144
 145     // Add LibraryInfo if we have some.
 146     if (LibraryInfo) FPM.add(new TargetLibraryInfo(*LibraryInfo));
 147
 148     if (OptLevel == 0) return;
 149
 150     addInitialAliasAnalysisPasses(FPM);
 151
 152     FPM.add(createCFGSimplificationPass());
 153     FPM.add(createScalarReplAggregatesPass());
 154     FPM.add(createEarlyCSEPass());
 155     FPM.add(createLowerExpectIntrinsicPass());
 156   }
 157
 158   /// populateModulePassManager - This sets up the primary pass manager.
 159   void populateModulePassManager(PassManagerBase &MPM) {
 160     // If all optimizations are disabled, just run the always-inline pass.
 161     if (OptLevel == 0) {
 162       if (Inliner) {
 163         MPM.add(Inliner);
 164         Inliner = 0;
 165       }
 166       return;
 167     }
 168
 169     // Add LibraryInfo if we have some.
 170     if (LibraryInfo) MPM.add(new TargetLibraryInfo(*LibraryInfo));
 171
 172     addInitialAliasAnalysisPasses(MPM);
 173
 174     if (!DisableUnitAtATime) {
 175       MPM.add(createGlobalOptimizerPass());     // Optimize out global vars
 176
 177       MPM.add(createIPSCCPPass());              // IP SCCP
 178       MPM.add(createDeadArgEliminationPass());  // Dead argument elimination
 179
 180       MPM.add(createInstructionCombiningPass());// Clean up after IPCP & DAE
 181       MPM.add(createCFGSimplificationPass());   // Clean up after IPCP & DAE
 182     }
 183
 184     // Start of CallGraph SCC passes.
 185     if (!DisableUnitAtATime)
 186       MPM.add(createPruneEHPass());             // Remove dead EH info
 187     if (Inliner) {
 188       MPM.add(Inliner);
 189       Inliner = 0;
 190     }
 191     if (!DisableUnitAtATime)
 192       MPM.add(createFunctionAttrsPass());       // Set readonly/readnone attrs
 193     if (OptLevel > 2)
 194       MPM.add(createArgumentPromotionPass());   // Scalarize uninlined fn args
 195
 196     // Start of function pass.
 197     // Break up aggregate allocas, using SSAUpdater.
 198     MPM.add(createScalarReplAggregatesPass(-1, false));
 199     MPM.add(createEarlyCSEPass());              // Catch trivial redundancies
 200     if (!DisableSimplifyLibCalls)
 201       MPM.add(createSimplifyLibCallsPass());    // Library Call Optimizations
 202     MPM.add(createJumpThreadingPass());         // Thread jumps.
 203     MPM.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
 204     MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
 205     MPM.add(createInstructionCombiningPass());  // Combine silly seq's
 206
 207     MPM.add(createTailCallEliminationPass());   // Eliminate tail calls
 208     MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
 209     MPM.add(createReassociatePass());           // Reassociate expressions
 210     MPM.add(createLoopRotatePass());            // Rotate Loop
 211     MPM.add(createLICMPass());                  // Hoist loop invariants
 212     MPM.add(createLoopUnswitchPass(SizeLevel || OptLevel < 3));
 213     MPM.add(createInstructionCombiningPass());
 214     MPM.add(createIndVarSimplifyPass());        // Canonicalize indvars
 215     MPM.add(createLoopIdiomPass());             // Recognize idioms like memset.
 216     MPM.add(createLoopDeletionPass());          // Delete dead loops
 217     if (!DisableUnrollLoops)
 218       MPM.add(createLoopUnrollPass());          // Unroll small loops
 219     addExtensionsToPM(EP_LoopOptimizerEnd, MPM);
 220
 221     if (OptLevel > 1)
 222       MPM.add(createGVNPass());                 // Remove redundancies
 223     MPM.add(createMemCpyOptPass());             // Remove memcpy / form memset
 224     MPM.add(createSCCPPass());                  // Constant prop with SCCP
 225
 226     // Run instcombine after redundancy elimination to exploit opportunities
 227     // opened up by them.
 228     MPM.add(createInstructionCombiningPass());
 229     MPM.add(createJumpThreadingPass());         // Thread jumps
 230     MPM.add(createCorrelatedValuePropagationPass());
 231     MPM.add(createDeadStoreEliminationPass());  // Delete dead stores
 232
 233     addExtensionsToPM(EP_ScalarOptimizerLate, MPM);
 234
 235     MPM.add(createAggressiveDCEPass());         // Delete dead instructions
 236     MPM.add(createCFGSimplificationPass());     // Merge & remove BBs
 237     MPM.add(createInstructionCombiningPass());  // Clean up after everything.
 238
 239     if (!DisableUnitAtATime) {
 240       // FIXME: We shouldn't bother with this anymore.
 241       MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
 242
 243       // GlobalOpt already deletes dead functions and globals, at -O3 try a
 244       // late pass of GlobalDCE.  It is capable of deleting dead cycles.
 245       if (OptLevel > 2)
 246         MPM.add(createGlobalDCEPass());         // Remove dead fns and globals.
 247
 248       if (OptLevel > 1)
 249         MPM.add(createConstantMergePass());     // Merge dup global constants
 250     }
 251   }
 252
 253   void populateLTOPassManager(PassManagerBase &PM, bool Internalize,
 254                               bool RunInliner) {
 255     // Provide AliasAnalysis services for optimizations.
 256     addInitialAliasAnalysisPasses(PM);
 257
 258     // Now that composite has been compiled, scan through the module, looking
 259     // for a main function.  If main is defined, mark all other functions
 260     // internal.
 261     if (Internalize)
 262       PM.add(createInternalizePass(true));
 263
 264     // Propagate constants at call sites into the functions they call.  This
 265     // opens opportunities for globalopt (and inlining) by substituting function
 266     // pointers passed as arguments to direct uses of functions.
 267     PM.add(createIPSCCPPass());
 268
 269     // Now that we internalized some globals, see if we can hack on them!
 270     PM.add(createGlobalOptimizerPass());
 271
 272     // Linking modules together can lead to duplicated global constants, only
 273     // keep one copy of each constant.
 274     PM.add(createConstantMergePass());
 275
 276     // Remove unused arguments from functions.
 277     PM.add(createDeadArgEliminationPass());
 278
 279     // Reduce the code after globalopt and ipsccp.  Both can open up significant
 280     // simplification opportunities, and both can propagate functions through
 281     // function pointers.  When this happens, we often have to resolve varargs
 282     // calls, etc, so let instcombine do this.
 283     PM.add(createInstructionCombiningPass());
 284
 285     // Inline small functions
 286     if (RunInliner)
 287       PM.add(createFunctionInliningPass());
 288
 289     PM.add(createPruneEHPass());   // Remove dead EH info.
 290
 291     // Optimize globals again if we ran the inliner.
 292     if (RunInliner)
 293       PM.add(createGlobalOptimizerPass());
 294     PM.add(createGlobalDCEPass()); // Remove dead functions.
 295
 296     // If we didn't decide to inline a function, check to see if we can
 297     // transform it to pass arguments by value instead of by reference.
 298     PM.add(createArgumentPromotionPass());
 299
 300     // The IPO passes may leave cruft around.  Clean up after them.
 301     PM.add(createInstructionCombiningPass());
 302     PM.add(createJumpThreadingPass());
 303     // Break up allocas
 304     PM.add(createScalarReplAggregatesPass());
 305
 306     // Run a few AA driven optimizations here and now, to cleanup the code.
 307     PM.add(createFunctionAttrsPass()); // Add nocapture.
 308     PM.add(createGlobalsModRefPass()); // IP alias analysis.
 309
 310     PM.add(createLICMPass());      // Hoist loop invariants.
 311     PM.add(createGVNPass());       // Remove redundancies.
 312     PM.add(createMemCpyOptPass()); // Remove dead memcpys.
 313     // Nuke dead stores.
 314     PM.add(createDeadStoreEliminationPass());
 315
 316     // Cleanup and simplify the code after the scalar optimizations.
 317     PM.add(createInstructionCombiningPass());
 318
 319     PM.add(createJumpThreadingPass());
 320
 321     // Delete basic blocks, which optimization passes may have killed.
 322     PM.add(createCFGSimplificationPass());
 323
 324     // Now that we have optimized the program, discard unreachable functions.
 325     PM.add(createGlobalDCEPass());
 326   }
 327 };
 328
 329
 330 } // end namespace llvm
 331 #endif