Move PMTopLevelManager, PMDataManager and FPPassManger classes into

new PassManagers.h header.

This opens door for implementing CGPassManager in IPA library.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33135 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 38 insertions, 323 deletions

diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index a45b8f8..28b0b89 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -12,7 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 
-#include "llvm/PassManager.h"
+#include "llvm/PassManagers.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Module.h"
@@ -22,76 +22,7 @@
 #include <vector>
 #include <map>
 
-using namespace llvm;
-class llvm::PMDataManager;
-class llvm::PMStack;
-
-//===----------------------------------------------------------------------===//
-// Overview:
-// The Pass Manager Infrastructure manages passes. It's responsibilities are:
-// 
-//   o Manage optimization pass execution order
-//   o Make required Analysis information available before pass P is run
-//   o Release memory occupied by dead passes
-//   o If Analysis information is dirtied by a pass then regenerate Analysis 
-//     information before it is consumed by another pass.
-//
-// Pass Manager Infrastructure uses multiple pass managers.  They are
-// PassManager, FunctionPassManager, MPPassManager, FPPassManager, BBPassManager.
-// This class hierarcy uses multiple inheritance but pass managers do not derive
-// from another pass manager.
-//
-// PassManager and FunctionPassManager are two top-level pass manager that
-// represents the external interface of this entire pass manager infrastucture.
-//
-// Important classes :
-//
-// [o] class PMTopLevelManager;
-//
-// Two top level managers, PassManager and FunctionPassManager, derive from 
-// PMTopLevelManager. PMTopLevelManager manages information used by top level 
-// managers such as last user info.
-//
-// [o] class PMDataManager;
-//
-// PMDataManager manages information, e.g. list of available analysis info, 
-// used by a pass manager to manage execution order of passes. It also provides
-// a place to implement common pass manager APIs. All pass managers derive from
-// PMDataManager.
-//
-// [o] class BBPassManager : public FunctionPass, public PMDataManager;
-//
-// BBPassManager manages BasicBlockPasses.
-//
-// [o] class FunctionPassManager;
-//
-// This is a external interface used by JIT to manage FunctionPasses. This
-// interface relies on FunctionPassManagerImpl to do all the tasks.
-//
-// [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager,
-//                                     public PMTopLevelManager;
-//
-// FunctionPassManagerImpl is a top level manager. It manages FPPassManagers
-//
-// [o] class FPPassManager : public ModulePass, public PMDataManager;
-//
-// FPPassManager manages FunctionPasses and BBPassManagers
-//
-// [o] class MPPassManager : public Pass, public PMDataManager;
-//
-// MPPassManager manages ModulePasses and FPPassManagers
-//
-// [o] class PassManager;
-//
-// This is a external interface used by various tools to manages passes. It
-// relies on PassManagerImpl to do all the tasks.
-//
-// [o] class PassManagerImpl : public Pass, public PMDataManager,
-//                             public PMDTopLevelManager
-//
-// PassManagerImpl is a top level pass manager responsible for managing
-// MPPassManagers.
-//===----------------------------------------------------------------------===//
+// See PassManagers.h for Pass Manager infrastructure overview.
 
 namespace llvm {
 
@@ -122,208 +53,6 @@ PassDebugging_New("debug-pass", cl::Hidden,
 namespace {
 
 //===----------------------------------------------------------------------===//
-// PMTopLevelManager
-//
-/// PMTopLevelManager manages LastUser info and collects common APIs used by
-/// top level pass managers.
-class VISIBILITY_HIDDEN PMTopLevelManager {
-public:
-
-  virtual unsigned getNumContainedManagers() {
-    return PassManagers.size();
-  }
-
-  /// Schedule pass P for execution. Make sure that passes required by
-  /// P are run before P is run. Update analysis info maintained by
-  /// the manager. Remove dead passes. This is a recursive function.
-  void schedulePass(Pass *P);
-
-  /// This is implemented by top level pass manager and used by 
-  /// schedulePass() to add analysis info passes that are not available.
-  virtual void addTopLevelPass(Pass  *P) = 0;
-
-  /// Set pass P as the last user of the given analysis passes.
-  void setLastUser(std::vector<Pass *> &AnalysisPasses, Pass *P);
-
-  /// Collect passes whose last user is P
-  void collectLastUses(std::vector<Pass *> &LastUses, Pass *P);
-
-  /// Find the pass that implements Analysis AID. Search immutable
-  /// passes and all pass managers. If desired pass is not found
-  /// then return NULL.
-  Pass *findAnalysisPass(AnalysisID AID);
-
-  virtual ~PMTopLevelManager() {
-    for (std::vector<Pass *>::iterator I = PassManagers.begin(),
-           E = PassManagers.end(); I != E; ++I)
-      delete *I;
-
-    for (std::vector<ImmutablePass *>::iterator
-           I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I)
-      delete *I;
-
-    PassManagers.clear();
-  }
-
-  /// Add immutable pass and initialize it.
-  inline void addImmutablePass(ImmutablePass *P) {
-    P->initializePass();
-    ImmutablePasses.push_back(P);
-  }
-
-  inline std::vector<ImmutablePass *>& getImmutablePasses() {
-    return ImmutablePasses;
-  }
-
-  void addPassManager(Pass *Manager) {
-    PassManagers.push_back(Manager);
-  }
-
-  // Add Manager into the list of managers that are not directly
-  // maintained by this top level pass manager
-  inline void addIndirectPassManager(PMDataManager *Manager) {
-    IndirectPassManagers.push_back(Manager);
-  }
-
-  // Print passes managed by this top level manager.
-  void dumpPasses() const;
-  void dumpArguments() const;
-
-  void initializeAllAnalysisInfo();
-
-  // Active Pass Managers
-  PMStack activeStack;
-
-protected:
-  
-  /// Collection of pass managers
-  std::vector<Pass *> PassManagers;
-
-private:
-
-  /// Collection of pass managers that are not directly maintained
-  /// by this pass manager
-  std::vector<PMDataManager *> IndirectPassManagers;
-
-  // Map to keep track of last user of the analysis pass.
-  // LastUser->second is the last user of Lastuser->first.
-  std::map<Pass *, Pass *> LastUser;
-
-  /// Immutable passes are managed by top level manager.
-  std::vector<ImmutablePass *> ImmutablePasses;
-};
-
-} // End of anon namespace
-  
-//===----------------------------------------------------------------------===//
-// PMDataManager
-
-namespace llvm {
-/// PMDataManager provides the common place to manage the analysis data
-/// used by pass managers.
-class PMDataManager {
-public:
-  PMDataManager(int Depth) : TPM(NULL), Depth(Depth) {
-    initializeAnalysisInfo();
-  }
-
-  virtual ~PMDataManager() {
-
-    for (std::vector<Pass *>::iterator I = PassVector.begin(),
-           E = PassVector.end(); I != E; ++I)
-      delete *I;
-
-    PassVector.clear();
-  }
-
-  /// Return true IFF pass P's required analysis set does not required new
-  /// manager.
-  bool manageablePass(Pass *P);
-
-  /// Augment AvailableAnalysis by adding analysis made available by pass P.
-  void recordAvailableAnalysis(Pass *P);
-
-  /// Remove Analysis that is not preserved by the pass
-  void removeNotPreservedAnalysis(Pass *P);
-  
-  /// Remove dead passes
-  void removeDeadPasses(Pass *P, std::string &Msg);
-
-  /// Add pass P into the PassVector. Update 
-  /// AvailableAnalysis appropriately if ProcessAnalysis is true.
-  void addPassToManager(Pass *P, bool ProcessAnalysis = true);
-
-  /// Initialize available analysis information.
-  void initializeAnalysisInfo() { 
-    TransferLastUses.clear();
-    AvailableAnalysis.clear();
-  }
-
-  /// Populate RequiredPasses with the analysis pass that are required by
-  /// pass P.
-  void collectRequiredAnalysisPasses(std::vector<Pass *> &RequiredPasses,
-                                     Pass *P);
-
-  /// All Required analyses should be available to the pass as it runs!  Here
-  /// we fill in the AnalysisImpls member of the pass so that it can
-  /// successfully use the getAnalysis() method to retrieve the
-  /// implementations it needs.
-  void initializeAnalysisImpl(Pass *P);
-
-  /// Find the pass that implements Analysis AID. If desired pass is not found
-  /// then return NULL.
-  Pass *findAnalysisPass(AnalysisID AID, bool Direction);
-
-  // Access toplevel manager
-  PMTopLevelManager *getTopLevelManager() { return TPM; }
-  void setTopLevelManager(PMTopLevelManager *T) { TPM = T; }
-
-  unsigned getDepth() const { return Depth; }
-
-  // Print routines used by debug-pass
-  void dumpLastUses(Pass *P, unsigned Offset) const;
-  void dumpPassArguments() const;
-  void dumpPassInfo(Pass *P,  std::string &Msg1, std::string &Msg2) const;
-  void dumpAnalysisSetInfo(const char *Msg, Pass *P,
-                           const std::vector<AnalysisID> &Set) const;
-
-  std::vector<Pass *>& getTransferredLastUses() {
-    return TransferLastUses;
-  }
-
-  virtual unsigned getNumContainedPasses() { 
-    return PassVector.size();
-  }
-
-  virtual PassManagerType getPassManagerType() { 
-    assert ( 0 && "Invalid use of getPassManagerType");
-    return PMT_Unknown; 
-  }
-protected:
-
-  // If a FunctionPass F is the last user of ModulePass info M
-  // then the F's manager, not F, records itself as a last user of M.
-  // Current pass manage is requesting parent manager to record parent
-  // manager as the last user of these TrransferLastUses passes.
-  std::vector<Pass *> TransferLastUses;
-
-  // Top level manager.
-  PMTopLevelManager *TPM;
-
-  // Collection of pass that are managed by this manager
-  std::vector<Pass *> PassVector;
-
-private:
-  // Set of available Analysis. This information is used while scheduling 
-  // pass. If a pass requires an analysis which is not not available then 
-  // equired analysis pass is scheduled to run before the pass itself is 
-  // scheduled to run.
-  std::map<AnalysisID, Pass*> AvailableAnalysis;
-
-  unsigned Depth;
-};
-
-//===----------------------------------------------------------------------===//
 // BBPassManager
 //
 /// BBPassManager manages BasicBlockPass. It batches all the
@@ -370,57 +99,9 @@ public:
   }
 };
 
-//===----------------------------------------------------------------------===//
-// FPPassManager
-//
-/// FPPassManager manages BBPassManagers and FunctionPasses.
-/// It batches all function passes and basic block pass managers together and 
-/// sequence them to process one function at a time before processing next 
-/// function.
-
-class FPPassManager : public ModulePass, public PMDataManager {
- 
-public:
-  FPPassManager(int Depth) : PMDataManager(Depth) { }
-  
-  /// run - Execute all of the passes scheduled for execution.  Keep track of
-  /// whether any of the passes modifies the module, and if so, return true.
-  bool runOnFunction(Function &F);
-  bool runOnModule(Module &M);
-
-  /// doInitialization - Run all of the initializers for the function passes.
-  ///
-  bool doInitialization(Module &M);
-  
-  /// doFinalization - Run all of the initializers for the function passes.
-  ///
-  bool doFinalization(Module &M);
-
-  /// Pass Manager itself does not invalidate any analysis info.
-  void getAnalysisUsage(AnalysisUsage &Info) const {
-    Info.setPreservesAll();
-  }
-
-  // Print passes managed by this manager
-  void dumpPassStructure(unsigned Offset) {
-    llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n";
-    for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
-      FunctionPass *FP = getContainedPass(Index);
-      FP->dumpPassStructure(Offset + 1);
-      dumpLastUses(FP, Offset+1);
-    }
-  }
-
-  FunctionPass *getContainedPass(unsigned N) {
-    assert ( N < PassVector.size() && "Pass number out of range!");
-    FunctionPass *FP = static_cast<FunctionPass *>(PassVector[N]);
-    return FP;
-  }
+}
 
