X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=5620d0f886cca8fbabcdab447a21a8c0bbfae3fe;hb=e6be34a53ecbe8c2ff9f0793b13d847e94c0de91;hp=bc85967ee1c0fd62218667cc64e70085c18f3156;hpb=63925c831ae17a6f894744dbc153dbc9ed4c1902;p=oota-llvm.git diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index bc85967ee1c..5620d0f886c 100644 --- a/lib/VMCore/PassManager.cpp +++ b/lib/VMCore/PassManager.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Devang Patel and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -19,8 +19,10 @@ #include "llvm/ModuleProvider.h" #include "llvm/Support/Streams.h" #include "llvm/Support/ManagedStatic.h" +#include #include #include +using namespace llvm; // See PassManagers.h for Pass Manager infrastructure overview. @@ -62,7 +64,9 @@ class VISIBILITY_HIDDEN BBPassManager : public PMDataManager, public FunctionPass { public: - BBPassManager(int Depth) : PMDataManager(Depth) { } + static char ID; + explicit BBPassManager(int Depth) + : PMDataManager(Depth), FunctionPass((intptr_t)&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. @@ -98,11 +102,12 @@ public: return BP; } - virtual PassManagerType getPassManagerType() { + virtual PassManagerType getPassManagerType() const { return PMT_BasicBlockPassManager; } }; +char BBPassManager::ID = 0; } namespace llvm { @@ -115,9 +120,10 @@ class FunctionPassManagerImpl : public Pass, public PMDataManager, public PMTopLevelManager { public: - - FunctionPassManagerImpl(int Depth) : PMDataManager(Depth), - PMTopLevelManager(TLM_Function) { } + static char ID; + explicit FunctionPassManagerImpl(int Depth) : + Pass((intptr_t)&ID), PMDataManager(Depth), + PMTopLevelManager(TLM_Function) { } /// 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 @@ -135,7 +141,7 @@ public: /// bool doInitialization(Module &M); - /// doFinalization - Run all of the initializers for the function passes. + /// doFinalization - Run all of the finalizers for the function passes. /// bool doFinalization(Module &M); @@ -157,7 +163,6 @@ public: recordAvailableAnalysis(IP); } else { P->assignPassManager(activeStack); - activeStack.handleLastUserOverflow(); } } @@ -167,9 +172,9 @@ public: FPPassManager *FP = static_cast(PassManagers[N]); return FP; } - }; +char FunctionPassManagerImpl::ID = 0; //===----------------------------------------------------------------------===// // MPPassManager // @@ -179,8 +184,20 @@ public: class MPPassManager : public Pass, public PMDataManager { public: - MPPassManager(int Depth) : PMDataManager(Depth) { } - + static char ID; + explicit MPPassManager(int Depth) : + Pass((intptr_t)&ID), PMDataManager(Depth) { } + + // Delete on the fly managers. + virtual ~MPPassManager() { + for (std::map::iterator + I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end(); + I != E; ++I) { + FunctionPassManagerImpl *FPP = I->second; + delete FPP; + } + } + /// 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); @@ -190,6 +207,16 @@ public: Info.setPreservesAll(); } + /// Add RequiredPass into list of lower level passes required by pass P. + /// RequiredPass is run on the fly by Pass Manager when P requests it + /// through getAnalysis interface. + virtual void addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass); + + /// Return function pass corresponding to PassInfo PI, that is + /// required by module pass MP. Instantiate analysis pass, by using + /// its runOnFunction() for function F. + virtual Pass* getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F); + virtual const char *getPassName() const { return "Module Pass Manager"; } @@ -200,6 +227,8 @@ public: for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { ModulePass *MP = getContainedPass(Index); MP->dumpPassStructure(Offset + 1); + if (FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]) + FPP->dumpPassStructure(Offset + 2); dumpLastUses(MP, Offset+1); } } @@ -210,21 +239,31 @@ public: return MP; } - virtual PassManagerType getPassManagerType() { return PMT_ModulePassManager; } + virtual PassManagerType getPassManagerType() const { + return PMT_ModulePassManager; + } + + private: + /// Collection of on the fly FPPassManagers. These managers manage + /// function passes that are required by module passes. + std::map OnTheFlyManagers; }; +char MPPassManager::ID = 0; //===----------------------------------------------------------------------===// // PassManagerImpl // + /// PassManagerImpl manages MPPassManagers class PassManagerImpl : public Pass, public PMDataManager, public PMTopLevelManager { public: - - PassManagerImpl(int Depth) : PMDataManager(Depth), - PMTopLevelManager(TLM_Pass) { } + static char ID; + explicit PassManagerImpl(int Depth) : + Pass((intptr_t)&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 @@ -256,7 +295,6 @@ public: recordAvailableAnalysis(IP); } else { P->assignPassManager(activeStack); - activeStack.handleLastUserOverflow(); } } @@ -269,6 +307,7 @@ public: }; +char PassManagerImpl::ID = 0; } // End of llvm namespace namespace { @@ -345,13 +384,17 @@ PMTopLevelManager::PMTopLevelManager (enum TopLevelManagerType t) { } /// Set pass P as the last user of the given analysis passes. -void PMTopLevelManager::setLastUser(std::vector &AnalysisPasses, +void PMTopLevelManager::setLastUser(SmallVector &AnalysisPasses, Pass *P) { - for (std::vector::iterator I = AnalysisPasses.begin(), + for (SmallVector::iterator I = AnalysisPasses.begin(), E = AnalysisPasses.end(); I != E; ++I) { Pass *AP = *I; LastUser[AP] = P; + + if (P == AP) + continue; + // If AP is the last user of other passes then make P last user of // such passes. for (std::map::iterator LUI = LastUser.begin(), @@ -363,7 +406,7 @@ void PMTopLevelManager::setLastUser(std::vector &AnalysisPasses, } /// Collect passes whose last user is P -void PMTopLevelManager::collectLastUses(std::vector &LastUses, +void PMTopLevelManager::collectLastUses(SmallVector &LastUses, Pass *P) { for (std::map::iterator LUI = LastUser.begin(), LUE = LastUser.end(); LUI != LUE; ++LUI) @@ -379,10 +422,8 @@ void PMTopLevelManager::schedulePass(Pass *P) { // TODO : Allocate function manager for this pass, other wise required set // may be inserted into previous function manager - // If this Analysis is already requested by one of the previous pass - // and it is still available then do not insert new pass in the queue again. - if (findAnalysisPass(P->getPassInfo())) - return; + // Give pass a chance to prepare the stage. + P->preparePassManager(activeStack); AnalysisUsage AnUsage; P->getAnalysisUsage(AnUsage); @@ -392,9 +433,14 @@ void PMTopLevelManager::schedulePass(Pass *P) { Pass *AnalysisPass = findAnalysisPass(*I); if (!AnalysisPass) { - // Schedule this analysis run first. AnalysisPass = (*I)->createPass(); - schedulePass(AnalysisPass); + // 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; } } @@ -429,7 +475,8 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { // If Pass not found then check the interfaces implemented by Immutable Pass if (!P) { - const std::vector &ImmPI = PI->getInterfacesImplemented(); + const std::vector &ImmPI = + PI->getInterfacesImplemented(); if (std::find(ImmPI.begin(), ImmPI.end(), AID) != ImmPI.end()) P = *I; } @@ -528,11 +575,50 @@ void PMDataManager::recordAvailableAnalysis(Pass *P) { } } +// Return true if P preserves high level analysis used by other +// passes managed by this manager +bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { + + AnalysisUsage AnUsage; + P->getAnalysisUsage(AnUsage); + + if (AnUsage.getPreservesAll()) + return true; + + const std::vector &PreservedSet = AnUsage.getPreservedSet(); + for (std::vector::iterator I = HigherLevelAnalysis.begin(), + E = HigherLevelAnalysis.end(); I != E; ++I) { + Pass *P1 = *I; + if (!dynamic_cast(P1) && + std::find(PreservedSet.begin(), PreservedSet.end(), + P1->getPassInfo()) == + PreservedSet.end()) + return false; + } + + return true; +} + +/// verifyPreservedAnalysis -- Verify analysis presreved by pass P. +void PMDataManager::verifyPreservedAnalysis(Pass *P) { + AnalysisUsage AnUsage; + P->getAnalysisUsage(AnUsage); + const std::vector &PreservedSet = AnUsage.getPreservedSet(); + + // Verify preserved analysis + for (std::vector::const_iterator I = PreservedSet.begin(), + E = PreservedSet.end(); I != E; ++I) { + AnalysisID AID = *I; + Pass *AP = findAnalysisPass(AID, true); + if (AP) + AP->verifyAnalysis(); + } +} + /// Remove Analyss not preserved by Pass P void PMDataManager::removeNotPreservedAnalysis(Pass *P) { AnalysisUsage AnUsage; P->getAnalysisUsage(AnUsage); - if (AnUsage.getPreservesAll()) return; @@ -540,30 +626,54 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) { for (std::map::iterator I = AvailableAnalysis.begin(), E = AvailableAnalysis.end(); I != E; ) { std::map::iterator Info = I++; - if (std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == - PreservedSet.end()) { + if (!dynamic_cast(Info->second) + && std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == + PreservedSet.end()) // Remove this analysis - if (!dynamic_cast(Info->second)) - AvailableAnalysis.erase(Info); + AvailableAnalysis.erase(Info); + } + + // Check inherited analysis also. If P is not preserving analysis + // provided by parent manager then remove it here. + for (unsigned Index = 0; Index < PMT_Last; ++Index) { + + if (!InheritedAnalysis[Index]) + continue; + + for (std::map::iterator + I = InheritedAnalysis[Index]->begin(), + E = InheritedAnalysis[Index]->end(); I != E; ) { + std::map::iterator Info = I++; + if (!dynamic_cast(Info->second) && + std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == + PreservedSet.end()) + // Remove this analysis + InheritedAnalysis[Index]->erase(Info); } } + } /// Remove analysis passes that are not used any longer -void PMDataManager::removeDeadPasses(Pass *P, std::string &Msg) { +void PMDataManager::removeDeadPasses(Pass *P, const char *Msg, + enum PassDebuggingString DBG_STR) { + + SmallVector DeadPasses; + + // If this is a on the fly manager then it does not have TPM. + if (!TPM) + return; - std::vector DeadPasses; TPM->collectLastUses(DeadPasses, P); - for (std::vector::iterator I = DeadPasses.begin(), + for (SmallVector::iterator I = DeadPasses.begin(), E = DeadPasses.end(); I != E; ++I) { - std::string Msg1 = " Freeing Pass '"; - dumpPassInfo(*I, Msg1, Msg); + dumpPassInfo(*I, FREEING_MSG, DBG_STR, Msg); - if (TheTimeInfo) TheTimeInfo->passStarted(P); + if (TheTimeInfo) TheTimeInfo->passStarted(*I); (*I)->releaseMemory(); - if (TheTimeInfo) TheTimeInfo->passEnded(P); + if (TheTimeInfo) TheTimeInfo->passEnded(*I); std::map::iterator Pos = AvailableAnalysis.find((*I)->getPassInfo()); @@ -584,15 +694,22 @@ void PMDataManager::add(Pass *P, AnalysisResolver *AR = new AnalysisResolver(*this); P->setResolver(AR); + // If a FunctionPass F is the last user of ModulePass info M + // then the F's manager, not F, records itself as a last user of M. + SmallVector TransferLastUses; + if (ProcessAnalysis) { // At the moment, this pass is the last user of all required passes. - std::vector LastUses; - std::vector RequiredPasses; + SmallVector LastUses; + SmallVector RequiredPasses; + SmallVector ReqAnalysisNotAvailable; + unsigned PDepth = this->getDepth(); - collectRequiredAnalysisPasses(RequiredPasses, P); - for (std::vector::iterator I = RequiredPasses.begin(), + collectRequiredAnalysis(RequiredPasses, + ReqAnalysisNotAvailable, P); + for (SmallVector::iterator I = RequiredPasses.begin(), E = RequiredPasses.end(); I != E; ++I) { Pass *PRequired = *I; unsigned RDepth = 0; @@ -605,11 +722,10 @@ void PMDataManager::add(Pass *P, else if (PDepth > RDepth) { // Let the parent claim responsibility of last use TransferLastUses.push_back(PRequired); - } else { - // Note : This feature is not yet implemented - assert (0 && - "Unable to handle Pass that requires lower level Analysis pass"); - } + // Keep track of higher level analysis used by this manager. + HigherLevelAnalysis.push_back(PRequired); + } else + assert (0 && "Unable to accomodate Required Pass"); } // Set P as P's last user until someone starts using P. @@ -619,6 +735,20 @@ void PMDataManager::add(Pass *P, LastUses.push_back(P); TPM->setLastUser(LastUses, P); + if (!TransferLastUses.empty()) { + Pass *My_PM = dynamic_cast(this); + TPM->setLastUser(TransferLastUses, My_PM); + TransferLastUses.clear(); + } + + // Now, take care of required analysises that are not available. + for (SmallVector::iterator + I = ReqAnalysisNotAvailable.begin(), + E = ReqAnalysisNotAvailable.end() ;I != E; ++I) { + Pass *AnalysisPass = (*I)->createPass(); + this->addLowerLevelRequiredPass(P, AnalysisPass); + } + // Take a note of analysis required and made available by this pass. // Remove the analysis not preserved by this pass removeNotPreservedAnalysis(P); @@ -629,27 +759,34 @@ void PMDataManager::add(Pass *P, PassVector.push_back(P); } -/// Populate RequiredPasses with the analysis pass that are required by -/// pass P. -void PMDataManager::collectRequiredAnalysisPasses(std::vector &RP, - Pass *P) { + +/// Populate RP with analysis pass that are required by +/// pass P and are available. Populate RP_NotAvail with analysis +/// pass that are required by pass P but are not available. +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 I = RequiredSet.begin(), E = RequiredSet.end(); I != E; ++I) { - Pass *AnalysisPass = findAnalysisPass(*I, true); - assert (AnalysisPass && "Analysis pass is not available"); - RP.push_back(AnalysisPass); + AnalysisID AID = *I; + if (Pass *AnalysisPass = findAnalysisPass(*I, true)) + RP.push_back(AnalysisPass); + else + RP_NotAvail.push_back(AID); } const std::vector &IDs = AnUsage.getRequiredTransitiveSet(); for (std::vector::const_iterator I = IDs.begin(), E = IDs.end(); I != E; ++I) { - Pass *AnalysisPass = findAnalysisPass(*I, true); - assert (AnalysisPass && "Analysis pass is not available"); - RP.push_back(AnalysisPass); + AnalysisID AID = *I; + if (Pass *AnalysisPass = findAnalysisPass(*I, true)) + RP.push_back(AnalysisPass); + else + RP_NotAvail.push_back(AID); } } @@ -667,7 +804,9 @@ void PMDataManager::initializeAnalysisImpl(Pass *P) { E = AnUsage.getRequiredSet().end(); I != E; ++I) { Pass *Impl = findAnalysisPass(*I, true); if (Impl == 0) - assert(0 && "Analysis used but not available!"); + // This may be analysis pass that is initialized on the fly. + // If that is not the case then it will raise an assert when it is used. + continue; AnalysisResolver *AR = P->getResolver(); AR->addAnalysisImplsPair(*I, Impl); } @@ -693,12 +832,15 @@ Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { // Print list of passes that are last used by P. void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ - std::vector LUses; - - assert (TPM && "Top Level Manager is missing"); + SmallVector LUses; + + // If this is a on the fly manager then it does not have TPM. + if (!TPM) + return; + TPM->collectLastUses(LUses, P); - for (std::vector::iterator I = LUses.begin(), + for (SmallVector::iterator I = LUses.begin(), E = LUses.end(); I != E; ++I) { llvm::cerr << "--" << std::string(Offset*2, ' '); (*I)->dumpPassStructure(0); @@ -717,14 +859,44 @@ void PMDataManager::dumpPassArguments() const { } } -void PMDataManager:: dumpPassInfo(Pass *P, std::string &Msg1, - std::string &Msg2) const { +void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1, + enum PassDebuggingString S2, + const char *Msg) { if (PassDebugging < Executions) return; cerr << (void*)this << std::string(getDepth()*2+1, ' '); - cerr << Msg1; - cerr << P->getPassName(); - cerr << Msg2; + switch (S1) { + case EXECUTION_MSG: + cerr << "Executing Pass '" << P->getPassName(); + break; + case MODIFICATION_MSG: + cerr << "Made Modification '" << P->getPassName(); + break; + case FREEING_MSG: + cerr << " Freeing Pass '" << P->getPassName(); + break; + default: + break; + } + switch (S2) { + case ON_BASICBLOCK_MSG: + cerr << "' on BasicBlock '" << Msg << "'...\n"; + break; + case ON_FUNCTION_MSG: + cerr << "' on Function '" << Msg << "'...\n"; + break; + case ON_MODULE_MSG: + cerr << "' on Module '" << Msg << "'...\n"; + break; + case ON_LOOP_MSG: + cerr << "' on Loop " << Msg << "'...\n"; + break; + case ON_CG_MSG: + cerr << "' on Call Graph " << Msg << "'...\n"; + break; + default: + break; + } } void PMDataManager::dumpAnalysisSetInfo(const char *Msg, Pass *P, @@ -740,6 +912,28 @@ void PMDataManager::dumpAnalysisSetInfo(const char *Msg, Pass *P, } } +/// Add RequiredPass into list of lower level passes required by pass P. +/// RequiredPass is run on the fly by Pass Manager when P requests it +/// through getAnalysis interface. +/// This should be handled by specific pass manager. +void PMDataManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { + if (TPM) { + TPM->dumpArguments(); + TPM->dumpPasses(); + } + + // Module Level pass may required Function Level analysis info + // (e.g. dominator info). Pass manager uses on the fly function pass manager + // to provide this on demand. In that case, in Pass manager terminology, + // module level pass is requiring lower level analysis info managed by + // lower level pass manager. + + // When Pass manager is not able to order required analysis info, Pass manager + // checks whether any lower level manager will be able to provide this + // analysis info on demand or not. + assert (0 && "Unable to handle Pass that requires lower level Analysis pass"); +} + // Destructor PMDataManager::~PMDataManager() { @@ -757,6 +951,11 @@ Pass *AnalysisResolver::getAnalysisToUpdate(AnalysisID ID, bool dir) const { return PM.findAnalysisPass(ID, dir); } +Pass *AnalysisResolver::findImplPass(Pass *P, const PassInfo *AnalysisPI, + Function &F) { + return PM.getOnTheFlyPass(P, AnalysisPI, F); +} + //===----------------------------------------------------------------------===// // BBPassManager implementation @@ -771,17 +970,13 @@ BBPassManager::runOnFunction(Function &F) { bool Changed = doInitialization(F); - std::string Msg1 = "Executing Pass '"; - std::string Msg3 = "' Made Modification '"; - 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); - std::string Msg2 = "' on BasicBlock '" + (*I).getName() + "'...\n"; - dumpPassInfo(BP, Msg1, Msg2); + dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getNameStart()); dumpAnalysisSetInfo("Required", BP, AnUsage.getRequiredSet()); initializeAnalysisImpl(BP); @@ -790,14 +985,17 @@ BBPassManager::runOnFunction(Function &F) { Changed |= BP->runOnBasicBlock(*I); if (TheTimeInfo) TheTimeInfo->passEnded(BP); - if (Changed) - dumpPassInfo(BP, Msg3, Msg2); + if (Changed) + dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, + I->getNameStart()); dumpAnalysisSetInfo("Preserved", BP, AnUsage.getPreservedSet()); + verifyPreservedAnalysis(BP); removeNotPreservedAnalysis(BP); recordAvailableAnalysis(BP); - removeDeadPasses(BP, Msg2); + removeDeadPasses(BP, I->getNameStart(), ON_BASICBLOCK_MSG); } + return Changed |= doFinalization(F); } @@ -883,7 +1081,7 @@ void FunctionPassManager::add(Pass *P) { bool FunctionPassManager::run(Function &F) { std::string errstr; if (MP->materializeFunction(&F, &errstr)) { - cerr << "Error reading bytecode file: " << errstr << "\n"; + cerr << "Error reading bitcode file: " << errstr << "\n"; abort(); } return FPM->run(F); @@ -896,7 +1094,7 @@ bool FunctionPassManager::doInitialization() { return FPM->doInitialization(*MP->getModule()); } -/// doFinalization - Run all of the initializers for the function passes. +/// doFinalization - Run all of the finalizers for the function passes. /// bool FunctionPassManager::doFinalization() { return FPM->doFinalization(*MP->getModule()); @@ -949,6 +1147,7 @@ bool FunctionPassManagerImpl::run(Function &F) { //===----------------------------------------------------------------------===// // FPPassManager implementation +char FPPassManager::ID = 0; /// Print passes managed by this manager void FPPassManager::dumpPassStructure(unsigned Offset) { llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; @@ -970,17 +1169,13 @@ bool FPPassManager::runOnFunction(Function &F) { if (F.isDeclaration()) return false; - std::string Msg1 = "Executing Pass '"; - std::string Msg3 = "' Made Modification '"; - for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { FunctionPass *FP = getContainedPass(Index); AnalysisUsage AnUsage; FP->getAnalysisUsage(AnUsage); - std::string Msg2 = "' on Function '" + F.getName() + "'...\n"; - dumpPassInfo(FP, Msg1, Msg2); + dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getNameStart()); dumpAnalysisSetInfo("Required", FP, AnUsage.getRequiredSet()); initializeAnalysisImpl(FP); @@ -989,13 +1184,14 @@ bool FPPassManager::runOnFunction(Function &F) { Changed |= FP->runOnFunction(F); if (TheTimeInfo) TheTimeInfo->passEnded(FP); - if (Changed) - dumpPassInfo(FP, Msg3, Msg2); + if (Changed) + dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getNameStart()); dumpAnalysisSetInfo("Preserved", FP, AnUsage.getPreservedSet()); + verifyPreservedAnalysis(FP); removeNotPreservedAnalysis(FP); recordAvailableAnalysis(FP); - removeDeadPasses(FP, Msg2); + removeDeadPasses(FP, F.getNameStart(), ON_FUNCTION_MSG); } return Changed; } @@ -1042,17 +1238,14 @@ bool MPPassManager::runOnModule(Module &M) { bool Changed = false; - std::string Msg1 = "Executing Pass '"; - std::string Msg3 = "' Made Modification '"; - for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { ModulePass *MP = getContainedPass(Index); AnalysisUsage AnUsage; MP->getAnalysisUsage(AnUsage); - std::string Msg2 = "' on Module '" + M.getModuleIdentifier() + "'...\n"; - dumpPassInfo(MP, Msg1, Msg2); + dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, + M.getModuleIdentifier().c_str()); dumpAnalysisSetInfo("Required", MP, AnUsage.getRequiredSet()); initializeAnalysisImpl(MP); @@ -1061,17 +1254,60 @@ MPPassManager::runOnModule(Module &M) { Changed |= MP->runOnModule(M); if (TheTimeInfo) TheTimeInfo->passEnded(MP); - if (Changed) - dumpPassInfo(MP, Msg3, Msg2); + if (Changed) + dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, + M.getModuleIdentifier().c_str()); dumpAnalysisSetInfo("Preserved", MP, AnUsage.getPreservedSet()); + verifyPreservedAnalysis(MP); removeNotPreservedAnalysis(MP); recordAvailableAnalysis(MP); - removeDeadPasses(MP, Msg2); + removeDeadPasses(MP, M.getModuleIdentifier().c_str(), ON_MODULE_MSG); } return Changed; } +/// Add RequiredPass into list of lower level passes required by pass P. +/// RequiredPass is run on the fly by Pass Manager when P requests it +/// through getAnalysis interface. +void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { + + assert (P->getPotentialPassManagerType() == PMT_ModulePassManager + && "Unable to handle Pass that requires lower level Analysis pass"); + assert ((P->getPotentialPassManagerType() < + RequiredPass->getPotentialPassManagerType()) + && "Unable to handle Pass that requires lower level Analysis pass"); + + FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; + if (!FPP) { + FPP = new FunctionPassManagerImpl(0); + // FPP is the top level manager. + FPP->setTopLevelManager(FPP); + + OnTheFlyManagers[P] = FPP; + } + FPP->add(RequiredPass); + + // Register P as the last user of RequiredPass. + SmallVector LU; + LU.push_back(RequiredPass); + FPP->setLastUser(LU, P); +} + +/// Return function pass corresponding to PassInfo PI, that is +/// required by module pass MP. Instantiate analysis pass, by using +/// its runOnFunction() for function F. +Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, + Function &F) { + AnalysisID AID = PI; + FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]; + assert (FPP && "Unable to find on the fly pass"); + + FPP->run(F); + return (dynamic_cast(FPP))->findAnalysisPass(AID); +} + + //===----------------------------------------------------------------------===// // PassManagerImpl implementation // @@ -1191,9 +1427,6 @@ void PMStack::push(Pass *P) { PM->setTopLevelManager(TPM); } - AnalysisResolver *AR = new AnalysisResolver(*Top); - P->setResolver(AR); - S.push_back(PM); } @@ -1202,36 +1435,16 @@ void PMStack::dump() { for(std::deque::iterator I = S.begin(), E = S.end(); I != E; ++I) { Pass *P = dynamic_cast(*I); - printf ("%s ", P->getPassName()); + printf("%s ", P->getPassName()); } if (!S.empty()) - printf ("\n"); -} - -// Walk Pass Manager stack and set LastUse markers if any -// manager is transfering this priviledge to its parent manager -void PMStack::handleLastUserOverflow() { - - for(PMStack::iterator I = this->begin(), E = this->end(); I != E;) { - - PMDataManager *Child = *I++; - if (I != E) { - PMDataManager *Parent = *I++; - PMTopLevelManager *TPM = Parent->getTopLevelManager(); - std::vector &TLU = Child->getTransferredLastUses(); - if (!TLU.empty()) { - Pass *P = dynamic_cast(Parent); - TPM->setLastUser(TLU, P); - TLU.clear(); - } - } - } + printf("\n"); } /// Find appropriate Module Pass Manager in the PM Stack and /// add self into that manager. void ModulePass::assignPassManager(PMStack &PMS, - PassManagerType PreferredType) { + PassManagerType PreferredType) { // Find Module Pass Manager while(!PMS.empty()) { @@ -1250,7 +1463,7 @@ void ModulePass::assignPassManager(PMStack &PMS, /// Find appropriate Function Pass Manager or Call Graph Pass Manager /// in the PM Stack and add self into that manager. void FunctionPass::assignPassManager(PMStack &PMS, - PassManagerType PreferredType) { + PassManagerType PreferredType) { // Find Module Pass Manager (TODO : Or Call Graph Pass Manager) while(!PMS.empty()) { @@ -1295,15 +1508,14 @@ void FunctionPass::assignPassManager(PMStack &PMS, /// Find appropriate Basic Pass Manager or Call Graph Pass Manager /// in the PM Stack and add self into that manager. void BasicBlockPass::assignPassManager(PMStack &PMS, - PassManagerType PreferredType) { + PassManagerType PreferredType) { BBPassManager *BBP = NULL; // Basic Pass Manager is a leaf pass manager. It does not handle // any other pass manager. - if (!PMS.empty()) { + if (!PMS.empty()) BBP = dynamic_cast(PMS.top()); - } // If leaf manager is not Basic Block Pass manager then create new // basic Block Pass manager.