PassManager.cpp revision 9750b5d5779e6efec10a93633dd1d36c5f61dbc3
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 char 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 109char 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 char 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 176char 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 char 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 250char 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 char 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 307char 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 // Give pass a chance to prepare the stage. 423 P->preparePassManager(activeStack); 424 425 AnalysisUsage AnUsage; 426 P->getAnalysisUsage(AnUsage); 427 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 428 for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(), 429 E = RequiredSet.end(); I != E; ++I) { 430 431 Pass *AnalysisPass = findAnalysisPass(*I); 432 if (!AnalysisPass) { 433 AnalysisPass = (*I)->createPass(); 434 // Schedule this analysis run first only if it is not a lower level 435 // analysis pass. Lower level analsyis passes are run on the fly. 436 if (P->getPotentialPassManagerType () >= 437 AnalysisPass->getPotentialPassManagerType()) 438 schedulePass(AnalysisPass); 439 else 440 delete AnalysisPass; 441 } 442 } 443 444 // Now all required passes are available. 445 addTopLevelPass(P); 446} 447 448/// Find the pass that implements Analysis AID. Search immutable 449/// passes and all pass managers. If desired pass is not found 450/// then return NULL. 451Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { 452 453 Pass *P = NULL; 454 // Check pass managers 455 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 456 E = PassManagers.end(); P == NULL && I != E; ++I) { 457 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 458 assert(PMD && "This is not a PassManager"); 459 P = PMD->findAnalysisPass(AID, false); 460 } 461 462 // Check other pass managers 463 for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(), 464 E = IndirectPassManagers.end(); P == NULL && I != E; ++I) 465 P = (*I)->findAnalysisPass(AID, false); 466 467 for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(), 468 E = ImmutablePasses.end(); P == NULL && I != E; ++I) { 469 const PassInfo *PI = (*I)->getPassInfo(); 470 if (PI == AID) 471 P = *I; 472 473 // If Pass not found then check the interfaces implemented by Immutable Pass 474 if (!P) { 475 const std::vector<const PassInfo*> &ImmPI = PI->getInterfacesImplemented(); 476 if (std::find(ImmPI.begin(), ImmPI.end(), AID) != ImmPI.end()) 477 P = *I; 478 } 479 } 480 481 return P; 482} 483 484// Print passes managed by this top level manager. 485void PMTopLevelManager::dumpPasses() const { 486 487 if (PassDebugging < Structure) 488 return; 489 490 // Print out the immutable passes 491 for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) { 492 ImmutablePasses[i]->dumpPassStructure(0); 493 } 494 495 for (std::vector<Pass *>::const_iterator I = PassManagers.begin(), 496 E = PassManagers.end(); I != E; ++I) 497 (*I)->dumpPassStructure(1); 498} 499 500void PMTopLevelManager::dumpArguments() const { 501 502 if (PassDebugging < Arguments) 503 return; 504 505 cerr << "Pass Arguments: "; 506 for (std::vector<Pass *>::const_iterator I = PassManagers.begin(), 507 E = PassManagers.end(); I != E; ++I) { 508 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 509 assert(PMD && "This is not a PassManager"); 510 PMD->dumpPassArguments(); 511 } 512 cerr << "\n"; 513} 514 515void PMTopLevelManager::initializeAllAnalysisInfo() { 516 517 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 518 E = PassManagers.end(); I != E; ++I) { 519 PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I); 520 assert(PMD && "This is not a PassManager"); 521 PMD->initializeAnalysisInfo(); 522 } 523 524 // Initailize other pass managers 525 for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(), 526 E = IndirectPassManagers.end(); I != E; ++I) 527 (*I)->initializeAnalysisInfo(); 528} 529 530/// Destructor 531PMTopLevelManager::~PMTopLevelManager() { 532 for (std::vector<Pass *>::iterator I = PassManagers.begin(), 533 E = PassManagers.end(); I != E; ++I) 534 delete *I; 535 536 for (std::vector<ImmutablePass *>::iterator 537 I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) 538 delete *I; 539 540 PassManagers.clear(); 541} 542 543//===----------------------------------------------------------------------===// 544// PMDataManager implementation 545 546/// Return true IFF pass P's required analysis set does not required new 547/// manager. 548bool PMDataManager::manageablePass(Pass *P) { 549 550 // TODO 551 // If this pass is not preserving information that is required by a 552 // pass maintained by higher level pass manager then do not insert 553 // this pass into current manager. Use new manager. For example, 554 // For example, If FunctionPass F is not preserving ModulePass Info M1 555 // that is used by another ModulePass M2 then do not insert F in 556 // current function pass manager. 557 return true; 558} 559 560/// Augement AvailableAnalysis by adding analysis made available by pass P. 561void PMDataManager::recordAvailableAnalysis(Pass *P) { 562 563 if (const PassInfo *PI = P->getPassInfo()) { 564 AvailableAnalysis[PI] = P; 565 566 //This pass is the current implementation of all of the interfaces it 567 //implements as well. 568 const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented(); 569 for (unsigned i = 0, e = II.size(); i != e; ++i) 570 AvailableAnalysis[II[i]] = P; 571 } 572} 573 574// Return true if P preserves high level analysis used by other 575// passes managed by this manager 576bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { 577 578 AnalysisUsage AnUsage; 579 P->getAnalysisUsage(AnUsage); 580 581 if (AnUsage.getPreservesAll()) 582 return true; 583 584 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 585 for (std::vector<Pass *>::iterator I = HigherLevelAnalysis.begin(), 586 E = HigherLevelAnalysis.end(); I != E; ++I) { 587 Pass *P1 = *I; 588 if (!dynamic_cast<ImmutablePass*>(P1) 589 && std::find(PreservedSet.begin(), PreservedSet.end(), P1->getPassInfo()) == 590 PreservedSet.end()) 591 return false; 592 } 593 594 return true; 595} 596 597/// Remove Analyss not preserved by Pass P 598void PMDataManager::removeNotPreservedAnalysis(Pass *P) { 599 AnalysisUsage AnUsage; 600 P->getAnalysisUsage(AnUsage); 601 const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet(); 602 603 // Verify preserved analysis 604 for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), 605 E = AvailableAnalysis.end(); I != E; ++I) { 606 Pass *AP = I->second; 607 AP->verifyAnalysis(); 608 } 609 610 if (AnUsage.getPreservesAll()) 611 return; 612 613 for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(), 614 E = AvailableAnalysis.end(); I != E; ) { 615 std::map<AnalysisID, Pass*>::iterator Info = I++; 616 if (!dynamic_cast<ImmutablePass*>(Info->second) 617 && std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == 618 PreservedSet.end()) 619 // Remove this analysis 620 AvailableAnalysis.erase(Info); 621 } 622 623 // Check inherited analysis also. If P is not preserving analysis 624 // provided by parent manager then remove it here. 625 for (unsigned Index = 0; Index < PMT_Last; ++Index) { 626 627 if (!InheritedAnalysis[Index]) 628 continue; 629 630 for (std::map<AnalysisID, Pass*>::iterator 631 I = InheritedAnalysis[Index]->begin(), 632 E = InheritedAnalysis[Index]->end(); I != E; ) { 633 std::map<AnalysisID, Pass *>::iterator Info = I++; 634 if (!dynamic_cast<ImmutablePass*>(Info->second) 635 && std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == 636 PreservedSet.end()) 637 // Remove this analysis 638 InheritedAnalysis[Index]->erase(Info); 639 } 640 } 641 642} 643 644/// Remove analysis passes that are not used any longer 645void PMDataManager::removeDeadPasses(Pass *P, std::string Msg, 646 enum PassDebuggingString DBG_STR) { 647 648 std::vector<Pass *> DeadPasses; 649 650 // If this is a on the fly manager then it does not have TPM. 651 if (!TPM) 652 return; 653 654 TPM->collectLastUses(DeadPasses, P); 655 656 for (std::vector<Pass *>::iterator I = DeadPasses.begin(), 657 E = DeadPasses.end(); I != E; ++I) { 658 659 dumpPassInfo(*I, FREEING_MSG, DBG_STR, Msg); 660 661 if (TheTimeInfo) TheTimeInfo->passStarted(*I); 662 (*I)->releaseMemory(); 663 if (TheTimeInfo) TheTimeInfo->passEnded(*I); 664 665 std::map<AnalysisID, Pass*>::iterator Pos = 666 AvailableAnalysis.find((*I)->getPassInfo()); 667 668 // It is possible that pass is already removed from the AvailableAnalysis 669 if (Pos != AvailableAnalysis.end()) 670 AvailableAnalysis.erase(Pos); 671 } 672} 673 674/// Add pass P into the PassVector. Update 675/// AvailableAnalysis appropriately if ProcessAnalysis is true. 676void PMDataManager::add(Pass *P, 677 bool ProcessAnalysis) { 678 679 // This manager is going to manage pass P. Set up analysis resolver 680 // to connect them. 681 AnalysisResolver *AR = new AnalysisResolver(*this); 682 P->setResolver(AR); 683 684 // If a FunctionPass F is the last user of ModulePass info M 685 // then the F's manager, not F, records itself as a last user of M. 686 std::vector<Pass *> TransferLastUses; 687 688 if (ProcessAnalysis) { 689 690 // At the moment, this pass is the last user of all required passes. 691 std::vector<Pass *> LastUses; 692 SmallVector<Pass *, 8> RequiredPasses; 693 SmallVector<AnalysisID, 8> ReqAnalysisNotAvailable; 694 695 unsigned PDepth = this->getDepth(); 696 697 collectRequiredAnalysis(RequiredPasses, 698 ReqAnalysisNotAvailable, P); 699 for (SmallVector<Pass *, 8>::iterator I = RequiredPasses.begin(), 700 E = RequiredPasses.end(); I != E; ++I) { 701 Pass *PRequired = *I; 702 unsigned RDepth = 0; 703 704 PMDataManager &DM = PRequired->getResolver()->getPMDataManager(); 705 RDepth = DM.getDepth(); 706 707 if (PDepth == RDepth) 708 LastUses.push_back(PRequired); 709 else if (PDepth > RDepth) { 710 // Let the parent claim responsibility of last use 711 TransferLastUses.push_back(PRequired); 712 // Keep track of higher level analysis used by this manager. 713 HigherLevelAnalysis.push_back(PRequired); 714 } else 715 assert (0 && "Unable to accomodate Required Pass"); 716 } 717 718 // Set P as P's last user until someone starts using P. 719 // However, if P is a Pass Manager then it does not need 720 // to record its last user. 721 if (!dynamic_cast<PMDataManager *>(P)) 722 LastUses.push_back(P); 723 TPM->setLastUser(LastUses, P); 724 725 if (!TransferLastUses.empty()) { 726 Pass *My_PM = dynamic_cast<Pass *>(this); 727 TPM->setLastUser(TransferLastUses, My_PM); 728 TransferLastUses.clear(); 729 } 730 731 // Now, take care of required analysises that are not available. 732 for (SmallVector<AnalysisID, 8>::iterator 733 I = ReqAnalysisNotAvailable.begin(), 734 E = ReqAnalysisNotAvailable.end() ;I != E; ++I) { 735 Pass *AnalysisPass = (*I)->createPass(); 736 this->addLowerLevelRequiredPass(P, AnalysisPass); 737 } 738 739 // Take a note of analysis required and made available by this pass. 740 // Remove the analysis not preserved by this pass 741 removeNotPreservedAnalysis(P); 742 recordAvailableAnalysis(P); 743 } 744 745 // Add pass 746 PassVector.push_back(P); 747} 748 749 750/// Populate RP with analysis pass that are required by 751/// pass P and are available. Populate RP_NotAvail with analysis 752/// pass that are required by pass P but are not available. 753void PMDataManager::collectRequiredAnalysis(SmallVector<Pass *, 8>&RP, 754 SmallVector<AnalysisID, 8> &RP_NotAvail, 755 Pass *P) { 756 AnalysisUsage AnUsage; 757 P->getAnalysisUsage(AnUsage); 758 const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet(); 759 for (std::vector<AnalysisID>::const_iterator 760 I = RequiredSet.begin(), E = RequiredSet.end(); 761 I != E; ++I) { 762 AnalysisID AID = *I; 763 if (Pass *AnalysisPass = findAnalysisPass(*I, true)) 764 RP.push_back(AnalysisPass); 765 else 766 RP_NotAvail.push_back(AID); 767 } 768 769 const std::vector<AnalysisID> &IDs = AnUsage.getRequiredTransitiveSet(); 770 for (std::vector<AnalysisID>::const_iterator I = IDs.begin(), 771 E = IDs.end(); I != E; ++I) { 772 AnalysisID AID = *I; 773 if (Pass *AnalysisPass = findAnalysisPass(*I, true)) 774 RP.push_back(AnalysisPass); 775 else 776 RP_NotAvail.push_back(AID); 777 } 778} 779 780// All Required analyses should be available to the pass as it runs! Here 781// we fill in the AnalysisImpls member of the pass so that it can 782// successfully use the getAnalysis() method to retrieve the 783// implementations it needs. 784// 785void PMDataManager::initializeAnalysisImpl(Pass *P) { 786 AnalysisUsage AnUsage; 787 P->getAnalysisUsage(AnUsage); 788 789 for (std::vector<const PassInfo *>::const_iterator 790 I = AnUsage.getRequiredSet().begin(), 791 E = AnUsage.getRequiredSet().end(); I != E; ++I) { 792 Pass *Impl = findAnalysisPass(*I, true); 793 if (Impl == 0) 794 // This may be analysis pass that is initialized on the fly. 795 // If that is not the case then it will raise an assert when it is used. 796 continue; 797 AnalysisResolver *AR = P->getResolver(); 798 AR->addAnalysisImplsPair(*I, Impl); 799 } 800} 801 802/// Find the pass that implements Analysis AID. If desired pass is not found 803/// then return NULL. 804Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { 805 806 // Check if AvailableAnalysis map has one entry. 807 std::map<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID); 808 809 if (I != AvailableAnalysis.end()) 810 return I->second; 811 812 // Search Parents through TopLevelManager 813 if (SearchParent) 814 return TPM->findAnalysisPass(AID); 815 816 return NULL; 817} 818 819// Print list of passes that are last used by P. 820void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ 821 822 std::vector<Pass *> LUses; 823 824 // If this is a on the fly manager then it does not have TPM. 825 if (!TPM) 826 return; 827 828 TPM->collectLastUses(LUses, P); 829 830 for (std::vector<Pass *>::iterator I = LUses.begin(), 831 E = LUses.end(); I != E; ++I) { 832 llvm::cerr << "--" << std::string(Offset*2, ' '); 833 (*I)->dumpPassStructure(0); 834 } 835} 836 837void PMDataManager::dumpPassArguments() const { 838 for(std::vector<Pass *>::const_iterator I = PassVector.begin(), 839 E = PassVector.end(); I != E; ++I) { 840 if (PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I)) 841 PMD->dumpPassArguments(); 842 else 843 if (const PassInfo *PI = (*I)->getPassInfo()) 844 if (!PI->isAnalysisGroup()) 845 cerr << " -" << PI->getPassArgument(); 846 } 847} 848 849void PMDataManager:: dumpPassInfo(Pass *P, enum PassDebuggingString S1, 850 enum PassDebuggingString S2, 851 std::string Msg) { 852 if (PassDebugging < Executions) 853 return; 854 cerr << (void*)this << std::string(getDepth()*2+1, ' '); 855 switch (S1) { 856 case EXECUTION_MSG: 857 cerr << "Executing Pass '" << P->getPassName(); 858 break; 859 case MODIFICATION_MSG: 860 cerr << "Made Modification '" << P->getPassName(); 861 break; 862 case FREEING_MSG: 863 cerr << " Freeing Pass '" << P->getPassName(); 864 break; 865 default: 866 break; 867 } 868 switch (S2) { 869 case ON_BASICBLOCK_MSG: 870 cerr << "' on BasicBlock '" << Msg << "'...\n"; 871 break; 872 case ON_FUNCTION_MSG: 873 cerr << "' on Function '" << Msg << "'...\n"; 874 break; 875 case ON_MODULE_MSG: 876 cerr << "' on Module '" << Msg << "'...\n"; 877 break; 878 case ON_LOOP_MSG: 879 cerr << "' on Loop " << Msg << "'...\n"; 880 break; 881 case ON_CG_MSG: 882 cerr << "' on Call Graph " << Msg << "'...\n"; 883 break; 884 default: 885 break; 886 } 887} 888 889void PMDataManager::dumpAnalysisSetInfo(const char *Msg, Pass *P, 890 const std::vector<AnalysisID> &Set) 891 const { 892 if (PassDebugging >= Details && !Set.empty()) { 893 cerr << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:"; 894 for (unsigned i = 0; i != Set.size(); ++i) { 895 if (i) cerr << ","; 896 cerr << " " << Set[i]->getPassName(); 897 } 898 cerr << "\n"; 899 } 900} 901 902// Destructor 903PMDataManager::~PMDataManager() { 904 905 for (std::vector<Pass *>::iterator I = PassVector.begin(), 906 E = PassVector.end(); I != E; ++I) 907 delete *I; 908 909 PassVector.clear(); 910} 911 912//===----------------------------------------------------------------------===// 913// NOTE: Is this the right place to define this method ? 914// getAnalysisToUpdate - Return an analysis result or null if it doesn't exist 915Pass *AnalysisResolver::getAnalysisToUpdate(AnalysisID ID, bool dir) const { 916 return PM.findAnalysisPass(ID, dir); 917} 918 919Pass *AnalysisResolver::findImplPass(Pass *P, const PassInfo *AnalysisPI, 920 Function &F) { 921 return PM.getOnTheFlyPass(P, AnalysisPI, F); 922} 923 924//===----------------------------------------------------------------------===// 925// BBPassManager implementation 926 927/// Execute all of the passes scheduled for execution by invoking 928/// runOnBasicBlock method. Keep track of whether any of the passes modifies 929/// the function, and if so, return true. 930bool 931BBPassManager::runOnFunction(Function &F) { 932 933 if (F.isDeclaration()) 934 return false; 935 936 bool Changed = doInitialization(F); 937 938 for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) 939 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 940 BasicBlockPass *BP = getContainedPass(Index); 941 AnalysisUsage AnUsage; 942 BP->getAnalysisUsage(AnUsage); 943 944 dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, (*I).getName()); 945 dumpAnalysisSetInfo("Required", BP, AnUsage.getRequiredSet()); 946 947 initializeAnalysisImpl(BP); 948 949 if (TheTimeInfo) TheTimeInfo->passStarted(BP); 950 Changed |= BP->runOnBasicBlock(*I); 951 if (TheTimeInfo) TheTimeInfo->passEnded(BP); 952 953 if (Changed) 954 dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, (*I).getName()); 955 dumpAnalysisSetInfo("Preserved", BP, AnUsage.getPreservedSet()); 956 957 removeNotPreservedAnalysis(BP); 958 recordAvailableAnalysis(BP); 959 removeDeadPasses(BP, (*I).getName(), ON_BASICBLOCK_MSG); 960 961 } 962 return Changed |= doFinalization(F); 963} 964 965// Implement doInitialization and doFinalization 966inline bool BBPassManager::doInitialization(Module &M) { 967 bool Changed = false; 968 969 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 970 BasicBlockPass *BP = getContainedPass(Index); 971 Changed |= BP->doInitialization(M); 972 } 973 974 return Changed; 975} 976 977inline bool BBPassManager::doFinalization(Module &M) { 978 bool Changed = false; 979 980 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 981 BasicBlockPass *BP = getContainedPass(Index); 982 Changed |= BP->doFinalization(M); 983 } 984 985 return Changed; 986} 987 988inline bool BBPassManager::doInitialization(Function &F) { 989 bool Changed = false; 990 991 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 992 BasicBlockPass *BP = getContainedPass(Index); 993 Changed |= BP->doInitialization(F); 994 } 995 996 return Changed; 997} 998 999inline bool BBPassManager::doFinalization(Function &F) { 1000 bool Changed = false; 1001 1002 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1003 BasicBlockPass *BP = getContainedPass(Index); 1004 Changed |= BP->doFinalization(F); 1005 } 1006 1007 return Changed; 1008} 1009 1010 1011//===----------------------------------------------------------------------===// 1012// FunctionPassManager implementation 1013 1014/// Create new Function pass manager 1015FunctionPassManager::FunctionPassManager(ModuleProvider *P) { 1016 FPM = new FunctionPassManagerImpl(0); 1017 // FPM is the top level manager. 1018 FPM->setTopLevelManager(FPM); 1019 1020 PMDataManager *PMD = dynamic_cast<PMDataManager *>(FPM); 1021 AnalysisResolver *AR = new AnalysisResolver(*PMD); 1022 FPM->setResolver(AR); 1023 1024 MP = P; 1025} 1026 1027FunctionPassManager::~FunctionPassManager() { 1028 delete FPM; 1029} 1030 1031/// add - Add a pass to the queue of passes to run. This passes 1032/// ownership of the Pass to the PassManager. When the 1033/// PassManager_X is destroyed, the pass will be destroyed as well, so 1034/// there is no need to delete the pass. (TODO delete passes.) 1035/// This implies that all passes MUST be allocated with 'new'. 1036void FunctionPassManager::add(Pass *P) { 1037 FPM->add(P); 1038} 1039 1040/// run - Execute all of the passes scheduled for execution. Keep 1041/// track of whether any of the passes modifies the function, and if 1042/// so, return true. 1043/// 1044bool FunctionPassManager::run(Function &F) { 1045 std::string errstr; 1046 if (MP->materializeFunction(&F, &errstr)) { 1047 cerr << "Error reading bitcode file: " << errstr << "\n"; 1048 abort(); 1049 } 1050 return FPM->run(F); 1051} 1052 1053 1054/// doInitialization - Run all of the initializers for the function passes. 1055/// 1056bool FunctionPassManager::doInitialization() { 1057 return FPM->doInitialization(*MP->getModule()); 1058} 1059 1060/// doFinalization - Run all of the initializers for the function passes. 1061/// 1062bool FunctionPassManager::doFinalization() { 1063 return FPM->doFinalization(*MP->getModule()); 1064} 1065 1066//===----------------------------------------------------------------------===// 1067// FunctionPassManagerImpl implementation 1068// 1069inline bool FunctionPassManagerImpl::doInitialization(Module &M) { 1070 bool Changed = false; 1071 1072 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1073 FPPassManager *FP = getContainedManager(Index); 1074 Changed |= FP->doInitialization(M); 1075 } 1076 1077 return Changed; 1078} 1079 1080inline bool FunctionPassManagerImpl::doFinalization(Module &M) { 1081 bool Changed = false; 1082 1083 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1084 FPPassManager *FP = getContainedManager(Index); 1085 Changed |= FP->doFinalization(M); 1086 } 1087 1088 return Changed; 1089} 1090 1091// Execute all the passes managed by this top level manager. 1092// Return true if any function is modified by a pass. 1093bool FunctionPassManagerImpl::run(Function &F) { 1094 1095 bool Changed = false; 1096 1097 TimingInfo::createTheTimeInfo(); 1098 1099 dumpArguments(); 1100 dumpPasses(); 1101 1102 initializeAllAnalysisInfo(); 1103 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1104 FPPassManager *FP = getContainedManager(Index); 1105 Changed |= FP->runOnFunction(F); 1106 } 1107 return Changed; 1108} 1109 1110//===----------------------------------------------------------------------===// 1111// FPPassManager implementation 1112 1113char FPPassManager::ID = 0; 1114/// Print passes managed by this manager 1115void FPPassManager::dumpPassStructure(unsigned Offset) { 1116 llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; 1117 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1118 FunctionPass *FP = getContainedPass(Index); 1119 FP->dumpPassStructure(Offset + 1); 1120 dumpLastUses(FP, Offset+1); 1121 } 1122} 1123 1124 1125/// Execute all of the passes scheduled for execution by invoking 1126/// runOnFunction method. Keep track of whether any of the passes modifies 1127/// the function, and if so, return true. 1128bool FPPassManager::runOnFunction(Function &F) { 1129 1130 bool Changed = false; 1131 1132 if (F.isDeclaration()) 1133 return false; 1134 1135 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1136 FunctionPass *FP = getContainedPass(Index); 1137 1138 AnalysisUsage AnUsage; 1139 FP->getAnalysisUsage(AnUsage); 1140 1141 dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName()); 1142 dumpAnalysisSetInfo("Required", FP, AnUsage.getRequiredSet()); 1143 1144 initializeAnalysisImpl(FP); 1145 1146 if (TheTimeInfo) TheTimeInfo->passStarted(FP); 1147 Changed |= FP->runOnFunction(F); 1148 if (TheTimeInfo) TheTimeInfo->passEnded(FP); 1149 1150 if (Changed) 1151 dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName()); 1152 dumpAnalysisSetInfo("Preserved", FP, AnUsage.getPreservedSet()); 1153 1154 removeNotPreservedAnalysis(FP); 1155 recordAvailableAnalysis(FP); 1156 removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG); 1157 } 1158 return Changed; 1159} 1160 1161bool FPPassManager::runOnModule(Module &M) { 1162 1163 bool Changed = doInitialization(M); 1164 1165 for(Module::iterator I = M.begin(), E = M.end(); I != E; ++I) 1166 this->runOnFunction(*I); 1167 1168 return Changed |= doFinalization(M); 1169} 1170 1171inline bool FPPassManager::doInitialization(Module &M) { 1172 bool Changed = false; 1173 1174 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1175 FunctionPass *FP = getContainedPass(Index); 1176 Changed |= FP->doInitialization(M); 1177 } 1178 1179 return Changed; 1180} 1181 1182inline bool FPPassManager::doFinalization(Module &M) { 1183 bool Changed = false; 1184 1185 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1186 FunctionPass *FP = getContainedPass(Index); 1187 Changed |= FP->doFinalization(M); 1188 } 1189 1190 return Changed; 1191} 1192 1193//===----------------------------------------------------------------------===// 1194// MPPassManager implementation 1195 1196/// Execute all of the passes scheduled for execution by invoking 1197/// runOnModule method. Keep track of whether any of the passes modifies 1198/// the module, and if so, return true. 1199bool 1200MPPassManager::runOnModule(Module &M) { 1201 bool Changed = false; 1202 1203 for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { 1204 ModulePass *MP = getContainedPass(Index); 1205 1206 AnalysisUsage AnUsage; 1207 MP->getAnalysisUsage(AnUsage); 1208 1209 dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier()); 1210 dumpAnalysisSetInfo("Required", MP, AnUsage.getRequiredSet()); 1211 1212 initializeAnalysisImpl(MP); 1213 1214 if (TheTimeInfo) TheTimeInfo->passStarted(MP); 1215 Changed |= MP->runOnModule(M); 1216 if (TheTimeInfo) TheTimeInfo->passEnded(MP); 1217 1218 if (Changed) 1219 dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, 1220 M.getModuleIdentifier()); 1221 dumpAnalysisSetInfo("Preserved", MP, AnUsage.getPreservedSet()); 1222 1223 removeNotPreservedAnalysis(MP); 1224 recordAvailableAnalysis(MP); 1225 removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG); 1226 } 1227 return Changed; 1228} 1229 1230/// Add RequiredPass into list of lower level passes required by pass P. 1231/// RequiredPass is run on the fly by Pass Manager when P requests it 1232/// through getAnalysis interface. 1233void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { 1234 1235 assert (P->getPotentialPassManagerType() == PMT_ModulePassManager 1236 && "Unable to handle Pass that requires lower level Analysis pass"); 1237 assert ((P->getPotentialPassManagerType() < 1238 RequiredPass->getPotentialPassManagerType()) 1239 && "Unable to handle Pass that requires lower level Analysis pass"); 1240 1241 FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; 1242 if (!FPP) { 1243 FPP = new FunctionPassManagerImpl(0); 1244 // FPP is the top level manager. 1245 FPP->setTopLevelManager(FPP); 1246 1247 OnTheFlyManagers[P] = FPP; 1248 } 1249 FPP->add(RequiredPass); 1250 1251 // Register P as the last user of RequiredPass. 1252 std::vector<Pass *> LU; 1253 LU.push_back(RequiredPass); 1254 FPP->setLastUser(LU, P); 1255} 1256 1257/// Return function pass corresponding to PassInfo PI, that is 1258/// required by module pass MP. Instantiate analysis pass, by using 1259/// its runOnFunction() for function F. 1260Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, 1261 Function &F) { 1262 AnalysisID AID = PI; 1263 FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]; 1264 assert (FPP && "Unable to find on the fly pass"); 1265 1266 FPP->run(F); 1267 return (dynamic_cast<PMTopLevelManager *>(FPP))->findAnalysisPass(AID); 1268} 1269 1270 1271//===----------------------------------------------------------------------===// 1272// PassManagerImpl implementation 1273// 1274/// run - Execute all of the passes scheduled for execution. Keep track of 1275/// whether any of the passes modifies the module, and if so, return true. 1276bool PassManagerImpl::run(Module &M) { 1277 1278 bool Changed = false; 1279 1280 TimingInfo::createTheTimeInfo(); 1281 1282 dumpArguments(); 1283 dumpPasses(); 1284 1285 initializeAllAnalysisInfo(); 1286 for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { 1287 MPPassManager *MP = getContainedManager(Index); 1288 Changed |= MP->runOnModule(M); 1289 } 1290 return Changed; 1291} 1292 1293//===----------------------------------------------------------------------===// 1294// PassManager implementation 1295 1296/// Create new pass manager 1297PassManager::PassManager() { 1298 PM = new PassManagerImpl(0); 1299 // PM is the top level manager 1300 PM->setTopLevelManager(PM); 1301} 1302 1303PassManager::~PassManager() { 1304 delete PM; 1305} 1306 1307/// add - Add a pass to the queue of passes to run. This passes ownership of 1308/// the Pass to the PassManager. When the PassManager is destroyed, the pass 1309/// will be destroyed as well, so there is no need to delete the pass. This 1310/// implies that all passes MUST be allocated with 'new'. 1311void 1312PassManager::add(Pass *P) { 1313 PM->add(P); 1314} 1315 1316/// run - Execute all of the passes scheduled for execution. Keep track of 1317/// whether any of the passes modifies the module, and if so, return true. 1318bool 1319PassManager::run(Module &M) { 1320 return PM->run(M); 1321} 1322 1323//===----------------------------------------------------------------------===// 1324// TimingInfo Class - This class is used to calculate information about the 1325// amount of time each pass takes to execute. This only happens with 1326// -time-passes is enabled on the command line. 1327// 1328bool llvm::TimePassesIsEnabled = false; 1329static cl::opt<bool,true> 1330EnableTiming("time-passes", cl::location(TimePassesIsEnabled), 1331 cl::desc("Time each pass, printing elapsed time for each on exit")); 1332 1333// createTheTimeInfo - This method either initializes the TheTimeInfo pointer to 1334// a non null value (if the -time-passes option is enabled) or it leaves it 1335// null. It may be called multiple times. 1336void TimingInfo::createTheTimeInfo() { 1337 if (!TimePassesIsEnabled || TheTimeInfo) return; 1338 1339 // Constructed the first time this is called, iff -time-passes is enabled. 1340 // This guarantees that the object will be constructed before static globals, 1341 // thus it will be destroyed before them. 1342 static ManagedStatic<TimingInfo> TTI; 1343 TheTimeInfo = &*TTI; 1344} 1345 1346/// If TimingInfo is enabled then start pass timer. 1347void StartPassTimer(Pass *P) { 1348 if (TheTimeInfo) 1349 TheTimeInfo->passStarted(P); 1350} 1351 1352/// If TimingInfo is enabled then stop pass timer. 1353void StopPassTimer(Pass *P) { 1354 if (TheTimeInfo) 1355 TheTimeInfo->passEnded(P); 1356} 1357 1358//===----------------------------------------------------------------------===// 1359// PMStack implementation 1360// 1361 1362// Pop Pass Manager from the stack and clear its analysis info. 1363void PMStack::pop() { 1364 1365 PMDataManager *Top = this->top(); 1366 Top->initializeAnalysisInfo(); 1367 1368 S.pop_back(); 1369} 1370 1371// Push PM on the stack and set its top level manager. 1372void PMStack::push(Pass *P) { 1373 1374 PMDataManager *Top = NULL; 1375 PMDataManager *PM = dynamic_cast<PMDataManager *>(P); 1376 assert (PM && "Unable to push. Pass Manager expected"); 1377 1378 if (this->empty()) { 1379 Top = PM; 1380 } 1381 else { 1382 Top = this->top(); 1383 PMTopLevelManager *TPM = Top->getTopLevelManager(); 1384 1385 assert (TPM && "Unable to find top level manager"); 1386 TPM->addIndirectPassManager(PM); 1387 PM->setTopLevelManager(TPM); 1388 } 1389 1390 S.push_back(PM); 1391} 1392 1393// Dump content of the pass manager stack. 1394void PMStack::dump() { 1395 for(std::deque<PMDataManager *>::iterator I = S.begin(), 1396 E = S.end(); I != E; ++I) { 1397 Pass *P = dynamic_cast<Pass *>(*I); 1398 printf ("%s ", P->getPassName()); 1399 } 1400 if (!S.empty()) 1401 printf ("\n"); 1402} 1403 1404/// Find appropriate Module Pass Manager in the PM Stack and 1405/// add self into that manager. 1406void ModulePass::assignPassManager(PMStack &PMS, 1407 PassManagerType PreferredType) { 1408 1409 // Find Module Pass Manager 1410 while(!PMS.empty()) { 1411 PassManagerType TopPMType = PMS.top()->getPassManagerType(); 1412 if (TopPMType == PreferredType) 1413 break; // We found desired pass manager 1414 else if (TopPMType > PMT_ModulePassManager) 1415 PMS.pop(); // Pop children pass managers 1416 else 1417 break; 1418 } 1419 1420 PMS.top()->add(this); 1421} 1422 1423/// Find appropriate Function Pass Manager or Call Graph Pass Manager 1424/// in the PM Stack and add self into that manager. 1425void FunctionPass::assignPassManager(PMStack &PMS, 1426 PassManagerType PreferredType) { 1427 1428 // Find Module Pass Manager (TODO : Or Call Graph Pass Manager) 1429 while(!PMS.empty()) { 1430 if (PMS.top()->getPassManagerType() > PMT_FunctionPassManager) 1431 PMS.pop(); 1432 else 1433 break; 1434 } 1435 FPPassManager *FPP = dynamic_cast<FPPassManager *>(PMS.top()); 1436 1437 // Create new Function Pass Manager 1438 if (!FPP) { 1439 assert(!PMS.empty() && "Unable to create Function Pass Manager"); 1440 PMDataManager *PMD = PMS.top(); 1441 1442 // [1] Create new Function Pass Manager 1443 FPP = new FPPassManager(PMD->getDepth() + 1); 1444 1445 // [2] Set up new manager's top level manager 1446 PMTopLevelManager *TPM = PMD->getTopLevelManager(); 1447 TPM->addIndirectPassManager(FPP); 1448 1449 // [3] Assign manager to manage this new manager. This may create 1450 // and push new managers into PMS 1451 Pass *P = dynamic_cast<Pass *>(FPP); 1452 1453 // If Call Graph Pass Manager is active then use it to manage 1454 // this new Function Pass manager. 1455 if (PMD->getPassManagerType() == PMT_CallGraphPassManager) 1456 P->assignPassManager(PMS, PMT_CallGraphPassManager); 1457 else 1458 P->assignPassManager(PMS); 1459 1460 // [4] Push new manager into PMS 1461 PMS.push(FPP); 1462 } 1463 1464 // Assign FPP as the manager of this pass. 1465 FPP->add(this); 1466} 1467 1468/// Find appropriate Basic Pass Manager or Call Graph Pass Manager 1469/// in the PM Stack and add self into that manager. 1470void BasicBlockPass::assignPassManager(PMStack &PMS, 1471 PassManagerType PreferredType) { 1472 1473 BBPassManager *BBP = NULL; 1474 1475 // Basic Pass Manager is a leaf pass manager. It does not handle 1476 // any other pass manager. 1477 if (!PMS.empty()) { 1478 BBP = dynamic_cast<BBPassManager *>(PMS.top()); 1479 } 1480 1481 // If leaf manager is not Basic Block Pass manager then create new 1482 // basic Block Pass manager. 1483 1484 if (!BBP) { 1485 assert(!PMS.empty() && "Unable to create BasicBlock Pass Manager"); 1486 PMDataManager *PMD = PMS.top(); 1487 1488 // [1] Create new Basic Block Manager 1489 BBP = new BBPassManager(PMD->getDepth() + 1); 1490 1491 // [2] Set up new manager's top level manager 1492 // Basic Block Pass Manager does not live by itself 1493 PMTopLevelManager *TPM = PMD->getTopLevelManager(); 1494 TPM->addIndirectPassManager(BBP); 1495 1496 // [3] Assign manager to manage this new manager. This may create 1497 // and push new managers into PMS 1498 Pass *P = dynamic_cast<Pass *>(BBP); 1499 P->assignPassManager(PMS); 1500 1501 // [4] Push new manager into PMS 1502 PMS.push(BBP); 1503 } 1504 1505 // Assign BBP as the manager of this pass. 1506 BBP->add(this); 1507} 1508 1509 1510