1//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// 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 "llvm/ADT/ArrayRef.h" 19 20namespace llvm { 21 22class ModulePass; 23class Pass; 24class Function; 25class BasicBlock; 26class GlobalValue; 27 28//===----------------------------------------------------------------------===// 29// 30// These functions removes symbols from functions and modules. If OnlyDebugInfo 31// is true, only debugging information is removed from the module. 32// 33ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false); 34 35//===----------------------------------------------------------------------===// 36// 37// These functions strips symbols from functions and modules. 38// Only debugging information is not stripped. 39// 40ModulePass *createStripNonDebugSymbolsPass(); 41 42//===----------------------------------------------------------------------===// 43// 44// These pass removes llvm.dbg.declare intrinsics. 45ModulePass *createStripDebugDeclarePass(); 46 47//===----------------------------------------------------------------------===// 48// 49// These pass removes unused symbols' debug info. 50ModulePass *createStripDeadDebugInfoPass(); 51 52//===----------------------------------------------------------------------===// 53/// createConstantMergePass - This function returns a new pass that merges 54/// duplicate global constants together into a single constant that is shared. 55/// This is useful because some passes (ie TraceValues) insert a lot of string 56/// constants into the program, regardless of whether or not they duplicate an 57/// existing string. 58/// 59ModulePass *createConstantMergePass(); 60 61 62//===----------------------------------------------------------------------===// 63/// createGlobalOptimizerPass - This function returns a new pass that optimizes 64/// non-address taken internal globals. 65/// 66ModulePass *createGlobalOptimizerPass(); 67 68 69//===----------------------------------------------------------------------===// 70/// createGlobalDCEPass - This transform is designed to eliminate unreachable 71/// internal globals (functions or global variables) 72/// 73ModulePass *createGlobalDCEPass(); 74 75 76//===----------------------------------------------------------------------===// 77/// createGVExtractionPass - If deleteFn is true, this pass deletes 78/// the specified global values. Otherwise, it deletes as much of the module as 79/// possible, except for the global values specified. 80/// 81ModulePass *createGVExtractionPass(std::vector<GlobalValue*>& GVs, bool 82 deleteFn = false); 83 84//===----------------------------------------------------------------------===// 85/// createFunctionInliningPass - Return a new pass object that uses a heuristic 86/// to inline direct function calls to small functions. 87/// 88/// The -inline-threshold command line option takes precedence over the 89/// threshold given here. 90Pass *createFunctionInliningPass(); 91Pass *createFunctionInliningPass(int Threshold); 92 93//===----------------------------------------------------------------------===// 94/// createAlwaysInlinerPass - Return a new pass object that inlines only 95/// functions that are marked as "always_inline". 96Pass *createAlwaysInlinerPass(); 97Pass *createAlwaysInlinerPass(bool InsertLifetime); 98 99//===----------------------------------------------------------------------===// 100/// createPruneEHPass - Return a new pass object which transforms invoke 101/// instructions into calls, if the callee can _not_ unwind the stack. 102/// 103Pass *createPruneEHPass(); 104 105//===----------------------------------------------------------------------===// 106/// createInternalizePass - This pass loops over all of the functions in the 107/// input module, internalizing all globals (functions and variables) it can. 108//// 109/// The symbols in \p ExportList are never internalized. 110/// 111/// The symbol in DSOList are internalized if it is safe to drop them from 112/// the symbol table. 113/// 114/// Note that commandline options that are used with the above function are not 115/// used now! 116ModulePass *createInternalizePass(ArrayRef<const char *> ExportList); 117/// createInternalizePass - Same as above, but with an empty exportList. 118ModulePass *createInternalizePass(); 119 120//===----------------------------------------------------------------------===// 121/// createDeadArgEliminationPass - This pass removes arguments from functions 122/// which are not used by the body of the function. 123/// 124ModulePass *createDeadArgEliminationPass(); 125 126/// DeadArgHacking pass - Same as DAE, but delete arguments of external 127/// functions as well. This is definitely not safe, and should only be used by 128/// bugpoint. 129ModulePass *createDeadArgHackingPass(); 130 131//===----------------------------------------------------------------------===// 132/// createArgumentPromotionPass - This pass promotes "by reference" arguments to 133/// be passed by value if the number of elements passed is smaller or 134/// equal to maxElements (maxElements == 0 means always promote). 135/// 136Pass *createArgumentPromotionPass(unsigned maxElements = 3); 137 138//===----------------------------------------------------------------------===// 139/// createIPConstantPropagationPass - This pass propagates constants from call 140/// sites into the bodies of functions. 141/// 142ModulePass *createIPConstantPropagationPass(); 143 144//===----------------------------------------------------------------------===// 145/// createIPSCCPPass - This pass propagates constants from call sites into the 146/// bodies of functions, and keeps track of whether basic blocks are executable 147/// in the process. 148/// 149ModulePass *createIPSCCPPass(); 150 151//===----------------------------------------------------------------------===// 152// 153/// createLoopExtractorPass - This pass extracts all natural loops from the 154/// program into a function if it can. 155/// 156Pass *createLoopExtractorPass(); 157 158/// createSingleLoopExtractorPass - This pass extracts one natural loop from the 159/// program into a function if it can. This is used by bugpoint. 160/// 161Pass *createSingleLoopExtractorPass(); 162 163/// createBlockExtractorPass - This pass extracts all blocks (except those 164/// specified in the argument list) from the functions in the module. 165/// 166ModulePass *createBlockExtractorPass(); 167 168/// createStripDeadPrototypesPass - This pass removes any function declarations 169/// (prototypes) that are not used. 170ModulePass *createStripDeadPrototypesPass(); 171 172//===----------------------------------------------------------------------===// 173/// createFunctionAttrsPass - This pass discovers functions that do not access 174/// memory, or only read memory, and gives them the readnone/readonly attribute. 175/// It also discovers function arguments that are not captured by the function 176/// and marks them with the nocapture attribute. 177/// 178Pass *createFunctionAttrsPass(); 179 180//===----------------------------------------------------------------------===// 181/// createMergeFunctionsPass - This pass discovers identical functions and 182/// collapses them. 183/// 184ModulePass *createMergeFunctionsPass(); 185 186//===----------------------------------------------------------------------===// 187/// createPartialInliningPass - This pass inlines parts of functions. 188/// 189ModulePass *createPartialInliningPass(); 190 191//===----------------------------------------------------------------------===// 192// createMetaRenamerPass - Rename everything with metasyntatic names. 193// 194ModulePass *createMetaRenamerPass(); 195 196//===----------------------------------------------------------------------===// 197/// createBarrierNoopPass - This pass is purely a module pass barrier in a pass 198/// manager. 199ModulePass *createBarrierNoopPass(); 200 201} // End llvm namespace 202 203#endif 204