blob: 80f5a527ab1029478c66fd8898322a1eb25f0488 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
//===- llvm/Transforms/IPO.h - Interprocedural Transformations --*- C++ -*-===//
//
// 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 header file defines prototypes for accessor functions that expose passes
// in the IPO transformations library.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_IPO_H
#define LLVM_TRANSFORMS_IPO_H
namespace llvm {
class Pass;
class Function;
//===----------------------------------------------------------------------===//
// 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.
//
Pass* createLowerSetJmpPass();
//===----------------------------------------------------------------------===//
// createConstantMergePass - This function returns a new pass that merges
// duplicate global constants together into a single constant that is shared.
// This is useful because some passes (ie TraceValues) insert a lot of string
// constants into the program, regardless of whether or not they duplicate an
// existing string.
//
Pass *createConstantMergePass();
//===----------------------------------------------------------------------===//
// createRaiseAllocationsPass - Return a new pass that transforms malloc and
// free function calls into malloc and free instructions.
//
Pass *createRaiseAllocationsPass();
//===----------------------------------------------------------------------===//
// createDeadTypeEliminationPass - Return a new pass that eliminates symbol
// table entries for types that are never used.
//
Pass *createDeadTypeEliminationPass();
//===----------------------------------------------------------------------===//
// createGlobalDCEPass - This transform is designed to eliminate unreachable
// internal globals (functions or global variables)
//
Pass *createGlobalDCEPass();
//===----------------------------------------------------------------------===//
// createFunctionExtractionPass - This pass deletes as much of the module as
// possible, except for the function specified.
//
Pass *createFunctionExtractionPass(Function *F);
//===----------------------------------------------------------------------===//
// 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.
//
Pass *createFunctionResolvingPass();
//===----------------------------------------------------------------------===//
// createFunctionInliningPass - Return a new pass object that uses a heuristic
// to inline direct function calls to small functions.
//
Pass *createFunctionInliningPass();
//===----------------------------------------------------------------------===//
// createPruneEHPass - Return a new pass object which transforms invoke
// instructions into calls, if the callee can _not_ unwind the stack.
//
Pass *createPruneEHPass();
//===----------------------------------------------------------------------===//
// createInternalizePass - This pass loops over all of the functions in the
// input module, looking for a main function. If a main function is found, all
// other functions are marked as internal.
//
Pass *createInternalizePass();
//===----------------------------------------------------------------------===//
// createDeadArgEliminationPass - This pass removes arguments from functions
// which are not used by the body of the function.
//
Pass *createDeadArgEliminationPass();
// DeadArgHacking pass - Same as DAE, but delete arguments of external functions
// as well. This is definately not safe, and should only be used by bugpoint.
Pass *createDeadArgHackingPass();
//===----------------------------------------------------------------------===//
// createIPConstantPropagationPass - This pass propagates constants from call
// sites into the bodies of functions.
//
Pass *createIPConstantPropagationPass();
//===----------------------------------------------------------------------===//
// These passes are wrappers that can do a few simple structure mutation
// transformations.
//
Pass *createSwapElementsPass();
Pass *createSortElementsPass();
} // End llvm namespace
#endif
|