-  virtual PassManagerType getPassManagerType() { 
-    return PMT_FunctionPassManager; 
-  }
-};
+namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // FunctionPassManagerImpl
@@ -785,6 +466,19 @@ void PMTopLevelManager::initializeAllAnalysisInfo() {
     (*I)->initializeAnalysisInfo();
 }
 
+/// Destructor
+PMTopLevelManager::~PMTopLevelManager() {
+  for (std::vector<Pass *>::iterator I = PassManagers.begin(),
+         E = PassManagers.end(); I != E; ++I)
+    delete *I;
+  
+  for (std::vector<ImmutablePass *>::iterator
+         I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I)
+    delete *I;
+  
+  PassManagers.clear();
+}
+
 //===----------------------------------------------------------------------===//
 // PMDataManager implementation
 
@@ -1024,6 +718,16 @@ void PMDataManager::dumpAnalysisSetInfo(const char *Msg, Pass *P,
   }
 }
 
+// Destructor
+PMDataManager::~PMDataManager() {
+  
+  for (std::vector<Pass *>::iterator I = PassVector.begin(),
+         E = PassVector.end(); I != E; ++I)
+    delete *I;
+  
+  PassVector.clear();
+}
+
 //===----------------------------------------------------------------------===//
 // NOTE: Is this the right place to define this method ?
 // getAnalysisToUpdate - Return an analysis result or null if it doesn't exist
@@ -1223,6 +927,17 @@ bool FunctionPassManagerImpl::run(Function &F) {
 //===----------------------------------------------------------------------===//
 // FPPassManager implementation
 
+/// Print passes managed by this manager
+void FPPassManager::dumpPassStructure(unsigned Offset) {
+  llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n";
+  for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
+    FunctionPass *FP = getContainedPass(Index);
+    FP->dumpPassStructure(Offset + 1);
+    dumpLastUses(FP, Offset+1);
+  }
+}
+
+
 /// Execute all of the passes scheduled for execution by invoking 
 /// runOnFunction method.  Keep track of whether any of the passes modifies 
 /// the function, and if so, return true.