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