diff options
author | Nick Lewycky <nicholas@mxc.ca> | 2011-05-10 22:16:06 +0000 |
---|---|---|
committer | Nick Lewycky <nicholas@mxc.ca> | 2011-05-10 22:16:06 +0000 |
commit | da07192f8e1127c1d7044ca4657cd5f2de92e564 (patch) | |
tree | 8bac6260fe6a5e07ae8efb01ce4c5fef86a8e791 /include/llvm | |
parent | 354c82bdf554bc5e6fa5c77f7c357577860d66d8 (diff) | |
download | llvm-da07192f8e1127c1d7044ca4657cd5f2de92e564.tar.gz llvm-da07192f8e1127c1d7044ca4657cd5f2de92e564.tar.bz2 llvm-da07192f8e1127c1d7044ca4657cd5f2de92e564.tar.xz |
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
Diffstat (limited to 'include/llvm')
-rw-r--r-- | include/llvm/PassSupport.h | 145 | ||||
-rw-r--r-- | include/llvm/Support/StandardPasses.h | 420 |
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); } } |