From: Nick Lewycky Date: Tue, 10 May 2011 22:16:06 +0000 (+0000) Subject: Revert r131155 for now. It makes VMCore depend on Analysis and Transforms X-Git-Url: http://plrg.eecs.uci.edu/git/?a=commitdiff_plain;h=da07192f8e1127c1d7044ca4657cd5f2de92e564;p=oota-llvm.git 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 --- diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h index ad6ab754b8a..082790956c4 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<> 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 - 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), - 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 c33322b95c5..e13e9fae173 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); } } diff --git a/lib/VMCore/StandardPasses.cpp b/lib/VMCore/StandardPasses.cpp index 56759a45c0e..e69de29bb2d 100644 --- a/lib/VMCore/StandardPasses.cpp +++ b/lib/VMCore/StandardPasses.cpp @@ -1,240 +0,0 @@ -//=========-- 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. -// -//===----------------------------------------------------------------------===// - -#include "llvm/PassManager.h" -#include "llvm/Analysis/Passes.h" -#include "llvm/Analysis/Verifier.h" -#include "llvm/Analysis/Verifier.h" -#include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/ManagedStatic.h" -#include "llvm/Support/Mutex.h" -#include "llvm/Support/DynamicLibrary.h" -#include "llvm/Transforms/Scalar.h" -#include "llvm/Transforms/IPO.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 bool initialized = false; - if (initialized) return; - - llvm::sys::SmartScopedLock Guard(*Lock); - if (initialized) return; - if (doRegister) { - // 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); - -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 - 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 = inliner; - if ((&InlinerPlaceholderID != i->passID) && 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;