Make some methods const. The only interesting change here is that

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

diff --git a/include/llvm/PassAnalysisSupport.h b/include/llvm/PassAnalysisSupport.h
index f8b139ecb1a5b72de12a6f2f5637b450c8df3f04..5864fad0d726c58e14f0bd40935cd304e9214510 100644 (file)
--- a/include/llvm/PassAnalysisSupport.h
+++ b/include/llvm/PassAnalysisSupport.h
@@ -20,11 +20,13 @@
 #define LLVM_PASS_ANALYSIS_SUPPORT_H
 
 #include <vector>
+#include "llvm/Pass.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
-// No need to include Pass.h, we are being included by it!
+class StringRef;
 
 //===----------------------------------------------------------------------===//
 // AnalysisUsage - Represent the analysis usage information of a pass.  This
@@ -79,6 +81,9 @@ public:
     return *this;
   }
 
+  // addPreserved - Add the specified Pass class to the set of analyses
+  // preserved by this pass.
+  //
   template<class PassClass>
   AnalysisUsage &addPreserved() {
     assert(Pass::getClassPassInfo<PassClass>() && "Pass class not registered!");
@@ -86,6 +91,18 @@ public:
     return *this;
   }
 
+  // addPreserved - Add the Pass with the specified argument string to the set
+  // of analyses preserved by this pass. If no such Pass exists, do nothing.
+  // This can be useful when a pass is trivially preserved, but may not be
+  // linked in. Be careful about spelling!
+  //
+  AnalysisUsage &addPreserved(StringRef Arg) {
+    const PassInfo *PI = Pass::lookupPassInfo(Arg);
+    // If the pass exists, preserve it. Otherwise silently do nothing.
+    if (PI) Preserved.push_back(PI);
+    return *this;
+  }
+
   // setPreservesAll - Set by analyses that do not transform their input at all
   void setPreservesAll() { PreservesAll = true; }
   bool getPreservesAll() const { return PreservesAll; }
@@ -143,13 +160,17 @@ public:
     AnalysisImpls.push_back(pir);
   }
 
+  /// clearAnalysisImpls - Clear cache that is used to connect a pass to the
+  /// the analysis (PassInfo).
+  void clearAnalysisImpls() {
+    AnalysisImpls.clear();
+  }
+
   // getAnalysisIfAvailable - Return analysis result or null if it doesn't exist
   Pass *getAnalysisIfAvailable(AnalysisID ID, bool Direction) const;
 
   // 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
-  // replaces AnalysisResolver
   std::vector<std::pair<const PassInfo*, Pass*> > AnalysisImpls;
 
 private:
@@ -222,23 +243,21 @@ AnalysisType &Pass::getAnalysis(Function &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;
+  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 &&  "Unable to find requested analysis info");
+  
+  // 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