//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
+// This file was developed by Devang Patel and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/PassManager.h"
-#include "llvm/Function.h"
#include "llvm/Module.h"
using namespace llvm;
+namespace llvm {
+
+/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
+/// pass together and sequence them to process one basic block before
+/// processing next basic block.
+class BasicBlockPassManager_New : public Pass,
+ public PassManagerAnalysisHelper {
+
+public:
+ BasicBlockPassManager_New() { }
+
+ /// Add a pass into a passmanager queue.
+ bool addPass(Pass *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 runOnFunction(Function &F);
+
+private:
+ // Collection of pass that are managed by this manager
+ std::vector<Pass *> PassVector;
+};
+
+/// 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 FunctionPassManagerImpl_New : public Pass,
+ public PassManagerAnalysisHelper {
+public:
+ FunctionPassManagerImpl_New(ModuleProvider *P) { /* TODO */ }
+ FunctionPassManagerImpl_New() {
+ activeBBPassManager = NULL;
+ }
+ ~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
+ /// 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 add(Pass *P) { /* TODO*/ }
+
+ /// Add pass into the pass manager queue.
+ bool addPass(Pass *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 runOnModule(Module &M);
+
+private:
+ // Collection of pass that are manged by this manager
+ std::vector<Pass *> PassVector;
+
+ // Active Pass Managers
+ BasicBlockPassManager_New *activeBBPassManager;
+};
+
+/// ModulePassManager_New manages ModulePasses and function pass managers.
+/// It batches all Module passes passes and function pass managers together and
+/// sequence them to process one module.
+class ModulePassManager_New : public Pass,
+ public PassManagerAnalysisHelper {
+
+public:
+ ModulePassManager_New() { activeFunctionPassManager = NULL; }
+
+ /// Add a pass into a passmanager queue.
+ bool addPass(Pass *p);
+
+ /// run - Execute all of the passes scheduled for execution. Keep track of
+ /// whether any of the passes modifies the module, and if so, return true.
+ bool runOnModule(Module &M);
+
+private:
+ // Collection of pass that are managed by this manager
+ std::vector<Pass *> PassVector;
+
+ // Active Pass Manager
+ FunctionPassManagerImpl_New *activeFunctionPassManager;
+};
+
+/// PassManager_New manages ModulePassManagers
+class PassManagerImpl_New : public Pass,
+ public PassManagerAnalysisHelper {
+
+public:
+
+ /// add - Add a pass to the queue of passes to run. This passes ownership of
+ /// the Pass to the PassManager. When the PassManager is destroyed, the pass
+ /// will be destroyed as well, so there is no need to delete the pass. This
+ /// implies that all passes MUST be allocated with 'new'.
+ void add(Pass *P);
+
+ /// run - Execute all of the passes scheduled for execution. Keep track of
+ /// whether any of the passes modifies the module, and if so, return true.
+ bool run(Module &M);
+
+private:
+
+ /// Add a pass into a passmanager queue. This is used by schedulePasses
+ bool addPass(Pass *p);
+
+ /// Schedule all passes collected in pass queue using add(). Add all the
+ /// schedule passes into various manager's queue using addPass().
+ void schedulePasses();
+
+ // Collection of pass managers
+ std::vector<ModulePassManager_New *> PassManagers;
+
+ // Collection of pass that are not yet scheduled
+ std::vector<Pass *> PassVector;
+
+ // Active Pass Manager
+ ModulePassManager_New *activeManager;
+};
+
+} // End of llvm namespace
+
// PassManagerAnalysisHelper implementation
-/// Return TRUE IFF pass P's required analysis set does not required new
+/// Return true IFF pass P's required analysis set does not required new
/// manager.
bool PassManagerAnalysisHelper::manageablePass(Pass *P) {
return true;
}
-/// Return TRUE iff AnalysisID AID is currently available.
+/// Return true IFF AnalysisID AID is currently available.
bool PassManagerAnalysisHelper::analysisCurrentlyAvailable(AnalysisID AID) {
// TODO
/// BasicBlockPassManager implementation
-/// Add pass P into PassVector and return TRUE. If this pass is not
-/// manageable by this manager then return FALSE.
+/// Add pass P into PassVector and return true. If this pass is not
+/// manageable by this manager then return false.
bool
-BasicBlockPassManager_New::addPass (Pass *P) {
+BasicBlockPassManager_New::addPass(Pass *P) {
BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
if (!BP)
return false;
- // TODO: Check if it suitable to manage P using this BasicBlockPassManager
- // or we need another instance of BasicBlockPassManager
+ // If this pass does not preserve anlysis that is used by other passes
+ // managed by this manager than it is not a suiable pass for this manager.
+ if (!manageablePass(P))
+ return false;
+
+ // Take a note of analysis required by this pass.
+ noteDownRequiredAnalysis(P);
// Add pass
PassVector.push_back(BP);
}
// 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
/// Add pass P into the pass manager queue. If P is a BasicBlockPass then
/// 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)) {
activeBBPassManager = new BasicBlockPassManager_New();
PassVector.push_back(activeBBPassManager);
- assert (!activeBBPassManager->addPass(BP) &&
- "Unable to add Pass");
+ if (!activeBBPassManager->addPass(BP))
+ assert(0 && "Unable to add Pass");
}
return true;
}
if (!FP)
return false;
- // TODO: Check if it suitable to manage P using this FunctionPassManager
- // or we need another instance of FunctionPassManager
+ // If this pass does not preserve anlysis that is used by other passes
+ // managed by this manager than it is not a suiable pass for this manager.
+ if (!manageablePass(P))
+ return false;
+
+ // Take a note of analysis required by this pass.
+ noteDownRequiredAnalysis(P);
PassVector.push_back(FP);
activeBBPassManager = NULL;
/// 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) {
+ModulePassManager_New::addPass(Pass *P) {
// If P is FunctionPass then use function pass maanager.
if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) {
if (!activeFunctionPassManager
|| !activeFunctionPassManager->addPass(P)) {
- activeFunctionPassManager = new FunctionPassManager_New();
+ activeFunctionPassManager = new FunctionPassManagerImpl_New();
PassVector.push_back(activeFunctionPassManager);
- assert (!activeFunctionPassManager->addPass(FP) &&
- "Unable to add Pass");
+ if (!activeFunctionPassManager->addPass(FP))
+ assert(0 && "Unable to add pass");
}
return true;
}
if (!MP)
return false;
- // TODO: Check if it suitable to manage P using this ModulePassManager
- // or we need another instance of ModulePassManager
+ // If this pass does not preserve anlysis that is used by other passes
+ // managed by this manager than it is not a suiable pass for this manager.
+ if (!manageablePass(P))
+ return false;
+
+ // Take a note of analysis required by this pass.
+ noteDownRequiredAnalysis(P);
PassVector.push_back(MP);
activeFunctionPassManager = NULL;
/// Schedule all passes from the queue by adding them in their
/// respective manager's queue.
void
-PassManager_New::schedulePasses() {
+PassManagerImpl_New::schedulePasses() {
/* TODO */
}
/// Add pass P to the queue of passes to run.
void
-PassManager_New::add(Pass *P) {
+PassManagerImpl_New::add(Pass *P) {
/* TODO */
}
/// Add P into active pass manager or use new module pass manager to
/// manage it.
bool
-PassManager_New::addPass (Pass *P) {
+PassManagerImpl_New::addPass(Pass *P) {
if (!activeManager) {
activeManager = new ModulePassManager_New();
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
bool
-PassManager_New::run(Module &M) {
+PassManagerImpl_New::run(Module &M) {
schedulePasses();
bool Changed = false;
}
return Changed;
}
+
+/// Create new pass manager
+PassManager_New::PassManager_New() {
+ PM = new PassManagerImpl_New();
+}
+
+/// add - Add a pass to the queue of passes to run. This passes ownership of
+/// the Pass to the PassManager. When the PassManager is destroyed, the pass
+/// will be destroyed as well, so there is no need to delete the pass. This
+/// implies that all passes MUST be allocated with 'new'.
+void
+PassManager_New::add(Pass *P) {
+ PM->add(P);
+}
+
+/// run - Execute all of the passes scheduled for execution. Keep track of
+/// whether any of the passes modifies the module, and if so, return true.
+bool
+PassManager_New::run(Module &M) {
+ return PM->run(M);
+}
+
projects / oota-llvm.git / blobdiff