remove StandardPasses, it has been replaced with PassManagerBuilder

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

3 files changed, 0 insertions, 651 deletions

diff --git a/include/llvm/Support/StandardPasses.h b/include/llvm/Support/StandardPasses.h
deleted file mode 100644
index cfea5be..0000000
--- a/include/llvm/Support/StandardPasses.h
+++ /dev/null
@@ -1,403 +0,0 @@
-//===-- llvm/Support/StandardPasses.h - Standard pass lists -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines utility functions for creating a "standard" set of
-// optimization passes, so that compilers and tools which use optimization
-// passes use the same set of standard passes.
-//
-// These are implemented as inline functions so that we do not have to worry
-// about link issues.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_SUPPORT_STANDARDPASSES_H
-#define LLVM_SUPPORT_STANDARDPASSES_H
-
-#include "llvm/PassManager.h"
-#include "llvm/DefaultPasses.h"
-#include "llvm/Analysis/Passes.h"
-#include "llvm/Analysis/Verifier.h"
-#include "llvm/Transforms/Scalar.h"
-#include "llvm/Transforms/IPO.h"
-
-namespace llvm {
-    //template<Pass*(*X)(void)> static Pass *CreatePassFn(void) { return X(); }
-
-  /// 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;
-      StandardPass::CreateVerifierPass = CreateVerifierPass;
-    }
-    private:
-    /// Define a set of function overloads that does the casting for us, so
-    /// that we can perform safe function pointer casts, but catch unsafe ones.
-    PassInfo::NormalCtor_t static CreatePassFn(llvm::ImmutablePass*(*X)(void)) {
-     return reinterpret_cast<PassInfo::NormalCtor_t>(X);
-    }
-    PassInfo::NormalCtor_t static CreatePassFn(llvm::ModulePass*(*X)(void)) {
-      return reinterpret_cast<PassInfo::NormalCtor_t>(X);
-    }
-    PassInfo::NormalCtor_t static CreatePassFn(llvm::FunctionPass*(*X)(void)) {
-      return reinterpret_cast<PassInfo::NormalCtor_t>(X);
-    }
-    PassInfo::NormalCtor_t static CreatePassFn(llvm::Pass*(*X)(void)) {
-      return reinterpret_cast<PassInfo::NormalCtor_t>(X);
-    }
-
-    static llvm::Pass *CreateVerifierPass() { return createVerifierPass(); }
-    /// Passes must be registered with functions that take no arguments, so we have
-    /// to wrap their existing constructors.  
-    static Pass *createScalarReplAggregatesPass(void) {
-      return llvm::createScalarReplAggregatesPass();
-    }
-    static Pass *createSSAScalarReplAggregatesPass(void) {
-      return llvm::createScalarReplAggregatesPass(-1, false);
-    }
-    static Pass *createDefaultLoopUnswitchPass(void) {
-      return createLoopUnswitchPass(false);
-    }
-    static Pass *createSizeOptimizingLoopUnswitchPass(void) {
-      return createLoopUnswitchPass(true);
-    }
-    static Pass *createArgumentPromotionPass(void) {
-      return llvm::createArgumentPromotionPass();
-    }
-    static Pass *createLoopUnrollPass(void) {
-      return llvm::createLoopUnrollPass();
-    }
-    static Pass *createGVNPass(void) {
-      return llvm::createGVNPass();
-    }
-    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(\
-    CreatePassFn(create ## pass ## Pass),\
-    &DefaultStandardPasses::pass ## ID, (unsigned char*)0, StandardPass::AliasAnalysis, flags)
-      DEFAULT_ALIAS_ANALYSIS_PASS(TypeBasedAliasAnalysis, 0);
-      DEFAULT_ALIAS_ANALYSIS_PASS(BasicAliasAnalysis, 0);
-#undef DEFAULT_ALIAS_ANALYSIS_PASS
-
-#define DEFAULT_FUNCTION_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-      CreatePassFn(create ## pass ## Pass),\
-      &DefaultStandardPasses::pass ## ID, 0, StandardPass::Function, flags)
-      DEFAULT_FUNCTION_PASS(CFGSimplification,
-          StandardPass::OptimzationFlags(1));
-      DEFAULT_FUNCTION_PASS(ScalarReplAggregates,
-          StandardPass::OptimzationFlags(1));
-      DEFAULT_FUNCTION_PASS(EarlyCSE, StandardPass::OptimzationFlags(1));
-#undef DEFAULT_FUNCTION_PASS
-
-#define DEFAULT_MODULE_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-      CreatePassFn(create ## pass ## Pass),\
-      &DefaultStandardPasses::pass ## ID, 0, StandardPass::Module, flags)
-      // Optimize out global vars
-      DEFAULT_MODULE_PASS(GlobalOptimizer,
-          StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
-      // IP SCCP
-      DEFAULT_MODULE_PASS(IPSCCP,
-          StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
-      // Dead argument elimination
-      DEFAULT_MODULE_PASS(DeadArgElimination,
-          StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
-      // Clean up after IPCP & DAE
-      DEFAULT_MODULE_PASS(InstructionCombining,
-          StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
-      // Clean up after IPCP & DAE
-      DEFAULT_MODULE_PASS(CFGSimplification,
-          StandardPass::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
-
-      // Remove dead EH info
-      DEFAULT_MODULE_PASS(PruneEH, StandardPass::OptimzationFlags(0, 0,
-            StandardPass::UnitAtATime | StandardPass::HaveExceptions));
-      // Placeholder that will be replaced by an inliner if one is specified
-      StandardPass::RegisterDefaultPass(0,
-        &DefaultStandardPasses::InlinerPlaceholderID, 0,
-        StandardPass::Module);
-      // Set readonly/readnone attrs
-      DEFAULT_MODULE_PASS(FunctionAttrs, StandardPass::OptimzationFlags(0, 0,
-            StandardPass::UnitAtATime));
-      // Scalarize uninlined fn args
-      DEFAULT_MODULE_PASS(ArgumentPromotion, StandardPass::OptimzationFlags(3));
-      // Start of function pass.
-      // Break up aggregate allocas, using SSAUpdater.
-      StandardPass::RegisterDefaultPass(
-          CreatePassFn(createSSAScalarReplAggregatesPass),
-          &DefaultStandardPasses::ScalarReplAggregatesID, 0,
-          StandardPass::Module, 0);
-      // Catch trivial redundancies
-      DEFAULT_MODULE_PASS(EarlyCSE, 0);
-      // Library Call Optimizations
-      DEFAULT_MODULE_PASS(SimplifyLibCalls,
-          StandardPass::OptimzationFlags(0, 0, 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(
-          CreatePassFn(createSizeOptimizingLoopUnswitchPass),
-          &DefaultStandardPasses::LoopUnswitchID, 0,
-          StandardPass::Module,
-          StandardPass::OptimzationFlags(0, 2));
-      // Optimize for size if the optimzation level is >2, and OptimizeSize is
-      // set
-      StandardPass::RegisterDefaultPass(
-          CreatePassFn(createSizeOptimizingLoopUnswitchPass),
-          &DefaultStandardPasses::LoopUnswitchID, 0,
-          StandardPass::Module,
-          StandardPass::OptimzationFlags(3, 0, StandardPass::OptimizeSize));
-      // Don't optimize for size if optimisation level is >2 and OptimizeSize
-      // is not set
-      StandardPass::RegisterDefaultPass(
-          CreatePassFn(createDefaultLoopUnswitchPass),
-          &DefaultStandardPasses::LoopUnswitchID, 0,
-          StandardPass::Module,
-          StandardPass::OptimzationFlags(3, 0, 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::OptimzationFlags(0, 0, StandardPass::UnrollLoops));
-      // Remove redundancies
-      DEFAULT_MODULE_PASS(GVN, StandardPass::OptimzationFlags(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::OptimzationFlags(0, 0, StandardPass::UnitAtATime));
-      // Eliminate dead types
-      DEFAULT_MODULE_PASS(DeadTypeElimination,
-              StandardPass::OptimzationFlags(0, 0, 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,
-              StandardPass::OptimzationFlags(3, 0, StandardPass::UnitAtATime));
-      // Merge dup global constants
-      DEFAULT_MODULE_PASS(ConstantMerge,
-              StandardPass::OptimzationFlags(2, 0, StandardPass::UnitAtATime));
-#undef DEFAULT_MODULE_PASS
-
-#define DEFAULT_LTO_PASS(pass, flags)\
-  StandardPass::RegisterDefaultPass(\
-      CreatePassFn(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::OptimzationFlags(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::OptimzationFlags(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);
-  }
-
-  /// createStandardFunctionPasses - Add the standard list of function passes to
-  /// the provided pass manager.
-  ///
-  /// \arg OptimizationLevel - The optimization level, corresponding to -O0,
-  /// -O1, etc.
-  static inline void createStandardFunctionPasses(PassManagerBase *PM,
-                                                  unsigned OptimizationLevel) {
-    StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis);
-    StandardPass::AddPassesFromSet(PM, StandardPass::Function, OptimizationLevel);
-  }
-
-  /// createStandardModulePasses - Add the standard list of module passes to the
-  /// provided pass manager.
-  ///
-  /// \arg OptimizationLevel - The optimization level, corresponding to -O0,
-  /// -O1, etc.
-  /// \arg OptimizeSize - Whether the transformations should optimize for size.
-  /// \arg UnitAtATime - Allow passes which may make global module changes.
-  /// \arg UnrollLoops - Allow loop unrolling.
-  /// \arg SimplifyLibCalls - Allow library calls to be simplified.
-  /// \arg HaveExceptions - Whether the module may have code using exceptions.
-  /// \arg InliningPass - The inlining pass to use, if any, or null. This will
-  /// always be added, even at -O0.
-  static inline void createStandardModulePasses(PassManagerBase *PM,
-                                                unsigned OptimizationLevel,
-                                                bool OptimizeSize,
-                                                bool UnitAtATime,
-                                                bool UnrollLoops,
-                                                bool SimplifyLibCalls,
-                                                bool HaveExceptions,
-                                                Pass *InliningPass) {
-    createStandardAliasAnalysisPasses(PM);
-
-    // If all optimizations are disabled, just run the always-inline pass.
-    if (OptimizationLevel == 0) {
-      if (InliningPass)
-        PM->add(InliningPass);
-      return;
-    }
-
-    StandardPass::AddPassesFromSet(PM, StandardPass::Module,
-      StandardPass::OptimzationFlags(OptimizationLevel, 0,
-        (OptimizeSize ? StandardPass::OptimizeSize : 0) |
-        (UnitAtATime ? StandardPass::UnitAtATime : 0) |
-        (UnrollLoops ? StandardPass::UnrollLoops : 0) |
-        (SimplifyLibCalls ? StandardPass::SimplifyLibCalls : 0) |
-        (HaveExceptions ? StandardPass::HaveExceptions : 0)),
-      false,
-      InliningPass);
-    
-  }
-
-  /// createStandardLTOPasses - Add the standard list of module passes suitable
-  /// for link time optimization.
-  ///
-  /// Internalize - Run the internalize pass.
-  /// RunInliner - Use a function inlining pass.
-  /// VerifyEach - Run the verifier after each pass.
-  static inline void createStandardLTOPasses(PassManagerBase *PM,
-                                             bool Internalize,
-                                             bool RunInliner,
-                                             bool VerifyEach) {
-    // Provide AliasAnalysis services for optimizations.
-    createStandardAliasAnalysisPasses(PM);
-
-    // 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());
-    }
-
-    StandardPass::AddPassesFromSet(PM, StandardPass::LTO,
-      StandardPass::OptimzationFlags(0, 0, RunInliner ?
-        StandardPass::RunInliner : 0), VerifyEach);
-  }
-}
-
-#endif
diff --git a/lib/VMCore/CMakeLists.txt b/lib/VMCore/CMakeLists.txt
index 4295804..6bde263 100644
--- a/lib/VMCore/CMakeLists.txt
+++ b/lib/VMCore/CMakeLists.txt
@@ -28,7 +28,6 @@ add_llvm_library(LLVMCore
   PassManager.cpp
   PassRegistry.cpp
   PrintModulePass.cpp
-  StandardPasses.cpp
   Type.cpp
   TypeSymbolTable.cpp
   Use.cpp
diff --git a/lib/VMCore/StandardPasses.cpp b/lib/VMCore/StandardPasses.cpp
deleted file mode 100644
index 842fbd4..0000000
--- a/lib/VMCore/StandardPasses.cpp
+++ /dev/null
@@ -1,247 +0,0 @@
-//===-- lib/Support/StandardPasses.cpp - Standard pass lists -----*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines utility functions for creating a "standard" set of
-// optimization passes, so that compilers and tools which use optimization
-// passes use the same set of standard passes.
-//
-// This allows the creation of multiple standard sets, and their later
-// modification by plugins and front ends.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/PassManager.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/ManagedStatic.h"
-#include "llvm/DefaultPasses.h"
-#include "llvm/Support/Mutex.h"
-
-using namespace llvm::DefaultStandardPasses;
-using namespace llvm;
-
-namespace {
-
-/// Entry in the standard passes list.
-struct StandardPassEntry {
-  /// Function called to create the pass
-  PassInfo::NormalCtor_t createPass;
-  /// Unique identifier for this pass
-  unsigned char *passID;
-  /// Flags specifying when this pass should be run
-  unsigned flags;
-
-  StandardPassEntry(PassInfo::NormalCtor_t constructor, unsigned char *ID,
-      unsigned f) : createPass(constructor), passID(ID), flags(f) {}
-};
-
-/// Standard alias analysis passes
-static llvm::SmallVector<StandardPassEntry, 4> AAPasses;
-/// Standard function passes
-static llvm::SmallVector<StandardPassEntry, 32> FunctionPasses;
-/// Standard module passes
-static llvm::SmallVector<StandardPassEntry, 32> ModulePasses;
-/// Standard link-time optimization passes
-static llvm::SmallVector<StandardPassEntry, 32> LTOPasses;
-
-/// Entry in the unresolved standard pass list.  IF a pass is inserted in front
-/// of a pass that is not yet registered in the standard pass list then it is
-/// stored in a separate list and resolved later.
-struct UnresolvedStandardPass : public StandardPassEntry {
-  /// The set into which this is stored
-  StandardPass::StandardSet set;
-  /// The unique ID of the pass that should follow this one in the sequence
-  unsigned char *next;
-  UnresolvedStandardPass(PassInfo::NormalCtor_t constructor,
-                         unsigned char *newPass,
-                         unsigned char *oldPass,
-                         StandardPass::StandardSet s,
-                         unsigned f) :
-    StandardPassEntry(constructor, newPass, f), set(s), next(oldPass) {}
-};
-
-/// The passes that can not be inserted into the correct lists yet because of
-/// their place in the sequence.
-static llvm::SmallVector<UnresolvedStandardPass, 16> UnresolvedPasses;
-
-/// Returns a reference to the pass list for the corresponding set of
-/// optimisations.
-llvm::SmallVectorImpl<StandardPassEntry>&
-PassList(StandardPass::StandardSet set) {
-  switch (set) {
-    case StandardPass::AliasAnalysis: return AAPasses;
-    case StandardPass::Function: return FunctionPasses;
-    case StandardPass::Module: return ModulePasses;
-    case StandardPass::LTO: return LTOPasses; 
-  }
-  // We could use a map of standard pass lists to allow definition of new
-  // default sets
-  llvm_unreachable("Invalid standard optimization set requested");
-}
-
-static ManagedStatic<sys::SmartMutex<true> > Lock;
-
-/// Registers the default set of standard passes.  This is called lazily when
-/// an attempt is made to read or modify the standard pass list
-void RegisterDefaultStandardPasses(void(*doRegister)(void)) {
-  // Only initialize the standard passes once
-  static volatile bool initialized = false;
-  if (initialized) return;
-
-  llvm::sys::SmartScopedLock<true> Guard(*Lock);
-  if (initialized) return;
-  if (doRegister) {
-    assert("No passes registered before setting default passes" &&
-            AAPasses.size() == 0 &&
-            FunctionPasses.size() == 0 &&
-            LTOPasses.size() == 0 &&
-            ModulePasses.size() == 0);
-
-    // We must set initialized to true before calling this function, because
-    // the doRegister() function will probably call RegisterDefaultPasses(),
-    // which will call this function, and we'd end up with infinite recursion
-    // and breakage if we didn't.
-    initialized = true;
-    doRegister();
-  }
-}
-
-} // Anonymous namespace
-
-void (*StandardPass::RegisterDefaultPasses)(void);
-Pass* (*StandardPass::CreateVerifierPass)(void);
-
-void StandardPass::RegisterDefaultPass(PassInfo::NormalCtor_t constructor,
-                                       unsigned char *newPass,
-                                       unsigned char *oldPass,
-                                       StandardPass::StandardSet set,
-                                       unsigned flags) {
-  // Make sure that the standard sets are already regstered
-  RegisterDefaultStandardPasses(RegisterDefaultPasses);
-  // Get the correct list to modify
-  llvm::SmallVectorImpl<StandardPassEntry>& passList = PassList(set);
-
-  // If there is no old pass specified, then we are adding a new final pass, so
-  // just push it onto the end.
-  if (!oldPass) {
-    StandardPassEntry pass(constructor, newPass, flags);
-    passList.push_back(pass);
-    return;
-  }
-
-  // Find the correct place to insert the pass.  This is a linear search, but
-  // this shouldn't be too slow since the SmallVector will store the values in
-  // a contiguous block of memory.  Each entry is just three words of memory, so
-  // in most cases we are only going to be looking in one or two cache lines.
-  // The extra memory accesses from a more complex search structure would
-  // offset any performance gain (unless someone decides to add an insanely
-  // large set of standard passes to a set)
-  for (SmallVectorImpl<StandardPassEntry>::iterator i=passList.begin(),
-       e=passList.end() ; i!=e ; ++i) {
-    if (i->passID == oldPass) {
-      StandardPassEntry pass(constructor, newPass, flags);
-      passList.insert(i, pass);
-      // If we've added a new pass, then there may have gained the ability to
-      // insert one of the previously unresolved ones.  If so, insert the new
-      // one.
-      for (SmallVectorImpl<UnresolvedStandardPass>::iterator
-          u=UnresolvedPasses.begin(), eu=UnresolvedPasses.end() ; u!=eu ; ++u){
-        if (u->next == newPass && u->set == set) {
-          UnresolvedStandardPass p = *u;
-          UnresolvedPasses.erase(u);
-          RegisterDefaultPass(p.createPass, p.passID, p.next, p.set, p.flags);
-        }
-      }
-      return;
-    }
-  }
-  // If we get to here, then we didn't find the correct place to insert the new
-  // pass
-  UnresolvedStandardPass pass(constructor, newPass, oldPass, set, flags);
-  UnresolvedPasses.push_back(pass);
-}
-
-void StandardPass::AddPassesFromSet(PassManagerBase *PM,
-                                    StandardSet set,
-                                    unsigned flags,
-                                    bool VerifyEach,
-                                    Pass *inliner) {
-  RegisterDefaultStandardPasses(RegisterDefaultPasses);
-  unsigned level = OptimizationLevel(flags);
-  flags = RequiredFlags(flags);
-  llvm::SmallVectorImpl<StandardPassEntry>& passList = PassList(set);
-
-  // Add all of the passes from this set
-  for (SmallVectorImpl<StandardPassEntry>::iterator i=passList.begin(),
-       e=passList.end() ; i!=e ; ++i) {
-    // Skip passes that don't have conditions that match the ones specified
-    // here.  For a pass to match:
-    // - Its minimum optimisation level must be less than or equal to the
-    //   specified level.
-    // - Its maximum optimisation level must be greater than or equal to the
-    //   specified level
-    // - All of its required flags must be set
-    // - None of its disallowed flags may be set
-    if ((level >= OptimizationLevel(i->flags)) &&
-        ((level <= MaxOptimizationLevel(i->flags))
-          || MaxOptimizationLevel(i->flags) == 0)  &&
-        ((RequiredFlags(i->flags) & flags) == RequiredFlags(i->flags)) &&
-        ((DisallowedFlags(i->flags) & flags) == 0)) {
-      // This is quite an ugly way of allowing us to specify an inliner pass to
-      // insert.  Ideally, we'd replace this with a general mechanism allowing
-      // callers to replace arbitrary passes in the list.
-      Pass *p = 0;
-      if (&InlinerPlaceholderID == i->passID) {
-          p = inliner;
-      } else if (i->createPass)
-        p = i->createPass();
-      if (p) {
-        PM->add(p);
-        if (VerifyEach)
-          PM->add(CreateVerifierPass());
-      }
-    }
-  }
-}
-
-unsigned char DefaultStandardPasses::AggressiveDCEID;
-unsigned char DefaultStandardPasses::ArgumentPromotionID;
-unsigned char DefaultStandardPasses::BasicAliasAnalysisID;
-unsigned char DefaultStandardPasses::CFGSimplificationID;
-unsigned char DefaultStandardPasses::ConstantMergeID;
-unsigned char DefaultStandardPasses::CorrelatedValuePropagationID;
-unsigned char DefaultStandardPasses::DeadArgEliminationID;
-unsigned char DefaultStandardPasses::DeadStoreEliminationID;
-unsigned char DefaultStandardPasses::DeadTypeEliminationID;
-unsigned char DefaultStandardPasses::EarlyCSEID;
-unsigned char DefaultStandardPasses::FunctionAttrsID;
-unsigned char DefaultStandardPasses::FunctionInliningID;
-unsigned char DefaultStandardPasses::GVNID;
-unsigned char DefaultStandardPasses::GlobalDCEID;
-unsigned char DefaultStandardPasses::GlobalOptimizerID;
-unsigned char DefaultStandardPasses::GlobalsModRefID;
-unsigned char DefaultStandardPasses::IPSCCPID;
-unsigned char DefaultStandardPasses::IndVarSimplifyID;
-unsigned char DefaultStandardPasses::InlinerPlaceholderID;
-unsigned char DefaultStandardPasses::InstructionCombiningID;
-unsigned char DefaultStandardPasses::JumpThreadingID;
-unsigned char DefaultStandardPasses::LICMID;
-unsigned char DefaultStandardPasses::LoopDeletionID;
-unsigned char DefaultStandardPasses::LoopIdiomID;
-unsigned char DefaultStandardPasses::LoopRotateID;
-unsigned char DefaultStandardPasses::LoopUnrollID;
-unsigned char DefaultStandardPasses::LoopUnswitchID;
-unsigned char DefaultStandardPasses::MemCpyOptID;
-unsigned char DefaultStandardPasses::PruneEHID;
-unsigned char DefaultStandardPasses::ReassociateID;
-unsigned char DefaultStandardPasses::SCCPID;
-unsigned char DefaultStandardPasses::ScalarReplAggregatesID;
-unsigned char DefaultStandardPasses::SimplifyLibCallsID;
-unsigned char DefaultStandardPasses::StripDeadPrototypesID;
-unsigned char DefaultStandardPasses::TailCallEliminationID;
-unsigned char DefaultStandardPasses::TypeBasedAliasAnalysisID;