Revert r131155 for now. It makes VMCore depend on Analysis and Transforms

headers.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@131159 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 150 insertions, 415 deletions

diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h
index ad6ab754b8..082790956c 100644
--- a/include/llvm/PassSupport.h
+++ b/include/llvm/PassSupport.h
@@ -29,8 +29,6 @@
 
 namespace llvm {
 
-  class PassManagerBase;
-
 //===---------------------------------------------------------------------------
 /// PassInfo class - An instance of this class exists for every pass known by
 /// the system, and can be obtained from a live Pass by calling its
@@ -209,149 +207,6 @@ struct RegisterPass : public PassInfo {
   }
 };
 
-  /// Unique identifiers for the default standard passes.  The addresses of
-  /// these symbols are used to uniquely identify passes from the default list.
-  namespace DefaultStandardPasses {
-    extern unsigned char AggressiveDCEID;
-    extern unsigned char ArgumentPromotionID;
-    extern unsigned char BasicAliasAnalysisID;
-    extern unsigned char CFGSimplificationID;
-    extern unsigned char ConstantMergeID;
-    extern unsigned char CorrelatedValuePropagationID;
-    extern unsigned char DeadArgEliminationID;
-    extern unsigned char DeadStoreEliminationID;
-    extern unsigned char DeadTypeEliminationID;
-    extern unsigned char EarlyCSEID;
-    extern unsigned char FunctionAttrsID;
-    extern unsigned char FunctionInliningID;
-    extern unsigned char GVNID;
-    extern unsigned char GlobalDCEID;
-    extern unsigned char GlobalOptimizerID;
-    extern unsigned char GlobalsModRefID;
-    extern unsigned char IPSCCPID;
-    extern unsigned char IndVarSimplifyID;
-    extern unsigned char InlinerPlaceholderID;
-    extern unsigned char InstructionCombiningID;
-    extern unsigned char JumpThreadingID;
-    extern unsigned char LICMID;
-    extern unsigned char LoopDeletionID;
-    extern unsigned char LoopIdiomID;
-    extern unsigned char LoopRotateID;
-    extern unsigned char LoopUnrollID;
-    extern unsigned char LoopUnswitchID;
-    extern unsigned char MemCpyOptID;
-    extern unsigned char PruneEHID;
-    extern unsigned char ReassociateID;
-    extern unsigned char SCCPID;
-    extern unsigned char ScalarReplAggregatesID;
-    extern unsigned char SimplifyLibCallsID;
-    extern unsigned char StripDeadPrototypesID;
-    extern unsigned char TailCallEliminationID;
-    extern unsigned char TypeBasedAliasAnalysisID;
-  }
-
-
-class RegisterStandardPass;
-/// RegisterStandardPass - Registers a pass as a member of a standard set.  
-class StandardPass {
-  friend class RegisterStandardPassLists;
-  public:
-  /// Predefined standard sets of passes
-  enum StandardSet {
-    AliasAnalysis,
-    Function,
-    Module,
-    LTO
-  };
-  /// Flags to specify whether a pass should be enabled.  Passes registered
-  /// with the standard sets may specify a minimum optimization level and one
-  /// or more flags that must be set when constructing the set for the pass to
-  /// be used.
-  enum OptimizationFlags {
-    /// Optimize for size was requested.
-    OptimizeSize = 1<<0,
-    /// Allow passes which may make global module changes.
-    UnitAtATime = 1<<1,
-    /// UnrollLoops - Allow loop unrolling.
-    UnrollLoops = 1<<2,
-    /// Allow library calls to be simplified.
-    SimplifyLibCalls = 1<<3,
-    /// Whether the module may have code using exceptions.
-    HaveExceptions = 1<<4,
-    // Run an inliner pass as part of this set.
-    RunInliner = 1<<5
-  };
-  enum OptimizationFlagComponents {
-    /// The low bits are used to store the optimization level.  When requesting
-    /// passes, this should store the requested optimisation level.  When
-    /// setting passes, this should set the minimum optimization level at which
-    /// the pass will run.
-    OptimizationLevelMask = 0xf,
-    /// The maximum optimisation level at which the pass is run.
-    MaxOptimizationLevelMask = 0xf0,
-    // Flags that must be set
-    RequiredFlagMask = 0xff00,
-    // Flags that may not be set.
-    DisallowedFlagMask = 0xff0000,
-    MaxOptimizationLevelShift = 4,
-    RequiredFlagShift = 8,
-    DisallowedFlagShift = 16
-  };
-  /// Returns the optimisation level from a set of flags.
-  static unsigned OptimizationLevel(unsigned flags) {
-      return flags & OptimizationLevelMask;
-  }
-  /// Returns the maximum optimization level for this set of flags
-  static unsigned MaxOptimizationLevel(unsigned flags) {
-      return (flags & MaxOptimizationLevelMask) >> 4;
-  }
-  /// Constructs a set of flags from the specified minimum and maximum
-  /// optimisation level
-  static unsigned OptimizationFlags(unsigned minLevel=0, unsigned maxLevel=0xf,
-                                    unsigned requiredFlags=0,
-                                    unsigned disallowedFlags=0) {
-    return ((minLevel & OptimizationLevelMask) |
-            ((maxLevel<<MaxOptimizationLevelShift) & MaxOptimizationLevelMask)
-            | ((requiredFlags<<RequiredFlagShift) & RequiredFlagMask)
-            | ((disallowedFlags<<DisallowedFlagShift) & DisallowedFlagMask));
-  }
-  /// Returns the flags that must be set for this to match
-  static unsigned RequiredFlags(unsigned flags) {
-      return (flags & RequiredFlagMask) >> RequiredFlagShift;
-  }
-  /// Returns the flags that must not be set for this to match
-  static unsigned DisallowedFlags(unsigned flags) {
-      return (flags & DisallowedFlagMask) >> RequiredFlagShift;
-  }
-  /// Register a standard pass in the specified set.  If flags is non-zero,
-  /// then the pass will only be returned when the specified flags are set.
-  template<typename passName>
-  class RegisterStandardPass {
-    RegisterStandardPass(StandardSet set, unsigned char *runBefore=0,
-                         unsigned flags=0, unsigned char *ID=0) {
-      // Use the pass's ID if one is not specified
-      RegisterDefaultPass(PassInfo::NormalCtor_t(callDefaultCtor<passName>),
-                          ID ? ID : &passName::ID, runBefore, set, flags);
-    };
-  };
-  /// Adds the passes from the specified set to a pass manager.
-  static void AddPassesFromSet(PassManagerBase *PM,
-                               StandardSet Set,
-                               unsigned Flags=0,
-                               bool VerifyEach=false,
-                               Pass *Inliner=0);
-  private:
-  /// Registers the default passes.  This is set by RegisterStandardPassLists
-  /// and is called lazily.
-  static void (*RegisterDefaultPasses)(void);
-  /// Registers the pass
-  static void RegisterDefaultPass(PassInfo::NormalCtor_t constructor,
-                                  unsigned char *newPass,
-                                  unsigned char *oldPass,
-                                  StandardSet set,
-                                  unsigned flags=0);
-};
-
 
 /// RegisterAnalysisGroup - Register a Pass as a member of an analysis _group_.
 /// Analysis groups are used to define an interface (which need not derive from
diff --git a/include/llvm/Support/StandardPasses.h b/include/llvm/Support/StandardPasses.h
index c33322b95c..e13e9fae17 100644
--- a/include/llvm/Support/StandardPasses.h
+++ b/include/llvm/Support/StandardPasses.h
@@ -20,7 +20,6 @@
 #define LLVM_SUPPORT_STANDARDPASSES_H
 
 #include "llvm/PassManager.h"
-#include "llvm/PassSupport.h"
 #include "llvm/Analysis/Passes.h"
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Transforms/Scalar.h"
@@ -28,259 +27,12 @@
 
 namespace llvm {
 
-  /// RegisterStandardPassLists solves a circular dependency problem.  The
-  /// default list of passes has to live somewhere.  It can't live in the core
-  /// modules, because these don't link to the libraries that actually define
-  /// the passes.  It's in this header, so that a copy is created in every
-  /// library that requests the default set, while still allowing plugins to
-  /// register new passes without requiring them to link anything more than
-  /// VMCore.
-  class RegisterStandardPassLists {
-    public:
-    RegisterStandardPassLists() {
-      StandardPass::RegisterDefaultPasses = RegisterStandardPassList;
-    }
-    private:
-    /// Passes must be registered with functions that take no arguments, so we
-    /// have to wrap their existing constructors.  
-    static Pass *createDefaultScalarReplAggregatesPass(void) {
-      return createScalarReplAggregatesPass(-1, false);
-    }
-    static Pass *createDefaultLoopUnswitchPass(void) {
-      return createLoopUnswitchPass(false);
-    }
-    static Pass *createSizeOptimizingLoopUnswitchPass(void) {
-      return createLoopUnswitchPass(true);
-    }
-    static void RegisterStandardPassList(void) {
-      // Standard alias analysis passes
-
-      // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
-      // BasicAliasAnalysis wins if they disagree. This is intended to help
-      // support "obvious" type-punning idioms.
-#define DEFAULT_ALIAS_ANALYSIS_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-    PassInfo::NormalCtor_t(create ## pass ## Pass),\
-    &DefaultStandardPasses::pass ## ID, 0, StandardPass::AliasAnalysis, flags)
-      DEFAULT_ALIAS_ANALYSIS_PASS(BasicAliasAnalysis, 0);
-      DEFAULT_ALIAS_ANALYSIS_PASS(TypeBasedAliasAnalysis, 0);
-#undef DEFAULT_ALIAS_ANALYSIS_PASS
-
-#define DEFAULT_FUNCTION_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-      PassInfo::NormalCtor_t(create ## pass ## Pass),\
-      &DefaultStandardPasses::pass ## ID, 0, StandardPass::Function, flags)
-      DEFAULT_FUNCTION_PASS(CFGSimplification,
-          StandardPass::OptimizationFlags(1));
-      DEFAULT_FUNCTION_PASS(ScalarReplAggregates,
-          StandardPass::OptimizationFlags(1));
-      DEFAULT_FUNCTION_PASS(EarlyCSE, StandardPass::OptimizationFlags(1));
-#undef DEFAULT_FUNCTION_PASS
-
-#define DEFAULT_MODULE_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-      PassInfo::NormalCtor_t(create ## pass ## Pass),\
-      &DefaultStandardPasses::pass ## ID, 0, StandardPass::Module, flags)
-      // Optimize out global vars
-      DEFAULT_MODULE_PASS(GlobalOptimizer, StandardPass::UnitAtATime);
-      // IP SCCP
-      DEFAULT_MODULE_PASS(IPSCCP,
-          StandardPass::OptimizationFlags(0, 0, StandardPass::UnitAtATime));
-      // Dead argument elimination
-      DEFAULT_MODULE_PASS(DeadArgElimination,
-          StandardPass::OptimizationFlags(0, 0, StandardPass::UnitAtATime));
-      // Clean up after IPCP & DAE
-      DEFAULT_MODULE_PASS(InstructionCombining,
-          StandardPass::OptimizationFlags(0, 0, StandardPass::UnitAtATime));
-      // Clean up after IPCP & DAE
-      DEFAULT_MODULE_PASS(CFGSimplification,
-          StandardPass::OptimizationFlags(0, 0, StandardPass::UnitAtATime));
-
-      // Placeholder that will be replaced by an inliner if one is specified
-      StandardPass::RegisterDefaultPass(0,
-        &DefaultStandardPasses::InlinerPlaceholderID , 0,
-        StandardPass::Module);
-      // Remove dead EH info
-      DEFAULT_MODULE_PASS(PruneEH, StandardPass::OptimizationFlags(0, 0,
-            StandardPass::UnitAtATime | StandardPass::HaveExceptions));
-      // Set readonly/readnone attrs
-      DEFAULT_MODULE_PASS(FunctionAttrs, StandardPass::OptimizationFlags(0, 0,
-            StandardPass::UnitAtATime));
-      // Scalarize uninlined fn args
-      DEFAULT_MODULE_PASS(ArgumentPromotion, 2);
-      // Start of function pass.
-      // Break up aggregate allocas, using SSAUpdater.
-      StandardPass::RegisterDefaultPass(
-          PassInfo::NormalCtor_t(createDefaultScalarReplAggregatesPass),
-          &DefaultStandardPasses::ScalarReplAggregatesID, 0,
-          StandardPass::Module);
-      // Catch trivial redundancies
-      DEFAULT_MODULE_PASS(EarlyCSE, 0);
-      // Library Call Optimizations
-      DEFAULT_MODULE_PASS(SimplifyLibCalls, StandardPass::SimplifyLibCalls);
-      // Thread jumps
-      DEFAULT_MODULE_PASS(JumpThreading, 0);
-      // Propagate conditionals
-      DEFAULT_MODULE_PASS(CorrelatedValuePropagation, 0);
-      // Merge & remove BBs
-      DEFAULT_MODULE_PASS(CFGSimplification, 0);
-      // Combine silly seq's
-      DEFAULT_MODULE_PASS(InstructionCombining, 0);
-      // Eliminate tail calls
-      DEFAULT_MODULE_PASS(TailCallElimination, 0);
-      // Merge & remove BBs
-      DEFAULT_MODULE_PASS(CFGSimplification, 0);
-      // Reassociate expressions
-      DEFAULT_MODULE_PASS(Reassociate, 0);
-      // Rotate Loop
-      DEFAULT_MODULE_PASS(LoopRotate, 0);
-      // Hoist loop invariants
-      DEFAULT_MODULE_PASS(LICM, 0);
-      // Optimize for size if the optimzation level is 0-2
-      StandardPass::RegisterDefaultPass(
-          PassInfo::NormalCtor_t(createSizeOptimizingLoopUnswitchPass),
-          &DefaultStandardPasses::LoopUnswitchID, 0,
-          StandardPass::Module,
-          StandardPass::OptimizationFlags(0, 2));
-      // Optimize for size if the optimzation level is >2, and OptimizeSize is
-      // set
-      StandardPass::RegisterDefaultPass(
-          PassInfo::NormalCtor_t(createSizeOptimizingLoopUnswitchPass),
-          &DefaultStandardPasses::LoopUnswitchID, 0,
-          StandardPass::Module,
-          StandardPass::OptimizationFlags(0, 3, StandardPass::OptimizeSize));
-      // Don't optimize for size if optimisation level is >2 and OptimizeSize
-      // is not set
-      StandardPass::RegisterDefaultPass(
-          PassInfo::NormalCtor_t(createSizeOptimizingLoopUnswitchPass),
-          &DefaultStandardPasses::LoopUnswitchID, 0,
-          StandardPass::Module,
-          StandardPass::OptimizationFlags(0, 3, 0, StandardPass::OptimizeSize));
-      DEFAULT_MODULE_PASS(InstructionCombining, 0);
-      // Canonicalize indvars
-      DEFAULT_MODULE_PASS(IndVarSimplify, 0);
-      // Recognize idioms like memset.
-      DEFAULT_MODULE_PASS(LoopIdiom, 0);
-      // Delete dead loops
-      DEFAULT_MODULE_PASS(LoopDeletion, 0);
-      // Unroll small loops
-      DEFAULT_MODULE_PASS(LoopUnroll, StandardPass::UnrollLoops);
-      // Remove redundancies
-      DEFAULT_MODULE_PASS(GVN, 2);
-      // Remove memcpy / form memset
-      DEFAULT_MODULE_PASS(MemCpyOpt, 0);
-      // Constant prop with SCCP
-      DEFAULT_MODULE_PASS(SCCP, 0);
-
-      // Run instcombine after redundancy elimination to exploit opportunities
-      // opened up by them.
-      DEFAULT_MODULE_PASS(InstructionCombining, 0);
-      // Thread jumps
-      DEFAULT_MODULE_PASS(JumpThreading, 0);
-      DEFAULT_MODULE_PASS(CorrelatedValuePropagation, 0);
-      // Delete dead stores
-      DEFAULT_MODULE_PASS(DeadStoreElimination, 0);
-      // Delete dead instructions
-      DEFAULT_MODULE_PASS(AggressiveDCE, 0);
-      // Merge & remove BBs
-      DEFAULT_MODULE_PASS(CFGSimplification, 0);
-      // Clean up after everything.
-      DEFAULT_MODULE_PASS(InstructionCombining, 0);
-
-      // Get rid of dead prototypes
-      DEFAULT_MODULE_PASS(StripDeadPrototypes, StandardPass::UnitAtATime);
-      // Eliminate dead types
-      DEFAULT_MODULE_PASS(DeadTypeElimination, StandardPass::UnitAtATime);
-
-      // GlobalOpt already deletes dead functions and globals, at -O3 try a
-      // late pass of GlobalDCE.  It is capable of deleting dead cycles.
-      // Remove dead fns and globals.
-      DEFAULT_MODULE_PASS(GlobalDCE, 3 | StandardPass::UnitAtATime);
-      // Merge dup global constants
-      DEFAULT_MODULE_PASS(ConstantMerge, 2 | StandardPass::UnitAtATime);
-#undef DEFAULT_MODULE_PASS
-
-#define DEFAULT_LTO_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-      PassInfo::NormalCtor_t(create ## pass ## Pass),\
-      &DefaultStandardPasses::pass ## ID, 0, StandardPass::LTO, flags)
-
-      // LTO passes
-
-      // Propagate constants at call sites into the functions they call.  This
-      // opens opportunities for globalopt (and inlining) by substituting
-      // function pointers passed as arguments to direct uses of functions.  
-      DEFAULT_LTO_PASS(IPSCCP, 0);
-
-      // Now that we internalized some globals, see if we can hack on them!
-      DEFAULT_LTO_PASS(GlobalOptimizer, 0);
-      
-      // Linking modules together can lead to duplicated global constants, only
-      // keep one copy of each constant...
-      DEFAULT_LTO_PASS(ConstantMerge, 0);
-      
-      // Remove unused arguments from functions...
-      DEFAULT_LTO_PASS(DeadArgElimination, 0);
-
-      // Reduce the code after globalopt and ipsccp.  Both can open up
-      // significant simplification opportunities, and both can propagate
-      // functions through function pointers.  When this happens, we often have
-      // to resolve varargs calls, etc, so let instcombine do this.
-      DEFAULT_LTO_PASS(InstructionCombining, 0);
-
-      // Inline small functions
-      DEFAULT_LTO_PASS(FunctionInlining,
-          StandardPass::OptimizationFlags(0, 0xf, StandardPass::RunInliner));
-      // Remove dead EH info.
-      DEFAULT_LTO_PASS(PruneEH, 0);
-      // Optimize globals again if we ran the inliner.
-      DEFAULT_LTO_PASS(GlobalOptimizer,
-          StandardPass::OptimizationFlags(0, 0xf, StandardPass::RunInliner));
-      DEFAULT_LTO_PASS(GlobalDCE, 0);
-
-      // If we didn't decide to inline a function, check to see if we can
-      // transform it to pass arguments by value instead of by reference.
-      DEFAULT_LTO_PASS(ArgumentPromotion, 0);
-
-      // The IPO passes may leave cruft around.  Clean up after them.
-      DEFAULT_LTO_PASS(InstructionCombining, 0);
-      DEFAULT_LTO_PASS(JumpThreading, 0);
-      // Break up allocas
-      DEFAULT_LTO_PASS(ScalarReplAggregates, 0);
-
-      // Run a few AA driven optimizations here and now, to cleanup the code.
-      // Add nocapture.
-      DEFAULT_LTO_PASS(FunctionAttrs, 0);
-      // IP alias analysis.
-      DEFAULT_LTO_PASS(GlobalsModRef, 0);
-
-      // Hoist loop invariants.
-      DEFAULT_LTO_PASS(LICM, 0);
-      // Remove redundancies.
-      DEFAULT_LTO_PASS(GVN, 0);
-      // Remove dead memcpys.
-      DEFAULT_LTO_PASS(MemCpyOpt, 0);
-      // Nuke dead stores.
-      DEFAULT_LTO_PASS(DeadStoreElimination, 0);
-
-      // Cleanup and simplify the code after the scalar optimizations.
-      DEFAULT_LTO_PASS(InstructionCombining, 0);
-
-      DEFAULT_LTO_PASS(JumpThreading, 0);
-      
-      // Delete basic blocks, which optimization passes may have killed.
-      DEFAULT_LTO_PASS(CFGSimplification, 0);
-
-      // Now that we have optimized the program, discard unreachable functions.
-      DEFAULT_LTO_PASS(GlobalDCE, 0);
-#undef DEFAULT_LTO_PASS
-    }
-  };
-  static RegisterStandardPassLists AutoRegister;
-
-
   static inline void createStandardAliasAnalysisPasses(PassManagerBase *PM) {
-    StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis);
+    // Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
+    // BasicAliasAnalysis wins if they disagree. This is intended to help
+    // support "obvious" type-punning idioms.
+    PM->add(createTypeBasedAliasAnalysisPass());
+    PM->add(createBasicAliasAnalysisPass());
   }
 
   /// createStandardFunctionPasses - Add the standard list of function passes to
