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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
//===- llvm/PassManager.h - Container for Passes ----------------*- 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 file defines the PassManager class. This class is used to hold,
// maintain, and optimize execution of Passes. The PassManager class ensures
// that analysis results are available before a pass runs, and that Pass's are
// destroyed when the PassManager is destroyed.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_PASSMANAGER_H
#define LLVM_PASSMANAGER_H
#include "llvm/Pass.h"
namespace llvm {
class Pass;
class ModulePass;
class Module;
class ModuleProvider;
#ifdef USE_OLD_PASSMANAGER
class ModulePassManager;
class FunctionPassManagerT;
class BasicBlockPassManager;
class PassManager {
ModulePassManager *PM; // This is a straightforward Pimpl class
public:
PassManager();
~PassManager();
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// implies that all passes MUST be allocated with 'new'.
///
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
///
bool run(Module &M);
};
class FunctionPass;
class ImmutablePass;
class Function;
class FunctionPassManager {
FunctionPassManagerT *PM; // This is a straightforward Pimpl class
ModuleProvider *MP;
public:
FunctionPassManager(ModuleProvider *P);
~FunctionPassManager();
/// add - Add a pass to the queue of passes to run. This passes
/// ownership of the FunctionPass to the PassManager. When the
/// PassManager is destroyed, the pass will be destroyed as well, so
/// there is no need to delete the pass. This implies that all
/// passes MUST be allocated with 'new'.
///
void add(FunctionPass *P);
/// add - ImmutablePasses are not FunctionPasses, so we have a
/// special hack to get them into a FunctionPassManager.
///
void add(ImmutablePass *IP);
/// doInitialization - Run all of the initializers for the function passes.
///
bool doInitialization();
/// run - Execute all of the passes scheduled for execution. Keep
/// track of whether any of the passes modifies the function, and if
/// so, return true.
///
bool run(Function &F);
/// doFinalization - Run all of the initializers for the function passes.
///
bool doFinalization();
};
#else
class ModulePassManager;
class PassManagerImpl;
class FunctionPassManagerImpl;
/// PassManager manages ModulePassManagers
class PassManager {
public:
PassManager();
~PassManager();
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
/// will be destroyed as well, so there is no need to delete the pass. This
/// implies that all passes MUST be allocated with 'new'.
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
bool run(Module &M);
private:
/// PassManagerImpl_New is the actual class. PassManager is just the
/// wraper to publish simple pass manager interface
PassManagerImpl *PM;
};
/// FunctionPassManager manages FunctionPasses and BasicBlockPassManagers.
class FunctionPassManager {
public:
FunctionPassManager(ModuleProvider *P);
FunctionPassManager();
~FunctionPassManager();
/// add - Add a pass to the queue of passes to run. This passes
/// ownership of the Pass to the PassManager. When the
/// PassManager_X is destroyed, the pass will be destroyed as well, so
/// there is no need to delete the pass. (TODO delete passes.)
/// This implies that all passes MUST be allocated with 'new'.
void add(Pass *P);
/// run - Execute all of the passes scheduled for execution. Keep
/// track of whether any of the passes modifies the function, and if
/// so, return true.
///
bool run(Function &F);
/// doInitialization - Run all of the initializers for the function passes.
///
bool doInitialization();
/// doFinalization - Run all of the initializers for the function passes.
///
bool doFinalization();
private:
FunctionPassManagerImpl *FPM;
ModuleProvider *MP;
};
#endif
} // End llvm namespace
#endif
|
