//
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;
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
IP->initializePass();
}
+ // TODO: Once the world has been sanitised, the pure virtuals below can be
+ // brought in.
};
// 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
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();
+ }
};
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);
}
};
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);
+ }
};
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
// 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); }
+
};
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) {
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