PassManager.cpp revision 97cf759b822818414f9604c74d3bcfe75a91520b
1//===- PassManager.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 Manager infrastructure. 11// 12//===----------------------------------------------------------------------===// 13 14 15#include "llvm/PassManagers.h" 16#include "llvm/Support/CommandLine.h" 17#include "llvm/Support/Timer.h" 18#include "llvm/Module.h" 19#include "llvm/ModuleProvider.h" 20#include "llvm/Support/Streams.h" 21#include "llvm/Support/ManagedStatic.h" 22#include <algorithm> 23#include <vector> 24#include <map> 25using namespace llvm; 26 27// See PassManagers.h for Pass Manager infrastructure overview. 28 29namespace llvm { 30 31//===----------------------------------------------------------------------===// 32// Pass debugging information. Often it is useful to find out what pass is 33// running when a crash occurs in a utility. When this library is compiled with 34// debugging on, a command line option (--debug-pass) is enabled that causes the 35// pass name to be printed before it executes. 36// 37 38// Different debug levels that can be enabled... 39enum PassDebugLevel { 40 None, Arguments, Structure, Executions, Details 41}; 42 43static cl::opt<enum PassDebugLevel> 44PassDebugging("debug-pass", cl::Hidden, 45 cl::desc("Print PassManager debugging information"), 46 cl::values( 47 clEnumVal(None , "disable debug output"), 48 clEnumVal(Arguments , "print pass arguments to pass to 'opt'"), 49 clEnumVal(Structure , "print pass structure before run()"), 50 clEnumVal(Executions, "print pass name before it is executed"), 51 clEnumVal(Details , "print pass details when it is executed"), 52 clEnumValEnd)); 53} // End of llvm namespace 54 55namespace { 56 57//===----------------------------------------------------------------------===// 58// BBPassManager 59// 60/// BBPassManager manages BasicBlockPass. It batches all the 61/// pass together and sequence them to process one basic block before 62/// processing next basic block. 63class VISIBILITY_HIDDEN BBPassManager : public PMDataManager, 64 public FunctionPass { 65 66public: 67 static char ID; 68 explicit BBPassManager(int Depth) 69 : PMDataManager(Depth), FunctionPass((intptr_t)&ID) {} 70 71 /// Execute all of the passes scheduled for execution. Keep track of 72 /// whether any of the passes modifies the function, and if so, return true. 73 bool runOnFunction(Function &F); 74 75 /// Pass Manager itself does not invalidate any analysis info. 76 void getAnalysisUsage(AnalysisUsage &Info) const { 77 Info.setPreservesAll(); 78 } 79 80 bool doInitialization(Module &M); 81 bool doInitialization(Function &F); 82 bool doFinalization(Module &M); 83 bool doFinalization(Function &F); 84 85 virtual const char *getPassName() const { 86 return "BasicBlock Pass Manager"; 87 } 88 89 // Print passes managed by this manager 90 void dumpPassStructure(unsigned Offset) { 91 llvm::cerr << std::string(Offset*2, ' ') << "BasicBlockPass Manager\n"; 92 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 93 BasicBlockPass *BP = getContainedPass(Index); 94 BP->dumpPassStructure(Offset + 1); 95 dumpLastUses(BP, Offset+1); 96 } 97 } 98 99 BasicBlockPass *getContainedPass(unsigned N) { 100 assert ( N < PassVector.size() && "Pass number out of range!"); 101 BasicBlockPass *BP = static_cast<BasicBlockPass *>(PassVector[N]); 102 return BP; 103 } 104 105 virtual PassManagerType getPassManagerType() const { 106 return PMT_BasicBlockPassManager; 107 } 108}; 109 110char BBPassManager::ID = 0; 111} 112 113namespace llvm { 114 115//===----------------------------------------------------------------------===// 116// FunctionPassManagerImpl 117// 118/// FunctionPassManagerImpl manages FPPassManagers 119class FunctionPassManagerImpl : public Pass, 120 public PMDataManager, 121 public PMTopLevelManager { 122public: 123 static char ID; 124 explicit FunctionPassManagerImpl(int Depth) : 125 Pass((intptr_t)&ID), PMDataManager(Depth), 126 PMTopLevelManager(TLM_Function) { } 127 128 /// add - Add a pass to the queue of passes to run. This passes ownership of 129 /// the Pass to the PassManager. When the PassManager is destroyed, the pass 130 /// will be destroyed as well, so there is no need to delete the pass. This 131 /// implies that all passes MUST be allocated with 'new'. 132 void add(Pass *P) { 133 schedulePass(P); 134 } 135 136 /// run - Execute all of the passes scheduled for execution. Keep track of 137 /// whether any of the passes modifies the module, and if so, return true. 138 bool run(Function &F); 139 140 /// doInitialization - Run all of the initializers for the function passes. 141 /// 142 bool doInitialization(Module &M); 143 144 /// doFinalization - Run all of the finalizers for the function passes. 145 /// 146 bool doFinalization(Module &M); 147 148 /// Pass Manager itself does not invalidate any analysis info. 149 void getAnalysisUsage(AnalysisUsage &Info) const { 150 Info.setPreservesAll(); 151 } 152 153 inline void addTopLevelPass(Pass *P) { 154 155 if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) { 156 157 // P is a immutable pass and it will be managed by this 158 // top level manager. Set up analysis resolver to connect them. 159 AnalysisResolver *AR = new AnalysisResolver(*this); 160 P->setResolver(AR); 161 initializeAnalysisImpl(P); 162 addImmutablePass(IP); 163 recordAvailableAnalysis(IP); 164 } else { 165 P->assignPassManager(activeStack); 166 } 167 168 } 169 170 FPPassManager *getContainedManager(unsigned N) { 171 assert ( N < PassManagers.size() && "Pass number out of range!"); 172 FPPassManager *FP = static_cast<FPPassManager *>(PassManagers[N]); 173 return FP; 174 } 175}; 176 177char FunctionPassManagerImpl::ID = 0; 178//===----------------------------------------------------------------------===// 179// MPPassManager 180// 181/// MPPassManager manages ModulePasses and function pass managers. 182/// It batches all Module passes passes and function pass managers together and 183/// sequence them to process one module. 184class MPPassManager : public Pass, public PMDataManager { 185 186public: 187 static char ID; 188 explicit MPPassManager(int Depth) : 189 Pass((intptr_t)&ID), PMDataManager(Depth) { } 190 191 // Delete on the fly managers. 192 virtual ~MPPassManager() { 193 for (std::map<Pass *, FunctionPassManagerImpl *>::iterator 194 I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end(); 195 I != E; ++I) { 196 FunctionPassManagerImpl *FPP = I->second; 197 delete FPP; 198 } 199 } 200 201 /// run - Execute all of the passes scheduled for execution. Keep track of 202 /// whether any of the passes modifies the module, and if so, return true. 203 bool runOnModule(Module &M); 204 205 /// Pass Manager itself does not invalidate any analysis info. 206 void getAnalysisUsage(AnalysisUsage &Info) const { 207 Info.setPreservesAll(); 208 } 209 210 /// Add RequiredPass into list of lower level passes required by pass P. 211 /// RequiredPass is run on the fly by Pass Manager when P requests it 212 /// through getAnalysis interface. 213 virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass); 214 215 /// Return function pass corresponding to PassInfo PI, that is 216 /// required by module pass MP. Instantiate analysis pass, by using 217 /// its runOnFunction() for function F. 218 virtual Pass* getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F); 219 220 virtual const char *getPassName() const { 221 return "Module Pass Manager"; 222 } 223 224 // Print passes managed by this manager 225 void dumpPassStructure(unsigned Offset) { 226 llvm::cerr << std::string(Offset*2, ' ') << "ModulePass Manager\n"; 227 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 228 ModulePass *MP = getContainedPass(Index); 229 MP->dumpPassStructure(Offset + 1); 230 if (FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]) 231 FPP->dumpPassStructure(Offset + 2); 232 dumpLastUses(MP, Offset+1); 233 } 234 } 235 236 ModulePass *getContainedPass(unsigned N) { 237 assert ( N < PassVector.size() && "Pass number out of range!"); 238 ModulePass *MP = static_cast<ModulePass *>(PassVector[N]); 239 return MP; 240 } 241 242 virtual PassManagerType getPassManagerType() const { 243 return PMT_ModulePassManager; 244 } 245 246 private: 247 /// Collection of on the fly FPPassManagers. These managers manage 248 /// function passes that are required by module passes. 249 std::map<Pass *, FunctionPassManagerImpl *> OnTheFlyManagers; 250}; 251 252char MPPassManager::ID = 0; 253//===----------------------------------------------------------------------===// 254// PassManagerImpl 255// 256 257/// PassManagerImpl manages MPPassManagers 258class PassManagerImpl : public Pass, 259 public PMDataManager, 260 public PMTopLevelManager { 261 262public: 263 static char ID; 264 explicit PassManagerImpl(int Depth) : 265 Pass((intptr_t)&ID), PMDataManager(Depth), 266 PMTopLevelManager(TLM_Pass) { } 267 268 /// add - Add a pass to the queue of passes to run. This passes ownership of 269 /// the Pass to the PassManager. When the PassManager is destroyed, the pass 270 /// will be destroyed as well, so there is no need to delete the pass. This 271 /// implies that all passes MUST be allocated with 'new'. 272 void add(Pass *P) { 273 schedulePass(P); 274 } 275 276 /// run - Execute all of the passes scheduled for execution. Keep track of 277 /// whether any of the passes modifies the module, and if so, return true. 278 bool run(Module &M); 279 280 /// Pass Manager itself does not invalidate any analysis info. 281 void getAnalysisUsage(AnalysisUsage &Info) const { 282 Info.setPreservesAll(); 283 } 284 285 inline void addTopLevelPass(Pass *P) { 286 287 if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) { 288 289 // P is a immutable pass and it will be managed by this 290 // top level manager. Set up analysis resolver to connect them. 291 AnalysisResolver *AR = new AnalysisResolver(*this); 292 P->setResolver(AR); 293 initializeAnalysisImpl(P); 294 addImmutablePass(IP); 295 recordAvailableAnalysis(IP); 296 } else { 297 P->assignPassManager(activeStack); 298 } 299 300 } 301 302 MPPassManager *getContainedManager(unsigned N) { 303 assert ( N < PassManagers.size() && "Pass number out of range!"); 304 MPPassManager *MP = static_cast<MPPassManager *>(PassManagers[N]); 305 return MP; 306 } 307 308}; 309 310char PassManagerImpl::ID = 0; 311} // End of llvm namespace 312 313namespace { 314 315//===----------------------------------------------------------------------===// 316// TimingInfo Class - This class is used to calculate information about the 317// amount of time each pass takes to execute. This only happens when 318// -time-passes is enabled on the command line. 319// 320 321class VISIBILITY_HIDDEN TimingInfo { 322 std::map<Pass*, Timer> TimingData; 323 TimerGroup TG; 324 325public: 326 // Use 'create' member to get this. 327 TimingInfo() : TG("... Pass execution timing report ...") {} 328 329 // TimingDtor - Print out information about timing information 330 ~TimingInfo() { 331 // Delete all of the timers... 332 TimingData.clear(); 333 // TimerGroup is deleted next, printing the report. 334 } 335 336 // createTheTimeInfo - This method either initializes the TheTimeInfo pointer 337 // to a non null value (if the -time-passes option is enabled) or it leaves it 338 // null. It may be called multiple times. 339 static void createTheTimeInfo(); 340 341 void passStarted(Pass *P) { 342 343 if (dynamic_cast<PMDataManager *>(P)) 344 return; 345 346 std::map<Pass*, Timer>::iterator I = TimingData.find(P); 347 if (I == TimingData.end()) 348 I=TimingData.insert(std::make_pair(P, Timer(P->getPassName(), TG))).first; 349 I->second.startTimer(); 350 } 351 void passEnded(Pass *P) { 352 353 if (dynamic_cast<PMDataManager *>(P)) 354 return; 355 356 std::map<Pass*, Timer>::iterator I = TimingData.find(P); 357 assert (I != TimingData.end() && "passStarted/passEnded not nested right!"); 358 I->second.stopTimer(); 359 } 360}; 361 362static TimingInfo *TheTimeInfo; 363 364} // End of anon namespace 365 366//===----------------------------------------------------------------------===// 367// PMTopLevelManager implementation 368 369/// Initialize top level manager. Create first pass manager. 370PMTopLevelManager::PMTopLevelManager (enum TopLevelManagerType t) { 371 372 if (t == TLM_Pass) { 373 MPPassManager *MPP = new MPPassManager(1); 374 MPP->setTopLevelManager(this); 375 addPassManager(MPP); 376 activeStack.push(MPP); 377 } 378 else if (t == TLM_Function) { 379 FPPassManager *FPP = new FPPassManager(1); 380 FPP->setTopLevelManager(this); 381 addPassManager(FPP); 382 activeStack.push(FPP); 383 } 384} 385 386/// Set pass P as the last user of the given analysis passes. 387void PMTopLevelManager::setLastUser(SmallVector<Pass *, 12> &AnalysisPasses, 388 Pass *P) { 389 390 for (SmallVector<Pass *, 12>::iterator I = AnalysisPasses.begin(), 391 E = AnalysisPasses.end(); I != E; ++I) { 392 Pass *AP = *I; 393 LastUser[AP] = P; 394 395 if (P == AP) 396 continue; 397 398 // If AP is the last user of other passes then make P last user of 399 // such passes. 400 for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(), 401 LUE = LastUser.end(); LUI != LUE; ++LUI) { 402 if (LUI->second == AP) 403 LastUser[LUI->first] = P; 404 } 405 } 406} 407 408/// Collect passes whose last user is P 409void PMTopLevelManager::collectLastUses(SmallVector<Pass *, 12> &LastUses, 410 Pass *P) { 411 for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(), 412 LUE = LastUser.end(); LUI != LUE; ++LUI) 413 if (LUI->second == P) 414 LastUses.push_back(LUI->first); 415} 416 417/// Schedule pass P for execution. Make sure that passes required by 418/// P are run before P is run. Update analysis info maintained by 419/// the manager. Remove dead passes. This is a recursive function. 420void PMTopLevelManager::schedulePass(Pass *P) { 421 422 // TODO : Allocate function manager for this pass, other wise required set 423 // may be inserted into previous function manager 424 425 // Give pass a chance to prepare the stage. 426 P->preparePassManager(activeStack); 427 428 AnalysisUsage AnUsage; 429 P->getAnalysisUsage(AnUsage); 430 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 431 for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(), 432 E = RequiredSet.end(); I != E; ++I) { 433 434 Pass *AnalysisPass = findAnalysisPass(*I); 435 if (!AnalysisPass) { 436 AnalysisPass = (*I)->createPass(); 437 // Schedule this analysis run first only if it is not a lower level 438 // analysis pass. Lower level analsyis passes are run on the fly. 439 if (P->getPotentialPassManagerType () >= 440 AnalysisPass->getPotentialPassManagerType()) 441 schedulePass(AnalysisPass); 442 else 443 delete AnalysisPass; 444 } 445 } 446 447 // Now all required passes are available. 448 addTopLevelPass(P); 449} 450 451/// Find the pass that implements Analysis AID. Search immutable 452/// passes and all pass managers. If desired pass is not found 453/// then return NULL. 454Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { 455 456 Pass *P = NULL; 457 // Check pass managers 458 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 459 E = PassManagers.end(); P == NULL && I != E; ++I) { 460 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 461 assert(PMD && "This is not a PassManager"); 462 P = PMD->findAnalysisPass(AID, false); 463 } 464 465 // Check other pass managers 466 for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(), 467 E = IndirectPassManagers.end(); P == NULL && I != E; ++I) 468 P = (*I)->findAnalysisPass(AID, false); 469 470 for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(), 471 E = ImmutablePasses.end(); P == NULL && I != E; ++I) { 472 const PassInfo *PI = (*I)->getPassInfo(); 473 if (PI == AID) 474 P = *I; 475 476 // If Pass not found then check the interfaces implemented by Immutable Pass 477 if (!P) { 478 const std::vector<const PassInfo*> &ImmPI = 479 PI->getInterfacesImplemented(); 480 if (std::find(ImmPI.begin(), ImmPI.end(), AID) != ImmPI.end()) 481 P = *I; 482 } 483 } 484 485 return P; 486} 487 488// Print passes managed by this top level manager. 489void PMTopLevelManager::dumpPasses() const { 490 491 if (PassDebugging < Structure) 492 return; 493 494 // Print out the immutable passes 495 for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) { 496 ImmutablePasses[i]->dumpPassStructure(0); 497 } 498 499 for (std::vector<Pass *>::const_iterator I = PassManagers.begin(), 500 E = PassManagers.end(); I != E; ++I) 501 (*I)->dumpPassStructure(1); 502} 503 504void PMTopLevelManager::dumpArguments() const { 505 506 if (PassDebugging < Arguments) 507 return; 508 509 cerr << "Pass Arguments: "; 510 for (std::vector<Pass *>::const_iterator I = PassManagers.begin(), 511 E = PassManagers.end(); I != E; ++I) { 512 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 513 assert(PMD && "This is not a PassManager"); 514 PMD->dumpPassArguments(); 515 } 516 cerr << "\n"; 517} 518 519void PMTopLevelManager::initializeAllAnalysisInfo() { 520 521 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 522 E = PassManagers.end(); I != E; ++I) { 523 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 524 assert(PMD && "This is not a PassManager"); 525 PMD->initializeAnalysisInfo(); 526 } 527 528 // Initailize other pass managers 529 for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(), 530 E = IndirectPassManagers.end(); I != E; ++I) 531 (*I)->initializeAnalysisInfo(); 532} 533 534/// Destructor 535PMTopLevelManager::~PMTopLevelManager() { 536 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 537 E = PassManagers.end(); I != E; ++I) 538 delete *I; 539 540 for (std::vector<ImmutablePass *>::iterator 541 I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) 542 delete *I; 543 544 PassManagers.clear(); 545} 546 547//===----------------------------------------------------------------------===// 548// PMDataManager implementation 549 550/// Return true IFF pass P's required analysis set does not required new 551/// manager. 552bool PMDataManager::manageablePass(Pass *P) { 553 554 // TODO 555 // If this pass is not preserving information that is required by a 556 // pass maintained by higher level pass manager then do not insert 557 // this pass into current manager. Use new manager. For example, 558 // For example, If FunctionPass F is not preserving ModulePass Info M1 559 // that is used by another ModulePass M2 then do not insert F in 560 // current function pass manager. 561 return true; 562} 563 564/// Augement AvailableAnalysis by adding analysis made available by pass P. 565void PMDataManager::recordAvailableAnalysis(Pass *P) { 566 567 if (const PassInfo *PI = P->getPassInfo()) { 568 AvailableAnalysis[PI] = P; 569 570 //This pass is the current implementation of all of the interfaces it 571 //implements as well. 572 const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented(); 573 for (unsigned i = 0, e = II.size(); i != e; ++i) 574 AvailableAnalysis[II[i]] = P; 575 } 576} 577 578// Return true if P preserves high level analysis used by other 579// passes managed by this manager 580bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { 581 582 AnalysisUsage AnUsage; 583 P->getAnalysisUsage(AnUsage); 584 585 if (AnUsage.getPreservesAll()) 586 return true; 587 588 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 589 for (std::vector<Pass *>::iterator I = HigherLevelAnalysis.begin(), 590 E = HigherLevelAnalysis.end(); I != E; ++I) { 591 Pass *P1 = *I; 592 if (!dynamic_cast<ImmutablePass*>(P1) && 593 std::find(PreservedSet.begin(), PreservedSet.end(), 594 P1->getPassInfo()) == 595 PreservedSet.end()) 596 return false; 597 } 598 599 return true; 600} 601 602/// verifyPreservedAnalysis -- Verify analysis presreved by pass P. 603void PMDataManager::verifyPreservedAnalysis(Pass *P) { 604 AnalysisUsage AnUsage; 605 P->getAnalysisUsage(AnUsage); 606 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 607 608 // Verify preserved analysis 609 for (std::vector<AnalysisID>::const_iterator I = PreservedSet.begin(), 610 E = PreservedSet.end(); I != E; ++I) { 611 AnalysisID AID = *I; 612 Pass *AP = findAnalysisPass(AID, true); 613 if (AP) 614 AP->verifyAnalysis(); 615 } 616} 617 618/// Remove Analyss not preserved by Pass P 619void PMDataManager::removeNotPreservedAnalysis(Pass *P) { 620 AnalysisUsage AnUsage; 621 P->getAnalysisUsage(AnUsage); 622 if (AnUsage.getPreservesAll()) 623 return; 624 625 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 626 for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), 627 E = AvailableAnalysis.end(); I != E; ) { 628 std::map<AnalysisID, Pass*>::iterator Info = I++; 629 if (!dynamic_cast<ImmutablePass*>(Info->second) 630 && std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == 631 PreservedSet.end()) 632 // Remove this analysis 633 AvailableAnalysis.erase(Info); 634 } 635 636 // Check inherited analysis also. If P is not preserving analysis 637 // provided by parent manager then remove it here. 638 for (unsigned Index = 0; Index < PMT_Last; ++Index) { 639 640 if (!InheritedAnalysis[Index]) 641 continue; 642 643 for (std::map<AnalysisID, Pass*>::iterator 644 I = InheritedAnalysis[Index]->begin(), 645 E = InheritedAnalysis[Index]->end(); I != E; ) { 646 std::map<AnalysisID, Pass *>::iterator Info = I++; 647 if (!dynamic_cast<ImmutablePass*>(Info->second) && 648 std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == 649 PreservedSet.end()) 650 // Remove this analysis 651 InheritedAnalysis[Index]->erase(Info); 652 } 653 } 654 655} 656 657/// Remove analysis passes that are not used any longer 658void PMDataManager::removeDeadPasses(Pass *P, const char *Msg, 659 enum PassDebuggingString DBG_STR) { 660 661 SmallVector<Pass *, 12> DeadPasses; 662 663 // If this is a on the fly manager then it does not have TPM. 664 if (!TPM) 665 return; 666 667 TPM->collectLastUses(DeadPasses, P); 668 669 for (SmallVector<Pass *, 12>::iterator I = DeadPasses.begin(), 670 E = DeadPasses.end(); I != E; ++I) { 671 672 dumpPassInfo(*I, FREEING_MSG, DBG_STR, Msg); 673 674 if (TheTimeInfo) TheTimeInfo->passStarted(*I); 675 (*I)->releaseMemory(); 676 if (TheTimeInfo) TheTimeInfo->passEnded(*I); 677 678 std::map<AnalysisID, Pass*>::iterator Pos = 679 AvailableAnalysis.find((*I)->getPassInfo()); 680 681 // It is possible that pass is already removed from the AvailableAnalysis 682 if (Pos != AvailableAnalysis.end()) 683 AvailableAnalysis.erase(Pos); 684 } 685} 686 687/// Add pass P into the PassVector. Update 688/// AvailableAnalysis appropriately if ProcessAnalysis is true. 689void PMDataManager::add(Pass *P, 690 bool ProcessAnalysis) { 691 692 // This manager is going to manage pass P. Set up analysis resolver 693 // to connect them. 694 AnalysisResolver *AR = new AnalysisResolver(*this); 695 P->setResolver(AR); 696 697 // If a FunctionPass F is the last user of ModulePass info M 698 // then the F's manager, not F, records itself as a last user of M. 699 SmallVector<Pass *, 12> TransferLastUses; 700 701 if (ProcessAnalysis) { 702 703 // At the moment, this pass is the last user of all required passes. 704 SmallVector<Pass *, 12> LastUses; 705 SmallVector<Pass *, 8> RequiredPasses; 706 SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable; 707 708 unsigned PDepth = this->getDepth(); 709 710 collectRequiredAnalysis(RequiredPasses, 711 ReqAnalysisNotAvailable, P); 712 for (SmallVector<Pass *, 8>::iterator I = RequiredPasses.begin(), 713 E = RequiredPasses.end(); I != E; ++I) { 714 Pass *PRequired = *I; 715 unsigned RDepth = 0; 716 717 PMDataManager &DM = PRequired->getResolver()->getPMDataManager(); 718 RDepth = DM.getDepth(); 719 720 if (PDepth == RDepth) 721 LastUses.push_back(PRequired); 722 else if (PDepth > RDepth) { 723 // Let the parent claim responsibility of last use 724 TransferLastUses.push_back(PRequired); 725 // Keep track of higher level analysis used by this manager. 726 HigherLevelAnalysis.push_back(PRequired); 727 } else 728 assert (0 && "Unable to accomodate Required Pass"); 729 } 730 731 // Set P as P's last user until someone starts using P. 732 // However, if P is a Pass Manager then it does not need 733 // to record its last user. 734 if (!dynamic_cast<PMDataManager *>(P)) 735 LastUses.push_back(P); 736 TPM->setLastUser(LastUses, P); 737 738 if (!TransferLastUses.empty()) { 739 Pass *My_PM = dynamic_cast<Pass *>(this); 740 TPM->setLastUser(TransferLastUses, My_PM); 741 TransferLastUses.clear(); 742 } 743 744 // Now, take care of required analysises that are not available. 745 for (SmallVector<AnalysisID, 8>::iterator 746 I = ReqAnalysisNotAvailable.begin(), 747 E = ReqAnalysisNotAvailable.end() ;I != E; ++I) { 748 Pass *AnalysisPass = (*I)->createPass(); 749 this->addLowerLevelRequiredPass(P, AnalysisPass); 750 } 751 752 // Take a note of analysis required and made available by this pass. 753 // Remove the analysis not preserved by this pass 754 removeNotPreservedAnalysis(P); 755 recordAvailableAnalysis(P); 756 } 757 758 // Add pass 759 PassVector.push_back(P); 760} 761 762 763/// Populate RP with analysis pass that are required by 764/// pass P and are available. Populate RP_NotAvail with analysis 765/// pass that are required by pass P but are not available. 766void PMDataManager::collectRequiredAnalysis(SmallVector<Pass *, 8>&RP, 767 SmallVector<AnalysisID, 8> &RP_NotAvail, 768 Pass *P) { 769 AnalysisUsage AnUsage; 770 P->getAnalysisUsage(AnUsage); 771 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 772 for (std::vector<AnalysisID>::const_iterator 773 I = RequiredSet.begin(), E = RequiredSet.end(); 774 I != E; ++I) { 775 AnalysisID AID = *I; 776 if (Pass *AnalysisPass = findAnalysisPass(*I, true)) 777 RP.push_back(AnalysisPass); 778 else 779 RP_NotAvail.push_back(AID); 780 } 781 782 const std::vector<AnalysisID> &IDs = AnUsage.getRequiredTransitiveSet(); 783 for (std::vector<AnalysisID>::const_iterator I = IDs.begin(), 784 E = IDs.end(); I != E; ++I) { 785 AnalysisID AID = *I; 786 if (Pass *AnalysisPass = findAnalysisPass(*I, true)) 787 RP.push_back(AnalysisPass); 788 else 789 RP_NotAvail.push_back(AID); 790 } 791} 792 793// All Required analyses should be available to the pass as it runs! Here 794// we fill in the AnalysisImpls member of the pass so that it can 795// successfully use the getAnalysis() method to retrieve the 796// implementations it needs. 797// 798void PMDataManager::initializeAnalysisImpl(Pass *P) { 799 AnalysisUsage AnUsage; 800 P->getAnalysisUsage(AnUsage); 801 802 for (std::vector<const PassInfo *>::const_iterator 803 I = AnUsage.getRequiredSet().begin(), 804 E = AnUsage.getRequiredSet().end(); I != E; ++I) { 805 Pass *Impl = findAnalysisPass(*I, true); 806 if (Impl == 0) 807 // This may be analysis pass that is initialized on the fly. 808 // If that is not the case then it will raise an assert when it is used. 809 continue; 810 AnalysisResolver *AR = P->getResolver(); 811 AR->addAnalysisImplsPair(*I, Impl); 812 } 813} 814 815/// Find the pass that implements Analysis AID. If desired pass is not found 816/// then return NULL. 817Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { 818 819 // Check if AvailableAnalysis map has one entry. 820 std::map<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID); 821 822 if (I != AvailableAnalysis.end()) 823 return I->second; 824 825 // Search Parents through TopLevelManager 826 if (SearchParent) 827 return TPM->findAnalysisPass(AID); 828 829 return NULL; 830} 831 832// Print list of passes that are last used by P. 833void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ 834 835 SmallVector<Pass *, 12> LUses; 836 837 // If this is a on the fly manager then it does not have TPM. 838 if (!TPM) 839 return; 840 841 TPM->collectLastUses(LUses, P); 842 843 for (SmallVector<Pass *, 12>::iterator I = LUses.begin(), 844 E = LUses.end(); I != E; ++I) { 845 llvm::cerr << "--" << std::string(Offset*2, ' '); 846 (*I)->dumpPassStructure(0); 847 } 848} 849 850void PMDataManager::dumpPassArguments() const { 851 for(std::vector<Pass *>::const_iterator I = PassVector.begin(), 852 E = PassVector.end(); I != E; ++I) { 853 if (PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I)) 854 PMD->dumpPassArguments(); 855 else 856 if (const PassInfo *PI = (*I)->getPassInfo()) 857 if (!PI->isAnalysisGroup()) 858 cerr << " -" << PI->getPassArgument(); 859 } 860} 861 862void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1, 863 enum PassDebuggingString S2, 864 const char *Msg) { 865 if (PassDebugging < Executions) 866 return; 867 cerr << (void*)this << std::string(getDepth()*2+1, ' '); 868 switch (S1) { 869 case EXECUTION_MSG: 870 cerr << "Executing Pass '" << P->getPassName(); 871 break; 872 case MODIFICATION_MSG: 873 cerr << "Made Modification '" << P->getPassName(); 874 break; 875 case FREEING_MSG: 876 cerr << " Freeing Pass '" << P->getPassName(); 877 break; 878 default: 879 break; 880 } 881 switch (S2) { 882 case ON_BASICBLOCK_MSG: 883 cerr << "' on BasicBlock '" << Msg << "'...\n"; 884 break; 885 case ON_FUNCTION_MSG: 886 cerr << "' on Function '" << Msg << "'...\n"; 887 break; 888 case ON_MODULE_MSG: 889 cerr << "' on Module '" << Msg << "'...\n"; 890 break; 891 case ON_LOOP_MSG: 892 cerr << "' on Loop " << Msg << "'...\n"; 893 break; 894 case ON_CG_MSG: 895 cerr << "' on Call Graph " << Msg << "'...\n"; 896 break; 897 default: 898 break; 899 } 900} 901 902void PMDataManager::dumpAnalysisSetInfo(const char *Msg, Pass *P, 903 const std::vector<AnalysisID> &Set) 904 const { 905 if (PassDebugging >= Details && !Set.empty()) { 906 cerr << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:"; 907 for (unsigned i = 0; i != Set.size(); ++i) { 908 if (i) cerr << ","; 909 cerr << " " << Set[i]->getPassName(); 910 } 911 cerr << "\n"; 912 } 913} 914 915/// Add RequiredPass into list of lower level passes required by pass P. 916/// RequiredPass is run on the fly by Pass Manager when P requests it 917/// through getAnalysis interface. 918/// This should be handled by specific pass manager. 919void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { 920 if (TPM) { 921 TPM->dumpArguments(); 922 TPM->dumpPasses(); 923 } 924 assert (0 && "Unable to handle Pass that requires lower level Analysis pass"); 925} 926 927// Destructor 928PMDataManager::~PMDataManager() { 929 930 for (std::vector<Pass *>::iterator I = PassVector.begin(), 931 E = PassVector.end(); I != E; ++I) 932 delete *I; 933 934 PassVector.clear(); 935} 936 937//===----------------------------------------------------------------------===// 938// NOTE: Is this the right place to define this method ? 939// getAnalysisToUpdate - Return an analysis result or null if it doesn't exist 940Pass *AnalysisResolver::getAnalysisToUpdate(AnalysisID ID, bool dir) const { 941 return PM.findAnalysisPass(ID, dir); 942} 943 944Pass *AnalysisResolver::findImplPass(Pass *P, const PassInfo *AnalysisPI, 945 Function &F) { 946 return PM.getOnTheFlyPass(P, AnalysisPI, F); 947} 948 949//===----------------------------------------------------------------------===// 950// BBPassManager implementation 951 952/// Execute all of the passes scheduled for execution by invoking 953/// runOnBasicBlock method. Keep track of whether any of the passes modifies 954/// the function, and if so, return true. 955bool 956BBPassManager::runOnFunction(Function &F) { 957 958 if (F.isDeclaration()) 959 return false; 960 961 bool Changed = doInitialization(F); 962 963 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 964 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 965 BasicBlockPass *BP = getContainedPass(Index); 966 AnalysisUsage AnUsage; 967 BP->getAnalysisUsage(AnUsage); 968 969 dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getNameStart()); 970 dumpAnalysisSetInfo("Required", BP, AnUsage.getRequiredSet()); 971 972 initializeAnalysisImpl(BP); 973 974 if (TheTimeInfo) TheTimeInfo->passStarted(BP); 975 Changed |= BP->runOnBasicBlock(*I); 976 if (TheTimeInfo) TheTimeInfo->passEnded(BP); 977 978 if (Changed) 979 dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, 980 I->getNameStart()); 981 dumpAnalysisSetInfo("Preserved", BP, AnUsage.getPreservedSet()); 982 983 verifyPreservedAnalysis(BP); 984 removeNotPreservedAnalysis(BP); 985 recordAvailableAnalysis(BP); 986 removeDeadPasses(BP, I->getNameStart(), ON_BASICBLOCK_MSG); 987 } 988 989 return Changed |= doFinalization(F); 990} 991 992// Implement doInitialization and doFinalization 993inline bool BBPassManager::doInitialization(Module &M) { 994 bool Changed = false; 995 996 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 997 BasicBlockPass *BP = getContainedPass(Index); 998 Changed |= BP->doInitialization(M); 999 } 1000 1001 return Changed; 1002} 1003 1004inline bool BBPassManager::doFinalization(Module &M) { 1005 bool Changed = false; 1006 1007 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1008 BasicBlockPass *BP = getContainedPass(Index); 1009 Changed |= BP->doFinalization(M); 1010 } 1011 1012 return Changed; 1013} 1014 1015inline bool BBPassManager::doInitialization(Function &F) { 1016 bool Changed = false; 1017 1018 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1019 BasicBlockPass *BP = getContainedPass(Index); 1020 Changed |= BP->doInitialization(F); 1021 } 1022 1023 return Changed; 1024} 1025 1026inline bool BBPassManager::doFinalization(Function &F) { 1027 bool Changed = false; 1028 1029 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1030 BasicBlockPass *BP = getContainedPass(Index); 1031 Changed |= BP->doFinalization(F); 1032 } 1033 1034 return Changed; 1035} 1036 1037 1038//===----------------------------------------------------------------------===// 1039// FunctionPassManager implementation 1040 1041/// Create new Function pass manager 1042FunctionPassManager::FunctionPassManager(ModuleProvider *P) { 1043 FPM = new FunctionPassManagerImpl(0); 1044 // FPM is the top level manager. 1045 FPM->setTopLevelManager(FPM); 1046 1047 PMDataManager *PMD = dynamic_cast<PMDataManager *>(FPM); 1048 AnalysisResolver *AR = new AnalysisResolver(*PMD); 1049 FPM->setResolver(AR); 1050 1051 MP = P; 1052} 1053 1054FunctionPassManager::~FunctionPassManager() { 1055 delete FPM; 1056} 1057 1058/// add - Add a pass to the queue of passes to run. This passes 1059/// ownership of the Pass to the PassManager. When the 1060/// PassManager_X is destroyed, the pass will be destroyed as well, so 1061/// there is no need to delete the pass. (TODO delete passes.) 1062/// This implies that all passes MUST be allocated with 'new'. 1063void FunctionPassManager::add(Pass *P) { 1064 FPM->add(P); 1065} 1066 1067/// run - Execute all of the passes scheduled for execution. Keep 1068/// track of whether any of the passes modifies the function, and if 1069/// so, return true. 1070/// 1071bool FunctionPassManager::run(Function &F) { 1072 std::string errstr; 1073 if (MP->materializeFunction(&F, &errstr)) { 1074 cerr << "Error reading bitcode file: " << errstr << "\n"; 1075 abort(); 1076 } 1077 return FPM->run(F); 1078} 1079 1080 1081/// doInitialization - Run all of the initializers for the function passes. 1082/// 1083bool FunctionPassManager::doInitialization() { 1084 return FPM->doInitialization(*MP->getModule()); 1085} 1086 1087/// doFinalization - Run all of the finalizers for the function passes. 1088/// 1089bool FunctionPassManager::doFinalization() { 1090 return FPM->doFinalization(*MP->getModule()); 1091} 1092 1093//===----------------------------------------------------------------------===// 1094// FunctionPassManagerImpl implementation 1095// 1096inline bool FunctionPassManagerImpl::doInitialization(Module &M) { 1097 bool Changed = false; 1098 1099 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1100 FPPassManager *FP = getContainedManager(Index); 1101 Changed |= FP->doInitialization(M); 1102 } 1103 1104 return Changed; 1105} 1106 1107inline bool FunctionPassManagerImpl::doFinalization(Module &M) { 1108 bool Changed = false; 1109 1110 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1111 FPPassManager *FP = getContainedManager(Index); 1112 Changed |= FP->doFinalization(M); 1113 } 1114 1115 return Changed; 1116} 1117 1118// Execute all the passes managed by this top level manager. 1119// Return true if any function is modified by a pass. 1120bool FunctionPassManagerImpl::run(Function &F) { 1121 1122 bool Changed = false; 1123 1124 TimingInfo::createTheTimeInfo(); 1125 1126 dumpArguments(); 1127 dumpPasses(); 1128 1129 initializeAllAnalysisInfo(); 1130 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1131 FPPassManager *FP = getContainedManager(Index); 1132 Changed |= FP->runOnFunction(F); 1133 } 1134 return Changed; 1135} 1136 1137//===----------------------------------------------------------------------===// 1138// FPPassManager implementation 1139 1140char FPPassManager::ID = 0; 1141/// Print passes managed by this manager 1142void FPPassManager::dumpPassStructure(unsigned Offset) { 1143 llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; 1144 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1145 FunctionPass *FP = getContainedPass(Index); 1146 FP->dumpPassStructure(Offset + 1); 1147 dumpLastUses(FP, Offset+1); 1148 } 1149} 1150 1151 1152/// Execute all of the passes scheduled for execution by invoking 1153/// runOnFunction method. Keep track of whether any of the passes modifies 1154/// the function, and if so, return true. 1155bool FPPassManager::runOnFunction(Function &F) { 1156 1157 bool Changed = false; 1158 1159 if (F.isDeclaration()) 1160 return false; 1161 1162 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1163 FunctionPass *FP = getContainedPass(Index); 1164 1165 AnalysisUsage AnUsage; 1166 FP->getAnalysisUsage(AnUsage); 1167 1168 dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getNameStart()); 1169 dumpAnalysisSetInfo("Required", FP, AnUsage.getRequiredSet()); 1170 1171 initializeAnalysisImpl(FP); 1172 1173 if (TheTimeInfo) TheTimeInfo->passStarted(FP); 1174 Changed |= FP->runOnFunction(F); 1175 if (TheTimeInfo) TheTimeInfo->passEnded(FP); 1176 1177 if (Changed) 1178 dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getNameStart()); 1179 dumpAnalysisSetInfo("Preserved", FP, AnUsage.getPreservedSet()); 1180 1181 verifyPreservedAnalysis(FP); 1182 removeNotPreservedAnalysis(FP); 1183 recordAvailableAnalysis(FP); 1184 removeDeadPasses(FP, F.getNameStart(), ON_FUNCTION_MSG); 1185 } 1186 return Changed; 1187} 1188 1189bool FPPassManager::runOnModule(Module &M) { 1190 1191 bool Changed = doInitialization(M); 1192 1193 for(Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 1194 this->runOnFunction(*I); 1195 1196 return Changed |= doFinalization(M); 1197} 1198 1199inline bool FPPassManager::doInitialization(Module &M) { 1200 bool Changed = false; 1201 1202 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1203 FunctionPass *FP = getContainedPass(Index); 1204 Changed |= FP->doInitialization(M); 1205 } 1206 1207 return Changed; 1208} 1209 1210inline bool FPPassManager::doFinalization(Module &M) { 1211 bool Changed = false; 1212 1213 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1214 FunctionPass *FP = getContainedPass(Index); 1215 Changed |= FP->doFinalization(M); 1216 } 1217 1218 return Changed; 1219} 1220 1221//===----------------------------------------------------------------------===// 1222// MPPassManager implementation 1223 1224/// Execute all of the passes scheduled for execution by invoking 1225/// runOnModule method. Keep track of whether any of the passes modifies 1226/// the module, and if so, return true. 1227bool 1228MPPassManager::runOnModule(Module &M) { 1229 bool Changed = false; 1230 1231 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1232 ModulePass *MP = getContainedPass(Index); 1233 1234 AnalysisUsage AnUsage; 1235 MP->getAnalysisUsage(AnUsage); 1236 1237 dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, 1238 M.getModuleIdentifier().c_str()); 1239 dumpAnalysisSetInfo("Required", MP, AnUsage.getRequiredSet()); 1240 1241 initializeAnalysisImpl(MP); 1242 1243 if (TheTimeInfo) TheTimeInfo->passStarted(MP); 1244 Changed |= MP->runOnModule(M); 1245 if (TheTimeInfo) TheTimeInfo->passEnded(MP); 1246 1247 if (Changed) 1248 dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, 1249 M.getModuleIdentifier().c_str()); 1250 dumpAnalysisSetInfo("Preserved", MP, AnUsage.getPreservedSet()); 1251 1252 verifyPreservedAnalysis(MP); 1253 removeNotPreservedAnalysis(MP); 1254 recordAvailableAnalysis(MP); 1255 removeDeadPasses(MP, M.getModuleIdentifier().c_str(), ON_MODULE_MSG); 1256 } 1257 return Changed; 1258} 1259 1260/// Add RequiredPass into list of lower level passes required by pass P. 1261/// RequiredPass is run on the fly by Pass Manager when P requests it 1262/// through getAnalysis interface. 1263void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { 1264 1265 assert (P->getPotentialPassManagerType() == PMT_ModulePassManager 1266 && "Unable to handle Pass that requires lower level Analysis pass"); 1267 assert ((P->getPotentialPassManagerType() < 1268 RequiredPass->getPotentialPassManagerType()) 1269 && "Unable to handle Pass that requires lower level Analysis pass"); 1270 1271 FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; 1272 if (!FPP) { 1273 FPP = new FunctionPassManagerImpl(0); 1274 // FPP is the top level manager. 1275 FPP->setTopLevelManager(FPP); 1276 1277 OnTheFlyManagers[P] = FPP; 1278 } 1279 FPP->add(RequiredPass); 1280 1281 // Register P as the last user of RequiredPass. 1282 SmallVector<Pass *, 12> LU; 1283 LU.push_back(RequiredPass); 1284 FPP->setLastUser(LU, P); 1285} 1286 1287/// Return function pass corresponding to PassInfo PI, that is 1288/// required by module pass MP. Instantiate analysis pass, by using 1289/// its runOnFunction() for function F. 1290Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, 1291 Function &F) { 1292 AnalysisID AID = PI; 1293 FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]; 1294 assert (FPP && "Unable to find on the fly pass"); 1295 1296 FPP->run(F); 1297 return (dynamic_cast<PMTopLevelManager *>(FPP))->findAnalysisPass(AID); 1298} 1299 1300 1301//===----------------------------------------------------------------------===// 1302// PassManagerImpl implementation 1303// 1304/// run - Execute all of the passes scheduled for execution. Keep track of 1305/// whether any of the passes modifies the module, and if so, return true. 1306bool PassManagerImpl::run(Module &M) { 1307 1308 bool Changed = false; 1309 1310 TimingInfo::createTheTimeInfo(); 1311 1312 dumpArguments(); 1313 dumpPasses(); 1314 1315 initializeAllAnalysisInfo(); 1316 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1317 MPPassManager *MP = getContainedManager(Index); 1318 Changed |= MP->runOnModule(M); 1319 } 1320 return Changed; 1321} 1322 1323//===----------------------------------------------------------------------===// 1324// PassManager implementation 1325 1326/// Create new pass manager 1327PassManager::PassManager() { 1328 PM = new PassManagerImpl(0); 1329 // PM is the top level manager 1330 PM->setTopLevelManager(PM); 1331} 1332 1333PassManager::~PassManager() { 1334 delete PM; 1335} 1336 1337/// add - Add a pass to the queue of passes to run. This passes ownership of 1338/// the Pass to the PassManager. When the PassManager is destroyed, the pass 1339/// will be destroyed as well, so there is no need to delete the pass. This 1340/// implies that all passes MUST be allocated with 'new'. 1341void 1342PassManager::add(Pass *P) { 1343 PM->add(P); 1344} 1345 1346/// run - Execute all of the passes scheduled for execution. Keep track of 1347/// whether any of the passes modifies the module, and if so, return true. 1348bool 1349PassManager::run(Module &M) { 1350 return PM->run(M); 1351} 1352 1353//===----------------------------------------------------------------------===// 1354// TimingInfo Class - This class is used to calculate information about the 1355// amount of time each pass takes to execute. This only happens with 1356// -time-passes is enabled on the command line. 1357// 1358bool llvm::TimePassesIsEnabled = false; 1359static cl::opt<bool,true> 1360EnableTiming("time-passes", cl::location(TimePassesIsEnabled), 1361 cl::desc("Time each pass, printing elapsed time for each on exit")); 1362 1363// createTheTimeInfo - This method either initializes the TheTimeInfo pointer to 1364// a non null value (if the -time-passes option is enabled) or it leaves it 1365// null. It may be called multiple times. 1366void TimingInfo::createTheTimeInfo() { 1367 if (!TimePassesIsEnabled || TheTimeInfo) return; 1368 1369 // Constructed the first time this is called, iff -time-passes is enabled. 1370 // This guarantees that the object will be constructed before static globals, 1371 // thus it will be destroyed before them. 1372 static ManagedStatic<TimingInfo> TTI; 1373 TheTimeInfo = &*TTI; 1374} 1375 1376/// If TimingInfo is enabled then start pass timer. 1377void StartPassTimer(Pass *P) { 1378 if (TheTimeInfo) 1379 TheTimeInfo->passStarted(P); 1380} 1381 1382/// If TimingInfo is enabled then stop pass timer. 1383void StopPassTimer(Pass *P) { 1384 if (TheTimeInfo) 1385 TheTimeInfo->passEnded(P); 1386} 1387 1388//===----------------------------------------------------------------------===// 1389// PMStack implementation 1390// 1391 1392// Pop Pass Manager from the stack and clear its analysis info. 1393void PMStack::pop() { 1394 1395 PMDataManager *Top = this->top(); 1396 Top->initializeAnalysisInfo(); 1397 1398 S.pop_back(); 1399} 1400 1401// Push PM on the stack and set its top level manager. 1402void PMStack::push(Pass *P) { 1403 1404 PMDataManager *Top = NULL; 1405 PMDataManager *PM = dynamic_cast<PMDataManager *>(P); 1406 assert (PM && "Unable to push. Pass Manager expected"); 1407 1408 if (this->empty()) { 1409 Top = PM; 1410 } 1411 else { 1412 Top = this->top(); 1413 PMTopLevelManager *TPM = Top->getTopLevelManager(); 1414 1415 assert (TPM && "Unable to find top level manager"); 1416 TPM->addIndirectPassManager(PM); 1417 PM->setTopLevelManager(TPM); 1418 } 1419 1420 S.push_back(PM); 1421} 1422 1423// Dump content of the pass manager stack. 1424void PMStack::dump() { 1425 for(std::deque<PMDataManager *>::iterator I = S.begin(), 1426 E = S.end(); I != E; ++I) { 1427 Pass *P = dynamic_cast<Pass *>(*I); 1428 printf("%s ", P->getPassName()); 1429 } 1430 if (!S.empty()) 1431 printf("\n"); 1432} 1433 1434/// Find appropriate Module Pass Manager in the PM Stack and 1435/// add self into that manager. 1436void ModulePass::assignPassManager(PMStack &PMS, 1437 PassManagerType PreferredType) { 1438 1439 // Find Module Pass Manager 1440 while(!PMS.empty()) { 1441 PassManagerType TopPMType = PMS.top()->getPassManagerType(); 1442 if (TopPMType == PreferredType) 1443 break; // We found desired pass manager 1444 else if (TopPMType > PMT_ModulePassManager) 1445 PMS.pop(); // Pop children pass managers 1446 else 1447 break; 1448 } 1449 1450 PMS.top()->add(this); 1451} 1452 1453/// Find appropriate Function Pass Manager or Call Graph Pass Manager 1454/// in the PM Stack and add self into that manager. 1455void FunctionPass::assignPassManager(PMStack &PMS, 1456 PassManagerType PreferredType) { 1457 1458 // Find Module Pass Manager (TODO : Or Call Graph Pass Manager) 1459 while(!PMS.empty()) { 1460 if (PMS.top()->getPassManagerType() > PMT_FunctionPassManager) 1461 PMS.pop(); 1462 else 1463 break; 1464 } 1465 FPPassManager *FPP = dynamic_cast<FPPassManager *>(PMS.top()); 1466 1467 // Create new Function Pass Manager 1468 if (!FPP) { 1469 assert(!PMS.empty() && "Unable to create Function Pass Manager"); 1470 PMDataManager *PMD = PMS.top(); 1471 1472 // [1] Create new Function Pass Manager 1473 FPP = new FPPassManager(PMD->getDepth() + 1); 1474 1475 // [2] Set up new manager's top level manager 1476 PMTopLevelManager *TPM = PMD->getTopLevelManager(); 1477 TPM->addIndirectPassManager(FPP); 1478 1479 // [3] Assign manager to manage this new manager. This may create 1480 // and push new managers into PMS 1481 Pass *P = dynamic_cast<Pass *>(FPP); 1482 1483 // If Call Graph Pass Manager is active then use it to manage 1484 // this new Function Pass manager. 1485 if (PMD->getPassManagerType() == PMT_CallGraphPassManager) 1486 P->assignPassManager(PMS, PMT_CallGraphPassManager); 1487 else 1488 P->assignPassManager(PMS); 1489 1490 // [4] Push new manager into PMS 1491 PMS.push(FPP); 1492 } 1493 1494 // Assign FPP as the manager of this pass. 1495 FPP->add(this); 1496} 1497 1498/// Find appropriate Basic Pass Manager or Call Graph Pass Manager 1499/// in the PM Stack and add self into that manager. 1500void BasicBlockPass::assignPassManager(PMStack &PMS, 1501 PassManagerType PreferredType) { 1502 1503 BBPassManager *BBP = NULL; 1504 1505 // Basic Pass Manager is a leaf pass manager. It does not handle 1506 // any other pass manager. 1507 if (!PMS.empty()) 1508 BBP = dynamic_cast<BBPassManager *>(PMS.top()); 1509 1510 // If leaf manager is not Basic Block Pass manager then create new 1511 // basic Block Pass manager. 1512 1513 if (!BBP) { 1514 assert(!PMS.empty() && "Unable to create BasicBlock Pass Manager"); 1515 PMDataManager *PMD = PMS.top(); 1516 1517 // [1] Create new Basic Block Manager 1518 BBP = new BBPassManager(PMD->getDepth() + 1); 1519 1520 // [2] Set up new manager's top level manager 1521 // Basic Block Pass Manager does not live by itself 1522 PMTopLevelManager *TPM = PMD->getTopLevelManager(); 1523 TPM->addIndirectPassManager(BBP); 1524 1525 // [3] Assign manager to manage this new manager. This may create 1526 // and push new managers into PMS 1527 Pass *P = dynamic_cast<Pass *>(BBP); 1528 P->assignPassManager(PMS); 1529 1530 // [4] Push new manager into PMS 1531 PMS.push(BBP); 1532 } 1533 1534 // Assign BBP as the manager of this pass. 1535 BBP->add(this); 1536} 1537 1538 1539