X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassAnalysisSupport.h;h=75434a25ef2bbae96cdaf95222e0ad119fbbffc1;hb=c651e4c51e11feb58e6c12fee8a8f85631269f2f;hp=3ef43fdcb7f37798d2aa3ab7c4008621758d4558;hpb=f3dc6d9f95d4ba7756105154df4a8075bbbcf931;p=oota-llvm.git

diff --git a/include/llvm/PassAnalysisSupport.h b/include/llvm/PassAnalysisSupport.h
index 3ef43fdcb7f..75434a25ef2 100644
--- a/include/llvm/PassAnalysisSupport.h
+++ b/include/llvm/PassAnalysisSupport.h
@@ -106,12 +106,12 @@ public:
 // the pass.
 //
 class PMDataManager;
-class AnalysisResolver_New {
+class AnalysisResolver {
 private:
-  AnalysisResolver_New();  // DO NOT IMPLEMENT
+  AnalysisResolver();  // DO NOT IMPLEMENT
 
 public:
-  AnalysisResolver_New(PMDataManager &P) : PM(P) { }
+  explicit AnalysisResolver(PMDataManager &P) : PM(P) { }
   
   inline PMDataManager &getPMDataManager() { return PM; }
 
@@ -127,6 +127,9 @@ public:
     return ResultPass;
   }
 
+  // Find pass that is implementing PI. Initialize pass for Function F.
+  Pass *findImplPass(Pass *P, const PassInfo *PI, Function &F);
+
   void addAnalysisImplsPair(const PassInfo *PI, Pass *P) {
     std::pair<const PassInfo*, Pass*> pir = std::make_pair(PI,P);
     AnalysisImpls.push_back(pir);
@@ -137,7 +140,7 @@ public:
 
   // AnalysisImpls - This keeps track of which passes implements the interfaces
   // that are required by the current pass (to implement getAnalysis()).
-  // NOTE : Remove AnalysisImpls from class Pass, when AnalysisResolver_New
+  // NOTE : Remove AnalysisImpls from class Pass, when AnalysisResolver
   // replaces AnalysisResolver
   std::vector<std::pair<const PassInfo*, Pass*> > AnalysisImpls;
 
@@ -146,39 +149,6 @@ private:
   PMDataManager &PM;
 };
 
-//===----------------------------------------------------------------------===//
-// AnalysisResolver - Simple interface implemented by PassManager objects that
-// is used to pull analysis information out of them.
-//
-struct AnalysisResolver {
-  virtual ~AnalysisResolver();
-  virtual Pass *getAnalysisOrNullUp(AnalysisID ID) const = 0;
-  virtual Pass *getAnalysisOrNullDown(AnalysisID ID) const = 0;
-  virtual void addPass(ImmutablePass *IP, AnalysisUsage &AU) = 0;
-  Pass *getAnalysis(AnalysisID ID) const {
-    Pass *Result = getAnalysisOrNullUp(ID);
-    assert(Result && "Pass has an incorrect analysis uses set!");
-    return Result;
-  }
-
-  // getAnalysisToUpdate - Return an analysis result or null if it doesn't exist
-  Pass *getAnalysisToUpdate(AnalysisID ID) const {
-    return getAnalysisOrNullUp(ID);
-  }
-
-  // Methods for introspecting into pass manager objects...
-  virtual unsigned getDepth() const = 0;
-  virtual unsigned getNumContainedPasses() const = 0;
-  virtual const Pass *getContainedPass(unsigned N) const = 0;
-
-  virtual void markPassUsed(AnalysisID P, Pass *User) = 0;
-
-  void startPass(Pass *P) {}
-  void endPass(Pass *P) {}
-protected:
-  void setAnalysisResolver(Pass *P, AnalysisResolver *AR);
-};
-
 /// getAnalysisToUpdate<AnalysisType>() - This function is used by subclasses
 /// to get to the analysis information that might be around that needs to be
 /// updated.  This is different than getAnalysis in that it can fail (ie the
@@ -190,9 +160,77 @@ protected:
 template<typename AnalysisType>
 AnalysisType *Pass::getAnalysisToUpdate() const {
   assert(Resolver && "Pass not resident in a PassManager object!");
+
   const PassInfo *PI = getClassPassInfo<AnalysisType>();
   if (PI == 0) return 0;
-  return dynamic_cast<AnalysisType*>(Resolver->getAnalysisToUpdate(PI));
+  return dynamic_cast<AnalysisType*>
+    (Resolver->getAnalysisToUpdate(PI, true));
+}
+
+/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
+/// to the analysis information that they claim to use by overriding the
+/// getAnalysisUsage function.
+///
+template<typename AnalysisType>
+AnalysisType &Pass::getAnalysis() const {
+  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
+
+  return getAnalysisID<AnalysisType>(getClassPassInfo<AnalysisType>());
+}
+
+template<typename AnalysisType>
+AnalysisType &Pass::getAnalysisID(const PassInfo *PI) const {
+  assert(PI && "getAnalysis for unregistered pass!");
+  assert(Resolver&&"Pass has not been inserted into a PassManager object!");
+  // 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 = Resolver->findImplPass(PI);
+  assert (ResultPass && 
+          "getAnalysis*() called on an analysis that was not "
+          "'required' by pass!");
+
+  // 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;
+}
+
+/// getAnalysis<AnalysisType>() - This function is used by subclasses to get
+/// to the analysis information that they claim to use by overriding the
+/// getAnalysisUsage function.
+///
+template<typename AnalysisType>
+AnalysisType &Pass::getAnalysis(Function &F) {
+  assert(Resolver &&"Pass has not been inserted into a PassManager object!");
+
+  return getAnalysisID<AnalysisType>(getClassPassInfo<AnalysisType>(), F);
+}
+
+template<typename AnalysisType>
+AnalysisType &Pass::getAnalysisID(const PassInfo *PI, Function &F) {
+  assert(PI && "getAnalysis for unregistered pass!");
+   assert(Resolver&&"Pass has not been inserted into a PassManager object!");
+   // 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 = Resolver->findImplPass(this, PI, F);
+   assert (ResultPass && 
+           "getAnalysis*() called on an analysis that was not "
+           "'required' by pass!");
+ 
+   // 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;
 }
 
 } // End llvm namespace