X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassAnalysisSupport.h;h=892d203ba3ac980c58936aa1e0b68fe18dcfb2f5;hb=c0ac317f93bef323437d791e4ef5a97f36d50515;hp=f04b4a6b468ce8e0fb0d562185ad36168cae376e;hpb=5791bb70b12dfce83e2fcd3857af5a5c7fe9782e;p=oota-llvm.git

diff --git a/include/llvm/PassAnalysisSupport.h b/include/llvm/PassAnalysisSupport.h
index f04b4a6b468..892d203ba3a 100644
--- a/include/llvm/PassAnalysisSupport.h
+++ b/include/llvm/PassAnalysisSupport.h
@@ -1,4 +1,11 @@
-//===- llvm/PassAnalysisSupport.h - Analysis Pass Support code ---*- C++ -*-==//
+//===- llvm/PassAnalysisSupport.h - Analysis Pass Support code --*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
 //
 // This file defines stuff that is used to define and "use" Analysis Passes.
 // This file is automatically #included by Pass.h, so:
@@ -12,24 +19,27 @@
 #ifndef LLVM_PASS_ANALYSIS_SUPPORT_H
 #define LLVM_PASS_ANALYSIS_SUPPORT_H
 
-// No need to include Pass.h, we are being included by it!
+#include <vector>
 
+namespace llvm {
 
+// No need to include Pass.h, we are being included by it!
 
 //===----------------------------------------------------------------------===//
 // AnalysisUsage - Represent the analysis usage information of a pass.  This
-// tracks analyses that the pass REQUIRES (must available when the pass runs),
-// and analyses that the pass PRESERVES (the pass does not invalidate the
+// tracks analyses that the pass REQUIRES (must be available when the pass
+// runs), REQUIRES TRANSITIVE (must be available throughout the lifetime of the
+// pass), and analyses that the pass PRESERVES (the pass does not invalidate the
 // results of these analyses).  This information is provided by a pass to the
 // Pass infrastructure through the getAnalysisUsage virtual function.
 //
 class AnalysisUsage {
   // Sets of analyses required and preserved by a pass
-  std::vector<AnalysisID> Required, Preserved;
+  std::vector<AnalysisID> Required, RequiredTransitive, Preserved;
   bool PreservesAll;
 public:
   AnalysisUsage() : PreservesAll(false) {}
-  
+
   // addRequired - Add the specified ID to the required set of the usage info
   // for a pass.
   //
@@ -39,7 +49,17 @@ public:
   }
   template<class PassClass>
   AnalysisUsage &addRequired() {
-    Required.push_back(PassClass::ID);
+    assert(Pass::getClassPassInfo<PassClass>() && "Pass class not registered!");
+    Required.push_back(Pass::getClassPassInfo<PassClass>());
+    return *this;
+  }
+
+  template<class PassClass>
+  AnalysisUsage &addRequiredTransitive() {
+    AnalysisID ID = Pass::getClassPassInfo<PassClass>();
+    assert(ID && "Pass class not registered!");
+    Required.push_back(ID);
+    RequiredTransitive.push_back(ID);
     return *this;
   }
 
@@ -53,25 +73,30 @@ public:
 
   template<class PassClass>
   AnalysisUsage &addPreserved() {
-    Preserved.push_back(PassClass::ID);
+    assert(Pass::getClassPassInfo<PassClass>() && "Pass class not registered!");
+    Preserved.push_back(Pass::getClassPassInfo<PassClass>());
     return *this;
   }
 
   // setPreservesAll - Set by analyses that do not transform their input at all
   void setPreservesAll() { PreservesAll = true; }
-  bool preservesAll() const { return PreservesAll; }
-
-  // preservesCFG - This function should be called by the pass, iff they do not:
-  //
-  //  1. Add or remove basic blocks from the function
-  //  2. Modify terminator instructions in any way.
-  //
-  // This function annotates the AnalysisUsage info object to say that analyses
-  // that only depend on the CFG are preserved by this pass.
-  //
-  void preservesCFG();
+  bool getPreservesAll() const { return PreservesAll; }
+
+  /// setPreservesCFG - This function should be called by the pass, iff they do
+  /// not:
+  ///
+  ///  1. Add or remove basic blocks from the function
+  ///  2. Modify terminator instructions in any way.
+  ///
+  /// This function annotates the AnalysisUsage info object to say that analyses
+  /// that only depend on the CFG are preserved by this pass.
+  ///
+  void setPreservesCFG();
 
   const std::vector<AnalysisID> &getRequiredSet() const { return Required; }
+  const std::vector<AnalysisID> &getRequiredTransitiveSet() const {
+    return RequiredTransitive;
+  }
   const std::vector<AnalysisID> &getPreservedSet() const { return Preserved; }
 };
 
@@ -82,16 +107,18 @@ public:
 // 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;
-  Pass *getAnalysis(AnalysisID ID) {
+  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) {
+  Pass *getAnalysisToUpdate(AnalysisID ID) const {
     return getAnalysisOrNullUp(ID);
   }
 
@@ -108,4 +135,22 @@ 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
+/// analysis results haven't been computed), so should only be used if you
+/// provide the capability to update an analysis that exists.  This method is
+/// often used by transformation APIs to update analysis results for a pass
+/// automatically as the transform is performed.
+///
+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));
+}
+
+} // End llvm namespace
+
 #endif