X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;ds=sidebyside;f=include%2Fllvm%2FPass.h;h=9dc8643343def079626982e93392a70a3f70502f;hb=80a75bfae980df96f969f1c05b0c4a80ce975240;hp=d2f717991fa4fa27efaf81684590f7958efe0e21;hpb=4d447f512122a8c3784f4ab2c55b4b1be47db82e;p=oota-llvm.git diff --git a/include/llvm/Pass.h b/include/llvm/Pass.h index d2f717991fa..9dc8643343d 100644 --- a/include/llvm/Pass.h +++ b/include/llvm/Pass.h @@ -29,12 +29,12 @@ #ifndef LLVM_PASS_H #define LLVM_PASS_H +#include "llvm/Support/DataTypes.h" #include "llvm/Support/Streams.h" #include #include #include #include -#include #include namespace llvm { @@ -46,8 +46,6 @@ class Module; class AnalysisUsage; class PassInfo; class ImmutablePass; -class BasicBlockPassManager; -class ModulePassManager; class PMStack; class AnalysisResolver; class PMDataManager; @@ -64,7 +62,8 @@ enum PassManagerType { PMT_CallGraphPassManager, /// CGPassManager PMT_FunctionPassManager, /// FPPassManager PMT_LoopPassManager, /// LPPassManager - PMT_BasicBlockPassManager /// BBPassManager + PMT_BasicBlockPassManager, /// BBPassManager + PMT_Last }; typedef enum PassManagerType PassManagerType; @@ -76,7 +75,7 @@ typedef enum PassManagerType PassManagerType; /// class Pass { AnalysisResolver *Resolver; // Used to resolve analysis - const PassInfo *PassInfoCache; + intptr_t PassID; // AnalysisImpls - This keeps track of which passes implement the interfaces // that are required by the current pass (to implement getAnalysis()). @@ -86,8 +85,9 @@ class Pass { void operator=(const Pass&); // DO NOT IMPLEMENT Pass(const Pass &); // DO NOT IMPLEMENT public: - Pass() : Resolver(0), PassInfoCache(0) {} - virtual ~Pass() {} // Destructor is virtual so we can be subclassed + explicit Pass(intptr_t pid) : Resolver(0), PassID(pid) {} + explicit Pass(const void *pid) : Resolver(0), PassID((intptr_t)pid) {} + virtual ~Pass(); /// getPassName - Return a nice clean name for a pass. This usually /// implemented in terms of the name that is registered by one of the @@ -119,11 +119,27 @@ public: void print(std::ostream *O, const Module *M) const { if (O) print(*O, M); } void dump() const; // dump - call print(std::cerr, 0); + /// Each pass is responsible for assigning a pass manager to itself. + /// PMS is the stack of available pass manager. virtual void assignPassManager(PMStack &PMS, - PassManagerType T = PMT_Unknown) {} + PassManagerType T = PMT_Unknown) {} + /// Check if available pass managers are suitable for this pass or not. + virtual void preparePassManager(PMStack &PMS) {} + + /// Return what kind of Pass Manager can manage this pass. + virtual PassManagerType getPotentialPassManagerType() const { + return PMT_Unknown; + } + // Access AnalysisResolver - inline void setResolver(AnalysisResolver *AR) { Resolver = AR; } - inline AnalysisResolver *getResolver() { return Resolver; } + inline void setResolver(AnalysisResolver *AR) { + assert (!Resolver && "Resolver is already set"); + Resolver = AR; + } + inline AnalysisResolver *getResolver() { + assert (Resolver && "Resolver is not set"); + return Resolver; + } /// getAnalysisUsage - This function should be overriden by passes that need /// analysis information to do their job. If a pass specifies that it uses a @@ -147,17 +163,21 @@ public: /// virtual void releaseMemory() {} + /// verifyAnalysis() - This member can be implemented by a analysis pass to + /// check state of analysis information. + virtual void verifyAnalysis() const {} + // dumpPassStructure - Implement the -debug-passes=PassStructure option virtual void dumpPassStructure(unsigned Offset = 0); template static const PassInfo *getClassPassInfo() { - return lookupPassInfo(typeid(AnalysisClass)); + return lookupPassInfo(intptr_t(&AnalysisClass::ID)); } // lookupPassInfo - Return the pass info object for the specified pass class, // or null if it is not known. - static const PassInfo *lookupPassInfo(const std::type_info &TI); + static const PassInfo *lookupPassInfo(intptr_t TI); /// getAnalysisToUpdate() - This function is used by subclasses /// to get to the analysis information that might be around that needs to be @@ -185,9 +205,14 @@ public: template AnalysisType &getAnalysis() const; // Defined in PassAnalysisSupport.h + template + AnalysisType &getAnalysis(Function &F); // Defined in PassanalysisSupport.h + template AnalysisType &getAnalysisID(const PassInfo *PI) const; - + + template + AnalysisType &getAnalysisID(const PassInfo *PI, Function &F); }; inline std::ostream &operator<<(std::ostream &OS, const Pass &P) { @@ -209,7 +234,15 @@ public: virtual bool runPass(BasicBlock&) { return false; } virtual void assignPassManager(PMStack &PMS, - PassManagerType T = PMT_ModulePassManager); + PassManagerType T = PMT_ModulePassManager); + + /// Return what kind of Pass Manager can manage this pass. + virtual PassManagerType getPotentialPassManagerType() const { + return PMT_ModulePassManager; + } + + explicit ModulePass(intptr_t pid) : Pass(pid) {} + explicit ModulePass(const void *pid) : Pass(pid) {} // Force out-of-line virtual method. virtual ~ModulePass(); }; @@ -232,8 +265,11 @@ public: /// ImmutablePasses are never run. /// - virtual bool runOnModule(Module &M) { return false; } + bool runOnModule(Module &M) { return false; } + explicit ImmutablePass(intptr_t pid) : ModulePass(pid) {} + explicit ImmutablePass(const void *pid) : ModulePass(pid) {} + // Force out-of-line virtual method. virtual ~ImmutablePass(); }; @@ -247,8 +283,11 @@ public: /// 2. Optimizing a function does not cause the addition or removal of any /// functions in the module /// -class FunctionPass : public ModulePass { +class FunctionPass : public Pass { public: + explicit FunctionPass(intptr_t pid) : Pass(pid) {} + explicit FunctionPass(const void *pid) : Pass(pid) {} + /// doInitialization - Virtual method overridden by subclasses to do /// any necessary per-module initialization. /// @@ -276,7 +315,12 @@ public: bool run(Function &F); virtual void assignPassManager(PMStack &PMS, - PassManagerType T = PMT_FunctionPassManager); + PassManagerType T = PMT_FunctionPassManager); + + /// Return what kind of Pass Manager can manage this pass. + virtual PassManagerType getPotentialPassManagerType() const { + return PMT_FunctionPassManager; + } }; @@ -293,6 +337,9 @@ public: /// class BasicBlockPass : public Pass { public: + explicit BasicBlockPass(intptr_t pid) : Pass(pid) {} + explicit BasicBlockPass(const void *pid) : Pass(pid) {} + /// doInitialization - Virtual method overridden by subclasses to do /// any necessary per-module initialization. /// @@ -331,7 +378,12 @@ public: virtual bool runPass(BasicBlock &BB); virtual void assignPassManager(PMStack &PMS, - PassManagerType T = PMT_BasicBlockPassManager); + PassManagerType T = PMT_BasicBlockPassManager); + + /// Return what kind of Pass Manager can manage this pass. + virtual PassManagerType getPotentialPassManagerType() const { + return PMT_BasicBlockPassManager; + } }; /// PMStack