PassManager.cpp revision 3b14fbe300b96c353a9abfadf481b64324f17375
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// PMDataManager 204 205/// PMDataManager provides the common place to manage the analysis data 206/// used by pass managers. 207class PMDataManager { 208 209public: 210 211 PMDataManager(int D) : TPM(NULL), Depth(D) { 212 initializeAnalysisInfo(); 213 } 214 215 /// Return true IFF pass P's required analysis set does not required new 216 /// manager. 217 bool manageablePass(Pass *P); 218 219 Pass *getAnalysisPass(AnalysisID AID) const { 220 221 std::map<AnalysisID, Pass*>::const_iterator I = 222 AvailableAnalysis.find(AID); 223 224 if (I != AvailableAnalysis.end()) 225 return NULL; 226 else 227 return I->second; 228 } 229 230 /// Augment AvailableAnalysis by adding analysis made available by pass P. 231 void recordAvailableAnalysis(Pass *P); 232 233 /// Remove Analysis that is not preserved by the pass 234 void removeNotPreservedAnalysis(Pass *P); 235 236 /// Remove dead passes 237 void removeDeadPasses(Pass *P); 238 239 /// Add pass P into the PassVector. Update 240 /// AvailableAnalysis appropriately if ProcessAnalysis is true. 241 void addPassToManager (Pass *P, bool ProcessAnalysis = true); 242 243 /// Initialize available analysis information. 244 void initializeAnalysisInfo() { 245 ForcedLastUses.clear(); 246 AvailableAnalysis.clear(); 247 248 // Include immutable passes into AvailableAnalysis vector. 249 std::vector<ImmutablePass *> &ImmutablePasses = TPM->getImmutablePasses(); 250 for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(), 251 E = ImmutablePasses.end(); I != E; ++I) 252 recordAvailableAnalysis(*I); 253 } 254 255 /// Populate RequiredPasses with the analysis pass that are required by 256 /// pass P. 257 void collectRequiredAnalysisPasses(std::vector<Pass *> &RequiredPasses, 258 Pass *P); 259 260 /// All Required analyses should be available to the pass as it runs! Here 261 /// we fill in the AnalysisImpls member of the pass so that it can 262 /// successfully use the getAnalysis() method to retrieve the 263 /// implementations it needs. 264 void initializeAnalysisImpl(Pass *P); 265 266 inline std::vector<Pass *>::iterator passVectorBegin() { 267 return PassVector.begin(); 268 } 269 270 inline std::vector<Pass *>::iterator passVectorEnd() { 271 return PassVector.end(); 272 } 273 274 // Access toplevel manager 275 PMTopLevelManager *getTopLevelManager() { return TPM; } 276 void setTopLevelManager(PMTopLevelManager *T) { TPM = T; } 277 278 unsigned getDepth() { return Depth; } 279 280protected: 281 282 // Collection of pass whose last user asked this manager to claim 283 // last use. If a FunctionPass F is the last user of ModulePass info M 284 // then the F's manager, not F, records itself as a last user of M. 285 std::vector<Pass *> ForcedLastUses; 286 287 // Top level manager. 288 // TODO : Make it a reference. 289 PMTopLevelManager *TPM; 290 291private: 292 // Set of available Analysis. This information is used while scheduling 293 // pass. If a pass requires an analysis which is not not available then 294 // equired analysis pass is scheduled to run before the pass itself is 295 // scheduled to run. 296 std::map<AnalysisID, Pass*> AvailableAnalysis; 297 298 // Collection of pass that are managed by this manager 299 std::vector<Pass *> PassVector; 300 301 unsigned Depth; 302}; 303 304/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the 305/// pass together and sequence them to process one basic block before 306/// processing next basic block. 307class BasicBlockPassManager_New : public PMDataManager, 308 public FunctionPass { 309 310public: 311 BasicBlockPassManager_New(int D) : PMDataManager(D) { } 312 313 /// Add a pass into a passmanager queue. 314 bool addPass(Pass *p); 315 316 /// Execute all of the passes scheduled for execution. Keep track of 317 /// whether any of the passes modifies the function, and if so, return true. 318 bool runOnFunction(Function &F); 319 320 /// Return true IFF AnalysisID AID is currently available. 321 /// TODO : Replace this method with getAnalysisPass() 322 Pass *getAnalysisPassFromManager(AnalysisID AID); 323 324 /// Pass Manager itself does not invalidate any analysis info. 325 void getAnalysisUsage(AnalysisUsage &Info) const { 326 Info.setPreservesAll(); 327 } 328 329 bool doInitialization(Module &M); 330 bool doInitialization(Function &F); 331 bool doFinalization(Module &M); 332 bool doFinalization(Function &F); 333 334}; 335 336/// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers. 337/// It batches all function passes and basic block pass managers together and 338/// sequence them to process one function at a time before processing next 339/// function. 340class FunctionPassManagerImpl_New : public ModulePass, 341 public PMDataManager, 342 public PMTopLevelManager { 343public: 344 FunctionPassManagerImpl_New(ModuleProvider *P, int D) : 345 PMDataManager(D) { /* TODO */ } 346 FunctionPassManagerImpl_New(int D) : PMDataManager(D) { 347 activeBBPassManager = NULL; 348 } 349 ~FunctionPassManagerImpl_New() { /* TODO */ }; 350 351 inline void addTopLevelPass(Pass *P) { 352 addPass(P); 353 } 354 355 /// add - Add a pass to the queue of passes to run. This passes 356 /// ownership of the Pass to the PassManager. When the 357 /// PassManager_X is destroyed, the pass will be destroyed as well, so 358 /// there is no need to delete the pass. (TODO delete passes.) 359 /// This implies that all passes MUST be allocated with 'new'. 360 void add(Pass *P) { 361 schedulePass(P, this); 362 } 363 364 /// Add pass into the pass manager queue. 365 bool addPass(Pass *P); 366 367 /// Execute all of the passes scheduled for execution. Keep 368 /// track of whether any of the passes modifies the function, and if 369 /// so, return true. 370 bool runOnModule(Module &M); 371 bool runOnFunction(Function &F); 372 373 /// Return true IFF AnalysisID AID is currently available. 374 /// TODO : Replace this method with getAnalysisPass() 375 Pass *getAnalysisPassFromManager(AnalysisID AID); 376 377 /// doInitialization - Run all of the initializers for the function passes. 378 /// 379 bool doInitialization(Module &M); 380 381 /// doFinalization - Run all of the initializers for the function passes. 382 /// 383 bool doFinalization(Module &M); 384 385 /// Pass Manager itself does not invalidate any analysis info. 386 void getAnalysisUsage(AnalysisUsage &Info) const { 387 Info.setPreservesAll(); 388 } 389 390private: 391 // Active Pass Managers 392 BasicBlockPassManager_New *activeBBPassManager; 393}; 394 395/// ModulePassManager_New manages ModulePasses and function pass managers. 396/// It batches all Module passes passes and function pass managers together and 397/// sequence them to process one module. 398class ModulePassManager_New : public Pass, 399 public PMDataManager { 400 401public: 402 ModulePassManager_New(int D) : PMDataManager(D) { 403 activeFunctionPassManager = NULL; 404 } 405 406 /// Add a pass into a passmanager queue. 407 bool addPass(Pass *p); 408 409 /// run - Execute all of the passes scheduled for execution. Keep track of 410 /// whether any of the passes modifies the module, and if so, return true. 411 bool runOnModule(Module &M); 412 413 /// Return true IFF AnalysisID AID is currently available. 414 /// TODO : Replace this method with getAnalysisPass() 415 Pass *getAnalysisPassFromManager(AnalysisID AID); 416 417 /// Pass Manager itself does not invalidate any analysis info. 418 void getAnalysisUsage(AnalysisUsage &Info) const { 419 Info.setPreservesAll(); 420 } 421 422private: 423 // Active Pass Manager 424 FunctionPassManagerImpl_New *activeFunctionPassManager; 425}; 426 427/// PassManager_New manages ModulePassManagers 428class PassManagerImpl_New : public Pass, 429 public PMDataManager, 430 public PMTopLevelManager { 431 432public: 433 434 PassManagerImpl_New(int D) : PMDataManager(D) {} 435 436 /// add - Add a pass to the queue of passes to run. This passes ownership of 437 /// the Pass to the PassManager. When the PassManager is destroyed, the pass 438 /// will be destroyed as well, so there is no need to delete the pass. This 439 /// implies that all passes MUST be allocated with 'new'. 440 void add(Pass *P) { 441 schedulePass(P, this); 442 } 443 444 /// run - Execute all of the passes scheduled for execution. Keep track of 445 /// whether any of the passes modifies the module, and if so, return true. 446 bool run(Module &M); 447 448 /// Return true IFF AnalysisID AID is currently available. 449 /// TODO : Replace this method with getAnalysisPass() 450 Pass *getAnalysisPassFromManager(AnalysisID AID); 451 452 /// Pass Manager itself does not invalidate any analysis info. 453 void getAnalysisUsage(AnalysisUsage &Info) const { 454 Info.setPreservesAll(); 455 } 456 457 inline void addTopLevelPass(Pass *P) { 458 addPass(P); 459 } 460 461private: 462 463 /// Add a pass into a passmanager queue. 464 bool addPass(Pass *p); 465 466 // Collection of pass managers 467 std::vector<ModulePassManager_New *> PassManagers; 468 469 // Active Pass Manager 470 ModulePassManager_New *activeManager; 471}; 472 473} // End of llvm namespace 474 475//===----------------------------------------------------------------------===// 476// PMDataManager implementation 477 478/// Return true IFF pass P's required analysis set does not required new 479/// manager. 480bool PMDataManager::manageablePass(Pass *P) { 481 482 // TODO 483 // If this pass is not preserving information that is required by a 484 // pass maintained by higher level pass manager then do not insert 485 // this pass into current manager. Use new manager. For example, 486 // For example, If FunctionPass F is not preserving ModulePass Info M1 487 // that is used by another ModulePass M2 then do not insert F in 488 // current function pass manager. 489 return true; 490} 491 492/// Augement AvailableAnalysis by adding analysis made available by pass P. 493void PMDataManager::recordAvailableAnalysis(Pass *P) { 494 495 if (const PassInfo *PI = P->getPassInfo()) { 496 AvailableAnalysis[PI] = P; 497 498 //This pass is the current implementation of all of the interfaces it 499 //implements as well. 500 const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented(); 501 for (unsigned i = 0, e = II.size(); i != e; ++i) 502 AvailableAnalysis[II[i]] = P; 503 } 504} 505 506/// Remove Analyss not preserved by Pass P 507void PMDataManager::removeNotPreservedAnalysis(Pass *P) { 508 AnalysisUsage AnUsage; 509 P->getAnalysisUsage(AnUsage); 510 511 if (AnUsage.getPreservesAll()) 512 return; 513 514 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 515 for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), 516 E = AvailableAnalysis.end(); I != E; ++I ) { 517 if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) == 518 PreservedSet.end()) { 519 // Remove this analysis 520 std::map<AnalysisID, Pass*>::iterator J = I++; 521 AvailableAnalysis.erase(J); 522 } 523 } 524} 525 526/// Remove analysis passes that are not used any longer 527void PMDataManager::removeDeadPasses(Pass *P) { 528 529 std::vector<Pass *> DeadPasses; 530 TPM->collectLastUses(DeadPasses, P); 531 532 for (std::vector<Pass *>::iterator I = DeadPasses.begin(), 533 E = DeadPasses.end(); I != E; ++I) { 534 (*I)->releaseMemory(); 535 536 std::map<AnalysisID, Pass*>::iterator Pos = 537 AvailableAnalysis.find((*I)->getPassInfo()); 538 539 // It is possible that pass is already removed from the AvailableAnalysis 540 if (Pos != AvailableAnalysis.end()) 541 AvailableAnalysis.erase(Pos); 542 } 543} 544 545/// Add pass P into the PassVector. Update 546/// AvailableAnalysis appropriately if ProcessAnalysis is true. 547void PMDataManager::addPassToManager(Pass *P, 548 bool ProcessAnalysis) { 549 550 if (ProcessAnalysis) { 551 552 // At the moment, this pass is the last user of all required passes. 553 std::vector<Pass *> LastUses; 554 std::vector<Pass *> RequiredPasses; 555 unsigned PDepth = this->getDepth(); 556 557 collectRequiredAnalysisPasses(RequiredPasses, P); 558 for (std::vector<Pass *>::iterator I = RequiredPasses.begin(), 559 E = RequiredPasses.end(); I != E; ++I) { 560 Pass *PRequired = *I; 561 unsigned RDepth = 0; 562 //FIXME: RDepth = PRequired->getResolver()->getDepth(); 563 if (PDepth == RDepth) 564 LastUses.push_back(PRequired); 565 else if (PDepth > RDepth) { 566 // Let the parent claim responsibility of last use 567 ForcedLastUses.push_back(PRequired); 568 } else { 569 // Note : This feature is not yet implemented 570 assert (0 && 571 "Unable to handle Pass that requires lower level Analysis pass"); 572 } 573 } 574 575 if (!LastUses.empty()) 576 TPM->setLastUser(LastUses, P); 577 578 // Take a note of analysis required and made available by this pass. 579 // Remove the analysis not preserved by this pass 580 initializeAnalysisImpl(P); 581 removeNotPreservedAnalysis(P); 582 recordAvailableAnalysis(P); 583 } 584 585 // Add pass 586 PassVector.push_back(P); 587} 588 589/// Populate RequiredPasses with the analysis pass that are required by 590/// pass P. 591void PMDataManager::collectRequiredAnalysisPasses(std::vector<Pass *> &RP, 592 Pass *P) { 593 AnalysisUsage AnUsage; 594 P->getAnalysisUsage(AnUsage); 595 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 596 for (std::vector<AnalysisID>::const_iterator 597 I = RequiredSet.begin(), E = RequiredSet.end(); 598 I != E; ++I) { 599 Pass *AnalysisPass = NULL; //FIXME findAnalysisPass(*I,true); 600 assert (AnalysisPass && "Analysis pass is not available"); 601 RP.push_back(AnalysisPass); 602 } 603} 604 605// All Required analyses should be available to the pass as it runs! Here 606// we fill in the AnalysisImpls member of the pass so that it can 607// successfully use the getAnalysis() method to retrieve the 608// implementations it needs. 609// 610void PMDataManager::initializeAnalysisImpl(Pass *P) { 611 AnalysisUsage AnUsage; 612 P->getAnalysisUsage(AnUsage); 613 614 for (std::vector<const PassInfo *>::const_iterator 615 I = AnUsage.getRequiredSet().begin(), 616 E = AnUsage.getRequiredSet().end(); I != E; ++I) { 617 Pass *Impl = getAnalysisPass(*I); 618 if (Impl == 0) 619 assert(0 && "Analysis used but not available!"); 620 // TODO: P->AnalysisImpls.push_back(std::make_pair(*I, Impl)); 621 } 622} 623 624//===----------------------------------------------------------------------===// 625// BasicBlockPassManager_New implementation 626 627/// Add pass P into PassVector and return true. If this pass is not 628/// manageable by this manager then return false. 629bool 630BasicBlockPassManager_New::addPass(Pass *P) { 631 632 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 633 if (!BP) 634 return false; 635 636 // If this pass does not preserve anlysis that is used by other passes 637 // managed by this manager than it is not a suiable pass for this manager. 638 if (!manageablePass(P)) 639 return false; 640 641 addPassToManager (BP); 642 643 return true; 644} 645 646/// Execute all of the passes scheduled for execution by invoking 647/// runOnBasicBlock method. Keep track of whether any of the passes modifies 648/// the function, and if so, return true. 649bool 650BasicBlockPassManager_New::runOnFunction(Function &F) { 651 652 bool Changed = doInitialization(F); 653 initializeAnalysisInfo(); 654 655 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 656 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 657 e = passVectorEnd(); itr != e; ++itr) { 658 Pass *P = *itr; 659 660 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 661 Changed |= BP->runOnBasicBlock(*I); 662 removeNotPreservedAnalysis(P); 663 recordAvailableAnalysis(P); 664 removeDeadPasses(P); 665 } 666 return Changed | doFinalization(F); 667} 668 669/// Return true IFF AnalysisID AID is currently available. 670/// TODO : Replace this method with getAnalysisPass() 671Pass * BasicBlockPassManager_New::getAnalysisPassFromManager(AnalysisID AID) { 672 return getAnalysisPass(AID); 673} 674 675// Implement doInitialization and doFinalization 676inline bool BasicBlockPassManager_New::doInitialization(Module &M) { 677 bool Changed = false; 678 679 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 680 e = passVectorEnd(); itr != e; ++itr) { 681 Pass *P = *itr; 682 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 683 Changed |= BP->doInitialization(M); 684 } 685 686 return Changed; 687} 688 689inline bool BasicBlockPassManager_New::doFinalization(Module &M) { 690 bool Changed = false; 691 692 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 693 e = passVectorEnd(); itr != e; ++itr) { 694 Pass *P = *itr; 695 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 696 Changed |= BP->doFinalization(M); 697 } 698 699 return Changed; 700} 701 702inline bool BasicBlockPassManager_New::doInitialization(Function &F) { 703 bool Changed = false; 704 705 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 706 e = passVectorEnd(); itr != e; ++itr) { 707 Pass *P = *itr; 708 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 709 Changed |= BP->doInitialization(F); 710 } 711 712 return Changed; 713} 714 715inline bool BasicBlockPassManager_New::doFinalization(Function &F) { 716 bool Changed = false; 717 718 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 719 e = passVectorEnd(); itr != e; ++itr) { 720 Pass *P = *itr; 721 BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P); 722 Changed |= BP->doFinalization(F); 723 } 724 725 return Changed; 726} 727 728 729//===----------------------------------------------------------------------===// 730// FunctionPassManager_New implementation 731 732/// Create new Function pass manager 733FunctionPassManager_New::FunctionPassManager_New() { 734 FPM = new FunctionPassManagerImpl_New(0); 735} 736 737/// add - Add a pass to the queue of passes to run. This passes 738/// ownership of the Pass to the PassManager. When the 739/// PassManager_X is destroyed, the pass will be destroyed as well, so 740/// there is no need to delete the pass. (TODO delete passes.) 741/// This implies that all passes MUST be allocated with 'new'. 742void FunctionPassManager_New::add(Pass *P) { 743 FPM->add(P); 744} 745 746/// Execute all of the passes scheduled for execution. Keep 747/// track of whether any of the passes modifies the function, and if 748/// so, return true. 749bool FunctionPassManager_New::runOnModule(Module &M) { 750 return FPM->runOnModule(M); 751} 752 753/// run - Execute all of the passes scheduled for execution. Keep 754/// track of whether any of the passes modifies the function, and if 755/// so, return true. 756/// 757bool FunctionPassManager_New::run(Function &F) { 758 std::string errstr; 759 if (MP->materializeFunction(&F, &errstr)) { 760 cerr << "Error reading bytecode file: " << errstr << "\n"; 761 abort(); 762 } 763 return FPM->runOnFunction(F); 764} 765 766 767/// doInitialization - Run all of the initializers for the function passes. 768/// 769bool FunctionPassManager_New::doInitialization() { 770 return FPM->doInitialization(*MP->getModule()); 771} 772 773/// doFinalization - Run all of the initializers for the function passes. 774/// 775bool FunctionPassManager_New::doFinalization() { 776 return FPM->doFinalization(*MP->getModule()); 777} 778 779//===----------------------------------------------------------------------===// 780// FunctionPassManagerImpl_New implementation 781 782/// Add pass P into the pass manager queue. If P is a BasicBlockPass then 783/// either use it into active basic block pass manager or create new basic 784/// block pass manager to handle pass P. 785bool 786FunctionPassManagerImpl_New::addPass(Pass *P) { 787 788 // If P is a BasicBlockPass then use BasicBlockPassManager_New. 789 if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) { 790 791 if (!activeBBPassManager || !activeBBPassManager->addPass(BP)) { 792 793 // If active manager exists then clear its analysis info. 794 if (activeBBPassManager) 795 activeBBPassManager->initializeAnalysisInfo(); 796 797 // Create and add new manager 798 activeBBPassManager = 799 new BasicBlockPassManager_New(getDepth() + 1); 800 addPassToManager(activeBBPassManager, false); 801 802 // Add pass into new manager. This time it must succeed. 803 if (!activeBBPassManager->addPass(BP)) 804 assert(0 && "Unable to add Pass"); 805 } 806 807 if (!ForcedLastUses.empty()) 808 TPM->setLastUser(ForcedLastUses, this); 809 810 return true; 811 } 812 813 FunctionPass *FP = dynamic_cast<FunctionPass *>(P); 814 if (!FP) 815 return false; 816 817 // If this pass does not preserve anlysis that is used by other passes 818 // managed by this manager than it is not a suiable pass for this manager. 819 if (!manageablePass(P)) 820 return false; 821 822 addPassToManager (FP); 823 824 // If active manager exists then clear its analysis info. 825 if (activeBBPassManager) { 826 activeBBPassManager->initializeAnalysisInfo(); 827 activeBBPassManager = NULL; 828 } 829 830 return true; 831} 832 833/// Execute all of the passes scheduled for execution by invoking 834/// runOnFunction method. Keep track of whether any of the passes modifies 835/// the function, and if so, return true. 836bool FunctionPassManagerImpl_New::runOnModule(Module &M) { 837 838 bool Changed = false; 839 initializeAnalysisInfo(); 840 841 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 842 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 843 e = passVectorEnd(); itr != e; ++itr) { 844 Pass *P = *itr; 845 846 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 847 Changed |= FP->runOnFunction(*I); 848 removeNotPreservedAnalysis(P); 849 recordAvailableAnalysis(P); 850 removeDeadPasses(P); 851 } 852 return Changed; 853} 854 855/// Execute all of the passes scheduled for execution by invoking 856/// runOnFunction method. Keep track of whether any of the passes modifies 857/// the function, and if so, return true. 858bool FunctionPassManagerImpl_New::runOnFunction(Function &F) { 859 860 bool Changed = false; 861 initializeAnalysisInfo(); 862 863 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 864 e = passVectorEnd(); itr != e; ++itr) { 865 Pass *P = *itr; 866 867 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 868 Changed |= FP->runOnFunction(F); 869 removeNotPreservedAnalysis(P); 870 recordAvailableAnalysis(P); 871 removeDeadPasses(P); 872 } 873 return Changed; 874} 875 876 877/// Return true IFF AnalysisID AID is currently available. 878/// TODO : Replace this method with getAnalysisPass() 879Pass *FunctionPassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) { 880 881 Pass *P = getAnalysisPass(AID); 882 if (P) 883 return P; 884 885 if (activeBBPassManager && 886 activeBBPassManager->getAnalysisPass(AID) != 0) 887 return activeBBPassManager->getAnalysisPass(AID); 888 889 // TODO : Check inactive managers 890 return NULL; 891} 892 893inline bool FunctionPassManagerImpl_New::doInitialization(Module &M) { 894 bool Changed = false; 895 896 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 897 e = passVectorEnd(); itr != e; ++itr) { 898 Pass *P = *itr; 899 900 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 901 Changed |= FP->doInitialization(M); 902 } 903 904 return Changed; 905} 906 907inline bool FunctionPassManagerImpl_New::doFinalization(Module &M) { 908 bool Changed = false; 909 910 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 911 e = passVectorEnd(); itr != e; ++itr) { 912 Pass *P = *itr; 913 914 FunctionPass *FP = dynamic_cast<FunctionPass*>(P); 915 Changed |= FP->doFinalization(M); 916 } 917 918 919 return Changed; 920} 921 922//===----------------------------------------------------------------------===// 923// ModulePassManager implementation 924 925/// Add P into pass vector if it is manageble. If P is a FunctionPass 926/// then use FunctionPassManagerImpl_New to manage it. Return false if P 927/// is not manageable by this manager. 928bool 929ModulePassManager_New::addPass(Pass *P) { 930 931 // If P is FunctionPass then use function pass maanager. 932 if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) { 933 934 if (!activeFunctionPassManager 935 || !activeFunctionPassManager->addPass(P)) { 936 937 // If active manager exists then clear its analysis info. 938 if (activeFunctionPassManager) 939 activeFunctionPassManager->initializeAnalysisInfo(); 940 941 // Create and add new manager 942 activeFunctionPassManager = 943 new FunctionPassManagerImpl_New(getDepth() + 1); 944 addPassToManager(activeFunctionPassManager, false); 945 946 // Add pass into new manager. This time it must succeed. 947 if (!activeFunctionPassManager->addPass(FP)) 948 assert(0 && "Unable to add pass"); 949 } 950 951 if (!ForcedLastUses.empty()) 952 TPM->setLastUser(ForcedLastUses, this); 953 954 return true; 955 } 956 957 ModulePass *MP = dynamic_cast<ModulePass *>(P); 958 if (!MP) 959 return false; 960 961 // If this pass does not preserve anlysis that is used by other passes 962 // managed by this manager than it is not a suiable pass for this manager. 963 if (!manageablePass(P)) 964 return false; 965 966 addPassToManager(MP); 967 // If active manager exists then clear its analysis info. 968 if (activeFunctionPassManager) { 969 activeFunctionPassManager->initializeAnalysisInfo(); 970 activeFunctionPassManager = NULL; 971 } 972 973 return true; 974} 975 976 977/// Execute all of the passes scheduled for execution by invoking 978/// runOnModule method. Keep track of whether any of the passes modifies 979/// the module, and if so, return true. 980bool 981ModulePassManager_New::runOnModule(Module &M) { 982 bool Changed = false; 983 initializeAnalysisInfo(); 984 985 for (std::vector<Pass *>::iterator itr = passVectorBegin(), 986 e = passVectorEnd(); itr != e; ++itr) { 987 Pass *P = *itr; 988 989 ModulePass *MP = dynamic_cast<ModulePass*>(P); 990 Changed |= MP->runOnModule(M); 991 removeNotPreservedAnalysis(P); 992 recordAvailableAnalysis(P); 993 removeDeadPasses(P); 994 } 995 return Changed; 996} 997 998/// Return true IFF AnalysisID AID is currently available. 999/// TODO : Replace this method with getAnalysisPass() 1000Pass *ModulePassManager_New::getAnalysisPassFromManager(AnalysisID AID) { 1001 1002 Pass *P = getAnalysisPass(AID); 1003 if (P) 1004 return P; 1005 1006 if (activeFunctionPassManager && 1007 activeFunctionPassManager->getAnalysisPass(AID) != 0) 1008 return activeFunctionPassManager->getAnalysisPass(AID); 1009 1010 // TODO : Check inactive managers 1011 return NULL; 1012} 1013 1014//===----------------------------------------------------------------------===// 1015// PassManagerImpl implementation 1016 1017/// Return true IFF AnalysisID AID is currently available. 1018/// TODO : Replace this method with getAnalysisPass() 1019Pass *PassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) { 1020 1021 Pass *P = NULL; 1022 for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(), 1023 e = PassManagers.end(); !P && itr != e; ++itr) 1024 P = (*itr)->getAnalysisPassFromManager(AID); 1025 return P; 1026} 1027 1028// PassManager_New implementation 1029/// Add P into active pass manager or use new module pass manager to 1030/// manage it. 1031bool PassManagerImpl_New::addPass(Pass *P) { 1032 1033 if (!activeManager || !activeManager->addPass(P)) { 1034 activeManager = new ModulePassManager_New(getDepth() + 1); 1035 PassManagers.push_back(activeManager); 1036 return activeManager->addPass(P); 1037 } 1038 return true; 1039} 1040 1041/// run - Execute all of the passes scheduled for execution. Keep track of 1042/// whether any of the passes modifies the module, and if so, return true. 1043bool PassManagerImpl_New::run(Module &M) { 1044 1045 bool Changed = false; 1046 for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(), 1047 e = PassManagers.end(); itr != e; ++itr) { 1048 ModulePassManager_New *pm = *itr; 1049 Changed |= pm->runOnModule(M); 1050 } 1051 return Changed; 1052} 1053 1054//===----------------------------------------------------------------------===// 1055// PassManager implementation 1056 1057/// Create new pass manager 1058PassManager_New::PassManager_New() { 1059 PM = new PassManagerImpl_New(0); 1060} 1061 1062/// add - Add a pass to the queue of passes to run. This passes ownership of 1063/// the Pass to the PassManager. When the PassManager is destroyed, the pass 1064/// will be destroyed as well, so there is no need to delete the pass. This 1065/// implies that all passes MUST be allocated with 'new'. 1066void 1067PassManager_New::add(Pass *P) { 1068 PM->add(P); 1069} 1070 1071/// run - Execute all of the passes scheduled for execution. Keep track of 1072/// whether any of the passes modifies the module, and if so, return true. 1073bool 1074PassManager_New::run(Module &M) { 1075 return PM->run(M); 1076} 1077 1078