X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FIPO.h;h=f9d7f9e6b98afb9dfaf9be10198ac0893c04b3a4;hb=2fac1d5d61a83c45dcf44119c41dce15ef10e9dc;hp=e7590ac019b2aa944a715f488a4cdfb5e85ccd12;hpb=120d053e3ba810b44047fbcb719824bed5673ca9;p=oota-llvm.git diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index e7590ac019b..f9d7f9e6b98 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -19,11 +19,11 @@ namespace llvm { -class FunctionPass; class ModulePass; class Pass; class Function; class BasicBlock; +class GlobalValue; //===----------------------------------------------------------------------===// // @@ -33,11 +33,21 @@ class BasicBlock; ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); //===----------------------------------------------------------------------===// -/// createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics -/// to invoke/unwind instructions. This should really be part of the C/C++ -/// front-end, but it's so much easier to write transformations in LLVM proper. -/// -ModulePass* createLowerSetJmpPass(); +// +// These functions strips symbols from functions and modules. +// Only debugging information is not stripped. +// +ModulePass *createStripNonDebugSymbolsPass(); + +//===----------------------------------------------------------------------===// +// +// These pass removes llvm.dbg.declare intrinsics. +ModulePass *createStripDebugDeclarePass(); + +//===----------------------------------------------------------------------===// +// +// These pass removes unused symbols' debug info. +ModulePass *createStripDeadDebugInfoPass(); //===----------------------------------------------------------------------===// /// createConstantMergePass - This function returns a new pass that merges @@ -56,20 +66,6 @@ ModulePass *createConstantMergePass(); ModulePass *createGlobalOptimizerPass(); -//===----------------------------------------------------------------------===// -/// createRaiseAllocationsPass - Return a new pass that transforms malloc and -/// free function calls into malloc and free instructions. -/// -ModulePass *createRaiseAllocationsPass(); - - -//===----------------------------------------------------------------------===// -/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol -/// table entries for types that are never used. -/// -ModulePass *createDeadTypeEliminationPass(); - - //===----------------------------------------------------------------------===// /// createGlobalDCEPass - This transform is designed to eliminate unreachable /// internal globals (functions or global variables) @@ -78,21 +74,27 @@ ModulePass *createGlobalDCEPass(); //===----------------------------------------------------------------------===// -/// createFunctionExtractionPass - If deleteFn is true, this pass deletes as -/// the specified function. Otherwise, it deletes as much of the module as -/// possible, except for the function specified. +/// createGVExtractionPass - If deleteFn is true, this pass deletes +/// the specified global values. Otherwise, it deletes as much of the module as +/// possible, except for the global values specified. /// -ModulePass *createFunctionExtractionPass(Function *F, bool deleteFn = false, - bool relinkCallees = false); - +ModulePass *createGVExtractionPass(std::vector& GVs, bool + deleteFn = false); //===----------------------------------------------------------------------===// /// createFunctionInliningPass - Return a new pass object that uses a heuristic /// to inline direct function calls to small functions. /// +/// The -inline-threshold command line option takes precedence over the +/// threshold given here. Pass *createFunctionInliningPass(); Pass *createFunctionInliningPass(int Threshold); +//===----------------------------------------------------------------------===// +/// createAlwaysInlinerPass - Return a new pass object that inlines only +/// functions that are marked as "always_inline". +Pass *createAlwaysInlinerPass(); + //===----------------------------------------------------------------------===// /// createPruneEHPass - Return a new pass object which transforms invoke /// instructions into calls, if the callee can _not_ unwind the stack. @@ -101,12 +103,22 @@ Pass *createPruneEHPass(); //===----------------------------------------------------------------------===// /// createInternalizePass - This pass loops over all of the functions in the -/// input module, looking for a main function. If a list of symbols is -/// specified with the -internalize-public-api-* command line options, those -/// symbols are internalized. Otherwise if InternalizeEverything is set and -/// the main function is found, all other globals are marked as internal. +/// input module, internalizing all globals (functions and variables) not part +/// of the api. If a list of symbols is specified with the +/// -internalize-public-api-* command line options, those symbols are not +/// internalized and all others are. Otherwise if AllButMain is set and the +/// main function is found, all other globals are marked as internal. If no api +/// is supplied and AllButMain is not set, or no main function is found, nothing +/// is internalized. +/// +ModulePass *createInternalizePass(bool AllButMain); + +/// createInternalizePass - This pass loops over all of the functions in the +/// input module, internalizing all globals (functions and variables) not in the +/// given exportList. /// -ModulePass *createInternalizePass(bool InternalizeEverything); +/// Note that commandline options that are used with the above function are not +/// used now! Also, when exportList is empty, nothing is internalized. ModulePass *createInternalizePass(const std::vector &exportList); //===----------------------------------------------------------------------===// @@ -122,9 +134,10 @@ ModulePass *createDeadArgHackingPass(); //===----------------------------------------------------------------------===// /// createArgumentPromotionPass - This pass promotes "by reference" arguments to -/// be passed by value. +/// be passed by value if the number of elements passed is smaller or +/// equal to maxElements (maxElements == 0 means always promote). /// -Pass *createArgumentPromotionPass(); +Pass *createArgumentPromotionPass(unsigned maxElements = 3); //===----------------------------------------------------------------------===// /// createIPConstantPropagationPass - This pass propagates constants from call @@ -144,31 +157,41 @@ ModulePass *createIPSCCPPass(); /// createLoopExtractorPass - This pass extracts all natural loops from the /// program into a function if it can. /// -FunctionPass *createLoopExtractorPass(); +Pass *createLoopExtractorPass(); /// createSingleLoopExtractorPass - This pass extracts one natural loop from the /// program into a function if it can. This is used by bugpoint. /// -FunctionPass *createSingleLoopExtractorPass(); +Pass *createSingleLoopExtractorPass(); /// createBlockExtractorPass - This pass extracts all blocks (except those /// specified in the argument list) from the functions in the module. /// -ModulePass *createBlockExtractorPass(const std::vector &BTNE); - -/// createOptimizeWellKnownCallsPass - This pass optimizes specific calls to -/// specific well-known (library) functions. -ModulePass *createSimplifyLibCallsPass(); - - -/// createIndMemRemPass - This pass removes potential indirect calls of -/// malloc and free -ModulePass *createIndMemRemPass(); +ModulePass *createBlockExtractorPass(); /// createStripDeadPrototypesPass - This pass removes any function declarations /// (prototypes) that are not used. ModulePass *createStripDeadPrototypesPass(); +//===----------------------------------------------------------------------===// +/// createFunctionAttrsPass - This pass discovers functions that do not access +/// memory, or only read memory, and gives them the readnone/readonly attribute. +/// It also discovers function arguments that are not captured by the function +/// and marks them with the nocapture attribute. +/// +Pass *createFunctionAttrsPass(); + +//===----------------------------------------------------------------------===// +/// createMergeFunctionsPass - This pass discovers identical functions and +/// collapses them. +/// +ModulePass *createMergeFunctionsPass(); + +//===----------------------------------------------------------------------===// +/// createPartialInliningPass - This pass inlines parts of functions. +/// +ModulePass *createPartialInliningPass(); + } // End llvm namespace #endif