6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-21 02:24:22 +00:00
Code Issues Projects Releases Wiki Activity

Add #ifdef switch toggle between old and new pass manager. However,

Browse Source 
continue to use old pass manager at the moment. To use new manager
remove #define USE_OLD_PASSMANAGER 1 from Pass.h


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32525 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Devang Patel
2006-12-13 02:36:01 +00:00
parent 21c362d324
commit 3162691f69
5 changed files with 118 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
lib/VMCore/PassManager.cpp
View File

@ -84,6 +84,7 @@ using namespace llvm;
// ModulePassManagers.
//===----------------------------------------------------------------------===//
#ifndef USE_OLD_PASSMANAGER
namespace llvm {
class PMDataManager;
@ -125,6 +126,10 @@ public:
/// then return NULL.
Pass *findAnalysisPass(AnalysisID AID);
inline void clearManagers() {
PassManagers.clear();
}
virtual ~PMTopLevelManager() {
for (std::vector<Pass *>::iterator I = PassManagers.begin(),
@ -291,16 +296,16 @@ private:
};
//===----------------------------------------------------------------------===//
// BasicBlockPassManager_New
// BasicBlockPassManager
//
/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
/// BasicBlockPassManager 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 PMDataManager,
class BasicBlockPassManager : public PMDataManager,
public FunctionPass {
public:
BasicBlockPassManager_New(int D) : PMDataManager(D) { }
BasicBlockPassManager(int D) : PMDataManager(D) { }
/// Add a pass into a passmanager queue.
bool addPass(Pass *p);
@ -407,20 +412,20 @@ public:
private:
// Active Pass Managers
BasicBlockPassManager_New *activeBBPassManager;
BasicBlockPassManager *activeBBPassManager;
};
//===----------------------------------------------------------------------===//
// ModulePassManager_New
// ModulePassManager
//
/// ModulePassManager_New manages ModulePasses and function pass managers.
/// ModulePassManager 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,
class ModulePassManager : public Pass,
public PMDataManager {
public:
ModulePassManager_New(int D) : PMDataManager(D) {
ModulePassManager(int D) : PMDataManager(D) {
activeFunctionPassManager = NULL;
}
@ -504,7 +509,7 @@ private:
bool addPass(Pass *p);
// Active Pass Manager
ModulePassManager_New *activeManager;
ModulePassManager *activeManager;
};
} // End of llvm namespace
@ -814,12 +819,12 @@ Pass *AnalysisResolver_New::getAnalysisToUpdate(AnalysisID ID, bool dir) const {
}
//===----------------------------------------------------------------------===//
// BasicBlockPassManager_New implementation
// BasicBlockPassManager implementation
/// 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::addPass(Pass *P) {
BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
if (!BP)
@ -839,7 +844,7 @@ BasicBlockPassManager_New::addPass(Pass *P) {
/// runOnBasicBlock method. Keep track of whether any of the passes modifies
/// the function, and if so, return true.
bool
BasicBlockPassManager_New::runOnFunction(Function &F) {
BasicBlockPassManager::runOnFunction(Function &F) {
if (F.isExternal())
return false;
@ -862,7 +867,7 @@ BasicBlockPassManager_New::runOnFunction(Function &F) {
}
// Implement doInitialization and doFinalization
inline bool BasicBlockPassManager_New::doInitialization(Module &M) {
inline bool BasicBlockPassManager::doInitialization(Module &M) {
bool Changed = false;
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
@ -875,7 +880,7 @@ inline bool BasicBlockPassManager_New::doInitialization(Module &M) {
return Changed;
}
inline bool BasicBlockPassManager_New::doFinalization(Module &M) {
inline bool BasicBlockPassManager::doFinalization(Module &M) {
bool Changed = false;
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
@ -888,7 +893,7 @@ inline bool BasicBlockPassManager_New::doFinalization(Module &M) {
return Changed;
}
inline bool BasicBlockPassManager_New::doInitialization(Function &F) {
inline bool BasicBlockPassManager::doInitialization(Function &F) {
bool Changed = false;
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
@ -901,7 +906,7 @@ inline bool BasicBlockPassManager_New::doInitialization(Function &F) {
return Changed;
}
inline bool BasicBlockPassManager_New::doFinalization(Function &F) {
inline bool BasicBlockPassManager::doFinalization(Function &F) {
bool Changed = false;
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
@ -916,10 +921,10 @@ inline bool BasicBlockPassManager_New::doFinalization(Function &F) {
//===----------------------------------------------------------------------===//
// FunctionPassManager_New implementation
// FunctionPassManager implementation
/// Create new Function pass manager
FunctionPassManager_New::FunctionPassManager_New(ModuleProvider *P) {
FunctionPassManager::FunctionPassManager(ModuleProvider *P) {
FPM = new FunctionPassManagerImpl_New(0);
// FPM is the top level manager.
FPM->setTopLevelManager(FPM);
@ -932,7 +937,14 @@ FunctionPassManager_New::FunctionPassManager_New(ModuleProvider *P) {
MP = P;
}
FunctionPassManager_New::~FunctionPassManager_New() {
FunctionPassManager::~FunctionPassManager() {
// Note : FPM maintains one entry in PassManagers vector.
// This one entry is FPM itself. This is not ideal. One
// alternative is have one additional layer between
// FunctionPassManager and FunctionPassManagerImpl.
// Meanwhile, to avoid going into infinte loop, first
// remove FPM from its PassMangers vector.
FPM->clearManagers();
delete FPM;
}
@ -941,7 +953,7 @@ FunctionPassManager_New::~FunctionPassManager_New() {
/// 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) {
void FunctionPassManager::add(Pass *P) {
FPM->add(P);
}
@ -949,7 +961,7 @@ void FunctionPassManager_New::add(Pass *P) {
/// track of whether any of the passes modifies the function, and if
/// so, return true.
///
bool FunctionPassManager_New::run(Function &F) {
bool FunctionPassManager::run(Function &F) {
std::string errstr;
if (MP->materializeFunction(&F, &errstr)) {
cerr << "Error reading bytecode file: " << errstr << "\n";
@ -961,13 +973,13 @@ bool FunctionPassManager_New::run(Function &F) {
/// doInitialization - Run all of the initializers for the function passes.
///
bool FunctionPassManager_New::doInitialization() {
bool FunctionPassManager::doInitialization() {
return FPM->doInitialization(*MP->getModule());
}
/// doFinalization - Run all of the initializers for the function passes.
///
bool FunctionPassManager_New::doFinalization() {
bool FunctionPassManager::doFinalization() {
return FPM->doFinalization(*MP->getModule());
}
@ -980,7 +992,7 @@ bool FunctionPassManager_New::doFinalization() {
bool
FunctionPassManagerImpl_New::addPass(Pass *P) {
// If P is a BasicBlockPass then use BasicBlockPassManager_New.
// If P is a BasicBlockPass then use BasicBlockPassManager.
if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) {
if (!activeBBPassManager || !activeBBPassManager->addPass(BP)) {
@ -991,7 +1003,7 @@ FunctionPassManagerImpl_New::addPass(Pass *P) {
// Create and add new manager
activeBBPassManager =
new BasicBlockPassManager_New(getDepth() + 1);
new BasicBlockPassManager(getDepth() + 1);
// Inherit top level manager
activeBBPassManager->setTopLevelManager(this->getTopLevelManager());
@ -1109,7 +1121,8 @@ bool FunctionPassManagerImpl_New::run(Function &F) {
bool Changed = false;
for (std::vector<Pass *>::iterator I = passManagersBegin(),
E = passManagersEnd(); I != E; ++I) {
FunctionPass *FP = dynamic_cast<FunctionPass *>(*I);
FunctionPassManagerImpl_New *FP =
dynamic_cast<FunctionPassManagerImpl_New *>(*I);
Changed |= FP->runOnFunction(F);
}
return Changed;
@ -1122,7 +1135,7 @@ bool FunctionPassManagerImpl_New::run(Function &F) {
/// then use FunctionPassManagerImpl_New to manage it. Return false if P
/// is not manageable by this manager.
bool
ModulePassManager_New::addPass(Pass *P) {
ModulePassManager::addPass(Pass *P) {
// If P is FunctionPass then use function pass maanager.
if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) {
@ -1183,7 +1196,7 @@ ModulePassManager_New::addPass(Pass *P) {
/// runOnModule method. Keep track of whether any of the passes modifies
/// the module, and if so, return true.
bool
ModulePassManager_New::runOnModule(Module &M) {
ModulePassManager::runOnModule(Module &M) {
bool Changed = false;
initializeAnalysisInfo();
@ -1208,7 +1221,7 @@ ModulePassManager_New::runOnModule(Module &M) {
bool PassManagerImpl_New::addPass(Pass *P) {
if (!activeManager || !activeManager->addPass(P)) {
activeManager = new ModulePassManager_New(getDepth() + 1);
activeManager = new ModulePassManager(getDepth() + 1);
// Inherit top level manager
activeManager->setTopLevelManager(this->getTopLevelManager());
@ -1230,7 +1243,7 @@ bool PassManagerImpl_New::run(Module &M) {
bool Changed = false;
for (std::vector<Pass *>::iterator I = passManagersBegin(),
E = passManagersEnd(); I != E; ++I) {
ModulePassManager_New *MP = dynamic_cast<ModulePassManager_New *>(*I);
ModulePassManager *MP = dynamic_cast<ModulePassManager *>(*I);
Changed |= MP->runOnModule(M);
}
return Changed;
@ -1240,13 +1253,13 @@ bool PassManagerImpl_New::run(Module &M) {
// PassManager implementation
/// Create new pass manager
PassManager_New::PassManager_New() {
PassManager::PassManager() {
PM = new PassManagerImpl_New(0);
// PM is the top level manager
PM->setTopLevelManager(PM);
}
PassManager_New::~PassManager_New() {
PassManager::~PassManager() {
delete PM;
}
@ -1255,14 +1268,15 @@ PassManager_New::~PassManager_New() {
/// 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) {
PassManager::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) {
PassManager::run(Module &M) {
return PM->run(M);
}
#endif