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
127
128
129
130
131
132
133
134
|
//===-- llvm/AllOpts.h - Header file to get all opt passes -------*- C++ -*--=//
//
// This file #include's all of the small optimization header files.
//
// Note that all optimizations return true if they modified the program, false
// if not.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_OPT_ALLOPTS_H
#define LLVM_OPT_ALLOPTS_H
#include "llvm/Module.h"
#include "llvm/BasicBlock.h"
#include "llvm/Tools/STLExtras.h"
class Method;
class CallInst;
//===----------------------------------------------------------------------===//
// Helper functions
//
static inline bool ApplyOptToAllMethods(Module *C, bool (*Opt)(Method*)) {
return reduce_apply_bool(C->begin(), C->end(), ptr_fun(Opt));
}
//===----------------------------------------------------------------------===//
// Dead Code Elimination Pass
//
bool DoDeadCodeElimination(Method *M); // DCE a method
bool DoRemoveUnusedConstants(SymTabValue *S); // RUC a method or module
bool DoDeadCodeElimination(Module *C); // DCE & RUC a whole module
//===----------------------------------------------------------------------===//
// Constant Propogation Pass
//
bool DoConstantPropogation(Method *M);
static inline bool DoConstantPropogation(Module *C) {
return ApplyOptToAllMethods(C, DoConstantPropogation);
}
//===----------------------------------------------------------------------===//
// Constant Pool Merging Pass
//
// This function merges all constants in the specified constant pool that have
// identical types and values. This is useful for passes that generate lots of
// constants as a side effect of running.
//
bool DoConstantPoolMerging(ConstantPool &CP);
bool DoConstantPoolMerging(Method *M);
static inline bool DoConstantPoolMerging(Module *M) {
return ApplyOptToAllMethods(M, DoConstantPoolMerging) |
DoConstantPoolMerging(M->getConstantPool());
}
//===----------------------------------------------------------------------===//
// Sparse Conditional Constant Propogation Pass
//
bool DoSparseConditionalConstantProp(Method *M);
static inline bool DoSparseConditionalConstantProp(Module *M) {
return ApplyOptToAllMethods(M, DoSparseConditionalConstantProp);
}
// Define a shorter version of the name...
template <class Unit> bool DoSCCP(Unit *M) {
return DoSparseConditionalConstantProp(M);
}
//===----------------------------------------------------------------------===//
// Method Inlining Pass
//
// DoMethodInlining - Use a heuristic based approach to inline methods that seem
// to look good.
//
bool DoMethodInlining(Method *M);
static inline bool DoMethodInlining(Module *C) {
return ApplyOptToAllMethods(C, DoMethodInlining);
}
// InlineMethod - This function forcibly inlines the called method into the
// basic block of the caller. This returns true if it is not possible to inline
// this call. The program is still in a well defined state if this occurs
// though.
//
// Note that this only does one level of inlining. For example, if the
// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now
// exists in the instruction stream. Similiarly this will inline a recursive
// method by one level.
//
bool InlineMethod(CallInst *C);
bool InlineMethod(BasicBlock::iterator CI); // *CI must be CallInst
//===----------------------------------------------------------------------===//
// Symbol Stripping Pass
//
// DoSymbolStripping - Remove all symbolic information from a method
//
bool DoSymbolStripping(Method *M);
// DoSymbolStripping - Remove all symbolic information from all methods in a
// module
//
static inline bool DoSymbolStripping(Module *M) {
return ApplyOptToAllMethods(M, DoSymbolStripping);
}
// DoFullSymbolStripping - Remove all symbolic information from all methods
// in a module, and all module level symbols. (method names, etc...)
//
bool DoFullSymbolStripping(Module *M);
//===----------------------------------------------------------------------===//
// Induction Variable Cannonicalization
//
// DoInductionVariableCannonicalize - Simplify induction variables in loops
//
bool DoInductionVariableCannonicalize(Method *M);
static inline bool DoInductionVariableCannonicalize(Module *M) {
return ApplyOptToAllMethods(M, DoInductionVariableCannonicalize);
}
#endif
|
