PassManager.cpp revision 1209f416cf2f2ec0f335d91a7c115e3b0a37d603
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#include "llvm/ModuleProvider.h" 18#include "llvm/Support/Streams.h" 19#include <vector> 20#include <map> 21using namespace llvm; 22 23//===----------------------------------------------------------------------===// 24// Overview: 25// The Pass Manager Infrastructure manages passes. It's responsibilities are: 26// 27// o Manage optimization pass execution order 28// o Make required Analysis information available before pass P is run 29// o Release memory occupied by dead passes 30// o If Analysis information is dirtied by a pass then regenerate Analysis 31// information before it is consumed by another pass. 32// 33// Pass Manager Infrastructure uses multipe pass managers. They are PassManager, 34// FunctionPassManager, ModulePassManager, BasicBlockPassManager. This class 35// hierarcy uses multiple inheritance but pass managers do not derive from 36// another pass manager. 37// 38// PassManager and FunctionPassManager are two top level pass manager that 39// represents the external interface of this entire pass manager infrastucture. 40// 41// Important classes : 42// 43// [o] class PMTopLevelManager; 44// 45// Two top level managers, PassManager and FunctionPassManager, derive from 46// PMTopLevelManager. PMTopLevelManager manages information used by top level 47// managers such as last user info. 48// 49// [o] class PMDataManager; 50// 51// PMDataManager manages information, e.g. list of available analysis info, 52// used by a pass manager to manage execution order of passes. It also provides 53// a place to implement common pass manager APIs. All pass managers derive from 54// PMDataManager. 55// 56// [o] class BasicBlockPassManager : public FunctionPass, public PMDataManager; 57// 58// BasicBlockPassManager manages BasicBlockPasses. 59// 60// [o] class FunctionPassManager; 61// 62// This is a external interface used by JIT to manage FunctionPasses. This 63// interface relies on FunctionPassManagerImpl to do all the tasks. 64// 65// [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager, 66// public PMTopLevelManager; 67// 68// FunctionPassManagerImpl is a top level manager. It manages FunctionPasses 69// and BasicBlockPassManagers. 70// 71// [o] class ModulePassManager : public Pass, public PMDataManager; 72// 73// ModulePassManager manages ModulePasses and FunctionPassManagerImpls. 74// 75// [o] class PassManager; 76// 77// This is a external interface used by various tools to manages passes. It 78// relies on PassManagerImpl to do all the tasks. 79// 80// [o] class PassManagerImpl : public Pass, public PMDataManager, 81// public PMDTopLevelManager 82// 83// PassManagerImpl is a top level pass manager responsible for managing 84// ModulePassManagers. 85//===----------------------------------------------------------------------===// 86 87namespace llvm { 88 89//===----------------------------------------------------------------------===// 90// PMTopLevelManager 91// 92/// PMTopLevelManager manages LastUser info and collects common APIs used by 93/// top level pass managers. 94class PMTopLevelManager { 95 96public: 97 98 inline std::vector<Pass *>::iterator passManagersBegin() { 99 return PassManagers.begin(); 100 } 101 102 inline std::vector<Pass *>::iterator passManagersEnd() { 103 return PassManagers.end(); 104 } 105 106 /// Schedule pass P for execution. Make sure that passes required by 107 /// P are run before P is run. Update analysis info maintained by 108 /// the manager. Remove dead passes. This is a recursive function. 109 void schedulePass(Pass *P, Pass *PM); 110 111 /// This is implemented by top level pass manager and used by 112 /// schedulePass() to add analysis info passes that are not available. 113 virtual void addTopLevelPass(Pass *P) = 0; 114 115 /// Set pass P as the last user of the given analysis passes. 116 void setLastUser(std::vector<Pass *> &AnalysisPasses, Pass *P); 117 118 /// Collect passes whose last user is P 119 void collectLastUses(std::vector<Pass *> &LastUses, Pass *P); 120 121 virtual ~PMTopLevelManager() { 122 PassManagers.clear(); 123 } 124 125 /// Add immutable pass and initialize it. 126 inline void addImmutablePass(ImmutablePass *P) { 127 P->initializePass(); 128 ImmutablePasses.push_back(P); 129 } 130 131 inline std::vector<ImmutablePass *>& getImmutablePasses() { 132 return ImmutablePasses; 133 } 134 135private: 136 137 /// Collection of pass managers 138 std::vector<Pass *> PassManagers; 139 140 // Map to keep track of last user of the analysis pass. 141 // LastUser->second is the last user of Lastuser->first. 142 std::map<Pass *, Pass *> LastUser; 143 144 /// Immutable passes are managed by top level manager. 145 std::vector<ImmutablePass *> ImmutablePasses; 146}; 147 148/// Set pass P as the last user of the given analysis passes. 149void PMTopLevelManager::setLastUser(std::vector<Pass *> &AnalysisPasses, 150 Pass *P) { 151 152 for (std::vector<Pass *>::iterator I = AnalysisPasses.begin(), 153 E = AnalysisPasses.end(); I != E; ++I) { 154 Pass *AP = *I; 155 LastUser[AP] = P; 156 // If AP is the last user of other passes then make P last user of 157 // such passes. 158 for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(), 159 LUE = LastUser.end(); LUI != LUE; ++LUI) { 160 if (LUI->second == AP) 161 LastUser[LUI->first] = P; 162 } 163 } 164 165} 166 167/// Collect passes whose last user is P 168void PMTopLevelManager::collectLastUses(std::vector<Pass *> &LastUses, 169 Pass *P) { 170 for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(), 171 LUE = LastUser.end(); LUI != LUE; ++LUI) 172 if (LUI->second == P) 173 LastUses.push_back(LUI->first); 174} 175 176/// Schedule pass P for execution. Make sure that passes required by 177/// P are run before P is run. Update analysis info maintained by 178/// the manager. Remove dead passes. This is a recursive function. 179void PMTopLevelManager::schedulePass(Pass *P, Pass *PM) { 180 181 // TODO : Allocate function manager for this pass, other wise required set 182 // may be inserted into previous function manager 183 184 AnalysisUsage AnUsage; 185 P->getAnalysisUsage(AnUsage); 186 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 187 for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(), 188 E = RequiredSet.end(); I != E; ++I) { 189 190 Pass *AnalysisPass = NULL; // FIXME PM->getAnalysisPass(*I, true); 191 if (!AnalysisPass) { 192 // Schedule this analysis run first. 193 AnalysisPass = (*I)->createPass(); 194 schedulePass(AnalysisPass, PM); 195 } 196 } 197 198 // Now all required passes are available. 199 addTopLevelPass(P); 200} 201 202 203//===----------------------------------------------------------------------===// 204// PMDataManager 205 206/// PMDataManager provides the common place to manage the analysis data 207/// used by pass managers. 208class PMDataManager { 209 210public: 211 212 PMDataManager() : TPM(NULL) { 213 initializeAnalysisInfo(); 214 } 215 216 /// Return true IFF pass P's required analysis set does not required new 217 /// manager. 218 bool manageablePass(Pass *P); 219 220 Pass *getAnalysisPass(AnalysisID AID) const { 221 222 std::map<AnalysisID, Pass*>::const_iterator I = 223 AvailableAnalysis.find(AID); 224 225 if (I != AvailableAnalysis.end()) 226 return NULL; 227 else 228 return I->second; 229 } 230 231 /// Augment AvailableAnalysis by adding analysis made available by pass P. 232 void recordAvailableAnalysis(Pass *P); 233 234 /// Remove Analysis that is not preserved by the pass 235 void removeNotPreservedAnalysis(Pass *P); 236 237 /// Remove dead passes 238 void removeDeadPasses(Pass *P); 239 240 /// Add pass P into the PassVector. Update 241 /// AvailableAnalysis appropriately if ProcessAnalysis is true. 242 void addPassToManager (Pass *P, bool ProcessAnalysis = true); 243 244 // Initialize available analysis information. 245 void initializeAnalysisInfo() { 246 AvailableAnalysis.clear(); 247 LastUser.clear(); 248 249 // Include immutable passes into AvailableAnalysis vector. 250 std::vector<ImmutablePass *> &ImmutablePasses = TPM->getImmutablePasses(); 251 for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(), 252 E = ImmutablePasses.end(); I != E; ++I) 253 recordAvailableAnalysis(*I); 254 } 255 256 // All Required analyses should be available to the pass as it runs! Here 257 // we fill in the AnalysisImpls member of the pass so that it can 258 // successfully use the getAnalysis() method to retrieve the 259 // implementations it needs. 260 // 261 void initializeAnalysisImpl(Pass *P); 262 263 inline std::vector<Pass *>::iterator passVectorBegin() { 264 return PassVector.begin(); 265 } 266 267 inline std::vector<Pass *>::iterator passVectorEnd() { 268 return PassVector.end(); 269 } 270 271 inline void setLastUser(Pass *P, Pass *LU) { 272 LastUser[P] = LU; 273 // TODO : Check if pass P is available. 274 } 275 276 // Access toplevel manager 277 PMTopLevelManager *getTopLevelManager() { return TPM; } 278 void setTopLevelManager(PMTopLevelManager *T) { TPM = T; } 279 280private: 281 // Set of available Analysis. This information is used while scheduling 282 // pass. If a pass requires an analysis which is not not available then 283 // equired analysis pass is scheduled to run before the pass itself is 284 // scheduled to run. 285 std::map<AnalysisID, Pass*> AvailableAnalysis; 286 287 // Map to keep track of last user of the analysis pass. 288 // LastUser->second is the last user of Lastuser->first. 289 std::map<Pass *, Pass *> LastUser; 290 291 // Collection of pass that are managed by this manager 292 std::vector<Pass *> PassVector; 293 294 // Top level manager. 295 // TODO : Make it a reference. 296 PMTopLevelManager *TPM; 297}; 298 299/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the 300/// pass together and sequence them to process one basic block before 301/// processing next basic block. 302class BasicBlockPassManager_New : public PMDataManager, 303 public FunctionPass { 304 305public: 306 BasicBlockPassManager_New() { } 307 308 /// Add a pass into a passmanager queue. 309 bool addPass(Pass *p); 310 311 /// Execute all of the passes scheduled for execution. Keep track of 312 /// whether any of the passes modifies the function, and if so, return true. 313 bool runOnFunction(Function &F); 314 315 /// Return true IFF AnalysisID AID is currently available. 316 Pass *getAnalysisPassFromManager(AnalysisID AID); 317 318 /// Pass Manager itself does not invalidate any analysis info. 319 void getAnalysisUsage(AnalysisUsage &Info) const { 320 Info.setPreservesAll(); 321 } 322 323private: 324}; 325 326/// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers. 327/// It batches all function passes and basic block pass managers together and 328/// sequence them to process one function at a time before processing next 329/// function. 330class FunctionPassManagerImpl_New : public PMDataManager, 331 public ModulePass { 332public: 333 FunctionPassManagerImpl_New(ModuleProvider *P) { /* TODO */ } 334 FunctionPassManagerImpl_New() { 335 activeBBPassManager = NULL; 336 } 337 ~FunctionPassManagerImpl_New() { /* TODO */ }; 338 339 /// add - Add a pass to the queue of passes to run. This passes 340 /// ownership of the Pass to the PassManager. When the 341 /// PassManager_X is destroyed, the pass will be destroyed as well, so 342 /// there is no need to delete the pass. (TODO delete passes.) 343 /// This implies that all passes MUST be allocated with 'new'. 344 void add(Pass *P) { /* TODO*/ } 345 346 /// Add pass into the pass manager queue. 347 bool addPass(Pass *P); 348 349 /// Execute all of the passes scheduled for execution. Keep 350 /// track of whether any of the passes modifies the function, and if 351 /// so, return true. 352 bool runOnModule(Module &M); 353 bool runOnFunction(Function &F); 354 355 /// Return true IFF AnalysisID AID is currently available. 356 Pass *getAnalysisPassFromManager(AnalysisID AID); 357 358 /// doInitialization - Run all of the initializers for the function passes. 359 /// 360 bool doInitialization(Module &M); 361 362 /// doFinalization - Run all of the initializers for the function passes. 363 /// 364 bool doFinalization(Module &M); 365 366 /// Pass Manager itself does not invalidate any analysis info. 367 void getAnalysisUsage(AnalysisUsage &Info) const { 368 Info.setPreservesAll(); 369 } 370 371private: 372 // Active Pass Managers 373 BasicBlockPassManager_New *activeBBPassManager; 374}; 375 376/// ModulePassManager_New manages ModulePasses and function pass managers. 377/// It batches all Module passes passes and function pass managers together and 378/// sequence them to process one module. 379class ModulePassManager_New : public PMDataManager { 380 381public: 382 ModulePassManager_New() { activeFunctionPassManager = NULL; } 383 384 /// Add a pass into a passmanager queue. 385 bool addPass(Pass *p); 386 387 /// run - Execute all of the passes scheduled for execution. Keep track of 388 /// whether any of the passes modifies the module, and if so, return true. 389 bool runOnModule(Module &M); 390 391 /// Return true IFF AnalysisID AID is currently available. 392 Pass *getAnalysisPassFromManager(AnalysisID AID); 393 394 /// Pass Manager itself does not invalidate any analysis info. 395 void getAnalysisUsage(AnalysisUsage &Info) const { 396 Info.setPreservesAll(); 397 } 398 399private: 400 // Active Pass Manager 401 FunctionPassManagerImpl_New *activeFunctionPassManager; 402}; 403 404/// PassManager_New manages ModulePassManagers 405class PassManagerImpl_New : public PMDataManager { 406 407public: 408 409 /// add - Add a pass to the queue of passes to run. This passes ownership of 410 /// the Pass to the PassManager. When the PassManager is destroyed, the pass 411 /// will be destroyed as well, so there is no need to delete the pass. This 412 /// implies that all passes MUST be allocated with 'new'. 413 void add(Pass *P); 414 415 /// run - Execute all of the passes scheduled for execution. Keep track of 416 /// whether any of the passes modifies the module, and if so, return true. 417 bool run(Module &M); 418 419 /// Return true IFF AnalysisID AID is currently available. 420 Pass *getAnalysisPassFromManager(AnalysisID AID); 421 422 /// Pass Manager itself does not invalidate any analysis info. 423 void getAnalysisUsage(AnalysisUsage &Info) const { 424 Info.setPreservesAll(); 425 } 426 427private: 428 429 /// Add a pass into a passmanager queue. 430 bool addPass(Pass *p); 431 432 // Collection of pass managers 433 std::vector<ModulePassManager_New *> PassManagers; 434 435 // Active Pass Manager 436 ModulePassManager_New *activeManager; 437}; 438 439} // End of llvm namespace 440 441//===----------------------------------------------------------------------===// 442// PMDataManager implementation 443 444/// Return true IFF pass P's required analysis set does not required new 445/// manager. 446bool PMDataManager::manageablePass(Pass *P) { 447 448 // TODO 449 // If this pass is not preserving information that is required by a 450 // pass maintained by higher level pass manager then do not insert 451 // this pass into current manager. Use new manager. For example, 452 // For example, If FunctionPass F is not preserving ModulePass Info M1 453 // that is used by another ModulePass M2 then do not insert F in 454 // current function pass manager. 455 return true; 456} 457 458/// Augement AvailableAnalysis by adding analysis made available by pass P. 459void PMDataManager::recordAvailableAnalysis(Pass *P) { 460 461 if (const PassInfo *PI = P->getPassInfo()) { 462 AvailableAnalysis[PI] = P; 463 464 //This pass is the current implementation of all of the interfaces it 465 //implements as well. 466 const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented(); 467 for (unsigned i = 0, e = II.size(); i != e; ++i) 468 AvailableAnalysis[II[i]] = P; 469 } 470} 471 472/// Remove Analyss not preserved by Pass P 473void PMDataManager::removeNotPreservedAnalysis(Pass *P) { 474 AnalysisUsage AnUsage; 475 P->getAnalysisUsage(AnUsage); 476 477 if (AnUsage.getPreservesAll()) 478 return; 479 480 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 481 for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), 482 E = AvailableAnalysis.end(); I != E; ++I ) { 483 if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) == 484 PreservedSet.end()) { 485 // Remove this analysis 486 std::map<AnalysisID, Pass*>::iterator J = I++; 487 AvailableAnalysis.erase(J); 488 } 489 } 490} 491 492/// Remove analysis passes that are not used any longer 493void PMDataManager::removeDeadPasses(Pass *P) { 494 495 for (std::map<Pass *, Pass *>::iterator I = LastUser.begin(), 496 E = LastUser.end(); I !=E; ++I) { 497 if (I->second == P) { 498 Pass *deadPass = I->first; 499 deadPass->releaseMemory(); 500 501 std::map<AnalysisID, Pass*>::iterator Pos = 502 AvailableAnalysis.find(deadPass->getPassInfo()); 503 504 assert (Pos != AvailableAnalysis.end() && 505 "Pass is not available"); 506 AvailableAnalysis.erase(Pos); 507 } 508 } 509} 510 511/// Add pass P into the PassVector. Update 512/// AvailableAnalysis appropriately if ProcessAnalysis is true. 513void PMDataManager::addPassToManager(Pass *P, 514 bool ProcessAnalysis) { 515 516 if (ProcessAnalysis) { 517 // Take a note of analysis required and made available by this pass 518 initializeAnalysisImpl(P); 519 recordAvailableAnalysis(P); 520 521 // Remove the analysis not preserved by this pass 522 removeNotPreservedAnalysis(P); 523 } 524 525 // Add pass 526 PassVector.push_back(P); 527} 528 529// All Required analyses should be available to the pass as it runs! Here 530// we fill in the AnalysisImpls member of the pass so that it can 531// successfully use the getAnalysis() method to retrieve the 532// implementations it needs. 533// 534void PMDataManager::initializeAnalysisImpl(Pass *P) { 535 AnalysisUsage AnUsage; 536 P->getAnalysisUsage(AnUsage); 537 538 for (std::vector<const PassInfo *>::const_iterator 539 I = AnUsage.getRequiredSet().begin(), 540 E = AnUsage.getRequiredSet().end(); I != E; ++I) { 541 Pass *Impl = getAnalysisPass(*I); 542 if (Impl == 0) 543 assert(0 && "Analysis used but not available!"); 544 // TODO: P->AnalysisImpls.push_back(std::make_pair(*I, Impl)); 545 } 546} 547 548//===----------------------------------------------------------------------===// 549// BasicBlockPassManager_New implementation 550 551/// Add pass P into PassVector and return true. If this pass is not 552/// manageable by this manager then return false. 553bool 554BasicBlockPassManager_New::addPass(Pass *P) { 555 556 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 557 if (!BP) 558 return false; 559 560 // If this pass does not preserve anlysis that is used by other passes 561 // managed by this manager than it is not a suiable pass for this manager. 562 if (!manageablePass(P)) 563 return false; 564 565 addPassToManager (BP); 566 567 return true; 568} 569 570/// Execute all of the passes scheduled for execution by invoking 571/// runOnBasicBlock method. Keep track of whether any of the passes modifies 572/// the function, and if so, return true. 573bool 574BasicBlockPassManager_New::runOnFunction(Function &F) { 575 576 bool Changed = false; 577 initializeAnalysisInfo(); 578 579 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 580 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 581 e = passVectorEnd(); itr != e; ++itr) { 582 Pass *P = *itr; 583 584 recordAvailableAnalysis(P); 585 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 586 Changed |= BP->runOnBasicBlock(*I); 587 removeNotPreservedAnalysis(P); 588 removeDeadPasses(P); 589 } 590 return Changed; 591} 592 593/// Return true IFF AnalysisID AID is currently available. 594Pass * BasicBlockPassManager_New::getAnalysisPassFromManager(AnalysisID AID) { 595 return getAnalysisPass(AID); 596} 597 598//===----------------------------------------------------------------------===// 599// FunctionPassManager_New implementation 600 601/// Create new Function pass manager 602FunctionPassManager_New::FunctionPassManager_New() { 603 FPM = new FunctionPassManagerImpl_New(); 604} 605 606/// add - Add a pass to the queue of passes to run. This passes 607/// ownership of the Pass to the PassManager. When the 608/// PassManager_X is destroyed, the pass will be destroyed as well, so 609/// there is no need to delete the pass. (TODO delete passes.) 610/// This implies that all passes MUST be allocated with 'new'. 611void FunctionPassManager_New::add(Pass *P) { 612 FPM->add(P); 613} 614 615/// Execute all of the passes scheduled for execution. Keep 616/// track of whether any of the passes modifies the function, and if 617/// so, return true. 618bool FunctionPassManager_New::runOnModule(Module &M) { 619 return FPM->runOnModule(M); 620} 621 622/// run - Execute all of the passes scheduled for execution. Keep 623/// track of whether any of the passes modifies the function, and if 624/// so, return true. 625/// 626bool FunctionPassManager_New::run(Function &F) { 627 std::string errstr; 628 if (MP->materializeFunction(&F, &errstr)) { 629 cerr << "Error reading bytecode file: " << errstr << "\n"; 630 abort(); 631 } 632 return FPM->runOnFunction(F); 633} 634 635 636/// doInitialization - Run all of the initializers for the function passes. 637/// 638bool FunctionPassManager_New::doInitialization() { 639 return FPM->doInitialization(*MP->getModule()); 640} 641 642/// doFinalization - Run all of the initializers for the function passes. 643/// 644bool FunctionPassManager_New::doFinalization() { 645 return FPM->doFinalization(*MP->getModule()); 646} 647 648//===----------------------------------------------------------------------===// 649// FunctionPassManagerImpl_New implementation 650 651/// Add pass P into the pass manager queue. If P is a BasicBlockPass then 652/// either use it into active basic block pass manager or create new basic 653/// block pass manager to handle pass P. 654bool 655FunctionPassManagerImpl_New::addPass(Pass *P) { 656 657 // If P is a BasicBlockPass then use BasicBlockPassManager_New. 658 if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) { 659 660 if (!activeBBPassManager 661 || !activeBBPassManager->addPass(BP)) { 662 663 activeBBPassManager = new BasicBlockPassManager_New(); 664 addPassToManager(activeBBPassManager, false); 665 if (!activeBBPassManager->addPass(BP)) 666 assert(0 && "Unable to add Pass"); 667 } 668 return true; 669 } 670 671 FunctionPass *FP = dynamic_cast<FunctionPass *>(P); 672 if (!FP) 673 return false; 674 675 // If this pass does not preserve anlysis that is used by other passes 676 // managed by this manager than it is not a suiable pass for this manager. 677 if (!manageablePass(P)) 678 return false; 679 680 addPassToManager (FP); 681 activeBBPassManager = NULL; 682 return true; 683} 684 685/// Execute all of the passes scheduled for execution by invoking 686/// runOnFunction method. Keep track of whether any of the passes modifies 687/// the function, and if so, return true. 688bool FunctionPassManagerImpl_New::runOnModule(Module &M) { 689 690 bool Changed = false; 691 initializeAnalysisInfo(); 692 693 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 694 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 695 e = passVectorEnd(); itr != e; ++itr) { 696 Pass *P = *itr; 697 698 recordAvailableAnalysis(P); 699 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 700 Changed |= FP->runOnFunction(*I); 701 removeNotPreservedAnalysis(P); 702 removeDeadPasses(P); 703 } 704 return Changed; 705} 706 707/// Execute all of the passes scheduled for execution by invoking 708/// runOnFunction method. Keep track of whether any of the passes modifies 709/// the function, and if so, return true. 710bool FunctionPassManagerImpl_New::runOnFunction(Function &F) { 711 712 bool Changed = false; 713 initializeAnalysisInfo(); 714 715 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 716 e = passVectorEnd(); itr != e; ++itr) { 717 Pass *P = *itr; 718 719 recordAvailableAnalysis(P); 720 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 721 Changed |= FP->runOnFunction(F); 722 removeNotPreservedAnalysis(P); 723 removeDeadPasses(P); 724 } 725 return Changed; 726} 727 728 729/// Return true IFF AnalysisID AID is currently available. 730Pass *FunctionPassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) { 731 732 Pass *P = getAnalysisPass(AID); 733 if (P) 734 return P; 735 736 if (activeBBPassManager && 737 activeBBPassManager->getAnalysisPass(AID) != 0) 738 return activeBBPassManager->getAnalysisPass(AID); 739 740 // TODO : Check inactive managers 741 return NULL; 742} 743 744inline bool FunctionPassManagerImpl_New::doInitialization(Module &M) { 745 bool Changed = false; 746 747 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 748 e = passVectorEnd(); itr != e; ++itr) { 749 Pass *P = *itr; 750 751 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 752 Changed |= FP->doInitialization(M); 753 } 754 755 return Changed; 756} 757 758inline bool FunctionPassManagerImpl_New::doFinalization(Module &M) { 759 bool Changed = false; 760 761 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 762 e = passVectorEnd(); itr != e; ++itr) { 763 Pass *P = *itr; 764 765 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 766 Changed |= FP->doFinalization(M); 767 } 768 769 770 return Changed; 771} 772 773//===----------------------------------------------------------------------===// 774// ModulePassManager implementation 775 776/// Add P into pass vector if it is manageble. If P is a FunctionPass 777/// then use FunctionPassManagerImpl_New to manage it. Return false if P 778/// is not manageable by this manager. 779bool 780ModulePassManager_New::addPass(Pass *P) { 781 782 // If P is FunctionPass then use function pass maanager. 783 if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) { 784 785 activeFunctionPassManager = NULL; 786 787 if (!activeFunctionPassManager 788 || !activeFunctionPassManager->addPass(P)) { 789 790 activeFunctionPassManager = new FunctionPassManagerImpl_New(); 791 addPassToManager(activeFunctionPassManager, false); 792 if (!activeFunctionPassManager->addPass(FP)) 793 assert(0 && "Unable to add pass"); 794 } 795 return true; 796 } 797 798 ModulePass *MP = dynamic_cast<ModulePass *>(P); 799 if (!MP) 800 return false; 801 802 // If this pass does not preserve anlysis that is used by other passes 803 // managed by this manager than it is not a suiable pass for this manager. 804 if (!manageablePass(P)) 805 return false; 806 807 addPassToManager(MP); 808 activeFunctionPassManager = NULL; 809 return true; 810} 811 812 813/// Execute all of the passes scheduled for execution by invoking 814/// runOnModule method. Keep track of whether any of the passes modifies 815/// the module, and if so, return true. 816bool 817ModulePassManager_New::runOnModule(Module &M) { 818 bool Changed = false; 819 initializeAnalysisInfo(); 820 821 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 822 e = passVectorEnd(); itr != e; ++itr) { 823 Pass *P = *itr; 824 825 recordAvailableAnalysis(P); 826 ModulePass *MP = dynamic_cast<ModulePass*>(P); 827 Changed |= MP->runOnModule(M); 828 removeNotPreservedAnalysis(P); 829 removeDeadPasses(P); 830 } 831 return Changed; 832} 833 834/// Return true IFF AnalysisID AID is currently available. 835Pass *ModulePassManager_New::getAnalysisPassFromManager(AnalysisID AID) { 836 837 838 Pass *P = getAnalysisPass(AID); 839 if (P) 840 return P; 841 842 if (activeFunctionPassManager && 843 activeFunctionPassManager->getAnalysisPass(AID) != 0) 844 return activeFunctionPassManager->getAnalysisPass(AID); 845 846 // TODO : Check inactive managers 847 return NULL; 848} 849 850//===----------------------------------------------------------------------===// 851// PassManagerImpl implementation 852 853/// Return true IFF AnalysisID AID is currently available. 854Pass *PassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) { 855 856 Pass *P = NULL; 857 for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(), 858 e = PassManagers.end(); !P && itr != e; ++itr) 859 P = (*itr)->getAnalysisPassFromManager(AID); 860 return P; 861} 862 863/// Add pass P to the queue of passes to run. 864void PassManagerImpl_New::add(Pass *P) { 865 // Do not process Analysis now. Analysis is process while scheduling 866 // the pass vector. 867 addPassToManager(P, false); 868} 869 870// PassManager_New implementation 871/// Add P into active pass manager or use new module pass manager to 872/// manage it. 873bool PassManagerImpl_New::addPass(Pass *P) { 874 875 if (!activeManager || !activeManager->addPass(P)) { 876 activeManager = new ModulePassManager_New(); 877 PassManagers.push_back(activeManager); 878 } 879 880 return activeManager->addPass(P); 881} 882 883/// run - Execute all of the passes scheduled for execution. Keep track of 884/// whether any of the passes modifies the module, and if so, return true. 885bool PassManagerImpl_New::run(Module &M) { 886 887 bool Changed = false; 888 for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(), 889 e = PassManagers.end(); itr != e; ++itr) { 890 ModulePassManager_New *pm = *itr; 891 Changed |= pm->runOnModule(M); 892 } 893 return Changed; 894} 895 896//===----------------------------------------------------------------------===// 897// PassManager implementation 898 899/// Create new pass manager 900PassManager_New::PassManager_New() { 901 PM = new PassManagerImpl_New(); 902} 903 904/// add - Add a pass to the queue of passes to run. This passes ownership of 905/// the Pass to the PassManager. When the PassManager is destroyed, the pass 906/// will be destroyed as well, so there is no need to delete the pass. This 907/// implies that all passes MUST be allocated with 'new'. 908void 909PassManager_New::add(Pass *P) { 910 PM->add(P); 911} 912 913/// run - Execute all of the passes scheduled for execution. Keep track of 914/// whether any of the passes modifies the module, and if so, return true. 915bool 916PassManager_New::run(Module &M) { 917 return PM->run(M); 918} 919 920