IPO.h revision ecc1cef8bfd07575ba4026780adf7054c771e12e 
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