blob: bfb7b5768e22e983d8cc19c41e78415763d4f193 (
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
|
//===-- 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"
class Method;
class CallInst;
//===----------------------------------------------------------------------===//
// Helper functions
//
static inline bool ApplyOptToAllMethods(Module *C, bool (*Opt)(Method*)) {
bool Modified = false;
for (Module::MethodListType::iterator I = C->getMethodList().begin();
I != C->getMethodList().end(); I++)
Modified |= Opt(*I);
return Modified;
}
//===----------------------------------------------------------------------===//
// Dead Code Elimination Pass
//
bool DoDeadCodeElimination(Method *M); // DCE a method
bool DoRemoveUnusedConstants(SymTabValue *S); // RUC a method or class
bool DoDeadCodeElimination(Module *C); // DCE & RUC a whole class
//===----------------------------------------------------------------------===//
// Constant Propogation Pass
//
bool DoConstantPropogation(Method *M);
static inline bool DoConstantPropogation(Module *C) {
return ApplyOptToAllMethods(C, DoConstantPropogation);
}
//===----------------------------------------------------------------------===//
// 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::InstListType::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);
#endif
|
