std::vector<Pass *> PassVector;
};
-/// FunctionPassManager_New manages FunctionPasses and BasicBlockPassManagers.
+/// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers.
/// It batches all function passes and basic block pass managers together and
/// sequence them to process one function at a time before processing next
/// function.
-class FunctionPassManager_New : public Pass,
+class FunctionPassManagerImpl_New : public Pass,
public PassManagerAnalysisHelper {
public:
- FunctionPassManager_New(ModuleProvider *P) { /* TODO */ }
- FunctionPassManager_New() {
+ FunctionPassManagerImpl_New(ModuleProvider *P) { /* TODO */ }
+ FunctionPassManagerImpl_New() {
activeBBPassManager = NULL;
}
- ~FunctionPassManager_New() { /* TODO */ };
+ ~FunctionPassManagerImpl_New() { /* TODO */ };
/// add - Add a pass to the queue of passes to run. This passes
/// ownership of the Pass to the PassManager. When the
std::vector<Pass *> PassVector;
// Active Pass Manager
- FunctionPassManager_New *activeFunctionPassManager;
+ FunctionPassManagerImpl_New *activeFunctionPassManager;
};
/// PassManager_New manages ModulePassManagers
}
// FunctionPassManager_New implementation
+/// Create new Function pass manager
+FunctionPassManager_New::FunctionPassManager_New() {
+ FPM = new FunctionPassManagerImpl_New();
+}
+
+/// add - Add a pass to the queue of passes to run. This passes
+/// ownership of the Pass to the PassManager. When the
+/// PassManager_X is destroyed, the pass will be destroyed as well, so
+/// there is no need to delete the pass. (TODO delete passes.)
+/// This implies that all passes MUST be allocated with 'new'.
+void
+FunctionPassManager_New::add(Pass *P) {
+ FPM->add(P);
+}
+
+/// Execute all of the passes scheduled for execution. Keep
+/// track of whether any of the passes modifies the function, and if
+/// so, return true.
+bool
+FunctionPassManager_New::runOnModule(Module &M) {
+ return FPM->runOnModule(M);
+}
+
+// FunctionPassManagerImpl_New implementation
// FunctionPassManager
/// either use it into active basic block pass manager or create new basic
/// block pass manager to handle pass P.
bool
-FunctionPassManager_New::addPass(Pass *P) {
+FunctionPassManagerImpl_New::addPass(Pass *P) {
// If P is a BasicBlockPass then use BasicBlockPassManager_New.
if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) {
/// runOnFunction method. Keep track of whether any of the passes modifies
/// the function, and if so, return true.
bool
-FunctionPassManager_New::runOnModule(Module &M) {
+FunctionPassManagerImpl_New::runOnModule(Module &M) {
bool Changed = false;
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
// ModulePassManager implementation
/// Add P into pass vector if it is manageble. If P is a FunctionPass
-/// then use FunctionPassManager_New to manage it. Return false if P
+/// then use FunctionPassManagerImpl_New to manage it. Return false if P
/// is not manageable by this manager.
bool
ModulePassManager_New::addPass(Pass *P) {
if (!activeFunctionPassManager
|| !activeFunctionPassManager->addPass(P)) {
- activeFunctionPassManager = new FunctionPassManager_New();
+ activeFunctionPassManager = new FunctionPassManagerImpl_New();
PassVector.push_back(activeFunctionPassManager);
if (!activeFunctionPassManager->addPass(FP))