Enable new pass manager.

[oota-llvm.git] / include / llvm / Pass.h

diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h
index 4a929f0b215f69a8bc92a8bef8fc4e7b3c8f1c8a..5c3eb478f6c4a54dc8fa0ee0cc722792804ec03b 100644 (file)
--- a/include/llvm/Pass.h
+++ b/include/llvm/Pass.h
@@ -36,6 +36,8 @@
 #include <typeinfo>
 #include <cassert>
 
+//#define USE_OLD_PASSMANAGER 1
+
 namespace llvm {
 
 class Value;
@@ -50,6 +52,7 @@ class BasicBlockPassManager;
 class FunctionPassManagerT;
 class ModulePassManager;
 struct AnalysisResolver;
+class AnalysisResolver_New;
 
 // AnalysisID - Use the PassInfo to identify a pass...
 typedef const PassInfo* AnalysisID;
@@ -62,6 +65,7 @@ typedef const PassInfo* AnalysisID;
 class Pass {
   friend struct AnalysisResolver;
   AnalysisResolver *Resolver;  // AnalysisResolver this pass is owned by...
+  AnalysisResolver_New *Resolver_New;  // Used to resolve analysis
   const PassInfo *PassInfoCache;
 
   // AnalysisImpls - This keeps track of which passes implement the interfaces
@@ -72,7 +76,7 @@ class Pass {
   void operator=(const Pass&);  // DO NOT IMPLEMENT
   Pass(const Pass &);           // DO NOT IMPLEMENT
 public:
-  Pass() : Resolver(0), PassInfoCache(0) {}
+  Pass() : Resolver(0), Resolver_New(0), PassInfoCache(0) {}
   virtual ~Pass() {} // Destructor is virtual so we can be subclassed
 
   /// getPassName - Return a nice clean name for a pass.  This usually
@@ -101,12 +105,13 @@ public:
   /// provide the Module* in case the analysis doesn't need it it can just be
   /// ignored.
   ///
-  void print(OStream &O, const Module *M) const {
-    if (O.stream()) print(*O.stream(), M);
-  }
   virtual void print(std::ostream &O, const Module *M) const;
+  void print(std::ostream *O, const Module *M) const { if (O) print(*O, M); }
   void dump() const; // dump - call print(std::cerr, 0);
 
+  // Access AnalysisResolver_New
+  inline void setResolver(AnalysisResolver_New *AR) { Resolver_New = AR; }
+  inline AnalysisResolver_New *getResolver() { return Resolver_New; }
 
   /// getAnalysisUsage - This function should be overriden by passes that need
   /// analysis information to do their job.  If a pass specifies that it uses a
@@ -168,41 +173,11 @@ public:
   /// getAnalysisUsage function.
   ///
   template<typename AnalysisType>
-  AnalysisType &getAnalysis() const {
-    assert(Resolver && "Pass has not been inserted into a PassManager object!");
-    const PassInfo *PI = getClassPassInfo<AnalysisType>();
-    return getAnalysisID<AnalysisType>(PI);
-  }
+  AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h
 
   template<typename AnalysisType>
-  AnalysisType &getAnalysisID(const PassInfo *PI) const {
-    assert(Resolver && "Pass has not been inserted into a PassManager object!");
-    assert(PI && "getAnalysis for unregistered pass!");
-
-    // PI *must* appear in AnalysisImpls.  Because the number of passes used
-    // should be a small number, we just do a linear search over a (dense)
-    // vector.
-    Pass *ResultPass = 0;
-    for (unsigned i = 0; ; ++i) {
-      assert(i != AnalysisImpls.size() &&
-             "getAnalysis*() called on an analysis that was not "
-             "'required' by pass!");
-      if (AnalysisImpls[i].first == PI) {
-        ResultPass = AnalysisImpls[i].second;
-        break;
-      }
-    }
-
-    // Because the AnalysisType may not be a subclass of pass (for
-    // AnalysisGroups), we must use dynamic_cast here to potentially adjust the
-    // return pointer (because the class may multiply inherit, once from pass,
-    // once from AnalysisType).
-    //
-    AnalysisType *Result = dynamic_cast<AnalysisType*>(ResultPass);
-    assert(Result && "Pass does not implement interface required!");
-    return *Result;
-  }
-
+  AnalysisType &getAnalysisID(const PassInfo *PI) const;
+    
 private:
   template<typename Trait> friend class PassManagerT;
   friend class ModulePassManager;
@@ -228,7 +203,9 @@ public:
   virtual bool runPass(Module &M) { return runOnModule(M); }
   virtual bool runPass(BasicBlock&) { return false; }
 
+#ifdef USE_OLD_PASSMANAGER
   virtual void addToPassManager(ModulePassManager *PM, AnalysisUsage &AU);
+#endif
 };
 
 
@@ -251,10 +228,12 @@ public:
   ///
   virtual bool runOnModule(Module &M) { return false; }
 
+#ifdef USE_OLD_PASSMANAGER
 private:
   template<typename Trait> friend class PassManagerT;
   friend class ModulePassManager;
   virtual void addToPassManager(ModulePassManager *PM, AnalysisUsage &AU);
+#endif
 };
 
 //===----------------------------------------------------------------------===//
@@ -294,6 +273,7 @@ public:
   ///
   bool run(Function &F);
 
+#ifdef USE_OLD_PASSMANAGER
 protected:
   template<typename Trait> friend class PassManagerT;
   friend class ModulePassManager;
@@ -301,6 +281,7 @@ protected:
   friend class BasicBlockPassManager;
   virtual void addToPassManager(ModulePassManager *PM, AnalysisUsage &AU);
   virtual void addToPassManager(FunctionPassManagerT *PM, AnalysisUsage &AU);
+#endif
 };
 
 
@@ -354,6 +335,7 @@ public:
   virtual bool runPass(Module &M) { return false; }
   virtual bool runPass(BasicBlock &BB);
 
+#ifdef USE_OLD_PASSMANAGER
 private:
   template<typename Trait> friend class PassManagerT;
   friend class FunctionPassManagerT;
@@ -363,6 +345,7 @@ private:
   }
   virtual void addToPassManager(FunctionPassManagerT *PM, AnalysisUsage &AU);
   virtual void addToPassManager(BasicBlockPassManager *PM,AnalysisUsage &AU);
+#endif
 };
 
 /// If the user specifies the -time-passes argument on an LLVM tool command line