From d30efaf56ed1e374240b4c2fe2ea7054cbd7cb52 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 28 Apr 2002 20:46:05 +0000 Subject: * 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, 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 --- include/llvm/Pass.h | 19 +++++++++++++------ include/llvm/PassManager.h | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+), 6 deletions(-) create mode 100644 include/llvm/PassManager.h (limited to 'include/llvm') 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 PassManagerT; struct AnalysisResolver; -// PassManager - Top level PassManagerT instantiation intended to be used. -// Implemented in PassManager.h -typedef PassManagerT 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; friend class PassManagerT; 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 PassManagerT; + +class PassManager { + PassManagerT *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 -- cgit v1.1