include/llvm/Support/StandardPasses.h

   1 //===-- llvm/Support/StandardPasses.h - Standard pass lists -----*- 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 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.
  13 //
  14 // These are implemented as inline functions so that we do not have to worry
  15 // about link issues.
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #ifndef LLVM_SUPPORT_STANDARDPASSES_H
  20 #define LLVM_SUPPORT_STANDARDPASSES_H
  21
  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"
  28
  29 namespace llvm {
  30   /// createStandardFunctionPasses - Add the standard list of function passes to
  31   /// the provided pass manager.
  32   ///
  33   /// \arg OptimizationLevel - The optimization level, corresponding to -O0,
  34   /// -O1, etc.
  35   static inline void createStandardFunctionPasses(PassManagerBase *PM,
  36                                                   unsigned OptimizationLevel);
  37
  38   /// createStandardModulePasses - Add the standard list of module passes to the
  39   /// provided pass manager.
  40   ///
  41   /// \arg OptimizationLevel - The optimization level, corresponding to -O0,
  42   /// -O1, etc.
  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,
  52                                                 bool OptimizeSize,
  53                                                 bool UnitAtATime,
  54                                                 bool UnrollLoops,
  55                                                 bool SimplifyLibCalls,
  56                                                 bool HaveExceptions,
  57                                                 Pass *InliningPass);
  58
  59   /// createStandardLTOPasses - Add the standard list of module passes suitable
  60   /// for link time optimization.
  61   ///
  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,
  66                                              bool Internalize,
  67                                              bool RunInliner,
  68                                              bool VerifyEach);
  69
  70   // Implementations
  71
  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());
  78   }
  79
  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());
  87       else
  88         PM->add(createScalarReplAggregatesPass());
  89       PM->add(createInstructionCombiningPass());
  90     }
  91   }
  92
  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,
  97                                                 bool OptimizeSize,
  98                                                 bool UnitAtATime,
  99                                                 bool UnrollLoops,
 100                                                 bool OptimizeBuiltins,
 101                                                 bool HaveExceptions,
 102                                                 Pass *InliningPass) {
 103     createStandardAliasAnalysisPasses(PM);
 104
 105     if (OptimizationLevel == 0) {
 106       if (InliningPass)
 107         PM->add(InliningPass);
 108       return;
 109     }
 110
 111     if (UnitAtATime) {
 112       PM->add(createGlobalOptimizerPass());     // Optimize out global vars
 113
 114       PM->add(createIPSCCPPass());              // IP SCCP
 115       PM->add(createDeadArgEliminationPass());  // Dead argument elimination
 116     }
 117     PM->add(createInstructionCombiningPass());  // Clean up after IPCP & DAE
 118     PM->add(createCFGSimplificationPass());     // Clean up after IPCP & DAE
 119
 120     // Start of CallGraph SCC passes.
 121     if (UnitAtATime && HaveExceptions)
 122       PM->add(createPruneEHPass());           // Remove dead EH info
 123     if (InliningPass)
 124       PM->add(InliningPass);
 125     if (UnitAtATime)
 126       PM->add(createFunctionAttrsPass());       // Set readonly/readnone attrs
 127     if (OptimizationLevel > 2)
 128       PM->add(createArgumentPromotionPass());   // Scalarize uninlined fn args
 129
 130     // Start of function pass.
 131     PM->add(createScalarReplAggregatesPass());  // Break up aggregate allocas
 132     PM->add(createEarlyCSEPass());              // Catch trivial redundancies
 133     if (OptimizeBuiltins)
 134       PM->add(createSimplifyLibCallsPass());    // Library Call Optimizations
 135     PM->add(createInstructionCombiningPass());  // Cleanup for scalarrepl.
 136     PM->add(createJumpThreadingPass());         // Thread jumps.
 137     PM->add(createCorrelatedValuePropagationPass()); // Propagate conditionals
 138     PM->add(createCFGSimplificationPass());     // Merge & remove BBs
 139     PM->add(createInstructionCombiningPass());  // Combine silly seq's
 140
 141     PM->add(createTailCallEliminationPass());   // Eliminate tail calls
 142     PM->add(createCFGSimplificationPass());     // Merge & remove BBs
 143     PM->add(createReassociatePass());           // Reassociate expressions
 144     PM->add(createLoopRotatePass());            // Rotate Loop
 145     PM->add(createLICMPass());                  // Hoist loop invariants
 146     PM->add(createLoopUnswitchPass(OptimizeSize || OptimizationLevel < 3));
 147     PM->add(createInstructionCombiningPass());
 148     PM->add(createIndVarSimplifyPass());        // Canonicalize indvars
 149     if (OptimizeBuiltins)
 150       PM->add(createLoopIdiomPass());           // Recognize idioms like memset.
 151     PM->add(createLoopDeletionPass());          // Delete dead loops
 152     if (UnrollLoops)
 153       PM->add(createLoopUnrollPass());          // Unroll small loops
 154     PM->add(createInstructionCombiningPass());  // Clean up after the unroller
 155     if (OptimizationLevel > 1)
 156       PM->add(createGVNPass());                 // Remove redundancies
 157     PM->add(createMemCpyOptPass());             // Remove memcpy / form memset
 158     PM->add(createSCCPPass());                  // Constant prop with SCCP
 159
 160     // Run instcombine after redundancy elimination to exploit opportunities
 161     // opened up by them.
 162     PM->add(createInstructionCombiningPass());
 163     PM->add(createJumpThreadingPass());         // Thread jumps
 164     PM->add(createCorrelatedValuePropagationPass());
 165     PM->add(createDeadStoreEliminationPass());  // Delete dead stores
 166     PM->add(createAggressiveDCEPass());         // Delete dead instructions
 167     PM->add(createCFGSimplificationPass());     // Merge & remove BBs
 168
 169     if (UnitAtATime) {
 170       PM->add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
 171       PM->add(createDeadTypeEliminationPass()); // Eliminate dead types
 172
 173       // GlobalOpt already deletes dead functions and globals, at -O3 try a
 174       // late pass of GlobalDCE.  It is capable of deleting dead cycles.
 175       if (OptimizationLevel > 2)
 176         PM->add(createGlobalDCEPass());         // Remove dead fns and globals.
 177
 178       if (OptimizationLevel > 1)
 179         PM->add(createConstantMergePass());       // Merge dup global constants
 180     }
 181   }
 182
 183   static inline void addOnePass(PassManagerBase *PM, Pass *P, bool AndVerify) {
 184     PM->add(P);
 185
 186     if (AndVerify)
 187       PM->add(createVerifierPass());
 188   }
 189
 190   static inline void createStandardLTOPasses(PassManagerBase *PM,
 191                                              bool Internalize,
 192                                              bool RunInliner,
 193                                              bool VerifyEach) {
 194     // Provide AliasAnalysis services for optimizations.
 195     createStandardAliasAnalysisPasses(PM);
 196
 197     // Now that composite has been compiled, scan through the module, looking
 198     // for a main function.  If main is defined, mark all other functions
 199     // internal.
 200     if (Internalize)
 201       addOnePass(PM, createInternalizePass(true), VerifyEach);
 202
 203     // Propagate constants at call sites into the functions they call.  This
 204     // opens opportunities for globalopt (and inlining) by substituting function
 205     // pointers passed as arguments to direct uses of functions.
 206     addOnePass(PM, createIPSCCPPass(), VerifyEach);
 207
 208     // Now that we internalized some globals, see if we can hack on them!
 209     addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
 210
 211     // Linking modules together can lead to duplicated global constants, only
 212     // keep one copy of each constant...
 213     addOnePass(PM, createConstantMergePass(), VerifyEach);
 214
 215     // Remove unused arguments from functions...
 216     addOnePass(PM, createDeadArgEliminationPass(), VerifyEach);
 217
 218     // Reduce the code after globalopt and ipsccp.  Both can open up significant
 219     // simplification opportunities, and both can propagate functions through
 220     // function pointers.  When this happens, we often have to resolve varargs
 221     // calls, etc, so let instcombine do this.
 222     addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
 223
 224     // Inline small functions
 225     if (RunInliner)
 226       addOnePass(PM, createFunctionInliningPass(), VerifyEach);
 227
 228     addOnePass(PM, createPruneEHPass(), VerifyEach);   // Remove dead EH info.
 229     // Optimize globals again if we ran the inliner.
 230     if (RunInliner)
 231       addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
 232     addOnePass(PM, createGlobalDCEPass(), VerifyEach); // Remove dead functions.
 233
 234     // If we didn't decide to inline a function, check to see if we can
 235     // transform it to pass arguments by value instead of by reference.
 236     addOnePass(PM, createArgumentPromotionPass(), VerifyEach);
 237
 238     // The IPO passes may leave cruft around.  Clean up after them.
 239     addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
 240     addOnePass(PM, createJumpThreadingPass(), VerifyEach);
 241     // Break up allocas
 242     addOnePass(PM, createScalarReplAggregatesPass(), VerifyEach);
 243
 244     // Run a few AA driven optimizations here and now, to cleanup the code.
 245     addOnePass(PM, createFunctionAttrsPass(), VerifyEach); // Add nocapture.
 246     addOnePass(PM, createGlobalsModRefPass(), VerifyEach); // IP alias analysis.
 247
 248     addOnePass(PM, createLICMPass(), VerifyEach);      // Hoist loop invariants.
 249     addOnePass(PM, createGVNPass(), VerifyEach);       // Remove redundancies.
 250     addOnePass(PM, createMemCpyOptPass(), VerifyEach); // Remove dead memcpys.
 251     // Nuke dead stores.
 252     addOnePass(PM, createDeadStoreEliminationPass(), VerifyEach);
 253
 254     // Cleanup and simplify the code after the scalar optimizations.
 255     addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
 256
 257     addOnePass(PM, createJumpThreadingPass(), VerifyEach);
 258
 259     // Delete basic blocks, which optimization passes may have killed.
 260     addOnePass(PM, createCFGSimplificationPass(), VerifyEach);
 261
 262     // Now that we have optimized the program, discard unreachable functions.
 263     addOnePass(PM, createGlobalDCEPass(), VerifyEach);
 264   }
 265 }
 266
 267 #endif