From dcef3469486e187ea038938df7e40bd5ff922bff Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 22 May 2011 00:30:45 +0000 Subject: [PATCH] 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 --- include/llvm/Support/StandardPasses.h | 403 -------------------------- lib/VMCore/CMakeLists.txt | 1 - lib/VMCore/StandardPasses.cpp | 247 ---------------- 3 files changed, 651 deletions(-) delete mode 100644 include/llvm/Support/StandardPasses.h delete mode 100644 lib/VMCore/StandardPasses.cpp diff --git a/include/llvm/Support/StandardPasses.h b/include/llvm/Support/StandardPasses.h deleted file mode 100644 index cfea5be9467..00000000000 --- 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 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(X); - } - PassInfo::NormalCtor_t static CreatePassFn(llvm::ModulePass*(*X)(void)) { - return reinterpret_cast(X); - } - PassInfo::NormalCtor_t static CreatePassFn(llvm::FunctionPass*(*X)(void)) { - return reinterpret_cast(X); - } - PassInfo::NormalCtor_t static CreatePassFn(llvm::Pass*(*X)(void)) { - return reinterpret_cast(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 4295804723b..6bde263ce62 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 842fbd42282..00000000000 --- 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 AAPasses; -/// Standard function passes -static llvm::SmallVector FunctionPasses; -/// Standard module passes -static llvm::SmallVector ModulePasses; -/// Standard link-time optimization passes -static llvm::SmallVector 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 UnresolvedPasses; - -/// Returns a reference to the pass list for the corresponding set of -/// optimisations. -llvm::SmallVectorImpl& -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 > 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 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& 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::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::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& passList = PassList(set); - - // Add all of the passes from this set - for (SmallVectorImpl::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;