Changes in directory llvm/lib/VMCore:
PassManagerT.h updated: 1.61 -> 1.62 --- Log message: Saem's patch #5 of the passmanager refactoring --- Diffs of the changes: (+93 -47) PassManagerT.h | 140 +++++++++++++++++++++++++++++++++++++-------------------- 1 files changed, 93 insertions(+), 47 deletions(-) Index: llvm/lib/VMCore/PassManagerT.h diff -u llvm/lib/VMCore/PassManagerT.h:1.61 llvm/lib/VMCore/PassManagerT.h:1.62 --- llvm/lib/VMCore/PassManagerT.h:1.61 Tue Jan 3 22:36:11 2006 +++ llvm/lib/VMCore/PassManagerT.h Tue Jan 3 23:02:04 2006 @@ -136,6 +136,7 @@ // template<typename UnitType> class PassManagerT : public PassManagerTraits<UnitType>,public AnalysisResolver{ + // TODO:Edit these to reflect changes for world sanitisation typedef PassManagerTraits<UnitType> Traits; typedef typename Traits::PassClass PassClass; typedef typename Traits::SubPassClass SubPassClass; @@ -146,11 +147,17 @@ friend PassClass; friend SubPassClass; #else + // TODO:Redefine when sanitising friend class PassManagerTraits<UnitType>::PassClass; friend class PassManagerTraits<UnitType>::SubPassClass; #endif + // TODO:Redefine this when santising friend class PassManagerTraits<UnitType>; friend class ImmutablePass; + + friend class BasicBlockPassManager; + friend class FunctionPassManagerT; + friend class ModulePassManager; std::vector<PassClass*> Passes; // List of passes to run std::vector<ImmutablePass*> ImmutablePasses; // List of immutable passes @@ -621,6 +628,8 @@ IP->initializePass(); } + // TODO: Once the world has been sanitised, the pure virtuals below can be + // brought in. }; @@ -653,6 +662,13 @@ // PMType - The type of the passmanager that subclasses this class typedef PassManagerT<BasicBlock> PMType; + + // runPass - Specify how the pass should be run on the UnitType + static bool runPass(PassClass *P, BasicBlock *M) { + // todo, init and finalize + return P->runOnBasicBlock(*M); + } + virtual ~BasicBlockPassManager() {} // getPMName() - Return the name of the unit the PassManager operates on for @@ -661,10 +677,15 @@ virtual const char *getPassName() const { return "BasicBlock Pass Manager"; } + virtual bool doInitialization(Module &M); + virtual bool doInitialization(Function &F); virtual bool runOnBasicBlock(BasicBlock &BB); + virtual bool doFinalization(Function &F); + virtual bool doFinalization(Module &M); - - // TODO:Start absorbing PassManagerTraits<BasicBlock> + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } }; @@ -679,29 +700,42 @@ public: // runPass - Specify how the pass should be run on the UnitType static bool runPass(PassClass *P, BasicBlock *M) { - // todo, init and finalize - return P->runOnBasicBlock(*M); + return BasicBlockPassManager::runPass(P,M); } - // Implement the BasicBlockPass interface... - virtual bool doInitialization(Module &M); - virtual bool doInitialization(Function &F); + // Forwarded + virtual bool doInitialization(Module &M) { + return BasicBlockPassManager::doInitialization(M); + } + + // Forwarded + virtual bool doInitialization(Function &F) { + return BasicBlockPassManager::doInitialization(F); + } // Forwarded virtual bool runOnBasicBlock(BasicBlock &BB) { return BasicBlockPassManager::runOnBasicBlock(BB); } - virtual bool doFinalization(Function &F); - virtual bool doFinalization(Module &M); + // Forwarded + virtual bool doFinalization(Function &F) { + return BasicBlockPassManager::doFinalization(F); + } + + // Forwarded + virtual bool doFinalization(Module &M) { + return BasicBlockPassManager::doFinalization(M); + } // Forwarded virtual const char *getPassName() const { return BasicBlockPassManager::getPassName(); } + // Forwarded virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); + BasicBlockPassManager::getAnalysisUsage(AU); } }; @@ -740,8 +774,18 @@ virtual bool runOnFunction(Function &F); + virtual bool doInitialization(Module &M); + + virtual bool doFinalization(Module &M); - // TODO:Start absorbing PassManagerTraits<Function> + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } + + // runPass - Specify how the pass should be run on the UnitType + static bool runPass(PassClass *P, Function *F) { + return P->runOnFunction(*F); + } }; @@ -756,21 +800,27 @@ public: // runPass - Specify how the pass should be run on the UnitType static bool runPass(PassClass *P, Function *F) { - return P->runOnFunction(*F); + return FunctionPassManagerT::runPass(P,F); } - // Implement the FunctionPass interface... - virtual bool doInitialization(Module &M); + // Forwarded + virtual bool doInitialization(Module &M) { + return FunctionPassManagerT::doInitialization(M); + } // Forwarded virtual bool runOnFunction(Function &F) { return FunctionPassManagerT::runOnFunction(F); } - virtual bool doFinalization(Module &M); + // Forwarded + virtual bool doFinalization(Module &M) { + return FunctionPassManagerT::doFinalization(M); + } + // Forwarded virtual void getAnalysisUsage(AnalysisUsage &AU) const { - AU.setPreservesAll(); + FunctionPassManagerT::getAnalysisUsage(AU); } // Forwarded @@ -811,7 +861,9 @@ // runOnModule - Implement the PassManager interface. virtual bool runOnModule(Module &M); - // TODO:Start absorbing PassManagerTraits<Module> + // runPass - Specify how the pass should be run on the UnitType + static bool runPass(PassClass *P, Module *M) { return P->runOnModule(*M); } + }; @@ -823,8 +875,10 @@ template<> class PassManagerTraits<Module> : public ModulePass, public ModulePassManager { public: - // runPass - Specify how the pass should be run on the UnitType - static bool runPass(PassClass *P, Module *M) { return P->runOnModule(*M); } + // Forwarded + static bool runPass(PassClass *P, Module *M) { + return ModulePassManager::runPass(P,M); + } // Forwarded bool runOnModule(Module &M) { @@ -849,71 +903,63 @@ return ((PMType*)this)->runOnUnit(&BB); } -// FunctionPassManagerT Implementations -// - -inline bool FunctionPassManagerT::runOnFunction(Function &F) { - return ((PMType*)this)->runOnUnit(&F); -} - -// ModulePassManager Implementations -// - -bool ModulePassManager::runOnModule(Module &M) { - return ((PassManagerT<Module>*)this)->runOnUnit(&M); -} - -//===----------------------------------------------------------------------===// -// PassManagerTraits Method Implementations -// - -// PassManagerTraits<BasicBlock> Implementations -// -inline bool PassManagerTraits<BasicBlock>::doInitialization(Module &M) { +inline bool BasicBlockPassManager::doInitialization(Module &M) { bool Changed = false; for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i) ((PMType*)this)->Passes[i]->doInitialization(M); return Changed; } -inline bool PassManagerTraits<BasicBlock>::doInitialization(Function &F) { +inline bool BasicBlockPassManager::doInitialization(Function &F) { bool Changed = false; for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i) ((PMType*)this)->Passes[i]->doInitialization(F); return Changed; } -inline bool PassManagerTraits<BasicBlock>::doFinalization(Function &F) { +inline bool BasicBlockPassManager::doFinalization(Function &F) { bool Changed = false; for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i) ((PMType*)this)->Passes[i]->doFinalization(F); return Changed; } -inline bool PassManagerTraits<BasicBlock>::doFinalization(Module &M) { +inline bool BasicBlockPassManager::doFinalization(Module &M) { bool Changed = false; for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i) ((PMType*)this)->Passes[i]->doFinalization(M); return Changed; } - -// PassManagerTraits<Function> Implementations +// FunctionPassManagerT Implementations // -inline bool PassManagerTraits<Function>::doInitialization(Module &M) { + +inline bool FunctionPassManagerT::runOnFunction(Function &F) { + return ((PMType*)this)->runOnUnit(&F); +} + +inline bool FunctionPassManagerT::doInitialization(Module &M) { bool Changed = false; for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i) ((PMType*)this)->Passes[i]->doInitialization(M); return Changed; } -inline bool PassManagerTraits<Function>::doFinalization(Module &M) { +inline bool FunctionPassManagerT::doFinalization(Module &M) { bool Changed = false; for (unsigned i = 0, e = ((PMType*)this)->Passes.size(); i != e; ++i) ((PMType*)this)->Passes[i]->doFinalization(M); return Changed; } +// ModulePassManager Implementations +// + +bool ModulePassManager::runOnModule(Module &M) { + return ((PassManagerT<Module>*)this)->runOnUnit(&M); +} + + } // End llvm namespace #endif _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits