Move BasicBlockPassManager_New, FunctionPassManager_New and

ModulePassManager_New class declarations from PassManager.h
to PassManager.cpp


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

include/llvm/PassManager.h

@@ -88,6 +88,8 @@ public:
   bool doFinalization();
 };
 
+class ModulePassManager_New;
+
 /// PassManagerAnalysisHelper helps pass manager analysis required by
 /// the managed passes. It provides methods to add/remove analysis
 /// available and query if certain analysis is available or not.
@@ -119,87 +121,6 @@ private:
   std::vector<AnalysisID> RequiredSet;
 };
 
-/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
-/// pass together and sequence them to process one basic block before
-/// processing next basic block.
-class BasicBlockPassManager_New : public Pass,
-                                  public PassManagerAnalysisHelper {
-
-public:
-  BasicBlockPassManager_New() { }
-
-  /// Add a pass into a passmanager queue. 
-  bool addPass(Pass *p);
-  
-  /// Execute all of the passes scheduled for execution.  Keep track of
-  /// whether any of the passes modifies the function, and if so, return true.
-  bool runOnFunction(Function &F);
-
-private:
-  // Collection of pass that are managed by this manager
-  std::vector<Pass *> PassVector;
-};
-
-/// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers.
-/// 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 FunctionPassManager_New : public Pass,
-                                public PassManagerAnalysisHelper {
-public:
-  FunctionPassManager_New(ModuleProvider *P) { /* TODO */ }
-  FunctionPassManager_New() { 
-    activeBBPassManager = NULL;
-  }
-  ~FunctionPassManager_New() { /* TODO */ };
- 
-  /// add - Add a pass to the queue of passes to run.  This passes
-  /// ownership of the Pass to the PassManager.  When the
-  /// PassManager_X is destroyed, the pass will be destroyed as well, so
-  /// there is no need to delete the pass. (TODO delete passes.)
-  /// This implies that all passes MUST be allocated with 'new'.
-  void add(Pass *P) { /* TODO*/  }
-
-  /// Add pass into the pass manager queue.
-  bool addPass(Pass *P);
-
-  /// Execute all of the passes scheduled for execution.  Keep
-  /// track of whether any of the passes modifies the function, and if
-  /// so, return true.
-  bool runOnModule(Module &M);
-
-private:
-  // Collection of pass that are manged by this manager
-  std::vector<Pass *> PassVector;
- 
-  // Active Pass Managers
-  BasicBlockPassManager_New *activeBBPassManager;
-};
-
-/// ModulePassManager_New manages ModulePasses and function pass managers.
-/// It batches all Module passes  passes and function pass managers together and
-/// sequence them to process one module.
-class ModulePassManager_New : public Pass,
-                              public PassManagerAnalysisHelper {
- 
-public:
-  ModulePassManager_New() { activeFunctionPassManager = NULL; }
-  
-  /// Add a pass into a passmanager queue. 
-  bool addPass(Pass *p);
-  
-  /// 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 runOnModule(Module &M);
-  
-private:
-  // Collection of pass that are managed by this manager
-  std::vector<Pass *> PassVector;
-  
-  // Active Pass Manager
-  FunctionPassManager_New *activeFunctionPassManager;
-};
-
 /// PassManager_New manages ModulePassManagers
 class PassManager_New : public Pass,
                         public PassManagerAnalysisHelper {

lib/VMCore/PassManager.cpp

@@ -17,6 +17,91 @@
 
 using namespace llvm;
 
+namespace llvm {
+
+/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
+/// pass together and sequence them to process one basic block before
+/// processing next basic block.
+class BasicBlockPassManager_New : public Pass,
+                                  public PassManagerAnalysisHelper {
+
+public:
+  BasicBlockPassManager_New() { }
+
+  /// Add a pass into a passmanager queue. 
+  bool addPass(Pass *p);
+  
+  /// Execute all of the passes scheduled for execution.  Keep track of
+  /// whether any of the passes modifies the function, and if so, return true.
+  bool runOnFunction(Function &F);
+
+private:
+  // Collection of pass that are managed by this manager
+  std::vector<Pass *> PassVector;
+};
+
+/// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers.
+/// 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 FunctionPassManager_New : public Pass,
+                                public PassManagerAnalysisHelper {
+public:
+  FunctionPassManager_New(ModuleProvider *P) { /* TODO */ }
+  FunctionPassManager_New() { 
+    activeBBPassManager = NULL;
+  }
+  ~FunctionPassManager_New() { /* TODO */ };
+ 
+  /// add - Add a pass to the queue of passes to run.  This passes
+  /// ownership of the Pass to the PassManager.  When the
+  /// PassManager_X is destroyed, the pass will be destroyed as well, so
+  /// there is no need to delete the pass. (TODO delete passes.)
+  /// This implies that all passes MUST be allocated with 'new'.
+  void add(Pass *P) { /* TODO*/  }
+
+  /// Add pass into the pass manager queue.
+  bool addPass(Pass *P);
+
+  /// Execute all of the passes scheduled for execution.  Keep
+  /// track of whether any of the passes modifies the function, and if
+  /// so, return true.
+  bool runOnModule(Module &M);
+
+private:
+  // Collection of pass that are manged by this manager
+  std::vector<Pass *> PassVector;
+ 
+  // Active Pass Managers
+  BasicBlockPassManager_New *activeBBPassManager;
+};
+
+/// ModulePassManager_New manages ModulePasses and function pass managers.
+/// It batches all Module passes  passes and function pass managers together and
+/// sequence them to process one module.
+class ModulePassManager_New : public Pass,
+                              public PassManagerAnalysisHelper {
+ 
+public:
+  ModulePassManager_New() { activeFunctionPassManager = NULL; }
+  
+  /// Add a pass into a passmanager queue. 
+  bool addPass(Pass *p);
+  
+  /// 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 runOnModule(Module &M);
+  
+private:
+  // Collection of pass that are managed by this manager
+  std::vector<Pass *> PassVector;
+  
+  // Active Pass Manager
+  FunctionPassManager_New *activeFunctionPassManager;
+};
+
+} // End of llvm namespace
+
 // PassManagerAnalysisHelper implementation
 
 /// Return true IFF pass P's required analysis set does not required new