diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/llvm/PassSupport.h | 145 | ||||
| -rw-r--r-- | include/llvm/Support/StandardPasses.h | 420 |
2 files changed, 415 insertions, 150 deletions
diff --git a/include/llvm/PassSupport.h b/include/llvm/PassSupport.h index 082790956c..ad6ab754b8 100644 --- a/include/llvm/PassSupport.h +++ b/include/llvm/PassSupport.h @@ -29,6 +29,8 @@ 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 @@ -207,6 +209,149 @@ 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 e13e9fae17..c33322b95c 100644 --- a/include/llvm/Support/StandardPasses.h +++ b/include/llvm/Support/StandardPasses.h @@ -20,6 +20,7 @@ #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" @@ -27,12 +28,259 @@ 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) { - // 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()); + StandardPass::AddPassesFromSet(PM, StandardPass::AliasAnalysis); } /// createStandardFunctionPasses - Add the standard list of function passes to @@ -42,12 +290,7 @@ namespace llvm { /// -O1, etc. static inline void createStandardFunctionPasses(PassManagerBase *PM, unsigned OptimizationLevel) { - if (OptimizationLevel > 0) { - createStandardAliasAnalysisPasses(PM); - PM->add(createCFGSimplificationPass()); - PM->add(createScalarReplAggregatesPass()); - PM->add(createEarlyCSEPass()); - } + StandardPass::AddPassesFromSet(PM, StandardPass::Function, OptimizationLevel); } /// createStandardModulePasses - Add the standard list of module passes to the @@ -78,84 +321,16 @@ 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 - // 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. + 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); - 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 @@ -174,70 +349,15 @@ 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) - 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); + if (Internalize) { + PM->add(createInternalizePass(true)); + if (VerifyEach) + PM->add(createVerifierPass()); + } - // Now that we have optimized the program, discard unreachable functions. - addOnePass(PM, createGlobalDCEPass(), VerifyEach); + StandardPass::AddPassesFromSet(PM, StandardPass::LTO, + StandardPass::OptimizationFlags(0, 0, RunInliner ? + StandardPass::RunInliner : 0), VerifyEach); } } |