lib/VMCore/PassManager.cpp

   1 //===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Devang Patel and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the LLVM Pass Manager infrastructure.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14
  15 #include "llvm/PassManager.h"
  16 #include "llvm/Module.h"
  17 #include "llvm/ModuleProvider.h"
  18 #include "llvm/Support/Streams.h"
  19 #include <vector>
  20 #include <map>
  21 using namespace llvm;
  22
  23 //===----------------------------------------------------------------------===//
  24 // Overview:
  25 // The Pass Manager Infrastructure manages passes. It's responsibilities are:
  26 //
  27 //   o Manage optimization pass execution order
  28 //   o Make required Analysis information available before pass P is run
  29 //   o Release memory occupied by dead passes
  30 //   o If Analysis information is dirtied by a pass then regenerate Analysis
  31 //     information before it is consumed by another pass.
  32 //
  33 // Pass Manager Infrastructure uses multipe pass managers. They are PassManager,
  34 // FunctionPassManager, ModulePassManager, BasicBlockPassManager. This class
  35 // hierarcy uses multiple inheritance but pass managers do not derive from
  36 // another pass manager.
  37 //
  38 // PassManager and FunctionPassManager are two top level pass manager that
  39 // represents the external interface of this entire pass manager infrastucture.
  40 //
  41 // Important classes :
  42 //
  43 // [o] class PMTopLevelManager;
  44 //
  45 // Two top level managers, PassManager and FunctionPassManager, derive from
  46 // PMTopLevelManager. PMTopLevelManager manages information used by top level
  47 // managers such as last user info.
  48 //
  49 // [o] class PMDataManager;
  50 //
  51 // PMDataManager manages information, e.g. list of available analysis info,
  52 // used by a pass manager to manage execution order of passes. It also provides
  53 // a place to implement common pass manager APIs. All pass managers derive from
  54 // PMDataManager.
  55 //
  56 // [o] class BasicBlockPassManager : public FunctionPass, public PMDataManager;
  57 //
  58 // BasicBlockPassManager manages BasicBlockPasses.
  59 //
  60 // [o] class FunctionPassManager;
  61 //
  62 // This is a external interface used by JIT to manage FunctionPasses. This
  63 // interface relies on FunctionPassManagerImpl to do all the tasks.
  64 //
  65 // [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager,
  66 //                                     public PMTopLevelManager;
  67 //
  68 // FunctionPassManagerImpl is a top level manager. It manages FunctionPasses
  69 // and BasicBlockPassManagers.
  70 //
  71 // [o] class ModulePassManager : public Pass, public PMDataManager;
  72 //
  73 // ModulePassManager manages ModulePasses and FunctionPassManagerImpls.
  74 //
  75 // [o] class PassManager;
  76 //
  77 // This is a external interface used by various tools to manages passes. It
  78 // relies on PassManagerImpl to do all the tasks.
  79 //
  80 // [o] class PassManagerImpl : public Pass, public PMDataManager,
  81 //                             public PMDTopLevelManager
  82 //
  83 // PassManagerImpl is a top level pass manager responsible for managing
  84 // ModulePassManagers.
  85 //===----------------------------------------------------------------------===//
  86
  87 namespace llvm {
  88
  89 //===----------------------------------------------------------------------===//
  90 // PMTopLevelManager
  91 //
  92 /// PMTopLevelManager manages LastUser info and collects common APIs used by
  93 /// top level pass managers.
  94 class PMTopLevelManager {
  95
  96 public:
  97
  98   inline std::vector<Pass *>::iterator passManagersBegin() {
  99     return PassManagers.begin();
 100   }
 101
 102   inline std::vector<Pass *>::iterator passManagersEnd() {
 103     return PassManagers.end();
 104   }
 105
 106   /// Schedule pass P for execution. Make sure that passes required by
 107   /// P are run before P is run. Update analysis info maintained by
 108   /// the manager. Remove dead passes. This is a recursive function.
 109   void schedulePass(Pass *P, Pass *PM);
 110
 111   /// This is implemented by top level pass manager and used by
 112   /// schedulePass() to add analysis info passes that are not available.
 113   virtual void addTopLevelPass(Pass  *P) = 0;
 114
 115   /// Set pass P as the last user of the given analysis passes.
 116   void setLastUser(std::vector<Pass *> &AnalysisPasses, Pass *P);
 117
 118   /// Collect passes whose last user is P
 119   void collectLastUses(std::vector<Pass *> &LastUses, Pass *P);
 120
 121   virtual ~PMTopLevelManager() {
 122     PassManagers.clear();
 123   }
 124
 125   /// Add immutable pass and initialize it.
 126   inline void addImmutablePass(ImmutablePass *P) {
 127     P->initializePass();
 128     ImmutablePasses.push_back(P);
 129   }
 130
 131   inline std::vector<ImmutablePass *>& getImmutablePasses() {
 132     return ImmutablePasses;
 133   }
 134
 135 private:
 136
 137   /// Collection of pass managers
 138   std::vector<Pass *> PassManagers;
 139
 140   // Map to keep track of last user of the analysis pass.
 141   // LastUser->second is the last user of Lastuser->first.
 142   std::map<Pass *, Pass *> LastUser;
 143
 144   /// Immutable passes are managed by top level manager.
 145   std::vector<ImmutablePass *> ImmutablePasses;
 146 };
 147
 148 /// Set pass P as the last user of the given analysis passes.
 149 void PMTopLevelManager::setLastUser(std::vector<Pass *> &AnalysisPasses,
 150                                     Pass *P) {
 151
 152   for (std::vector<Pass *>::iterator I = AnalysisPasses.begin(),
 153          E = AnalysisPasses.end(); I != E; ++I) {
 154     Pass *AP = *I;
 155     LastUser[AP] = P;
 156     // If AP is the last user of other passes then make P last user of
 157     // such passes.
 158     for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(),
 159            LUE = LastUser.end(); LUI != LUE; ++LUI) {
 160       if (LUI->second == AP)
 161         LastUser[LUI->first] = P;
 162     }
 163   }
 164
 165 }
 166
 167 /// Collect passes whose last user is P
 168 void PMTopLevelManager::collectLastUses(std::vector<Pass *> &LastUses,
 169                                             Pass *P) {
 170    for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(),
 171           LUE = LastUser.end(); LUI != LUE; ++LUI)
 172       if (LUI->second == P)
 173         LastUses.push_back(LUI->first);
 174 }
 175
 176 /// Schedule pass P for execution. Make sure that passes required by
 177 /// P are run before P is run. Update analysis info maintained by
 178 /// the manager. Remove dead passes. This is a recursive function.
 179 void PMTopLevelManager::schedulePass(Pass *P, Pass *PM) {
 180
 181   // TODO : Allocate function manager for this pass, other wise required set
 182   // may be inserted into previous function manager
 183
 184   AnalysisUsage AnUsage;
 185   P->getAnalysisUsage(AnUsage);
 186   const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet();
 187   for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(),
 188          E = RequiredSet.end(); I != E; ++I) {
 189
 190     Pass *AnalysisPass = NULL; // FIXME PM->getAnalysisPass(*I, true);
 191     if (!AnalysisPass) {
 192       // Schedule this analysis run first.
 193       AnalysisPass = (*I)->createPass();
 194       schedulePass(AnalysisPass, PM);
 195     }
 196   }
 197
 198   // Now all required passes are available.
 199   addTopLevelPass(P);
 200 }
 201
 202
 203 //===----------------------------------------------------------------------===//
 204 // PMDataManager
 205
 206 /// PMDataManager provides the common place to manage the analysis data
 207 /// used by pass managers.
 208 class PMDataManager {
 209
 210 public:
 211
 212   PMDataManager() : TPM(NULL) {
 213     initializeAnalysisInfo();
 214   }
 215
 216   /// Return true IFF pass P's required analysis set does not required new
 217   /// manager.
 218   bool manageablePass(Pass *P);
 219
 220   Pass *getAnalysisPass(AnalysisID AID) const {
 221
 222     std::map<AnalysisID, Pass*>::const_iterator I =
 223       AvailableAnalysis.find(AID);
 224
 225     if (I != AvailableAnalysis.end())
 226       return NULL;
 227     else
 228       return I->second;
 229   }
 230
 231   /// Augment AvailableAnalysis by adding analysis made available by pass P.
 232   void recordAvailableAnalysis(Pass *P);
 233
 234   /// Remove Analysis that is not preserved by the pass
 235   void removeNotPreservedAnalysis(Pass *P);
 236
 237   /// Remove dead passes
 238   void removeDeadPasses(Pass *P);
 239
 240   /// Add pass P into the PassVector. Update
 241   /// AvailableAnalysis appropriately if ProcessAnalysis is true.
 242   void addPassToManager (Pass *P, bool ProcessAnalysis = true);
 243
 244   // Initialize available analysis information.
 245   void initializeAnalysisInfo() {
 246     AvailableAnalysis.clear();
 247     LastUser.clear();
 248
 249     // Include immutable passes into AvailableAnalysis vector.
 250     std::vector<ImmutablePass *> &ImmutablePasses =  TPM->getImmutablePasses();
 251     for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(),
 252            E = ImmutablePasses.end(); I != E; ++I)
 253       recordAvailableAnalysis(*I);
 254   }
 255
 256   // All Required analyses should be available to the pass as it runs!  Here
 257   // we fill in the AnalysisImpls member of the pass so that it can
 258   // successfully use the getAnalysis() method to retrieve the
 259   // implementations it needs.
 260   //
 261  void initializeAnalysisImpl(Pass *P);
 262
 263   inline std::vector<Pass *>::iterator passVectorBegin() {
 264     return PassVector.begin();
 265   }
 266
 267   inline std::vector<Pass *>::iterator passVectorEnd() {
 268     return PassVector.end();
 269   }
 270
 271   inline void setLastUser(Pass *P, Pass *LU) {
 272     LastUser[P] = LU;
 273     // TODO : Check if pass P is available.
 274   }
 275
 276   // Access toplevel manager
 277   PMTopLevelManager *getTopLevelManager() { return TPM; }
 278   void setTopLevelManager(PMTopLevelManager *T) { TPM = T; }
 279
 280 private:
 281   // Set of available Analysis. This information is used while scheduling
 282   // pass. If a pass requires an analysis which is not not available then
 283   // equired analysis pass is scheduled to run before the pass itself is
 284   // scheduled to run.
 285   std::map<AnalysisID, Pass*> AvailableAnalysis;
 286
 287   // Map to keep track of last user of the analysis pass.
 288   // LastUser->second is the last user of Lastuser->first.
 289   std::map<Pass *, Pass *> LastUser;
 290
 291   // Collection of pass that are managed by this manager
 292   std::vector<Pass *> PassVector;
 293
 294   // Top level manager.
 295   // TODO : Make it a reference.
 296   PMTopLevelManager *TPM;
 297 };
 298
 299 /// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
 300 /// pass together and sequence them to process one basic block before
 301 /// processing next basic block.
 302 class BasicBlockPassManager_New : public PMDataManager,
 303                                   public FunctionPass {
 304
 305 public:
 306   BasicBlockPassManager_New() { }
 307
 308   /// Add a pass into a passmanager queue.
 309   bool addPass(Pass *p);
 310
 311   /// Execute all of the passes scheduled for execution.  Keep track of
 312   /// whether any of the passes modifies the function, and if so, return true.
 313   bool runOnFunction(Function &F);
 314
 315   /// Return true IFF AnalysisID AID is currently available.
 316   Pass *getAnalysisPassFromManager(AnalysisID AID);
 317
 318   /// Pass Manager itself does not invalidate any analysis info.
 319   void getAnalysisUsage(AnalysisUsage &Info) const {
 320     Info.setPreservesAll();
 321   }
 322
 323 private:
 324 };
 325
 326 /// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers.
 327 /// It batches all function passes and basic block pass managers together and
 328 /// sequence them to process one function at a time before processing next
 329 /// function.
 330 class FunctionPassManagerImpl_New : public PMDataManager,
 331                                     public ModulePass {
 332 public:
 333   FunctionPassManagerImpl_New(ModuleProvider *P) { /* TODO */ }
 334   FunctionPassManagerImpl_New() {
 335     activeBBPassManager = NULL;
 336   }
 337   ~FunctionPassManagerImpl_New() { /* TODO */ };
 338
 339   /// add - Add a pass to the queue of passes to run.  This passes
 340   /// ownership of the Pass to the PassManager.  When the
 341   /// PassManager_X is destroyed, the pass will be destroyed as well, so
 342   /// there is no need to delete the pass. (TODO delete passes.)
 343   /// This implies that all passes MUST be allocated with 'new'.
 344   void add(Pass *P) { /* TODO*/  }
 345
 346   /// Add pass into the pass manager queue.
 347   bool addPass(Pass *P);
 348
 349   /// Execute all of the passes scheduled for execution.  Keep
 350   /// track of whether any of the passes modifies the function, and if
 351   /// so, return true.
 352   bool runOnModule(Module &M);
 353   bool runOnFunction(Function &F);
 354
 355   /// Return true IFF AnalysisID AID is currently available.
 356   Pass *getAnalysisPassFromManager(AnalysisID AID);
 357
 358   /// doInitialization - Run all of the initializers for the function passes.
 359   ///
 360   bool doInitialization(Module &M);
 361
 362   /// doFinalization - Run all of the initializers for the function passes.
 363   ///
 364   bool doFinalization(Module &M);
 365
 366   /// Pass Manager itself does not invalidate any analysis info.
 367   void getAnalysisUsage(AnalysisUsage &Info) const {
 368     Info.setPreservesAll();
 369   }
 370
 371 private:
 372   // Active Pass Managers
 373   BasicBlockPassManager_New *activeBBPassManager;
 374 };
 375
 376 /// ModulePassManager_New manages ModulePasses and function pass managers.
 377 /// It batches all Module passes  passes and function pass managers together and
 378 /// sequence them to process one module.
 379 class ModulePassManager_New : public PMDataManager {
 380
 381 public:
 382   ModulePassManager_New() { activeFunctionPassManager = NULL; }
 383
 384   /// Add a pass into a passmanager queue.
 385   bool addPass(Pass *p);
 386
 387   /// run - Execute all of the passes scheduled for execution.  Keep track of
 388   /// whether any of the passes modifies the module, and if so, return true.
 389   bool runOnModule(Module &M);
 390
 391   /// Return true IFF AnalysisID AID is currently available.
 392   Pass *getAnalysisPassFromManager(AnalysisID AID);
 393
 394   /// Pass Manager itself does not invalidate any analysis info.
 395   void getAnalysisUsage(AnalysisUsage &Info) const {
 396     Info.setPreservesAll();
 397   }
 398
 399 private:
 400   // Active Pass Manager
 401   FunctionPassManagerImpl_New *activeFunctionPassManager;
 402 };
 403
 404 /// PassManager_New manages ModulePassManagers
 405 class PassManagerImpl_New : public PMDataManager {
 406
 407 public:
 408
 409   /// add - Add a pass to the queue of passes to run.  This passes ownership of
 410   /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
 411   /// will be destroyed as well, so there is no need to delete the pass.  This
 412   /// implies that all passes MUST be allocated with 'new'.
 413   void add(Pass *P);
 414
 415   /// run - Execute all of the passes scheduled for execution.  Keep track of
 416   /// whether any of the passes modifies the module, and if so, return true.
 417   bool run(Module &M);
 418
 419   /// Return true IFF AnalysisID AID is currently available.
 420   Pass *getAnalysisPassFromManager(AnalysisID AID);
 421
 422   /// Pass Manager itself does not invalidate any analysis info.
 423   void getAnalysisUsage(AnalysisUsage &Info) const {
 424     Info.setPreservesAll();
 425   }
 426
 427 private:
 428
 429   /// Add a pass into a passmanager queue.
 430   bool addPass(Pass *p);
 431
 432   // Collection of pass managers
 433   std::vector<ModulePassManager_New *> PassManagers;
 434
 435   // Active Pass Manager
 436   ModulePassManager_New *activeManager;
 437 };
 438
 439 } // End of llvm namespace
 440
 441 //===----------------------------------------------------------------------===//
 442 // PMDataManager implementation
 443
 444 /// Return true IFF pass P's required analysis set does not required new
 445 /// manager.
 446 bool PMDataManager::manageablePass(Pass *P) {
 447
 448   // TODO
 449   // If this pass is not preserving information that is required by a
 450   // pass maintained by higher level pass manager then do not insert
 451   // this pass into current manager. Use new manager. For example,
 452   // For example, If FunctionPass F is not preserving ModulePass Info M1
 453   // that is used by another ModulePass M2 then do not insert F in
 454   // current function pass manager.
 455   return true;
 456 }
 457
 458 /// Augement AvailableAnalysis by adding analysis made available by pass P.
 459 void PMDataManager::recordAvailableAnalysis(Pass *P) {
 460
 461   if (const PassInfo *PI = P->getPassInfo()) {
 462     AvailableAnalysis[PI] = P;
 463
 464     //This pass is the current implementation of all of the interfaces it
 465     //implements as well.
 466     const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented();
 467     for (unsigned i = 0, e = II.size(); i != e; ++i)
 468       AvailableAnalysis[II[i]] = P;
 469   }
 470 }
 471
 472 /// Remove Analyss not preserved by Pass P
 473 void PMDataManager::removeNotPreservedAnalysis(Pass *P) {
 474   AnalysisUsage AnUsage;
 475   P->getAnalysisUsage(AnUsage);
 476
 477   if (AnUsage.getPreservesAll())
 478     return;
 479
 480   const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet();
 481   for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(),
 482          E = AvailableAnalysis.end(); I != E; ++I ) {
 483     if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) ==
 484         PreservedSet.end()) {
 485       // Remove this analysis
 486       std::map<AnalysisID, Pass*>::iterator J = I++;
 487       AvailableAnalysis.erase(J);
 488     }
 489   }
 490 }
 491
 492 /// Remove analysis passes that are not used any longer
 493 void PMDataManager::removeDeadPasses(Pass *P) {
 494
 495   for (std::map<Pass *, Pass *>::iterator I = LastUser.begin(),
 496          E = LastUser.end(); I !=E; ++I) {
 497     if (I->second == P) {
 498       Pass *deadPass = I->first;
 499       deadPass->releaseMemory();
 500
 501       std::map<AnalysisID, Pass*>::iterator Pos =
 502         AvailableAnalysis.find(deadPass->getPassInfo());
 503
 504       assert (Pos != AvailableAnalysis.end() &&
 505               "Pass is not available");
 506       AvailableAnalysis.erase(Pos);
 507     }
 508   }
 509 }
 510
 511 /// Add pass P into the PassVector. Update
 512 /// AvailableAnalysis appropriately if ProcessAnalysis is true.
 513 void PMDataManager::addPassToManager(Pass *P,
 514                                      bool ProcessAnalysis) {
 515
 516   if (ProcessAnalysis) {
 517     // Take a note of analysis required and made available by this pass
 518     initializeAnalysisImpl(P);
 519     recordAvailableAnalysis(P);
 520
 521     // Remove the analysis not preserved by this pass
 522     removeNotPreservedAnalysis(P);
 523   }
 524
 525   // Add pass
 526   PassVector.push_back(P);
 527 }
 528
 529 // All Required analyses should be available to the pass as it runs!  Here
 530 // we fill in the AnalysisImpls member of the pass so that it can
 531 // successfully use the getAnalysis() method to retrieve the
 532 // implementations it needs.
 533 //
 534 void PMDataManager::initializeAnalysisImpl(Pass *P) {
 535   AnalysisUsage AnUsage;
 536   P->getAnalysisUsage(AnUsage);
 537
 538   for (std::vector<const PassInfo *>::const_iterator
 539          I = AnUsage.getRequiredSet().begin(),
 540          E = AnUsage.getRequiredSet().end(); I != E; ++I) {
 541     Pass *Impl = getAnalysisPass(*I);
 542     if (Impl == 0)
 543       assert(0 && "Analysis used but not available!");
 544     // TODO:  P->AnalysisImpls.push_back(std::make_pair(*I, Impl));
 545   }
 546 }
 547
 548 //===----------------------------------------------------------------------===//
 549 // BasicBlockPassManager_New implementation
 550
 551 /// Add pass P into PassVector and return true. If this pass is not
 552 /// manageable by this manager then return false.
 553 bool
 554 BasicBlockPassManager_New::addPass(Pass *P) {
 555
 556   BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
 557   if (!BP)
 558     return false;
 559
 560   // If this pass does not preserve anlysis that is used by other passes
 561   // managed by this manager than it is not a suiable pass for this manager.
 562   if (!manageablePass(P))
 563     return false;
 564
 565   addPassToManager (BP);
 566
 567   return true;
 568 }
 569
 570 /// Execute all of the passes scheduled for execution by invoking
 571 /// runOnBasicBlock method.  Keep track of whether any of the passes modifies
 572 /// the function, and if so, return true.
 573 bool
 574 BasicBlockPassManager_New::runOnFunction(Function &F) {
 575
 576   bool Changed = false;
 577   initializeAnalysisInfo();
 578
 579   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
 580     for (std::vector<Pass *>::iterator itr = passVectorBegin(),
 581            e = passVectorEnd(); itr != e; ++itr) {
 582       Pass *P = *itr;
 583
 584       recordAvailableAnalysis(P);
 585       BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
 586       Changed |= BP->runOnBasicBlock(*I);
 587       removeNotPreservedAnalysis(P);
 588       removeDeadPasses(P);
 589     }
 590   return Changed;
 591 }
 592
 593 /// Return true IFF AnalysisID AID is currently available.
 594 Pass * BasicBlockPassManager_New::getAnalysisPassFromManager(AnalysisID AID) {
 595   return getAnalysisPass(AID);
 596 }
 597
 598 //===----------------------------------------------------------------------===//
 599 // FunctionPassManager_New implementation
 600
 601 /// Create new Function pass manager
 602 FunctionPassManager_New::FunctionPassManager_New() {
 603   FPM = new FunctionPassManagerImpl_New();
 604 }
 605
 606 /// add - Add a pass to the queue of passes to run.  This passes
 607 /// ownership of the Pass to the PassManager.  When the
 608 /// PassManager_X is destroyed, the pass will be destroyed as well, so
 609 /// there is no need to delete the pass. (TODO delete passes.)
 610 /// This implies that all passes MUST be allocated with 'new'.
 611 void FunctionPassManager_New::add(Pass *P) {
 612   FPM->add(P);
 613 }
 614
 615 /// Execute all of the passes scheduled for execution.  Keep
 616 /// track of whether any of the passes modifies the function, and if
 617 /// so, return true.
 618 bool FunctionPassManager_New::runOnModule(Module &M) {
 619   return FPM->runOnModule(M);
 620 }
 621
 622 /// run - Execute all of the passes scheduled for execution.  Keep
 623 /// track of whether any of the passes modifies the function, and if
 624 /// so, return true.
 625 ///
 626 bool FunctionPassManager_New::run(Function &F) {
 627   std::string errstr;
 628   if (MP->materializeFunction(&F, &errstr)) {
 629     cerr << "Error reading bytecode file: " << errstr << "\n";
 630     abort();
 631   }
 632   return FPM->runOnFunction(F);
 633 }
 634
 635
 636 /// doInitialization - Run all of the initializers for the function passes.
 637 ///
 638 bool FunctionPassManager_New::doInitialization() {
 639   return FPM->doInitialization(*MP->getModule());
 640 }
 641
 642 /// doFinalization - Run all of the initializers for the function passes.
 643 ///
 644 bool FunctionPassManager_New::doFinalization() {
 645   return FPM->doFinalization(*MP->getModule());
 646 }
 647
 648 //===----------------------------------------------------------------------===//
 649 // FunctionPassManagerImpl_New implementation
 650
 651 /// Add pass P into the pass manager queue. If P is a BasicBlockPass then
 652 /// either use it into active basic block pass manager or create new basic
 653 /// block pass manager to handle pass P.
 654 bool
 655 FunctionPassManagerImpl_New::addPass(Pass *P) {
 656
 657   // If P is a BasicBlockPass then use BasicBlockPassManager_New.
 658   if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) {
 659
 660     if (!activeBBPassManager
 661         || !activeBBPassManager->addPass(BP)) {
 662
 663       activeBBPassManager = new BasicBlockPassManager_New();
 664       addPassToManager(activeBBPassManager, false);
 665       if (!activeBBPassManager->addPass(BP))
 666         assert(0 && "Unable to add Pass");
 667     }
 668     return true;
 669   }
 670
 671   FunctionPass *FP = dynamic_cast<FunctionPass *>(P);
 672   if (!FP)
 673     return false;
 674
 675   // If this pass does not preserve anlysis that is used by other passes
 676   // managed by this manager than it is not a suiable pass for this manager.
 677   if (!manageablePass(P))
 678     return false;
 679
 680   addPassToManager (FP);
 681   activeBBPassManager = NULL;
 682   return true;
 683 }
 684
 685 /// Execute all of the passes scheduled for execution by invoking
 686 /// runOnFunction method.  Keep track of whether any of the passes modifies
 687 /// the function, and if so, return true.
 688 bool FunctionPassManagerImpl_New::runOnModule(Module &M) {
 689
 690   bool Changed = false;
 691   initializeAnalysisInfo();
 692
 693   for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
 694     for (std::vector<Pass *>::iterator itr = passVectorBegin(),
 695            e = passVectorEnd(); itr != e; ++itr) {
 696       Pass *P = *itr;
 697
 698       recordAvailableAnalysis(P);
 699       FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
 700       Changed |= FP->runOnFunction(*I);
 701       removeNotPreservedAnalysis(P);
 702       removeDeadPasses(P);
 703     }
 704   return Changed;
 705 }
 706
 707 /// Execute all of the passes scheduled for execution by invoking
 708 /// runOnFunction method.  Keep track of whether any of the passes modifies
 709 /// the function, and if so, return true.
 710 bool FunctionPassManagerImpl_New::runOnFunction(Function &F) {
 711
 712   bool Changed = false;
 713   initializeAnalysisInfo();
 714
 715   for (std::vector<Pass *>::iterator itr = passVectorBegin(),
 716          e = passVectorEnd(); itr != e; ++itr) {
 717     Pass *P = *itr;
 718
 719     recordAvailableAnalysis(P);
 720     FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
 721     Changed |= FP->runOnFunction(F);
 722     removeNotPreservedAnalysis(P);
 723     removeDeadPasses(P);
 724   }
 725   return Changed;
 726 }
 727
 728
 729 /// Return true IFF AnalysisID AID is currently available.
 730 Pass *FunctionPassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) {
 731
 732   Pass *P = getAnalysisPass(AID);
 733   if (P)
 734     return P;
 735
 736   if (activeBBPassManager &&
 737       activeBBPassManager->getAnalysisPass(AID) != 0)
 738     return activeBBPassManager->getAnalysisPass(AID);
 739
 740   // TODO : Check inactive managers
 741   return NULL;
 742 }
 743
 744 inline bool FunctionPassManagerImpl_New::doInitialization(Module &M) {
 745   bool Changed = false;
 746
 747   for (std::vector<Pass *>::iterator itr = passVectorBegin(),
 748          e = passVectorEnd(); itr != e; ++itr) {
 749     Pass *P = *itr;
 750
 751     FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
 752     Changed |= FP->doInitialization(M);
 753   }
 754
 755   return Changed;
 756 }
 757
 758 inline bool FunctionPassManagerImpl_New::doFinalization(Module &M) {
 759   bool Changed = false;
 760
 761   for (std::vector<Pass *>::iterator itr = passVectorBegin(),
 762          e = passVectorEnd(); itr != e; ++itr) {
 763     Pass *P = *itr;
 764
 765     FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
 766     Changed |= FP->doFinalization(M);
 767   }
 768
 769
 770   return Changed;
 771 }
 772
 773 //===----------------------------------------------------------------------===//
 774 // ModulePassManager implementation
 775
 776 /// Add P into pass vector if it is manageble. If P is a FunctionPass
 777 /// then use FunctionPassManagerImpl_New to manage it. Return false if P
 778 /// is not manageable by this manager.
 779 bool
 780 ModulePassManager_New::addPass(Pass *P) {
 781
 782   // If P is FunctionPass then use function pass maanager.
 783   if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) {
 784
 785     activeFunctionPassManager = NULL;
 786
 787     if (!activeFunctionPassManager
 788         || !activeFunctionPassManager->addPass(P)) {
 789
 790       activeFunctionPassManager = new FunctionPassManagerImpl_New();
 791       addPassToManager(activeFunctionPassManager, false);
 792       if (!activeFunctionPassManager->addPass(FP))
 793         assert(0 && "Unable to add pass");
 794     }
 795     return true;
 796   }
 797
 798   ModulePass *MP = dynamic_cast<ModulePass *>(P);
 799   if (!MP)
 800     return false;
 801
 802   // If this pass does not preserve anlysis that is used by other passes
 803   // managed by this manager than it is not a suiable pass for this manager.
 804   if (!manageablePass(P))
 805     return false;
 806
 807   addPassToManager(MP);
 808   activeFunctionPassManager = NULL;
 809   return true;
 810 }
 811
 812
 813 /// Execute all of the passes scheduled for execution by invoking
 814 /// runOnModule method.  Keep track of whether any of the passes modifies
 815 /// the module, and if so, return true.
 816 bool
 817 ModulePassManager_New::runOnModule(Module &M) {
 818   bool Changed = false;
 819   initializeAnalysisInfo();
 820
 821   for (std::vector<Pass *>::iterator itr = passVectorBegin(),
 822          e = passVectorEnd(); itr != e; ++itr) {
 823     Pass *P = *itr;
 824
 825     recordAvailableAnalysis(P);
 826     ModulePass *MP = dynamic_cast<ModulePass*>(P);
 827     Changed |= MP->runOnModule(M);
 828     removeNotPreservedAnalysis(P);
 829     removeDeadPasses(P);
 830   }
 831   return Changed;
 832 }
 833
 834 /// Return true IFF AnalysisID AID is currently available.
 835 Pass *ModulePassManager_New::getAnalysisPassFromManager(AnalysisID AID) {
 836
 837
 838   Pass *P = getAnalysisPass(AID);
 839   if (P)
 840     return P;
 841
 842   if (activeFunctionPassManager &&
 843       activeFunctionPassManager->getAnalysisPass(AID) != 0)
 844     return activeFunctionPassManager->getAnalysisPass(AID);
 845
 846   // TODO : Check inactive managers
 847   return NULL;
 848 }
 849
 850 //===----------------------------------------------------------------------===//
 851 // PassManagerImpl implementation
 852
 853 /// Return true IFF AnalysisID AID is currently available.
 854 Pass *PassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) {
 855
 856   Pass *P = NULL;
 857   for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(),
 858          e = PassManagers.end(); !P && itr != e; ++itr)
 859     P  = (*itr)->getAnalysisPassFromManager(AID);
 860   return P;
 861 }
 862
 863 /// Add pass P to the queue of passes to run.
 864 void PassManagerImpl_New::add(Pass *P) {
 865   // Do not process Analysis now. Analysis is process while scheduling
 866   // the pass vector.
 867   addPassToManager(P, false);
 868 }
 869
 870 // PassManager_New implementation
 871 /// Add P into active pass manager or use new module pass manager to
 872 /// manage it.
 873 bool PassManagerImpl_New::addPass(Pass *P) {
 874
 875   if (!activeManager || !activeManager->addPass(P)) {
 876     activeManager = new ModulePassManager_New();
 877     PassManagers.push_back(activeManager);
 878   }
 879
 880   return activeManager->addPass(P);
 881 }
 882
 883 /// run - Execute all of the passes scheduled for execution.  Keep track of
 884 /// whether any of the passes modifies the module, and if so, return true.
 885 bool PassManagerImpl_New::run(Module &M) {
 886
 887   bool Changed = false;
 888   for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(),
 889          e = PassManagers.end(); itr != e; ++itr) {
 890     ModulePassManager_New *pm = *itr;
 891     Changed |= pm->runOnModule(M);
 892   }
 893   return Changed;
 894 }
 895
 896 //===----------------------------------------------------------------------===//
 897 // PassManager implementation
 898
 899 /// Create new pass manager
 900 PassManager_New::PassManager_New() {
 901   PM = new PassManagerImpl_New();
 902 }
 903
 904 /// add - Add a pass to the queue of passes to run.  This passes ownership of
 905 /// the Pass to the PassManager.  When the PassManager is destroyed, the pass
 906 /// will be destroyed as well, so there is no need to delete the pass.  This
 907 /// implies that all passes MUST be allocated with 'new'.
 908 void
 909 PassManager_New::add(Pass *P) {
 910   PM->add(P);
 911 }
 912
 913 /// run - Execute all of the passes scheduled for execution.  Keep track of
 914 /// whether any of the passes modifies the module, and if so, return true.
 915 bool
 916 PassManager_New::run(Module &M) {
 917   return PM->run(M);
 918 }
 919