@@ -290,7 +42,12 @@ namespace llvm {
   /// -O1, etc.
   static inline void createStandardFunctionPasses(PassManagerBase *PM,
                                                   unsigned OptimizationLevel) {
-    StandardPass::AddPassesFromSet(PM, StandardPass::Function, OptimizationLevel);
+    if (OptimizationLevel > 0) {
+      createStandardAliasAnalysisPasses(PM);
+      PM->add(createCFGSimplificationPass());
+      PM->add(createScalarReplAggregatesPass());
+      PM->add(createEarlyCSEPass());
+    }
   }
 
   /// createStandardModulePasses - Add the standard list of module passes to the
@@ -321,16 +78,84 @@ namespace llvm {
         PM->add(InliningPass);
       return;
     }
+    
+    if (UnitAtATime) {
+      PM->add(createGlobalOptimizerPass());     // Optimize out global vars
+      
+      PM->add(createIPSCCPPass());              // IP SCCP
+      PM->add(createDeadArgEliminationPass());  // Dead argument elimination
+      
+      PM->add(createInstructionCombiningPass());// Clean up after IPCP & DAE
+      PM->add(createCFGSimplificationPass());   // Clean up after IPCP & DAE
+    }
+    
+    // Start of CallGraph SCC passes.
+    if (UnitAtATime && HaveExceptions)
+      PM->add(createPruneEHPass());             // Remove dead EH info
+    if (InliningPass)
+      PM->add(InliningPass);
+    if (UnitAtATime)
+      PM->add(createFunctionAttrsPass());       // Set readonly/readnone attrs
+    if (OptimizationLevel > 2)
+      PM->add(createArgumentPromotionPass());   // Scalarize uninlined fn args
+    
+    // Start of function pass.
+    // Break up aggregate allocas, using SSAUpdater.
+    PM->add(createScalarReplAggregatesPass(-1, false));
+    PM->add(createEarlyCSEPass());              // Catch trivial redundancies
+    if (SimplifyLibCalls)
+      PM->add(createSimplifyLibCallsPass());    // Library Call Optimizations
+    PM->add(createJumpThreadingPass());         // Thread jumps.
+    PM->add(createCorrelatedValuePropagationPass()); // Propagate conditionals
+    PM->add(createCFGSimplificationPass());     // Merge & remove BBs
+    PM->add(createInstructionCombiningPass());  // Combine silly seq's
+    
+    PM->add(createTailCallEliminationPass());   // Eliminate tail calls
+    PM->add(createCFGSimplificationPass());     // Merge & remove BBs
+    PM->add(createReassociatePass());           // Reassociate expressions
+    PM->add(createLoopRotatePass());            // Rotate Loop
+    PM->add(createLICMPass());                  // Hoist loop invariants
+    PM->add(createLoopUnswitchPass(OptimizeSize || OptimizationLevel < 3));
+    PM->add(createInstructionCombiningPass());  
+    PM->add(createIndVarSimplifyPass());        // Canonicalize indvars
+    PM->add(createLoopIdiomPass());             // Recognize idioms like memset.
+    PM->add(createLoopDeletionPass());          // Delete dead loops
+    if (UnrollLoops)
+      PM->add(createLoopUnrollPass());          // Unroll small loops
+    if (OptimizationLevel > 1)
+      PM->add(createGVNPass());                 // Remove redundancies
+    PM->add(createMemCpyOptPass());             // Remove memcpy / form memset
+    PM->add(createSCCPPass());                  // Constant prop with SCCP
+  
+    // Run instcombine after redundancy elimination to exploit opportunities
+    // opened up by them.
+    PM->add(createInstructionCombiningPass());
+    PM->add(createJumpThreadingPass());         // Thread jumps
+    PM->add(createCorrelatedValuePropagationPass());
+    PM->add(createDeadStoreEliminationPass());  // Delete dead stores
+    PM->add(createAggressiveDCEPass());         // Delete dead instructions
+    PM->add(createCFGSimplificationPass());     // Merge & remove BBs
+    PM->add(createInstructionCombiningPass());  // Clean up after everything.
+
+    if (UnitAtATime) {
+      PM->add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
+      PM->add(createDeadTypeEliminationPass()); // Eliminate dead types
 
-    StandardPass::AddPassesFromSet(PM, StandardPass::Module,
-      StandardPass::OptimizationFlags(OptimizationLevel,
-        (OptimizeSize ? StandardPass::OptimizeSize : 0) |
-        (UnitAtATime ? StandardPass::UnitAtATime : 0) |
-        (UnrollLoops ? StandardPass::UnrollLoops : 0) |
-        (SimplifyLibCalls ? StandardPass::SimplifyLibCalls : 0) |
-        (HaveExceptions ? StandardPass::HaveExceptions : 0)),
-      InliningPass);
+      // GlobalOpt already deletes dead functions and globals, at -O3 try a
+      // late pass of GlobalDCE.  It is capable of deleting dead cycles.
+      if (OptimizationLevel > 2)
+        PM->add(createGlobalDCEPass());         // Remove dead fns and globals.
     
+      if (OptimizationLevel > 1)
+        PM->add(createConstantMergePass());       // Merge dup global constants
+    }
+  }
+
+  static inline void addOnePass(PassManagerBase *PM, Pass *P, bool AndVerify) {
+    PM->add(P);
+
+    if (AndVerify)
+      PM->add(createVerifierPass());
   }
 
   /// createStandardLTOPasses - Add the standard list of module passes suitable
