IPO.h revision 34695381d626485a560594f162701088079589df
1//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header file defines prototypes for accessor functions that expose passes 11// in the IPO transformations library. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef LLVM_TRANSFORMS_IPO_H 16#define LLVM_TRANSFORMS_IPO_H 17 18#include <vector> 19 20namespace llvm { 21 22class FunctionPass; 23class ModulePass; 24class Function; 25class BasicBlock; 26 27//===----------------------------------------------------------------------===// 28// 29// These functions removes symbols from functions and modules. If OnlyDebugInfo 30// is true, only debugging information is removed from the module. 31// 32ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); 33 34//===----------------------------------------------------------------------===// 35/// createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics 36/// to invoke/unwind instructions. This should really be part of the C/C++ 37/// front-end, but it's so much easier to write transformations in LLVM proper. 38/// 39ModulePass* createLowerSetJmpPass(); 40 41//===----------------------------------------------------------------------===// 42/// createConstantMergePass - This function returns a new pass that merges 43/// duplicate global constants together into a single constant that is shared. 44/// This is useful because some passes (ie TraceValues) insert a lot of string 45/// constants into the program, regardless of whether or not they duplicate an 46/// existing string. 47/// 48ModulePass *createConstantMergePass(); 49 50 51//===----------------------------------------------------------------------===// 52/// createGlobalOptimizerPass - This function returns a new pass that optimizes 53/// non-address taken internal globals. 54/// 55ModulePass *createGlobalOptimizerPass(); 56 57 58//===----------------------------------------------------------------------===// 59/// createRaiseAllocationsPass - Return a new pass that transforms malloc and 60/// free function calls into malloc and free instructions. 61/// 62ModulePass *createRaiseAllocationsPass(); 63 64 65//===----------------------------------------------------------------------===// 66/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol 67/// table entries for types that are never used. 68/// 69ModulePass *createDeadTypeEliminationPass(); 70 71 72//===----------------------------------------------------------------------===// 73/// createGlobalDCEPass - This transform is designed to eliminate unreachable 74/// internal globals (functions or global variables) 75/// 76ModulePass *createGlobalDCEPass(); 77 78 79//===----------------------------------------------------------------------===// 80/// createFunctionExtractionPass - If deleteFn is true, this pass deletes as 81/// the specified function. Otherwise, it deletes as much of the module as 82/// possible, except for the function specified. 83/// 84ModulePass *createFunctionExtractionPass(Function *F, bool deleteFn = false); 85 86 87//===----------------------------------------------------------------------===// 88/// FunctionResolvingPass - Go over the functions that are in the module and 89/// look for functions that have the same name. More often than not, there will 90/// be things like: 91/// void "foo"(...) 92/// void "foo"(int, int) 93/// because of the way things are declared in C. If this is the case, patch 94/// things up. 95/// 96/// This is an interprocedural pass. 97/// 98ModulePass *createFunctionResolvingPass(); 99 100//===----------------------------------------------------------------------===// 101/// createFunctionInliningPass - Return a new pass object that uses a heuristic 102/// to inline direct function calls to small functions. 103/// 104ModulePass *createFunctionInliningPass(); 105 106//===----------------------------------------------------------------------===// 107/// createPruneEHPass - Return a new pass object which transforms invoke 108/// instructions into calls, if the callee can _not_ unwind the stack. 109/// 110ModulePass *createPruneEHPass(); 111 112//===----------------------------------------------------------------------===// 113/// createInternalizePass - This pass loops over all of the functions in the 114/// input module, looking for a main function. If a main function is found, all 115/// other functions are marked as internal. 116/// 117ModulePass *createInternalizePass(); 118 119//===----------------------------------------------------------------------===// 120/// createDeadArgEliminationPass - This pass removes arguments from functions 121/// which are not used by the body of the function. 122/// 123ModulePass *createDeadArgEliminationPass(); 124 125/// DeadArgHacking pass - Same as DAE, but delete arguments of external 126/// functions as well. This is definitely not safe, and should only be used by 127/// bugpoint. 128ModulePass *createDeadArgHackingPass(); 129 130//===----------------------------------------------------------------------===// 131/// createArgumentPromotionPass - This pass promotes "by reference" arguments to 132/// be passed by value. 133/// 134ModulePass *createArgumentPromotionPass(); 135 136//===----------------------------------------------------------------------===// 137/// createIPConstantPropagationPass - This pass propagates constants from call 138/// sites into the bodies of functions. 139/// 140ModulePass *createIPConstantPropagationPass(); 141 142//===----------------------------------------------------------------------===// 143/// createIPSCCPPass - This pass propagates constants from call sites into the 144/// bodies of functions, and keeps track of whether basic blocks are executable 145/// in the process. 146/// 147ModulePass *createIPSCCPPass(); 148 149//===----------------------------------------------------------------------===// 150// 151/// createLoopExtractorPass - This pass extracts all natural loops from the 152/// program into a function if it can. 153/// 154FunctionPass *createLoopExtractorPass(); 155 156/// createSingleLoopExtractorPass - This pass extracts one natural loop from the 157/// program into a function if it can. This is used by bugpoint. 158/// 159FunctionPass *createSingleLoopExtractorPass(); 160 161// createBlockExtractorPass - This pass extracts all blocks (except those 162// specified in the argument list) from the functions in the module. 163// 164ModulePass *createBlockExtractorPass(std::vector<BasicBlock*> &BTNE); 165 166} // End llvm namespace 167 168#endif 169