Remove the reverse iterators for arguments and global vars.

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

diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h
index 8a10ead35ef828149f817c13a3b78c7068605216..e6083a3ca88b0f6f0014617124cda4c17e11c881 100644 (file)
--- a/include/llvm/Pass.h
+++ b/include/llvm/Pass.h
@@ -56,7 +56,7 @@ typedef const PassInfo* AnalysisID;
 /// constrained passes described below.
 ///
 class Pass {
-  friend class AnalysisResolver;
+  friend struct AnalysisResolver;
   AnalysisResolver *Resolver;  // AnalysisResolver this pass is owned by...
   const PassInfo *PassInfoCache;
 
@@ -84,10 +84,11 @@ public:
   ///
   const PassInfo *getPassInfo() const;
 
-  /// run - Run this pass, returning true if a modification was made to the
+  /// runPass - Run this pass, returning true if a modification was made to the
   /// module argument.  This should be implemented by all concrete subclasses.
   ///
-  virtual bool run(Module &M) = 0;
+  virtual bool runPass(Module &M) { return false; }
+  virtual bool runPass(BasicBlock&) { return false; }
 
   /// print - Print out the internal state of the pass.  This is called by
   /// Analyze to print out the contents of an analysis.  Otherwise it is not
@@ -96,8 +97,7 @@ public:
   /// provide the Module* in case the analysis doesn't need it it can just be
   /// ignored.
   ///
-  virtual void print(std::ostream &O, const Module *M) const { print(O); }
-  virtual void print(std::ostream &O) const;
+  virtual void print(std::ostream &O, const Module *M) const;
   void dump() const; // dump - call print(std::cerr, 0);
 
 
@@ -178,7 +178,7 @@ public:
     Pass *ResultPass = 0;
     for (unsigned i = 0; ; ++i) {
       assert(i != AnalysisImpls.size() &&
-             "getAnalysis*() called on an analysis that we not "
+             "getAnalysis*() called on an analysis that was not "
              "'required' by pass!");
       if (AnalysisImpls[i].first == PI) {
         ResultPass = AnalysisImpls[i].second;
@@ -200,13 +200,28 @@ private:
   friend class PassManagerT<Module>;
   friend class PassManagerT<Function>;
   friend class PassManagerT<BasicBlock>;
-  virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU);
 };
 
 inline std::ostream &operator<<(std::ostream &OS, const Pass &P) {
   P.print(OS, 0); return OS;
 }
 
+//===----------------------------------------------------------------------===//
+/// ModulePass class - This class is used to implement unstructured
+/// interprocedural optimizations and analyses.  ModulePass's may do anything
+/// they want to the program.
+///
+class ModulePass : public Pass {
+public:
+  /// runOnModule - Virtual method overriden by subclasses to process the module
+  /// being operated on.
+  virtual bool runOnModule(Module &M) = 0;
+
+  virtual bool runPass(Module &M) { return runOnModule(M); }
+  virtual bool runPass(BasicBlock&) { return false; }
+
+  virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU);
+};
 
 
 //===----------------------------------------------------------------------===//
@@ -214,7 +229,8 @@ inline std::ostream &operator<<(std::ostream &OS, const Pass &P) {
 /// not need to be run.  This is useful for things like target information and
 /// "basic" versions of AnalysisGroups.
 ///
-struct ImmutablePass : public Pass {
+class ImmutablePass : public ModulePass {
+public:
   /// initializePass - This method may be overriden by immutable passes to allow
   /// them to perform various initialization actions they require.  This is
   /// primarily because an ImmutablePass can "require" another ImmutablePass,
@@ -225,14 +241,13 @@ struct ImmutablePass : public Pass {
 
   /// ImmutablePasses are never run.
   ///
-  virtual bool run(Module &M) { return false; }
+  virtual bool runOnModule(Module &M) { return false; }
 
 private:
   friend class PassManagerT<Module>;
   virtual void addToPassManager(PassManagerT<Module> *PM, AnalysisUsage &AU);
 };
 
-
 //===----------------------------------------------------------------------===//
 /// FunctionPass class - This class is used to implement most global
 /// optimizations.  Optimizations should subclass this class if they meet the
@@ -242,7 +257,8 @@ private:
 ///  2. Optimizing a function does not cause the addition or removal of any
 ///     functions in the module
 ///
-struct FunctionPass : public Pass {
+class FunctionPass : public ModulePass {
+public:
   /// doInitialization - Virtual method overridden by subclasses to do
   /// any necessary per-module initialization.
   ///
@@ -258,10 +274,11 @@ struct FunctionPass : public Pass {
   ///
   virtual bool doFinalization(Module &M) { return false; }
 
-  /// run - On a module, we run this pass by initializing, ronOnFunction'ing
-  /// once for every function in the module, then by finalizing.
+  /// runOnModule - On a module, we run this pass by initializing,
+  /// ronOnFunction'ing once for every function in the module, then by
+  /// finalizing.
   ///
-  virtual bool run(Module &M);
+  virtual bool runOnModule(Module &M);
 
   /// run - On a function, we simply initialize, run the function, then
   /// finalize.
@@ -323,7 +340,8 @@ struct BasicBlockPass : public FunctionPass {
   /// To run directly on the basic block, we initialize, runOnBasicBlock, then
   /// finalize.
   ///
-  bool run(BasicBlock &BB);
+  virtual bool runPass(Module &M) { return false; }
+  virtual bool runPass(BasicBlock &BB);
 
 private:
   friend class PassManagerT<Function>;
@@ -332,6 +350,11 @@ private:
   virtual void addToPassManager(PassManagerT<BasicBlock> *PM,AnalysisUsage &AU);
 };
 
+/// If the user specifies the -time-passes argument on an LLVM tool command line
+/// then the value of this boolean will be true, otherwise false.
+/// @brief This is the storage for the -time-passes option.
+extern bool TimePassesIsEnabled;
+
 } // End llvm namespace
 
 // Include support files that contain important APIs commonly used by Passes,