diff options
Diffstat (limited to 'include/llvm/Pass.h')
| -rw-r--r-- | include/llvm/Pass.h | 155 |
1 files changed, 15 insertions, 140 deletions
diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h index 097fc34..2cf85d4 100644 --- a/include/llvm/Pass.h +++ b/include/llvm/Pass.h @@ -13,6 +13,10 @@ // global optimizations should derive from FunctionPass, because they do not add // or delete functions, they operate on the internals of the function. // +// Note that this file #includes PassSupport.h and PassAnalysisSupport.h (at the +// bottom), so the APIs exposed by these files are also automatically available +// to all users of this file. +// //===----------------------------------------------------------------------===// #ifndef LLVM_PASS_H @@ -26,6 +30,7 @@ class Function; class Module; class AnalysisUsage; class AnalysisID; +class PassInfo; template<class UnitType> class PassManagerT; struct AnalysisResolver; @@ -38,8 +43,8 @@ class Pass { friend class AnalysisResolver; AnalysisResolver *Resolver; // AnalysisResolver this pass is owned by... public: - inline Pass(AnalysisResolver *AR = 0) : Resolver(AR) {} - inline virtual ~Pass() {} // Destructor is virtual so we can be subclassed + Pass(AnalysisResolver *AR = 0) : Resolver(AR) {} + virtual ~Pass() {} // Destructor is virtual so we can be subclassed // getPassName - Return a nice clean name for a pass. This should be // overloaded by the pass, but if it is not, C++ RTTI will be consulted to get @@ -47,6 +52,10 @@ public: // virtual const char *getPassName() const; + // getPassInfo - Return the PassInfo data structure that corresponds to this + // pass... + const PassInfo *getPassInfo() const; + // run - Run this pass, returning true if a modification was made to the // module argument. This should be implemented by all concrete subclasses. // @@ -186,144 +195,10 @@ private: virtual void addToPassManager(PassManagerT<BasicBlock> *PM,AnalysisUsage &AU); }; - -// CreatePass - Helper template to invoke the constructor for the AnalysisID -// class. Note that this should be a template internal to AnalysisID, but -// GCC 2.95.3 crashes if we do that, doh. -// -template<class AnalysisType> -static Pass *CreatePass(AnalysisID ID) { return new AnalysisType(ID); } - -//===----------------------------------------------------------------------===// -// AnalysisID - This class is used to uniquely identify an analysis pass that -// is referenced by a transformation. -// -class AnalysisID { - static unsigned NextID; // Next ID # to deal out... - unsigned ID; // Unique ID for this analysis - Pass *(*Constructor)(AnalysisID); // Constructor to return the Analysis - - AnalysisID(); // Disable default ctor - AnalysisID(unsigned id, Pass *(*Ct)(AnalysisID)) : ID(id), Constructor(Ct) {} -public: - // create - the only way to define a new AnalysisID. This static method is - // supposed to be used to define the class static AnalysisID's that are - // provided by analysis passes. In the implementation (.cpp) file for the - // class, there should be a line that looks like this (using CallGraph as an - // example): - // - // AnalysisID CallGraph::ID(AnalysisID::create<CallGraph>()); - // - template<class AnalysisType> - static AnalysisID create() { - return AnalysisID(NextID++, CreatePass<AnalysisType>); - } - - // Special Copy Constructor - This is how analysis passes declare that they - // only depend on the CFG of the function they are working on, so they are not - // invalidated by other passes that do not modify the CFG. This should be - // used like this: - // AnalysisID DominatorSet::ID(AnalysisID::create<DominatorSet>(), true); - // - AnalysisID(const AnalysisID &AID, bool DependsOnlyOnCFG = false); - - - inline Pass *createPass() const { return Constructor(*this); } - - inline bool operator==(const AnalysisID &A) const { - return A.ID == ID; - } - inline bool operator!=(const AnalysisID &A) const { - return A.ID != ID; - } - inline bool operator<(const AnalysisID &A) const { - return ID < A.ID; - } -}; - -//===----------------------------------------------------------------------===// -// 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 -// results of these analyses). This information is provided by a pass to the -// Pass infrastructure through the getAnalysisUsage virtual function. +// Include support files that contain important APIs commonly used by Passes, +// but that we want to seperate out to make it easier to read the header files. // -class AnalysisUsage { - // Sets of analyses required and preserved by a pass - std::vector<AnalysisID> Required, Preserved, Provided; - bool PreservesAll; -public: - AnalysisUsage() : PreservesAll(false) {} - - // addRequires - Add the specified ID to the required set of the usage info - // for a pass. - // - AnalysisUsage &addRequired(AnalysisID ID) { - Required.push_back(ID); - return *this; - } - - // addPreserves - Add the specified ID to the set of analyses preserved by - // this pass - // - AnalysisUsage &addPreserved(AnalysisID ID) { - Preserved.push_back(ID); - return *this; - } - - void addProvided(AnalysisID ID) { - Provided.push_back(ID); - } - - // PreservesAll - 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 to 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(); - - const std::vector<AnalysisID> &getRequiredSet() const { return Required; } - const std::vector<AnalysisID> &getPreservedSet() const { return Preserved; } - const std::vector<AnalysisID> &getProvidedSet() const { return Provided; } -}; - - - -//===----------------------------------------------------------------------===// -// AnalysisResolver - Simple interface implemented by PassManagers objects that -// is used to pull analysis information out of them. -// -struct AnalysisResolver { - virtual Pass *getAnalysisOrNullUp(AnalysisID ID) const = 0; - virtual Pass *getAnalysisOrNullDown(AnalysisID ID) const = 0; - Pass *getAnalysis(AnalysisID ID) { - 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 *Result = getAnalysisOrNullUp(ID); - return Result; - } - - virtual unsigned getDepth() const = 0; - - virtual void markPassUsed(AnalysisID P, Pass *User) = 0; - - void startPass(Pass *P) {} - void endPass(Pass *P) {} -protected: - void setAnalysisResolver(Pass *P, AnalysisResolver *AR); -}; +#include "llvm/PassSupport.h" +#include "llvm/PassAnalysisSupport.h" #endif |