X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FIPO.h;h=18176e8fdbb157012ea48c1100fc414b9c84f0e0;hb=3610a15c3581dee713820f72d8ffe2e2a632b057;hp=1adc1d16f809fcea2280810d21ce0e06fe3d1e85;hpb=45df557348d3c3e9ae3ebbb6304d739a88f46c54;p=oota-llvm.git diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index 1adc1d16f80..18176e8fdbb 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -1,10 +1,10 @@ //===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// // // This header file defines prototypes for accessor functions that expose passes @@ -19,81 +19,82 @@ namespace llvm { +class ModulePass; class Pass; class Function; class BasicBlock; +class GlobalValue; //===----------------------------------------------------------------------===// -/// 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. -/// -Pass* createLowerSetJmpPass(); +// +// These functions removes symbols from functions and modules. If OnlyDebugInfo +// is true, only debugging information is removed from the module. +// +ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); //===----------------------------------------------------------------------===// -/// createConstantMergePass - This function returns a new pass that merges -/// duplicate global constants together into a single constant that is shared. -/// This is useful because some passes (ie TraceValues) insert a lot of string -/// constants into the program, regardless of whether or not they duplicate an -/// existing string. -/// -Pass *createConstantMergePass(); - +// +// These functions strips symbols from functions and modules. +// Only debugging information is not stripped. +// +ModulePass *createStripNonDebugSymbolsPass(); //===----------------------------------------------------------------------===// -/// createGlobalConstifierPass - This function returns a new pass that marks -/// internal globals "constant" if they are provably never written to. -/// -Pass *createGlobalConstifierPass(); +// +// These pass removes llvm.dbg.declare intrinsics. +ModulePass *createStripDebugDeclarePass(); +//===----------------------------------------------------------------------===// +// +// These pass removes unused symbols' debug info. +ModulePass *createStripDeadDebugInfoPass(); //===----------------------------------------------------------------------===// -/// createRaiseAllocationsPass - Return a new pass that transforms malloc and -/// free function calls into malloc and free instructions. +/// createConstantMergePass - This function returns a new pass that merges +/// duplicate global constants together into a single constant that is shared. +/// This is useful because some passes (ie TraceValues) insert a lot of string +/// constants into the program, regardless of whether or not they duplicate an +/// existing string. /// -Pass *createRaiseAllocationsPass(); +ModulePass *createConstantMergePass(); //===----------------------------------------------------------------------===// -/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol -/// table entries for types that are never used. +/// createGlobalOptimizerPass - This function returns a new pass that optimizes +/// non-address taken internal globals. /// -Pass *createDeadTypeEliminationPass(); +ModulePass *createGlobalOptimizerPass(); //===----------------------------------------------------------------------===// /// createGlobalDCEPass - This transform is designed to eliminate unreachable /// internal globals (functions or global variables) /// -Pass *createGlobalDCEPass(); +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. /// -Pass *createFunctionExtractionPass(Function *F, bool deleteFn = false); - - -//===----------------------------------------------------------------------===// -/// FunctionResolvingPass - Go over the functions that are in the module and -/// look for functions that have the same name. More often than not, there will -/// be things like: -/// void "foo"(...) -/// void "foo"(int, int) -/// because of the way things are declared in C. If this is the case, patch -/// things up. -/// -/// This is an interprocedural pass. -/// -Pass *createFunctionResolvingPass(); +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(); +Pass *createAlwaysInlinerPass(bool InsertLifetime); //===----------------------------------------------------------------------===// /// createPruneEHPass - Return a new pass object which transforms invoke @@ -103,46 +104,94 @@ Pass *createPruneEHPass(); //===----------------------------------------------------------------------===// /// createInternalizePass - This pass loops over all of the functions in the -/// input module, looking for a main function. If a main function is found, all -/// other functions 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. /// -Pass *createInternalizePass(); +/// 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); //===----------------------------------------------------------------------===// /// createDeadArgEliminationPass - This pass removes arguments from functions /// which are not used by the body of the function. /// -Pass *createDeadArgEliminationPass(); +ModulePass *createDeadArgEliminationPass(); /// DeadArgHacking pass - Same as DAE, but delete arguments of external /// functions as well. This is definitely not safe, and should only be used by /// bugpoint. -Pass *createDeadArgHackingPass(); +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 /// sites into the bodies of functions. /// -Pass *createIPConstantPropagationPass(); +ModulePass *createIPConstantPropagationPass(); +//===----------------------------------------------------------------------===// +/// createIPSCCPPass - This pass propagates constants from call sites into the +/// bodies of functions, and keeps track of whether basic blocks are executable +/// in the process. +/// +ModulePass *createIPSCCPPass(); //===----------------------------------------------------------------------===// // +/// createLoopExtractorPass - This pass extracts all natural loops from the +/// program into a function if it can. +/// +Pass *createLoopExtractorPass(); + /// createSingleLoopExtractorPass - This pass extracts one natural loop from the /// program into a function if it can. This is used by bugpoint. /// Pass *createSingleLoopExtractorPass(); -// createBlockExtractorPass - This pass extracts all blocks (except those -// specified in the argument list) from the functions in the module. -// -Pass *llvm::createBlockExtractorPass(std::vector &BTNE); +/// createBlockExtractorPass - This pass extracts all blocks (except those +/// specified in the argument list) from the functions in the module. +/// +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