* Add a stub to FunctionPass so that subclasses can declare that they do not

  modify the CFG.  It currently does nothing, but will in the future.
* Changes to make the public PassManager.h be MUCH smaller, and devoid of
  implementation details.  Now PassManager is just a Pimpl class that wraps
  PassManagerT<Module>, but lib/VMCore/Pass.cpp is now the only class that
  has to #include PassManagerT.h


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2383 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 49 insertions, 6 deletions

diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h
index 0fcf6b3..251620c 100644
--- a/include/llvm/Pass.h
+++ b/include/llvm/Pass.h
@@ -11,7 +11,7 @@
 // Passes should extend one of the classes below, depending on the guarantees
 // that it can make about what will be modified as it is run.  For example, most
 // global optimizations should derive from FunctionPass, because they do not add
-// or delete functionss, they operate on the internals of the function.
+// or delete functions, they operate on the internals of the function.
 //
 //===----------------------------------------------------------------------===//
 
@@ -26,14 +26,9 @@ class Function;
 class Module;
 class AnalysisUsage;
 class AnalysisID;
-class Pass;
 template<class UnitType> class PassManagerT;
 struct AnalysisResolver;
 
-// PassManager - Top level PassManagerT instantiation intended to be used.
-// Implemented in PassManager.h
-typedef PassManagerT<Module> PassManager;
-
 //===----------------------------------------------------------------------===//
 // Pass interface - Implemented by all 'passes'.  Subclass this if you are an
 // interprocedural optimization or you do not fit into any of the more
@@ -143,6 +138,18 @@ struct FunctionPass : public Pass {
   //
   bool run(Function *F);
 
+protected:
+  // doesNotModifyCFG - This function should be called by our subclasses to
+  // implement the getAnalysisUsage virtual function, 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 doesNotModifyCFG(AnalysisUsage &Info);
+
 private:
   friend class PassManagerT<Module>;
   friend class PassManagerT<Function>;
diff --git a/include/llvm/PassManager.h b/include/llvm/PassManager.h
new file mode 100644
index 0000000..644e30b
--- /dev/null
+++ b/include/llvm/PassManager.h
@@ -0,0 +1,36 @@
+//===- llvm/PassManager.h - Container for Passes -----------------*- C++ -*--=//
+//
+// This file defines the PassManager class.  This class is used to hold,
+// maintain, and optimize execution of Pass's.  The PassManager class ensures
+// that analysis results are available before a pass runs, and that Pass's are
+// destroyed when the PassManager is destroyed.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PASSMANAGER_H
+#define LLVM_PASSMANAGER_H
+
+class Pass;
+class Module;
+template<class UnitType> class PassManagerT;
+
+class PassManager {
+  PassManagerT<Module> *PM;    // This is a straightforward Pimpl class
+public:
+  PassManager();
+  ~PassManager();
+
+  // add - Add a pass to the queue of passes to run.  This passes ownership of
+  // the Pass to the PassManager.  When the PassManager is destroyed, the pass
+  // will be destroyed as well, so there is no need to delete the pass.  This
+  // implies that all passes MUST be allocated with 'new'.
+  //
+  void add(Pass *P);
+
+  // run - Execute all of the passes scheduled for execution.  Keep track of
+  // whether any of the functions modifies the program, and if so, return true.
+  //
+  bool run(Module *M);
+};
+
+#endif