Mercurial > hg > Members > tobaru > cbc > CbC_llvm
comparison lib/IR/Pass.cpp @ 3:9ad51c7bc036
1st commit. remove git dir and add all files.
author | Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp> |
---|---|
date | Wed, 15 May 2013 06:43:32 +0900 |
parents | |
children | 54457678186b |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 3:9ad51c7bc036 |
---|---|
1 //===- Pass.cpp - LLVM Pass Infrastructure Implementation -----------------===// | |
2 // | |
3 // The LLVM Compiler Infrastructure | |
4 // | |
5 // This file is distributed under the University of Illinois Open Source | |
6 // License. See LICENSE.TXT for details. | |
7 // | |
8 //===----------------------------------------------------------------------===// | |
9 // | |
10 // This file implements the LLVM Pass infrastructure. It is primarily | |
11 // responsible with ensuring that passes are executed and batched together | |
12 // optimally. | |
13 // | |
14 //===----------------------------------------------------------------------===// | |
15 | |
16 #include "llvm/Pass.h" | |
17 #include "llvm/Assembly/PrintModulePass.h" | |
18 #include "llvm/PassRegistry.h" | |
19 #include "llvm/Support/Debug.h" | |
20 #include "llvm/Support/PassNameParser.h" | |
21 #include "llvm/Support/raw_ostream.h" | |
22 using namespace llvm; | |
23 | |
24 //===----------------------------------------------------------------------===// | |
25 // Pass Implementation | |
26 // | |
27 | |
28 // Force out-of-line virtual method. | |
29 Pass::~Pass() { | |
30 delete Resolver; | |
31 } | |
32 | |
33 // Force out-of-line virtual method. | |
34 ModulePass::~ModulePass() { } | |
35 | |
36 Pass *ModulePass::createPrinterPass(raw_ostream &O, | |
37 const std::string &Banner) const { | |
38 return createPrintModulePass(&O, false, Banner); | |
39 } | |
40 | |
41 PassManagerType ModulePass::getPotentialPassManagerType() const { | |
42 return PMT_ModulePassManager; | |
43 } | |
44 | |
45 bool Pass::mustPreserveAnalysisID(char &AID) const { | |
46 return Resolver->getAnalysisIfAvailable(&AID, true) != 0; | |
47 } | |
48 | |
49 // dumpPassStructure - Implement the -debug-pass=Structure option | |
50 void Pass::dumpPassStructure(unsigned Offset) { | |
51 dbgs().indent(Offset*2) << getPassName() << "\n"; | |
52 } | |
53 | |
54 /// getPassName - Return a nice clean name for a pass. This usually | |
55 /// implemented in terms of the name that is registered by one of the | |
56 /// Registration templates, but can be overloaded directly. | |
57 /// | |
58 const char *Pass::getPassName() const { | |
59 AnalysisID AID = getPassID(); | |
60 const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(AID); | |
61 if (PI) | |
62 return PI->getPassName(); | |
63 return "Unnamed pass: implement Pass::getPassName()"; | |
64 } | |
65 | |
66 void Pass::preparePassManager(PMStack &) { | |
67 // By default, don't do anything. | |
68 } | |
69 | |
70 PassManagerType Pass::getPotentialPassManagerType() const { | |
71 // Default implementation. | |
72 return PMT_Unknown; | |
73 } | |
74 | |
75 void Pass::getAnalysisUsage(AnalysisUsage &) const { | |
76 // By default, no analysis results are used, all are invalidated. | |
77 } | |
78 | |
79 void Pass::releaseMemory() { | |
80 // By default, don't do anything. | |
81 } | |
82 | |
83 void Pass::verifyAnalysis() const { | |
84 // By default, don't do anything. | |
85 } | |
86 | |
87 void *Pass::getAdjustedAnalysisPointer(AnalysisID AID) { | |
88 return this; | |
89 } | |
90 | |
91 ImmutablePass *Pass::getAsImmutablePass() { | |
92 return 0; | |
93 } | |
94 | |
95 PMDataManager *Pass::getAsPMDataManager() { | |
96 return 0; | |
97 } | |
98 | |
99 void Pass::setResolver(AnalysisResolver *AR) { | |
100 assert(!Resolver && "Resolver is already set"); | |
101 Resolver = AR; | |
102 } | |
103 | |
104 // print - Print out the internal state of the pass. This is called by Analyze | |
105 // to print out the contents of an analysis. Otherwise it is not necessary to | |
106 // implement this method. | |
107 // | |
108 void Pass::print(raw_ostream &O,const Module*) const { | |
109 O << "Pass::print not implemented for pass: '" << getPassName() << "'!\n"; | |
110 } | |
111 | |
112 // dump - call print(cerr); | |
113 void Pass::dump() const { | |
114 print(dbgs(), 0); | |
115 } | |
116 | |
117 //===----------------------------------------------------------------------===// | |
118 // ImmutablePass Implementation | |
119 // | |
120 // Force out-of-line virtual method. | |
121 ImmutablePass::~ImmutablePass() { } | |
122 | |
123 void ImmutablePass::initializePass() { | |
124 // By default, don't do anything. | |
125 } | |
126 | |
127 //===----------------------------------------------------------------------===// | |
128 // FunctionPass Implementation | |
129 // | |
130 | |
131 Pass *FunctionPass::createPrinterPass(raw_ostream &O, | |
132 const std::string &Banner) const { | |
133 return createPrintFunctionPass(Banner, &O); | |
134 } | |
135 | |
136 PassManagerType FunctionPass::getPotentialPassManagerType() const { | |
137 return PMT_FunctionPassManager; | |
138 } | |
139 | |
140 //===----------------------------------------------------------------------===// | |
141 // BasicBlockPass Implementation | |
142 // | |
143 | |
144 Pass *BasicBlockPass::createPrinterPass(raw_ostream &O, | |
145 const std::string &Banner) const { | |
146 return createPrintBasicBlockPass(&O, false, Banner); | |
147 } | |
148 | |
149 bool BasicBlockPass::doInitialization(Function &) { | |
150 // By default, don't do anything. | |
151 return false; | |
152 } | |
153 | |
154 bool BasicBlockPass::doFinalization(Function &) { | |
155 // By default, don't do anything. | |
156 return false; | |
157 } | |
158 | |
159 PassManagerType BasicBlockPass::getPotentialPassManagerType() const { | |
160 return PMT_BasicBlockPassManager; | |
161 } | |
162 | |
163 const PassInfo *Pass::lookupPassInfo(const void *TI) { | |
164 return PassRegistry::getPassRegistry()->getPassInfo(TI); | |
165 } | |
166 | |
167 const PassInfo *Pass::lookupPassInfo(StringRef Arg) { | |
168 return PassRegistry::getPassRegistry()->getPassInfo(Arg); | |
169 } | |
170 | |
171 Pass *Pass::createPass(AnalysisID ID) { | |
172 const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID); | |
173 if (!PI) | |
174 return NULL; | |
175 return PI->createPass(); | |
176 } | |
177 | |
178 Pass *PassInfo::createPass() const { | |
179 assert((!isAnalysisGroup() || NormalCtor) && | |
180 "No default implementation found for analysis group!"); | |
181 assert(NormalCtor && | |
182 "Cannot call createPass on PassInfo without default ctor!"); | |
183 return NormalCtor(); | |
184 } | |
185 | |
186 //===----------------------------------------------------------------------===// | |
187 // Analysis Group Implementation Code | |
188 //===----------------------------------------------------------------------===// | |
189 | |
190 // RegisterAGBase implementation | |
191 // | |
192 RegisterAGBase::RegisterAGBase(const char *Name, const void *InterfaceID, | |
193 const void *PassID, bool isDefault) | |
194 : PassInfo(Name, InterfaceID) { | |
195 PassRegistry::getPassRegistry()->registerAnalysisGroup(InterfaceID, PassID, | |
196 *this, isDefault); | |
197 } | |
198 | |
199 //===----------------------------------------------------------------------===// | |
200 // PassRegistrationListener implementation | |
201 // | |
202 | |
203 // PassRegistrationListener ctor - Add the current object to the list of | |
204 // PassRegistrationListeners... | |
205 PassRegistrationListener::PassRegistrationListener() { | |
206 PassRegistry::getPassRegistry()->addRegistrationListener(this); | |
207 } | |
208 | |
209 // dtor - Remove object from list of listeners... | |
210 PassRegistrationListener::~PassRegistrationListener() { | |
211 PassRegistry::getPassRegistry()->removeRegistrationListener(this); | |
212 } | |
213 | |
214 // enumeratePasses - Iterate over the registered passes, calling the | |
215 // passEnumerate callback on each PassInfo object. | |
216 // | |
217 void PassRegistrationListener::enumeratePasses() { | |
218 PassRegistry::getPassRegistry()->enumerateWith(this); | |
219 } | |
220 | |
221 PassNameParser::~PassNameParser() {} | |
222 | |
223 //===----------------------------------------------------------------------===// | |
224 // AnalysisUsage Class Implementation | |
225 // | |
226 | |
227 namespace { | |
228 struct GetCFGOnlyPasses : public PassRegistrationListener { | |
229 typedef AnalysisUsage::VectorType VectorType; | |
230 VectorType &CFGOnlyList; | |
231 GetCFGOnlyPasses(VectorType &L) : CFGOnlyList(L) {} | |
232 | |
233 void passEnumerate(const PassInfo *P) { | |
234 if (P->isCFGOnlyPass()) | |
235 CFGOnlyList.push_back(P->getTypeInfo()); | |
236 } | |
237 }; | |
238 } | |
239 | |
240 // setPreservesCFG - This function should be called to by the pass, iff they do | |
241 // not: | |
242 // | |
243 // 1. Add or remove basic blocks from the function | |
244 // 2. Modify terminator instructions in any way. | |
245 // | |
246 // This function annotates the AnalysisUsage info object to say that analyses | |
247 // that only depend on the CFG are preserved by this pass. | |
248 // | |
249 void AnalysisUsage::setPreservesCFG() { | |
250 // Since this transformation doesn't modify the CFG, it preserves all analyses | |
251 // that only depend on the CFG (like dominators, loop info, etc...) | |
252 GetCFGOnlyPasses(Preserved).enumeratePasses(); | |
253 } | |
254 | |
255 AnalysisUsage &AnalysisUsage::addPreserved(StringRef Arg) { | |
256 const PassInfo *PI = Pass::lookupPassInfo(Arg); | |
257 // If the pass exists, preserve it. Otherwise silently do nothing. | |
258 if (PI) Preserved.push_back(PI->getTypeInfo()); | |
259 return *this; | |
260 } | |
261 | |
262 AnalysisUsage &AnalysisUsage::addRequiredID(const void *ID) { | |
263 Required.push_back(ID); | |
264 return *this; | |
265 } | |
266 | |
267 AnalysisUsage &AnalysisUsage::addRequiredID(char &ID) { | |
268 Required.push_back(&ID); | |
269 return *this; | |
270 } | |
271 | |
272 AnalysisUsage &AnalysisUsage::addRequiredTransitiveID(char &ID) { | |
273 Required.push_back(&ID); | |
274 RequiredTransitive.push_back(&ID); | |
275 return *this; | |
276 } |