PassManager.cpp revision a363a0bdefd2e798a83acd8998591b5b07c4256e
1//===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by Devang Patel and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements the LLVM Pass Manager infrastructure. 11// 12//===----------------------------------------------------------------------===// 13 14 15#include "llvm/PassManager.h" 16#include "llvm/Module.h" 17 18using namespace llvm; 19 20namespace llvm { 21 22/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the 23/// pass together and sequence them to process one basic block before 24/// processing next basic block. 25class BasicBlockPassManager_New : public CommonPassManagerImpl { 26 27public: 28 BasicBlockPassManager_New() { } 29 30 /// Add a pass into a passmanager queue. 31 bool addPass(Pass *p); 32 33 /// Execute all of the passes scheduled for execution. Keep track of 34 /// whether any of the passes modifies the function, and if so, return true. 35 bool runOnFunction(Function &F); 36 37private: 38 // Collection of pass that are managed by this manager 39 std::vector<Pass *> PassVector; 40}; 41 42/// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers. 43/// It batches all function passes and basic block pass managers together and 44/// sequence them to process one function at a time before processing next 45/// function. 46class FunctionPassManagerImpl_New : public CommonPassManagerImpl { 47public: 48 FunctionPassManagerImpl_New(ModuleProvider *P) { /* TODO */ } 49 FunctionPassManagerImpl_New() { 50 activeBBPassManager = NULL; 51 } 52 ~FunctionPassManagerImpl_New() { /* TODO */ }; 53 54 /// add - Add a pass to the queue of passes to run. This passes 55 /// ownership of the Pass to the PassManager. When the 56 /// PassManager_X is destroyed, the pass will be destroyed as well, so 57 /// there is no need to delete the pass. (TODO delete passes.) 58 /// This implies that all passes MUST be allocated with 'new'. 59 void add(Pass *P) { /* TODO*/ } 60 61 /// Add pass into the pass manager queue. 62 bool addPass(Pass *P); 63 64 /// Execute all of the passes scheduled for execution. Keep 65 /// track of whether any of the passes modifies the function, and if 66 /// so, return true. 67 bool runOnModule(Module &M); 68 69private: 70 // Collection of pass that are manged by this manager 71 std::vector<Pass *> PassVector; 72 73 // Active Pass Managers 74 BasicBlockPassManager_New *activeBBPassManager; 75}; 76 77/// ModulePassManager_New manages ModulePasses and function pass managers. 78/// It batches all Module passes passes and function pass managers together and 79/// sequence them to process one module. 80class ModulePassManager_New : public CommonPassManagerImpl { 81 82public: 83 ModulePassManager_New() { activeFunctionPassManager = NULL; } 84 85 /// Add a pass into a passmanager queue. 86 bool addPass(Pass *p); 87 88 /// run - Execute all of the passes scheduled for execution. Keep track of 89 /// whether any of the passes modifies the module, and if so, return true. 90 bool runOnModule(Module &M); 91 92private: 93 // Collection of pass that are managed by this manager 94 std::vector<Pass *> PassVector; 95 96 // Active Pass Manager 97 FunctionPassManagerImpl_New *activeFunctionPassManager; 98}; 99 100/// PassManager_New manages ModulePassManagers 101class PassManagerImpl_New : public CommonPassManagerImpl { 102 103public: 104 105 /// add - Add a pass to the queue of passes to run. This passes ownership of 106 /// the Pass to the PassManager. When the PassManager is destroyed, the pass 107 /// will be destroyed as well, so there is no need to delete the pass. This 108 /// implies that all passes MUST be allocated with 'new'. 109 void add(Pass *P); 110 111 /// run - Execute all of the passes scheduled for execution. Keep track of 112 /// whether any of the passes modifies the module, and if so, return true. 113 bool run(Module &M); 114 115private: 116 117 /// Add a pass into a passmanager queue. This is used by schedulePasses 118 bool addPass(Pass *p); 119 120 /// Schedule all passes collected in pass queue using add(). Add all the 121 /// schedule passes into various manager's queue using addPass(). 122 void schedulePasses(); 123 124 // Collection of pass managers 125 std::vector<ModulePassManager_New *> PassManagers; 126 127 // Collection of pass that are not yet scheduled 128 std::vector<Pass *> PassVector; 129 130 // Active Pass Manager 131 ModulePassManager_New *activeManager; 132}; 133 134} // End of llvm namespace 135 136// CommonPassManagerImpl implementation 137 138/// Return true IFF pass P's required analysis set does not required new 139/// manager. 140bool CommonPassManagerImpl::manageablePass(Pass *P) { 141 142 AnalysisUsage AnUsage; 143 P->getAnalysisUsage(AnUsage); 144 145 // If this pass is not preserving information that is required by the other 146 // passes managed by this manager then use new manager 147 if (!AnUsage.getPreservesAll()) { 148 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 149 for (std::vector<AnalysisID>::iterator I = RequiredAnalysis.begin(), 150 E = RequiredAnalysis.end(); I != E; ++I) { 151 if (std::find(PreservedSet.begin(), PreservedSet.end(), *I) == 152 PreservedSet.end()) 153 // This analysis is not preserved. Need new manager. 154 return false; 155 } 156 } 157 return true; 158} 159 160/// Return true IFF AnalysisID AID is currently available. 161bool CommonPassManagerImpl::analysisCurrentlyAvailable(AnalysisID AID) { 162 163 // TODO 164 return false; 165} 166 167/// Augment RequiredSet by adding analysis required by pass P. 168void CommonPassManagerImpl::noteDownRequiredAnalysis(Pass *P) { 169 AnalysisUsage AnUsage; 170 P->getAnalysisUsage(AnUsage); 171 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 172 173 // FIXME: What about duplicates ? 174 RequiredAnalysis.insert(RequiredAnalysis.end(), RequiredSet.begin(), RequiredSet.end()); 175} 176 177/// Remove AnalysisID from the RequiredSet 178void CommonPassManagerImpl::removeAnalysis(AnalysisID AID) { 179 180 // TODO 181} 182 183/// Remove Analyss not preserved by Pass P 184void CommonPassManagerImpl::removeNotPreservedAnalysis(Pass *P) { 185 186 // TODO 187} 188 189/// BasicBlockPassManager implementation 190 191/// Add pass P into PassVector and return true. If this pass is not 192/// manageable by this manager then return false. 193bool 194BasicBlockPassManager_New::addPass(Pass *P) { 195 196 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 197 if (!BP) 198 return false; 199 200 // If this pass does not preserve anlysis that is used by other passes 201 // managed by this manager than it is not a suiable pass for this manager. 202 if (!manageablePass(P)) 203 return false; 204 205 // Take a note of analysis required by this pass. 206 noteDownRequiredAnalysis(P); 207 208 // Add pass 209 PassVector.push_back(BP); 210 return true; 211} 212 213/// Execute all of the passes scheduled for execution by invoking 214/// runOnBasicBlock method. Keep track of whether any of the passes modifies 215/// the function, and if so, return true. 216bool 217BasicBlockPassManager_New::runOnFunction(Function &F) { 218 219 bool Changed = false; 220 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 221 for (std::vector<Pass *>::iterator itr = PassVector.begin(), 222 e = PassVector.end(); itr != e; ++itr) { 223 Pass *P = *itr; 224 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 225 Changed |= BP->runOnBasicBlock(*I); 226 } 227 return Changed; 228} 229 230// FunctionPassManager_New implementation 231/// Create new Function pass manager 232FunctionPassManager_New::FunctionPassManager_New() { 233 FPM = new FunctionPassManagerImpl_New(); 234} 235 236/// add - Add a pass to the queue of passes to run. This passes 237/// ownership of the Pass to the PassManager. When the 238/// PassManager_X is destroyed, the pass will be destroyed as well, so 239/// there is no need to delete the pass. (TODO delete passes.) 240/// This implies that all passes MUST be allocated with 'new'. 241void 242FunctionPassManager_New::add(Pass *P) { 243 FPM->add(P); 244} 245 246/// Execute all of the passes scheduled for execution. Keep 247/// track of whether any of the passes modifies the function, and if 248/// so, return true. 249bool 250FunctionPassManager_New::runOnModule(Module &M) { 251 return FPM->runOnModule(M); 252} 253 254// FunctionPassManagerImpl_New implementation 255 256// FunctionPassManager 257 258/// Add pass P into the pass manager queue. If P is a BasicBlockPass then 259/// either use it into active basic block pass manager or create new basic 260/// block pass manager to handle pass P. 261bool 262FunctionPassManagerImpl_New::addPass(Pass *P) { 263 264 // If P is a BasicBlockPass then use BasicBlockPassManager_New. 265 if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) { 266 267 if (!activeBBPassManager 268 || !activeBBPassManager->addPass(BP)) { 269 270 activeBBPassManager = new BasicBlockPassManager_New(); 271 272 PassVector.push_back(activeBBPassManager); 273 if (!activeBBPassManager->addPass(BP)) 274 assert(0 && "Unable to add Pass"); 275 } 276 return true; 277 } 278 279 FunctionPass *FP = dynamic_cast<FunctionPass *>(P); 280 if (!FP) 281 return false; 282 283 // If this pass does not preserve anlysis that is used by other passes 284 // managed by this manager than it is not a suiable pass for this manager. 285 if (!manageablePass(P)) 286 return false; 287 288 // Take a note of analysis required by this pass. 289 noteDownRequiredAnalysis(P); 290 291 PassVector.push_back(FP); 292 activeBBPassManager = NULL; 293 return true; 294} 295 296/// Execute all of the passes scheduled for execution by invoking 297/// runOnFunction method. Keep track of whether any of the passes modifies 298/// the function, and if so, return true. 299bool 300FunctionPassManagerImpl_New::runOnModule(Module &M) { 301 302 bool Changed = false; 303 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 304 for (std::vector<Pass *>::iterator itr = PassVector.begin(), 305 e = PassVector.end(); itr != e; ++itr) { 306 Pass *P = *itr; 307 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 308 Changed |= FP->runOnFunction(*I); 309 } 310 return Changed; 311} 312 313 314// ModulePassManager implementation 315 316/// Add P into pass vector if it is manageble. If P is a FunctionPass 317/// then use FunctionPassManagerImpl_New to manage it. Return false if P 318/// is not manageable by this manager. 319bool 320ModulePassManager_New::addPass(Pass *P) { 321 322 // If P is FunctionPass then use function pass maanager. 323 if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) { 324 325 activeFunctionPassManager = NULL; 326 327 if (!activeFunctionPassManager 328 || !activeFunctionPassManager->addPass(P)) { 329 330 activeFunctionPassManager = new FunctionPassManagerImpl_New(); 331 332 PassVector.push_back(activeFunctionPassManager); 333 if (!activeFunctionPassManager->addPass(FP)) 334 assert(0 && "Unable to add pass"); 335 } 336 return true; 337 } 338 339 ModulePass *MP = dynamic_cast<ModulePass *>(P); 340 if (!MP) 341 return false; 342 343 // If this pass does not preserve anlysis that is used by other passes 344 // managed by this manager than it is not a suiable pass for this manager. 345 if (!manageablePass(P)) 346 return false; 347 348 // Take a note of analysis required by this pass. 349 noteDownRequiredAnalysis(P); 350 351 PassVector.push_back(MP); 352 activeFunctionPassManager = NULL; 353 return true; 354} 355 356 357/// Execute all of the passes scheduled for execution by invoking 358/// runOnModule method. Keep track of whether any of the passes modifies 359/// the module, and if so, return true. 360bool 361ModulePassManager_New::runOnModule(Module &M) { 362 bool Changed = false; 363 for (std::vector<Pass *>::iterator itr = PassVector.begin(), 364 e = PassVector.end(); itr != e; ++itr) { 365 Pass *P = *itr; 366 ModulePass *MP = dynamic_cast<ModulePass*>(P); 367 Changed |= MP->runOnModule(M); 368 } 369 return Changed; 370} 371 372/// Schedule all passes from the queue by adding them in their 373/// respective manager's queue. 374void 375PassManagerImpl_New::schedulePasses() { 376 /* TODO */ 377} 378 379/// Add pass P to the queue of passes to run. 380void 381PassManagerImpl_New::add(Pass *P) { 382 /* TODO */ 383} 384 385// PassManager_New implementation 386/// Add P into active pass manager or use new module pass manager to 387/// manage it. 388bool 389PassManagerImpl_New::addPass(Pass *P) { 390 391 if (!activeManager || !activeManager->addPass(P)) { 392 activeManager = new ModulePassManager_New(); 393 PassManagers.push_back(activeManager); 394 } 395 396 return activeManager->addPass(P); 397} 398 399/// run - Execute all of the passes scheduled for execution. Keep track of 400/// whether any of the passes modifies the module, and if so, return true. 401bool 402PassManagerImpl_New::run(Module &M) { 403 404 schedulePasses(); 405 bool Changed = false; 406 for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(), 407 e = PassManagers.end(); itr != e; ++itr) { 408 ModulePassManager_New *pm = *itr; 409 Changed |= pm->runOnModule(M); 410 } 411 return Changed; 412} 413 414/// Create new pass manager 415PassManager_New::PassManager_New() { 416 PM = new PassManagerImpl_New(); 417} 418 419/// add - Add a pass to the queue of passes to run. This passes ownership of 420/// the Pass to the PassManager. When the PassManager is destroyed, the pass 421/// will be destroyed as well, so there is no need to delete the pass. This 422/// implies that all passes MUST be allocated with 'new'. 423void 424PassManager_New::add(Pass *P) { 425 PM->add(P); 426} 427 428/// run - Execute all of the passes scheduled for execution. Keep track of 429/// whether any of the passes modifies the module, and if so, return true. 430bool 431PassManager_New::run(Module &M) { 432 return PM->run(M); 433} 434 435