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