X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=4335757a5093ca7f81c83fae037ba51b064161d2;hb=2625f9b2e4388a957286063f6c7fe5406fd0ca7a;hp=e2baecb6fcbd8879bc75a17677bb1d3d96360bdb;hpb=0af822508823b7f1602a2f32a5f75de170d649aa;p=oota-llvm.git diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index e2baecb6fcb..4335757a509 100644 --- a/lib/VMCore/PassManager.cpp +++ b/lib/VMCore/PassManager.cpp @@ -22,6 +22,7 @@ #include "llvm/Analysis/Dominators.h" #include "llvm-c/Core.h" #include +#include #include #include using namespace llvm; @@ -73,7 +74,7 @@ class VISIBILITY_HIDDEN BBPassManager : public PMDataManager, public: static char ID; explicit BBPassManager(int Depth) - : PMDataManager(Depth), FunctionPass((intptr_t)&ID) {} + : PMDataManager(Depth), FunctionPass(&ID) {} /// Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the function, and if so, return true. @@ -129,7 +130,7 @@ class FunctionPassManagerImpl : public Pass, public: static char ID; explicit FunctionPassManagerImpl(int Depth) : - Pass((intptr_t)&ID), PMDataManager(Depth), + Pass(&ID), PMDataManager(Depth), PMTopLevelManager(TLM_Function) { } /// add - Add a pass to the queue of passes to run. This passes ownership of @@ -193,7 +194,7 @@ class MPPassManager : public Pass, public PMDataManager { public: static char ID; explicit MPPassManager(int Depth) : - Pass((intptr_t)&ID), PMDataManager(Depth) { } + Pass(&ID), PMDataManager(Depth) { } // Delete on the fly managers. virtual ~MPPassManager() { @@ -269,8 +270,7 @@ class PassManagerImpl : public Pass, public: static char ID; explicit PassManagerImpl(int Depth) : - Pass((intptr_t)&ID), PMDataManager(Depth), - PMTopLevelManager(TLM_Pass) { } + Pass(&ID), PMDataManager(Depth), PMTopLevelManager(TLM_Pass) { } /// 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 @@ -404,9 +404,11 @@ void PMTopLevelManager::setLastUser(SmallVector &AnalysisPasses, // If AP is the last user of other passes then make P last user of // such passes. - for (std::map::iterator LUI = LastUser.begin(), + for (DenseMap::iterator LUI = LastUser.begin(), LUE = LastUser.end(); LUI != LUE; ++LUI) { if (LUI->second == AP) + // DenseMap iterator is not invalidated here because + // this is just updating exisitng entry. LastUser[LUI->first] = P; } } @@ -414,11 +416,31 @@ void PMTopLevelManager::setLastUser(SmallVector &AnalysisPasses, /// Collect passes whose last user is P void PMTopLevelManager::collectLastUses(SmallVector &LastUses, - Pass *P) { - for (std::map::iterator LUI = LastUser.begin(), - LUE = LastUser.end(); LUI != LUE; ++LUI) - if (LUI->second == P) - LastUses.push_back(LUI->first); + Pass *P) { + DenseMap >::iterator DMI = + InversedLastUser.find(P); + if (DMI == InversedLastUser.end()) + return; + + SmallPtrSet &LU = DMI->second; + for (SmallPtrSet::iterator I = LU.begin(), + E = LU.end(); I != E; ++I) { + LastUses.push_back(*I); + } + +} + +AnalysisUsage *PMTopLevelManager::findAnalysisUsage(Pass *P) { + AnalysisUsage *AnUsage = NULL; + DenseMap::iterator DMI = AnUsageMap.find(P); + if (DMI != AnUsageMap.end()) + AnUsage = DMI->second; + else { + AnUsage = new AnalysisUsage(); + P->getAnalysisUsage(*AnUsage); + AnUsageMap[P] = AnUsage; + } + return AnUsage; } /// Schedule pass P for execution. Make sure that passes required by @@ -436,25 +458,41 @@ void PMTopLevelManager::schedulePass(Pass *P) { // generate the analysis again. Stale analysis info should not be // available at this point. if (P->getPassInfo() && - P->getPassInfo()->isAnalysis() && findAnalysisPass(P->getPassInfo())) + P->getPassInfo()->isAnalysis() && findAnalysisPass(P->getPassInfo())) { + delete P; return; + } - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - const std::vector &RequiredSet = AnUsage.getRequiredSet(); - for (std::vector::const_iterator I = RequiredSet.begin(), - E = RequiredSet.end(); I != E; ++I) { - - Pass *AnalysisPass = findAnalysisPass(*I); - if (!AnalysisPass) { - AnalysisPass = (*I)->createPass(); - // Schedule this analysis run first only if it is not a lower level - // analysis pass. Lower level analsyis passes are run on the fly. - if (P->getPotentialPassManagerType () >= - AnalysisPass->getPotentialPassManagerType()) - schedulePass(AnalysisPass); - else - delete AnalysisPass; + AnalysisUsage *AnUsage = findAnalysisUsage(P); + + bool checkAnalysis = true; + while (checkAnalysis) { + checkAnalysis = false; + + const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet(); + for (AnalysisUsage::VectorType::const_iterator I = RequiredSet.begin(), + E = RequiredSet.end(); I != E; ++I) { + + Pass *AnalysisPass = findAnalysisPass(*I); + if (!AnalysisPass) { + AnalysisPass = (*I)->createPass(); + if (P->getPotentialPassManagerType () == + AnalysisPass->getPotentialPassManagerType()) + // Schedule analysis pass that is managed by the same pass manager. + schedulePass(AnalysisPass); + else if (P->getPotentialPassManagerType () > + AnalysisPass->getPotentialPassManagerType()) { + // Schedule analysis pass that is managed by a new manager. + schedulePass(AnalysisPass); + // Recheck analysis passes to ensure that required analysises that + // are already checked are still available. + checkAnalysis = true; + } + else + // Do not schedule this analysis. Lower level analsyis + // passes are run on the fly. + delete AnalysisPass; + } } } @@ -469,18 +507,18 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { Pass *P = NULL; // Check pass managers - for (std::vector::iterator I = PassManagers.begin(), + for (SmallVector::iterator I = PassManagers.begin(), E = PassManagers.end(); P == NULL && I != E; ++I) { PMDataManager *PMD = *I; P = PMD->findAnalysisPass(AID, false); } // Check other pass managers - for (std::vector::iterator I = IndirectPassManagers.begin(), + for (SmallVector::iterator I = IndirectPassManagers.begin(), E = IndirectPassManagers.end(); P == NULL && I != E; ++I) P = (*I)->findAnalysisPass(AID, false); - for (std::vector::iterator I = ImmutablePasses.begin(), + for (SmallVector::iterator I = ImmutablePasses.begin(), E = ImmutablePasses.end(); P == NULL && I != E; ++I) { const PassInfo *PI = (*I)->getPassInfo(); if (PI == AID) @@ -513,7 +551,7 @@ void PMTopLevelManager::dumpPasses() const { // (sometimes indirectly), but there's no inheritance relationship // between PMDataManager and Pass, so we have to dynamic_cast to get // from a PMDataManager* to a Pass*. - for (std::vector::const_iterator I = PassManagers.begin(), + for (SmallVector::const_iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) dynamic_cast(*I)->dumpPassStructure(1); } @@ -524,7 +562,7 @@ void PMTopLevelManager::dumpArguments() const { return; cerr << "Pass Arguments: "; - for (std::vector::const_iterator I = PassManagers.begin(), + for (SmallVector::const_iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) { PMDataManager *PMD = *I; PMD->dumpPassArguments(); @@ -534,27 +572,47 @@ void PMTopLevelManager::dumpArguments() const { void PMTopLevelManager::initializeAllAnalysisInfo() { - for (std::vector::iterator I = PassManagers.begin(), + for (SmallVector::iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) { PMDataManager *PMD = *I; PMD->initializeAnalysisInfo(); } // Initailize other pass managers - for (std::vector::iterator I = IndirectPassManagers.begin(), + for (SmallVector::iterator I = IndirectPassManagers.begin(), E = IndirectPassManagers.end(); I != E; ++I) (*I)->initializeAnalysisInfo(); + + for(DenseMap::iterator DMI = LastUser.begin(), + DME = LastUser.end(); DMI != DME; ++DMI) { + DenseMap >::iterator InvDMI = + InversedLastUser.find(DMI->second); + if (InvDMI != InversedLastUser.end()) { + SmallPtrSet &L = InvDMI->second; + L.insert(DMI->first); + } else { + SmallPtrSet L; L.insert(DMI->first); + InversedLastUser[DMI->second] = L; + } + } } /// Destructor PMTopLevelManager::~PMTopLevelManager() { - for (std::vector::iterator I = PassManagers.begin(), + for (SmallVector::iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) delete *I; - for (std::vector::iterator + for (SmallVector::iterator I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) delete *I; + + for (DenseMap::iterator DMI = AnUsageMap.begin(), + DME = AnUsageMap.end(); DMI != DME; ++DMI) { + AnalysisUsage *AU = DMI->second; + delete AU; + } + } //===----------------------------------------------------------------------===// @@ -578,14 +636,13 @@ void PMDataManager::recordAvailableAnalysis(Pass *P) { // passes managed by this manager bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); - if (AnUsage.getPreservesAll()) + if (AnUsage->getPreservesAll()) return true; - const std::vector &PreservedSet = AnUsage.getPreservedSet(); - for (std::vector::iterator I = HigherLevelAnalysis.begin(), + const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); + for (SmallVector::iterator I = HigherLevelAnalysis.begin(), E = HigherLevelAnalysis.end(); I != E; ++I) { Pass *P1 = *I; if (!dynamic_cast(P1) && @@ -598,18 +655,20 @@ bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { return true; } -/// verifyPreservedAnalysis -- Verify analysis presreved by pass P. +/// verifyPreservedAnalysis -- Verify analysis preserved by pass P. void PMDataManager::verifyPreservedAnalysis(Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - const std::vector &PreservedSet = AnUsage.getPreservedSet(); + // Don't do this unless assertions are enabled. +#ifdef NDEBUG + return; +#endif + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); // Verify preserved analysis - for (std::vector::const_iterator I = PreservedSet.begin(), + for (AnalysisUsage::VectorType::const_iterator I = PreservedSet.begin(), E = PreservedSet.end(); I != E; ++I) { AnalysisID AID = *I; - Pass *AP = findAnalysisPass(AID, true); - if (AP) + if (Pass *AP = findAnalysisPass(AID, true)) AP->verifyAnalysis(); } } @@ -620,7 +679,7 @@ void PMDataManager::verifyDomInfo(Pass &P, Function &F) { if (!VerifyDomInfo || !P.getResolver()) return; - DominatorTree *DT = P.getAnalysisToUpdate(); + DominatorTree *DT = P.getAnalysisIfAvailable(); if (!DT) return; @@ -636,7 +695,7 @@ void PMDataManager::verifyDomInfo(Pass &P, Function &F) { assert (0 && "Invalid dominator info"); } - DominanceFrontier *DF = P.getAnalysisToUpdate(); + DominanceFrontier *DF = P.getAnalysisIfAvailable(); if (!DF) return; @@ -656,12 +715,11 @@ void PMDataManager::verifyDomInfo(Pass &P, Function &F) { /// Remove Analysis not preserved by Pass P void PMDataManager::removeNotPreservedAnalysis(Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - if (AnUsage.getPreservesAll()) + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + if (AnUsage->getPreservesAll()) return; - const std::vector &PreservedSet = AnUsage.getPreservedSet(); + const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); for (std::map::iterator I = AvailableAnalysis.begin(), E = AvailableAnalysis.end(); I != E; ) { std::map::iterator Info = I++; @@ -669,12 +727,12 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) { && std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == PreservedSet.end()) { // Remove this analysis - AvailableAnalysis.erase(Info); if (PassDebugging >= Details) { Pass *S = Info->second; cerr << " -- '" << P->getPassName() << "' is not preserving '"; cerr << S->getPassName() << "'\n"; } + AvailableAnalysis.erase(Info); } } @@ -724,13 +782,23 @@ void PMDataManager::removeDeadPasses(Pass *P, const char *Msg, if (TheTimeInfo) TheTimeInfo->passStarted(*I); (*I)->releaseMemory(); if (TheTimeInfo) TheTimeInfo->passEnded(*I); - - std::map::iterator Pos = - AvailableAnalysis.find((*I)->getPassInfo()); - - // It is possible that pass is already removed from the AvailableAnalysis - if (Pos != AvailableAnalysis.end()) - AvailableAnalysis.erase(Pos); + if (const PassInfo *PI = (*I)->getPassInfo()) { + std::map::iterator Pos = + AvailableAnalysis.find(PI); + + // It is possible that pass is already removed from the AvailableAnalysis + if (Pos != AvailableAnalysis.end()) + AvailableAnalysis.erase(Pos); + + // Remove all interfaces this pass implements, for which it is also + // listed as the available implementation. + const std::vector &II = PI->getInterfacesImplemented(); + for (unsigned i = 0, e = II.size(); i != e; ++i) { + Pos = AvailableAnalysis.find(II[i]); + if (Pos != AvailableAnalysis.end() && Pos->second == *I) + AvailableAnalysis.erase(Pos); + } + } } } @@ -817,10 +885,9 @@ void PMDataManager::add(Pass *P, void PMDataManager::collectRequiredAnalysis(SmallVector&RP, SmallVector &RP_NotAvail, Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - const std::vector &RequiredSet = AnUsage.getRequiredSet(); - for (std::vector::const_iterator + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet(); + for (AnalysisUsage::VectorType::const_iterator I = RequiredSet.begin(), E = RequiredSet.end(); I != E; ++I) { AnalysisID AID = *I; @@ -830,8 +897,8 @@ void PMDataManager::collectRequiredAnalysis(SmallVector&RP, RP_NotAvail.push_back(AID); } - const std::vector &IDs = AnUsage.getRequiredTransitiveSet(); - for (std::vector::const_iterator I = IDs.begin(), + const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet(); + for (AnalysisUsage::VectorType::const_iterator I = IDs.begin(), E = IDs.end(); I != E; ++I) { AnalysisID AID = *I; if (Pass *AnalysisPass = findAnalysisPass(*I, true)) @@ -847,12 +914,11 @@ void PMDataManager::collectRequiredAnalysis(SmallVector&RP, // implementations it needs. // void PMDataManager::initializeAnalysisImpl(Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - - for (std::vector::const_iterator - I = AnUsage.getRequiredSet().begin(), - E = AnUsage.getRequiredSet().end(); I != E; ++I) { + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + + for (AnalysisUsage::VectorType::const_iterator + I = AnUsage->getRequiredSet().begin(), + E = AnUsage->getRequiredSet().end(); I != E; ++I) { Pass *Impl = findAnalysisPass(*I, true); if (Impl == 0) // This may be analysis pass that is initialized on the fly. @@ -900,7 +966,7 @@ void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ } void PMDataManager::dumpPassArguments() const { - for(std::vector::const_iterator I = PassVector.begin(), + for(SmallVector::const_iterator I = PassVector.begin(), E = PassVector.end(); I != E; ++I) { if (PMDataManager *PMD = dynamic_cast(*I)) PMD->dumpPassArguments(); @@ -951,17 +1017,38 @@ void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1, } } -void PMDataManager::dumpAnalysisSetInfo(const char *Msg, Pass *P, - const std::vector &Set) +void PMDataManager::dumpRequiredSet(const Pass *P) const { - if (PassDebugging >= Details && !Set.empty()) { - cerr << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:"; - for (unsigned i = 0; i != Set.size(); ++i) { - if (i) cerr << ","; - cerr << " " << Set[i]->getPassName(); - } - cerr << "\n"; - } + if (PassDebugging < Details) + return; + + AnalysisUsage analysisUsage; + P->getAnalysisUsage(analysisUsage); + dumpAnalysisUsage("Required", P, analysisUsage.getRequiredSet()); +} + +void PMDataManager::dumpPreservedSet(const Pass *P) + const { + if (PassDebugging < Details) + return; + + AnalysisUsage analysisUsage; + P->getAnalysisUsage(analysisUsage); + dumpAnalysisUsage("Preserved", P, analysisUsage.getPreservedSet()); +} + +void PMDataManager::dumpAnalysisUsage(const char *Msg, const Pass *P, + const AnalysisUsage::VectorType &Set) + const { + assert(PassDebugging >= Details); + if (Set.empty()) + return; + cerr << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:"; + for (unsigned i = 0; i != Set.size(); ++i) { + if (i) cerr << ","; + cerr << " " << Set[i]->getPassName(); + } + cerr << "\n"; } /// Add RequiredPass into list of lower level passes required by pass P. @@ -993,7 +1080,7 @@ void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { // Destructor PMDataManager::~PMDataManager() { - for (std::vector::iterator I = PassVector.begin(), + for (SmallVector::iterator I = PassVector.begin(), E = PassVector.end(); I != E; ++I) delete *I; @@ -1001,8 +1088,8 @@ PMDataManager::~PMDataManager() { //===----------------------------------------------------------------------===// // NOTE: Is this the right place to define this method ? -// getAnalysisToUpdate - Return an analysis result or null if it doesn't exist -Pass *AnalysisResolver::getAnalysisToUpdate(AnalysisID ID, bool dir) const { +// getAnalysisIfAvailable - Return analysis result or null if it doesn't exist. +Pass *AnalysisResolver::getAnalysisIfAvailable(AnalysisID ID, bool dir) const { return PM.findAnalysisPass(ID, dir); } @@ -1028,11 +1115,9 @@ BBPassManager::runOnFunction(Function &F) { for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { BasicBlockPass *BP = getContainedPass(Index); - AnalysisUsage AnUsage; - BP->getAnalysisUsage(AnUsage); dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getNameStart()); - dumpAnalysisSetInfo("Required", BP, AnUsage.getRequiredSet()); + dumpRequiredSet(BP); initializeAnalysisImpl(BP); @@ -1043,7 +1128,7 @@ BBPassManager::runOnFunction(Function &F) { if (Changed) dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, I->getNameStart()); - dumpAnalysisSetInfo("Preserved", BP, AnUsage.getPreservedSet()); + dumpPreservedSet(BP); verifyPreservedAnalysis(BP); removeNotPreservedAnalysis(BP); @@ -1055,7 +1140,7 @@ BBPassManager::runOnFunction(Function &F) { } // Implement doInitialization and doFinalization -inline bool BBPassManager::doInitialization(Module &M) { +bool BBPassManager::doInitialization(Module &M) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { @@ -1066,7 +1151,7 @@ inline bool BBPassManager::doInitialization(Module &M) { return Changed; } -inline bool BBPassManager::doFinalization(Module &M) { +bool BBPassManager::doFinalization(Module &M) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { @@ -1077,7 +1162,7 @@ inline bool BBPassManager::doFinalization(Module &M) { return Changed; } -inline bool BBPassManager::doInitialization(Function &F) { +bool BBPassManager::doInitialization(Function &F) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { @@ -1088,7 +1173,7 @@ inline bool BBPassManager::doInitialization(Function &F) { return Changed; } -inline bool BBPassManager::doFinalization(Function &F) { +bool BBPassManager::doFinalization(Function &F) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { @@ -1157,7 +1242,7 @@ bool FunctionPassManager::doFinalization() { //===----------------------------------------------------------------------===// // FunctionPassManagerImpl implementation // -inline bool FunctionPassManagerImpl::doInitialization(Module &M) { +bool FunctionPassManagerImpl::doInitialization(Module &M) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { @@ -1168,7 +1253,7 @@ inline bool FunctionPassManagerImpl::doInitialization(Module &M) { return Changed; } -inline bool FunctionPassManagerImpl::doFinalization(Module &M) { +bool FunctionPassManagerImpl::doFinalization(Module &M) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { @@ -1229,11 +1314,8 @@ bool FPPassManager::runOnFunction(Function &F) { for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { FunctionPass *FP = getContainedPass(Index); - AnalysisUsage AnUsage; - FP->getAnalysisUsage(AnUsage); - dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getNameStart()); - dumpAnalysisSetInfo("Required", FP, AnUsage.getRequiredSet()); + dumpRequiredSet(FP); initializeAnalysisImpl(FP); @@ -1243,7 +1325,7 @@ bool FPPassManager::runOnFunction(Function &F) { if (Changed) dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getNameStart()); - dumpAnalysisSetInfo("Preserved", FP, AnUsage.getPreservedSet()); + dumpPreservedSet(FP); verifyPreservedAnalysis(FP); removeNotPreservedAnalysis(FP); @@ -1266,7 +1348,7 @@ bool FPPassManager::runOnModule(Module &M) { return Changed |= doFinalization(M); } -inline bool FPPassManager::doInitialization(Module &M) { +bool FPPassManager::doInitialization(Module &M) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { @@ -1277,7 +1359,7 @@ inline bool FPPassManager::doInitialization(Module &M) { return Changed; } -inline bool FPPassManager::doFinalization(Module &M) { +bool FPPassManager::doFinalization(Module &M) { bool Changed = false; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { @@ -1301,12 +1383,9 @@ MPPassManager::runOnModule(Module &M) { for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { ModulePass *MP = getContainedPass(Index); - AnalysisUsage AnUsage; - MP->getAnalysisUsage(AnUsage); - dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier().c_str()); - dumpAnalysisSetInfo("Required", MP, AnUsage.getRequiredSet()); + dumpRequiredSet(MP); initializeAnalysisImpl(MP); @@ -1317,8 +1396,8 @@ MPPassManager::runOnModule(Module &M) { if (Changed) dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, M.getModuleIdentifier().c_str()); - dumpAnalysisSetInfo("Preserved", MP, AnUsage.getPreservedSet()); - + dumpPreservedSet(MP); + verifyPreservedAnalysis(MP); removeNotPreservedAnalysis(MP); recordAvailableAnalysis(MP); @@ -1515,7 +1594,7 @@ void ModulePass::assignPassManager(PMStack &PMS, else break; } - + assert(!PMS.empty() && "Unable to find appropriate Pass Manager"); PMS.top()->add(this); } @@ -1524,7 +1603,7 @@ void ModulePass::assignPassManager(PMStack &PMS, void FunctionPass::assignPassManager(PMStack &PMS, PassManagerType PreferredType) { - // Find Module Pass Manager (TODO : Or Call Graph Pass Manager) + // Find Module Pass Manager while(!PMS.empty()) { if (PMS.top()->getPassManagerType() > PMT_FunctionPassManager) PMS.pop(); @@ -1548,13 +1627,7 @@ void FunctionPass::assignPassManager(PMStack &PMS, // [3] Assign manager to manage this new manager. This may create // and push new managers into PMS - - // If Call Graph Pass Manager is active then use it to manage - // this new Function Pass manager. - if (PMD->getPassManagerType() == PMT_CallGraphPassManager) - FPP->assignPassManager(PMS, PMT_CallGraphPassManager); - else - FPP->assignPassManager(PMS); + FPP->assignPassManager(PMS, PMD->getPassManagerType()); // [4] Push new manager into PMS PMS.push(FPP);