X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTransforms%2FIPO.h;h=0c374a070ce8390247b27bb94229e9a40f52c3e6;hb=053615be026c65a88de1eb79642f2521174cd502;hp=eba40b8516bdd1b487358ecd559411aaaa035b0a;hpb=3433141a3e5cae22f79019f52b624d0f384018a7;p=oota-llvm.git diff --git a/include/llvm/Transforms/IPO.h b/include/llvm/Transforms/IPO.h index eba40b8516b..0c374a070ce 100644 --- a/include/llvm/Transforms/IPO.h +++ b/include/llvm/Transforms/IPO.h @@ -2,8 +2,8 @@ // // 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. // //===----------------------------------------------------------------------===// // @@ -15,14 +15,17 @@ #ifndef LLVM_TRANSFORMS_IPO_H #define LLVM_TRANSFORMS_IPO_H -#include +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/StringRef.h" namespace llvm { -class FunctionPass; +class FunctionInfoIndex; class ModulePass; +class Pass; class Function; class BasicBlock; +class GlobalValue; //===----------------------------------------------------------------------===// // @@ -32,11 +35,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 @@ -47,76 +60,75 @@ ModulePass* createLowerSetJmpPass(); /// ModulePass *createConstantMergePass(); - //===----------------------------------------------------------------------===// /// createGlobalOptimizerPass - This function returns a new pass that optimizes /// non-address taken internal globals. /// 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) /// 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. +/// This transform is designed to eliminate available external globals +/// (functions or global variables) /// -ModulePass *createFunctionExtractionPass(Function *F, bool deleteFn = false); - +ModulePass *createEliminateAvailableExternallyPass(); //===----------------------------------------------------------------------===// -/// 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. +/// 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 *createFunctionResolvingPass(); +ModulePass *createGVExtractionPass(std::vector& GVs, bool + deleteFn = false); + +//===----------------------------------------------------------------------===// +/// This pass performs iterative function importing from other modules. +Pass *createFunctionImportPass(const FunctionInfoIndex *Index = nullptr); //===----------------------------------------------------------------------===// /// createFunctionInliningPass - Return a new pass object that uses a heuristic /// to inline direct function calls to small functions. /// -ModulePass *createFunctionInliningPass(); +/// The Threshold can be passed directly, or asked to be computed from the +/// given optimization and size optimization arguments. +/// +/// The -inline-threshold command line option takes precedence over the +/// threshold given here. +Pass *createFunctionInliningPass(); +Pass *createFunctionInliningPass(int Threshold); +Pass *createFunctionInliningPass(unsigned OptLevel, unsigned SizeOptLevel); + +//===----------------------------------------------------------------------===// +/// 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 /// instructions into calls, if the callee can _not_ unwind the stack. /// -ModulePass *createPruneEHPass(); +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) it can. +//// +/// The symbols in \p ExportList are never internalized. +/// +/// The symbol in DSOList are internalized if it is safe to drop them from +/// the symbol table. /// -ModulePass *createInternalizePass(bool InternalizeEverything); +/// Note that commandline options that are used with the above function are not +/// used now! +ModulePass *createInternalizePass(ArrayRef ExportList); +/// createInternalizePass - Same as above, but with an empty exportList. +ModulePass *createInternalizePass(); //===----------------------------------------------------------------------===// /// createDeadArgEliminationPass - This pass removes arguments from functions @@ -131,9 +143,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). /// -ModulePass *createArgumentPromotionPass(); +Pass *createArgumentPromotionPass(unsigned maxElements = 3); //===----------------------------------------------------------------------===// /// createIPConstantPropagationPass - This pass propagates constants from call @@ -153,26 +166,63 @@ 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(); + +/// 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(); -// createBlockExtractorPass - This pass extracts all blocks (except those -// specified in the argument list) from the functions in the module. +//===----------------------------------------------------------------------===// +/// createPartialInliningPass - This pass inlines parts of functions. +/// +ModulePass *createPartialInliningPass(); + +//===----------------------------------------------------------------------===// +// createMetaRenamerPass - Rename everything with metasyntatic names. // -ModulePass *createBlockExtractorPass(std::vector &BTNE); +ModulePass *createMetaRenamerPass(); -// createOptimizeWellKnownCallsPass - This pass optimizes specific calls to -// specific well-known (library) functions. -ModulePass *createSimplifyLibCallsPass(); +//===----------------------------------------------------------------------===// +/// createBarrierNoopPass - This pass is purely a module pass barrier in a pass +/// manager. +ModulePass *createBarrierNoopPass(); +/// \brief This pass lowers bitset metadata and the llvm.bitset.test intrinsic +/// to bitsets. +ModulePass *createLowerBitSetsPass(); -// createIndMemRemPass - This pass removes potential indirect calls of -// malloc and free -ModulePass *createIndMemRemPass(); +/// \brief This pass export CFI checks for use by external modules. +ModulePass *createCrossDSOCFIPass(); + +//===----------------------------------------------------------------------===// +// SampleProfilePass - Loads sample profile data from disk and generates +// IR metadata to reflect the profile. +ModulePass *createSampleProfileLoaderPass(); +ModulePass *createSampleProfileLoaderPass(StringRef Name); } // End llvm namespace