diff --git a/include/llvm/DefaultPasses.h b/include/llvm/DefaultPasses.h index e69de29bb2d..8a87bc54144 100644 --- a/include/llvm/DefaultPasses.h +++ b/include/llvm/DefaultPasses.h @@ -0,0 +1,162 @@ +//===- llvm/DefaultPasses.h - Default Pass Support code --------*- 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 the infrastructure for registering the standard pass list. +// This defines sets of standard optimizations that plugins can modify and +// front ends can use. +//===----------------------------------------------------------------------===// + +#ifndef LLVM_DEFAULT_PASS_SUPPORT_H +#define LLVM_DEFAULT_PASS_SUPPORT_H + +namespace llvm { + +class PassManagerBase; + +/// 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; +} + +/// StandardPass - The class responsible for maintaining the lists of standard +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 OptimzationFlags(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) >> DisallowedFlagShift; }; + /// 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 { + public: + 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 : (unsigned char*)&passName::ID, runBefore, set, flags); + }; + }; + /// Adds the passes from the specified set to the provided 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); + /// Creates the verifier pass that is inserted when a VerifyEach is passed to + /// AddPassesFromSet() + static Pass* (*CreateVerifierPass)(void); + /// Registers the pass + static void RegisterDefaultPass(PassInfo::NormalCtor_t constructor, + unsigned char *newPass, + unsigned char *oldPass, + StandardSet set, + unsigned flags=0); +}; + +} // namespace llvm + +#endif diff --git a/include/llvm/Support/StandardPasses.h b/include/llvm/Support/StandardPasses.h index e13e9fae173..491ef1c1679 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/DefaultPasses.h" #include "llvm/Analysis/Passes.h" #include "llvm/Analysis/Verifier.h" #include "llvm/Transforms/Scalar.h" @@ -27,12 +28,279 @@ 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; + StandardPass::CreateVerifierPass = CreateVerifierPass; + } + private: + 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 *createDefaultScalarReplAggregatesPass(void) { + return createScalarReplAggregatesPass(-1, false); + } + static Pass *createDefaultLoopUnswitchPass(void) { + return createLoopUnswitchPass(false); + } + static Pass *createDefaultLoopUnrollPass(void) { + return createLoopUnrollPass(); + } + static Pass *createSizeOptimizingLoopUnswitchPass(void) { + return createLoopUnswitchPass(true); + } + static Pass *createDefaultGVNPass(void) { + return 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(\ + PassInfo::NormalCtor_t(create ## pass ## Pass),\ + &DefaultStandardPasses::pass ## ID, 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(\ + PassInfo::NormalCtor_t(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(\ + PassInfo::NormalCtor_t(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( + 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::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( + PassInfo::NormalCtor_t(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( + PassInfo::NormalCtor_t(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( + PassInfo::NormalCtor_t(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 + StandardPass::RegisterDefaultPass( + PassInfo::NormalCtor_t(createDefaultLoopUnrollPass), + &DefaultStandardPasses::LoopUnrollID, 0, + StandardPass::Module, + StandardPass::OptimzationFlags(0, 0, StandardPass::UnrollLoops)); + // Remove redundancies + StandardPass::RegisterDefaultPass( + PassInfo::NormalCtor_t(createDefaultGVNPass), + &DefaultStandardPasses::GVNID, 0, + StandardPass::Module, 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(\ + 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::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) { - // 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 +310,8 @@ 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::AliasAnalysis); + StandardPass::AddPassesFromSet(PM, StandardPass::Function, OptimizationLevel); } /// createStandardModulePasses - Add the standard list of module passes to the @@ -78,84 +342,17 @@ 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::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); - 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 +371,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); + if (Internalize) { + PM->add(createInternalizePass(true)); + if (VerifyEach) + PM->add(createVerifierPass()); + } - // 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); - - // Now that we have optimized the program, discard unreachable functions. - addOnePass(PM, createGlobalDCEPass(), VerifyEach); + StandardPass::AddPassesFromSet(PM, StandardPass::LTO, + StandardPass::OptimzationFlags(0, 0, RunInliner ? + StandardPass::RunInliner : 0), VerifyEach); } } diff --git a/lib/Support/StandardPasses.cpp b/lib/Support/StandardPasses.cpp index e69de29bb2d..5a98fd68043 100644 --- a/lib/Support/StandardPasses.cpp +++ b/lib/Support/StandardPasses.cpp @@ -0,0 +1,247 @@ +//===-- 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;