IPO.h revision b0ed11f4a0677f934c21c5a7180585bb1ab742a5 
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 <vector>
19
20namespace llvm {
21
22class FunctionPass;
23class ModulePass;
24class Pass;
25class Function;
26class BasicBlock;
27class GlobalValue;
28
29//===----------------------------------------------------------------------===//
30//
31// These functions removes symbols from functions and modules.  If OnlyDebugInfo
32// is true, only debugging information is removed from the module.
33//
34ModulePass *createStripSymbolsPass(bool OnlyDebugInfo = false);
35
36//===----------------------------------------------------------------------===//
37/// createLowerSetJmpPass - This function lowers the setjmp/longjmp intrinsics
38/// to invoke/unwind instructions.  This should really be part of the C/C++
39/// front-end, but it's so much easier to write transformations in LLVM proper.
40///
41ModulePass* createLowerSetJmpPass();
42
43//===----------------------------------------------------------------------===//
44/// createConstantMergePass - This function returns a new pass that merges
45/// duplicate global constants together into a single constant that is shared.
46/// This is useful because some passes (ie TraceValues) insert a lot of string
47/// constants into the program, regardless of whether or not they duplicate an
48/// existing string.
49///
50ModulePass *createConstantMergePass();
51
52
53//===----------------------------------------------------------------------===//
54/// createGlobalOptimizerPass - This function returns a new pass that optimizes
55/// non-address taken internal globals.
56///
57ModulePass *createGlobalOptimizerPass();
58
59
60//===----------------------------------------------------------------------===//
61/// createRaiseAllocationsPass - Return a new pass that transforms malloc and
62/// free function calls into malloc and free instructions.
63///
64ModulePass *createRaiseAllocationsPass();
65
66
67//===----------------------------------------------------------------------===//
68/// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
69/// table entries for types that are never used.
70///
71ModulePass *createDeadTypeEliminationPass();
72
73
74//===----------------------------------------------------------------------===//
75/// createGlobalDCEPass - This transform is designed to eliminate unreachable
76/// internal globals (functions or global variables)
77///
78ModulePass *createGlobalDCEPass();
79
80
81//===----------------------------------------------------------------------===//
82/// createGVExtractionPass - If deleteFn is true, this pass deletes as
83/// the specified global values. Otherwise, it deletes as much of the module as
84/// possible, except for the global values specified.
85///
86ModulePass *createGVExtractionPass(std::vector<GlobalValue*>& GVs, bool
87                                   deleteFn = false,
88                                   bool relinkCallees = false);
89
90//===----------------------------------------------------------------------===//
91/// createFunctionInliningPass - Return a new pass object that uses a heuristic
92/// to inline direct function calls to small functions.
93///
94Pass *createFunctionInliningPass();
95Pass *createFunctionInliningPass(int Threshold);
96
97//===----------------------------------------------------------------------===//
98/// createPruneEHPass - Return a new pass object which transforms invoke
99/// instructions into calls, if the callee can _not_ unwind the stack.
100///
101Pass *createPruneEHPass();
102
103//===----------------------------------------------------------------------===//
104/// createInternalizePass - This pass loops over all of the functions in the
105/// input module, internalizing all globals (functions and variables) not part
106/// of the api.  If a list of symbols is specified with the
107/// -internalize-public-api-* command line options, those symbols are not
108/// internalized and all others are.  Otherwise if AllButMain is set and the
109/// main function is found, all other globals are marked as internal. If no api
110/// is supplied and AllButMain is not set, or no main function is found, nothing
111/// is internalized.
112///
113ModulePass *createInternalizePass(bool AllButMain);
114
115/// createInternalizePass - This pass loops over all of the functions in the
116/// input module, internalizing all globals (functions and variables) not in the
117/// given exportList.
118///
119/// Note that commandline options that are used with the above function are not
120/// used now! Also, when exportList is empty, nothing is internalized.
121ModulePass *createInternalizePass(const std::vector<const char *> &exportList)
122
123//===----------------------------------------------------------------------===//
124/// createDeadArgEliminationPass - This pass removes arguments from functions
125/// which are not used by the body of the function.
126///
127ModulePass *createDeadArgEliminationPass();
128
129/// DeadArgHacking pass - Same as DAE, but delete arguments of external
130/// functions as well.  This is definitely not safe, and should only be used by
131/// bugpoint.
132ModulePass *createDeadArgHackingPass();
133
134//===----------------------------------------------------------------------===//
135/// createArgumentPromotionPass - This pass promotes "by reference" arguments to
136/// be passed by value if the number of elements passed is smaller or
137/// equal to maxElements (maxElements == 0 means always promote).
138///
139Pass *createArgumentPromotionPass(unsigned maxElements = 3);
140Pass *createStructRetPromotionPass();
141
142//===----------------------------------------------------------------------===//
143/// createIPConstantPropagationPass - This pass propagates constants from call
144/// sites into the bodies of functions.
145///
146ModulePass *createIPConstantPropagationPass();
147
148//===----------------------------------------------------------------------===//
149/// createIPSCCPPass - This pass propagates constants from call sites into the
150/// bodies of functions, and keeps track of whether basic blocks are executable
151/// in the process.
152///
153ModulePass *createIPSCCPPass();
154
155//===----------------------------------------------------------------------===//
156//
157/// createLoopExtractorPass - This pass extracts all natural loops from the
158/// program into a function if it can.
159///
160FunctionPass *createLoopExtractorPass();
161
162/// createSingleLoopExtractorPass - This pass extracts one natural loop from the
163/// program into a function if it can.  This is used by bugpoint.
164///
165FunctionPass *createSingleLoopExtractorPass();
166
167/// createBlockExtractorPass - This pass extracts all blocks (except those
168/// specified in the argument list) from the functions in the module.
169///
170ModulePass *createBlockExtractorPass(const std::vector<BasicBlock*> &BTNE);
171
172/// createIndMemRemPass - This pass removes potential indirect calls of
173/// malloc and free
174ModulePass *createIndMemRemPass();
175
176/// createStripDeadPrototypesPass - This pass removes any function declarations
177/// (prototypes) that are not used.
178ModulePass *createStripDeadPrototypesPass();
179
180} // End llvm namespace
181
182#endif
183