@@ -349,15 +174,70 @@ namespace llvm {
     // Now that composite has been compiled, scan through the module, looking
     // for a main function.  If main is defined, mark all other functions
     // internal.
-    if (Internalize) {
-      PM->add(createInternalizePass(true));
-      if (VerifyEach)
-        PM->add(createVerifierPass());
-    }
+    if (Internalize)
+      addOnePass(PM, createInternalizePass(true), VerifyEach);
+
+    // Propagate constants at call sites into the functions they call.  This
+    // opens opportunities for globalopt (and inlining) by substituting function
+    // pointers passed as arguments to direct uses of functions.  
+    addOnePass(PM, createIPSCCPPass(), VerifyEach);
+
+    // Now that we internalized some globals, see if we can hack on them!
+    addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
+    
+    // Linking modules together can lead to duplicated global constants, only
+    // keep one copy of each constant...
+    addOnePass(PM, createConstantMergePass(), VerifyEach);
+    
+    // Remove unused arguments from functions...
+    addOnePass(PM, createDeadArgEliminationPass(), VerifyEach);
+
+    // Reduce the code after globalopt and ipsccp.  Both can open up significant
+    // simplification opportunities, and both can propagate functions through
+    // function pointers.  When this happens, we often have to resolve varargs
+    // calls, etc, so let instcombine do this.
+    addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
+
+    // Inline small functions
+    if (RunInliner)
+      addOnePass(PM, createFunctionInliningPass(), VerifyEach);
+
+    addOnePass(PM, createPruneEHPass(), VerifyEach);   // Remove dead EH info.
+    // Optimize globals again if we ran the inliner.
+    if (RunInliner)
+      addOnePass(PM, createGlobalOptimizerPass(), VerifyEach);
+    addOnePass(PM, createGlobalDCEPass(), VerifyEach); // Remove dead functions.
+
+    // If we didn't decide to inline a function, check to see if we can
+    // transform it to pass arguments by value instead of by reference.
+    addOnePass(PM, createArgumentPromotionPass(), VerifyEach);
+
+    // The IPO passes may leave cruft around.  Clean up after them.
+    addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
+    addOnePass(PM, createJumpThreadingPass(), VerifyEach);
+    // Break up allocas
+    addOnePass(PM, createScalarReplAggregatesPass(), VerifyEach);
+
+    // Run a few AA driven optimizations here and now, to cleanup the code.
+    addOnePass(PM, createFunctionAttrsPass(), VerifyEach); // Add nocapture.
+    addOnePass(PM, createGlobalsModRefPass(), VerifyEach); // IP alias analysis.
+
+    addOnePass(PM, createLICMPass(), VerifyEach);      // Hoist loop invariants.
+    addOnePass(PM, createGVNPass(), VerifyEach);       // Remove redundancies.
+    addOnePass(PM, createMemCpyOptPass(), VerifyEach); // Remove dead memcpys.
+    // Nuke dead stores.
+    addOnePass(PM, createDeadStoreEliminationPass(), VerifyEach);
+
+    // Cleanup and simplify the code after the scalar optimizations.
+    addOnePass(PM, createInstructionCombiningPass(), VerifyEach);
+
+    addOnePass(PM, createJumpThreadingPass(), VerifyEach);
+    
+    // Delete basic blocks, which optimization passes may have killed.
+    addOnePass(PM, createCFGSimplificationPass(), VerifyEach);
 
-    StandardPass::AddPassesFromSet(PM, StandardPass::LTO,
-      StandardPass::OptimizationFlags(0, 0, RunInliner ?
-        StandardPass::RunInliner : 0), VerifyEach);
+    // Now that we have optimized the program, discard unreachable functions.
+    addOnePass(PM, createGlobalDCEPass(), VerifyEach);
   }
 }