X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=e1f8afe3b0ea069f77589a5e26e8ac05ab080731;hb=51cd9d6e073932fcb37f1857c66249d6c7d368ee;hp=1b2349006af9b6c9875f5e8a5b8de66a2c2af33d;hpb=0ed8df38c26a910bd7adbe105172b434898646f3;p=oota-llvm.git diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index 1b2349006af..e1f8afe3b0e 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,9 +19,11 @@ #include "llvm/ModuleProvider.h" #include "llvm/Support/Streams.h" #include "llvm/Support/ManagedStatic.h" +#include "llvm-c/Core.h" #include #include #include +using namespace llvm; // See PassManagers.h for Pass Manager infrastructure overview. @@ -63,7 +65,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. @@ -80,7 +84,7 @@ public: bool doFinalization(Function &F); virtual const char *getPassName() const { - return "BasicBlock Pass Manager"; + return "BasicBlock Pass Manager"; } // Print passes managed by this manager @@ -104,6 +108,7 @@ public: } }; +char BBPassManager::ID = 0; } namespace llvm { @@ -116,9 +121,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 @@ -136,7 +142,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); @@ -167,20 +173,32 @@ public: FPPassManager *FP = static_cast(PassManagers[N]); return FP; } - }; +char FunctionPassManagerImpl::ID = 0; //===----------------------------------------------------------------------===// // MPPassManager // /// MPPassManager manages ModulePasses and function pass managers. -/// It batches all Module passes passes and function pass managers together and -/// sequence them to process one module. +/// It batches all Module passes and function pass managers together and +/// sequences them to process one module. 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); @@ -210,6 +228,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); } } @@ -227,21 +247,24 @@ public: private: /// Collection of on the fly FPPassManagers. These managers manage /// function passes that are required by module passes. - std::map OnTheFlyManagers; + 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 @@ -285,6 +308,7 @@ public: }; +char PassManagerImpl::ID = 0; } // End of llvm namespace namespace { @@ -336,10 +360,10 @@ public: } }; -static TimingInfo *TheTimeInfo; - } // End of anon namespace +static TimingInfo *TheTimeInfo; + //===----------------------------------------------------------------------===// // PMTopLevelManager implementation @@ -361,10 +385,10 @@ 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; @@ -383,7 +407,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) @@ -399,14 +423,16 @@ 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); + // If P is an analysis pass and it is available then do not + // generate the analysis again. Stale analysis info should not be + // available at this point. + if (P->getPassInfo() && + P->getPassInfo()->isAnalysis() && findAnalysisPass(P->getPassInfo())) + return; + AnalysisUsage AnUsage; P->getAnalysisUsage(AnUsage); const std::vector &RequiredSet = AnUsage.getRequiredSet(); @@ -437,10 +463,9 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { Pass *P = NULL; // Check pass managers - for (std::vector::iterator I = PassManagers.begin(), + for (std::vector::iterator I = PassManagers.begin(), E = PassManagers.end(); P == NULL && I != E; ++I) { - PMDataManager *PMD = dynamic_cast(*I); - assert(PMD && "This is not a PassManager"); + PMDataManager *PMD = *I; P = PMD->findAnalysisPass(AID, false); } @@ -457,7 +482,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; } @@ -477,9 +503,13 @@ void PMTopLevelManager::dumpPasses() const { ImmutablePasses[i]->dumpPassStructure(0); } - for (std::vector::const_iterator I = PassManagers.begin(), + // Every class that derives from PMDataManager also derives from Pass + // (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(), E = PassManagers.end(); I != E; ++I) - (*I)->dumpPassStructure(1); + dynamic_cast(*I)->dumpPassStructure(1); } void PMTopLevelManager::dumpArguments() const { @@ -488,10 +518,9 @@ void PMTopLevelManager::dumpArguments() const { return; cerr << "Pass Arguments: "; - for (std::vector::const_iterator I = PassManagers.begin(), + for (std::vector::const_iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) { - PMDataManager *PMD = dynamic_cast(*I); - assert(PMD && "This is not a PassManager"); + PMDataManager *PMD = *I; PMD->dumpPassArguments(); } cerr << "\n"; @@ -499,10 +528,9 @@ void PMTopLevelManager::dumpArguments() const { void PMTopLevelManager::initializeAllAnalysisInfo() { - for (std::vector::iterator I = PassManagers.begin(), + for (std::vector::iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) { - PMDataManager *PMD = dynamic_cast(*I); - assert(PMD && "This is not a PassManager"); + PMDataManager *PMD = *I; PMD->initializeAnalysisInfo(); } @@ -514,34 +542,18 @@ void PMTopLevelManager::initializeAllAnalysisInfo() { /// Destructor PMTopLevelManager::~PMTopLevelManager() { - for (std::vector::iterator I = PassManagers.begin(), + for (std::vector::iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) delete *I; for (std::vector::iterator I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) delete *I; - - PassManagers.clear(); } //===----------------------------------------------------------------------===// // PMDataManager implementation -/// Return true IFF pass P's required analysis set does not required new -/// manager. -bool PMDataManager::manageablePass(Pass *P) { - - // TODO - // If this pass is not preserving information that is required by a - // pass maintained by higher level pass manager then do not insert - // this pass into current manager. Use new manager. For example, - // For example, If FunctionPass F is not preserving ModulePass Info M1 - // that is used by another ModulePass M2 then do not insert F in - // current function pass manager. - return true; -} - /// Augement AvailableAnalysis by adding analysis made available by pass P. void PMDataManager::recordAvailableAnalysis(Pass *P) { @@ -570,8 +582,9 @@ bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { 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()) == + if (!dynamic_cast(P1) && + std::find(PreservedSet.begin(), PreservedSet.end(), + P1->getPassInfo()) == PreservedSet.end()) return false; } @@ -579,11 +592,26 @@ bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { 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; @@ -593,9 +621,15 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) { std::map::iterator Info = I++; if (!dynamic_cast(Info->second) && std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == - PreservedSet.end()) + 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"; + } + } } // Check inherited analysis also. If P is not preserving analysis @@ -609,8 +643,8 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) { 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) == + if (!dynamic_cast(Info->second) && + std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == PreservedSet.end()) // Remove this analysis InheritedAnalysis[Index]->erase(Info); @@ -620,17 +654,24 @@ void PMDataManager::removeNotPreservedAnalysis(Pass *P) { } /// 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) { - std::vector DeadPasses; + SmallVector DeadPasses; + // If this is a on the fly manager then it does not have TPM. if (!TPM) return; TPM->collectLastUses(DeadPasses, P); - for (std::vector::iterator I = DeadPasses.begin(), + if (PassDebugging >= Details && !DeadPasses.empty()) { + cerr << " -*- " << P->getPassName(); + cerr << " is the last user of following pass instances."; + cerr << " Free these instances\n"; + } + + for (SmallVector::iterator I = DeadPasses.begin(), E = DeadPasses.end(); I != E; ++I) { dumpPassInfo(*I, FREEING_MSG, DBG_STR, Msg); @@ -660,12 +701,12 @@ void PMDataManager::add(Pass *P, // 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. - std::vector TransferLastUses; + SmallVector TransferLastUses; if (ProcessAnalysis) { // At the moment, this pass is the last user of all required passes. - std::vector LastUses; + SmallVector LastUses; SmallVector RequiredPasses; SmallVector ReqAnalysisNotAvailable; @@ -768,7 +809,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); } @@ -794,12 +837,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); @@ -818,9 +864,9 @@ void PMDataManager::dumpPassArguments() const { } } -void PMDataManager:: dumpPassInfo(Pass *P, enum PassDebuggingString S1, - enum PassDebuggingString S2, - std::string Msg) { +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, ' '); @@ -829,7 +875,7 @@ void PMDataManager:: dumpPassInfo(Pass *P, enum PassDebuggingString S1, cerr << "Executing Pass '" << P->getPassName(); break; case MODIFICATION_MSG: - cerr << "' Made Modification '" << P->getPassName(); + cerr << "Made Modification '" << P->getPassName(); break; case FREEING_MSG: cerr << " Freeing Pass '" << P->getPassName(); @@ -839,19 +885,19 @@ void PMDataManager:: dumpPassInfo(Pass *P, enum PassDebuggingString S1, } switch (S2) { case ON_BASICBLOCK_MSG: - cerr << "' on BasicBlock '" << Msg << "...\n"; + cerr << "' on BasicBlock '" << Msg << "'...\n"; break; case ON_FUNCTION_MSG: - cerr << "' on Function '" << Msg << "...\n"; + cerr << "' on Function '" << Msg << "'...\n"; break; case ON_MODULE_MSG: - cerr << "' on Module '" << Msg << "...\n"; + cerr << "' on Module '" << Msg << "'...\n"; break; case ON_LOOP_MSG: - cerr << "' on Loop " << Msg << "...\n"; + cerr << "' on Loop " << Msg << "'...\n"; break; case ON_CG_MSG: - cerr << "' on Call Graph " << Msg << "...\n"; + cerr << "' on Call Graph " << Msg << "'...\n"; break; default: break; @@ -871,6 +917,32 @@ 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. +#ifndef NDEBUG + cerr << "Unable to schedule " << RequiredPass->getPassName(); + cerr << " required by " << P->getPassName() << "\n"; +#endif + assert (0 && "Unable to schedule pass"); +} + // Destructor PMDataManager::~PMDataManager() { @@ -878,7 +950,6 @@ PMDataManager::~PMDataManager() { E = PassVector.end(); I != E; ++I) delete *I; - PassVector.clear(); } //===----------------------------------------------------------------------===// @@ -888,6 +959,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 @@ -908,7 +984,7 @@ BBPassManager::runOnFunction(Function &F) { AnalysisUsage AnUsage; BP->getAnalysisUsage(AnUsage); - dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, (*I).getName()); + dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getNameStart()); dumpAnalysisSetInfo("Required", BP, AnUsage.getRequiredSet()); initializeAnalysisImpl(BP); @@ -918,14 +994,16 @@ BBPassManager::runOnFunction(Function &F) { if (TheTimeInfo) TheTimeInfo->passEnded(BP); if (Changed) - dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, (*I).getName()); + dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, + I->getNameStart()); dumpAnalysisSetInfo("Preserved", BP, AnUsage.getPreservedSet()); + verifyPreservedAnalysis(BP); removeNotPreservedAnalysis(BP); recordAvailableAnalysis(BP); - removeDeadPasses(BP, (*I).getName(), ON_BASICBLOCK_MSG); - + removeDeadPasses(BP, I->getNameStart(), ON_BASICBLOCK_MSG); } + return Changed |= doFinalization(F); } @@ -984,8 +1062,7 @@ FunctionPassManager::FunctionPassManager(ModuleProvider *P) { // FPM is the top level manager. FPM->setTopLevelManager(FPM); - PMDataManager *PMD = dynamic_cast(FPM); - AnalysisResolver *AR = new AnalysisResolver(*PMD); + AnalysisResolver *AR = new AnalysisResolver(*FPM); FPM->setResolver(AR); MP = P; @@ -1011,7 +1088,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); @@ -1024,7 +1101,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()); @@ -1077,6 +1154,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"; @@ -1097,6 +1175,9 @@ bool FPPassManager::runOnFunction(Function &F) { if (F.isDeclaration()) return false; + + // Collect inherited analysis from Module level pass manager. + populateInheritedAnalysis(TPM->activeStack); for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { FunctionPass *FP = getContainedPass(Index); @@ -1104,7 +1185,7 @@ bool FPPassManager::runOnFunction(Function &F) { AnalysisUsage AnUsage; FP->getAnalysisUsage(AnUsage); - dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName()); + dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getNameStart()); dumpAnalysisSetInfo("Required", FP, AnUsage.getRequiredSet()); initializeAnalysisImpl(FP); @@ -1114,12 +1195,13 @@ bool FPPassManager::runOnFunction(Function &F) { if (TheTimeInfo) TheTimeInfo->passEnded(FP); if (Changed) - dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName()); + dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getNameStart()); dumpAnalysisSetInfo("Preserved", FP, AnUsage.getPreservedSet()); + verifyPreservedAnalysis(FP); removeNotPreservedAnalysis(FP); recordAvailableAnalysis(FP); - removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG); + removeDeadPasses(FP, F.getNameStart(), ON_FUNCTION_MSG); } return Changed; } @@ -1172,7 +1254,8 @@ MPPassManager::runOnModule(Module &M) { AnalysisUsage AnUsage; MP->getAnalysisUsage(AnUsage); - dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier()); + dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, + M.getModuleIdentifier().c_str()); dumpAnalysisSetInfo("Required", MP, AnUsage.getRequiredSet()); initializeAnalysisImpl(MP); @@ -1183,12 +1266,13 @@ MPPassManager::runOnModule(Module &M) { if (Changed) dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, - M.getModuleIdentifier()); + M.getModuleIdentifier().c_str()); dumpAnalysisSetInfo("Preserved", MP, AnUsage.getPreservedSet()); + verifyPreservedAnalysis(MP); removeNotPreservedAnalysis(MP); recordAvailableAnalysis(MP); - removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG); + removeDeadPasses(MP, M.getModuleIdentifier().c_str(), ON_MODULE_MSG); } return Changed; } @@ -1204,13 +1288,20 @@ void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { RequiredPass->getPotentialPassManagerType()) && "Unable to handle Pass that requires lower level Analysis pass"); - FPPassManager *FPP = OnTheFlyManagers[P]; + FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; if (!FPP) { - FPP = new FPPassManager(getDepth() + 1); + FPP = new FunctionPassManagerImpl(0); + // FPP is the top level manager. + FPP->setTopLevelManager(FPP); + OnTheFlyManagers[P] = FPP; } + FPP->add(RequiredPass); - FPP->add(RequiredPass, false); + // 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 @@ -1219,11 +1310,11 @@ void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F) { AnalysisID AID = PI; - FPPassManager *FPP =OnTheFlyManagers[MP]; + FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]; assert (FPP && "Unable to find on the fly pass"); - FPP->runOnFunction(F); - return FPP->findAnalysisPass(AID, false); + FPP->run(F); + return (dynamic_cast(FPP))->findAnalysisPass(AID); } @@ -1328,10 +1419,9 @@ void PMStack::pop() { } // Push PM on the stack and set its top level manager. -void PMStack::push(Pass *P) { +void PMStack::push(PMDataManager *PM) { PMDataManager *Top = NULL; - PMDataManager *PM = dynamic_cast(P); assert (PM && "Unable to push. Pass Manager expected"); if (this->empty()) { @@ -1346,9 +1436,6 @@ void PMStack::push(Pass *P) { PM->setTopLevelManager(TPM); } - AnalysisResolver *AR = new AnalysisResolver(*Top); - P->setResolver(AR); - S.push_back(PM); } @@ -1357,10 +1444,10 @@ 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"); + printf("\n"); } /// Find appropriate Module Pass Manager in the PM Stack and @@ -1403,6 +1490,7 @@ void FunctionPass::assignPassManager(PMStack &PMS, // [1] Create new Function Pass Manager FPP = new FPPassManager(PMD->getDepth() + 1); + FPP->populateInheritedAnalysis(PMS); // [2] Set up new manager's top level manager PMTopLevelManager *TPM = PMD->getTopLevelManager(); @@ -1410,14 +1498,13 @@ void FunctionPass::assignPassManager(PMStack &PMS, // [3] Assign manager to manage this new manager. This may create // and push new managers into PMS - Pass *P = dynamic_cast(FPP); // If Call Graph Pass Manager is active then use it to manage // this new Function Pass manager. if (PMD->getPassManagerType() == PMT_CallGraphPassManager) - P->assignPassManager(PMS, PMT_CallGraphPassManager); + FPP->assignPassManager(PMS, PMT_CallGraphPassManager); else - P->assignPassManager(PMS); + FPP->assignPassManager(PMS); // [4] Push new manager into PMS PMS.push(FPP); @@ -1436,9 +1523,8 @@ void BasicBlockPass::assignPassManager(PMStack &PMS, // 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. @@ -1457,8 +1543,7 @@ void BasicBlockPass::assignPassManager(PMStack &PMS, // [3] Assign manager to manage this new manager. This may create // and push new managers into PMS - Pass *P = dynamic_cast(BBP); - P->assignPassManager(PMS); + BBP->assignPassManager(PMS); // [4] Push new manager into PMS PMS.push(BBP); @@ -1468,4 +1553,34 @@ void BasicBlockPass::assignPassManager(PMStack &PMS, BBP->add(this); } +PassManagerBase::~PassManagerBase() {} + +/*===-- C Bindings --------------------------------------------------------===*/ +LLVMPassManagerRef LLVMCreatePassManager() { + return wrap(new PassManager()); +} + +LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) { + return wrap(new FunctionPassManager(unwrap(P))); +} + +int LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) { + return unwrap(PM)->run(*unwrap(M)); +} + +int LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) { + return unwrap(FPM)->doInitialization(); +} + +int LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) { + return unwrap(FPM)->run(*unwrap(F)); +} + +int LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) { + return unwrap(FPM)->doFinalization(); +} + +void LLVMDisposePassManager(LLVMPassManagerRef PM) { + delete unwrap(PM); +}