X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=ecedb1db66b0678346073a66c49d5210fa423f85;hb=b6777eae58392cb5e19282622996e81c72b72a3e;hp=df96190b43b27ac274624382acbe0209287ee1cc;hpb=7578ea887de6a7cb22c324b629101683a0afb3c5;p=oota-llvm.git diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index df96190b43b..ecedb1db66b 100644 --- a/lib/VMCore/PassManager.cpp +++ b/lib/VMCore/PassManager.cpp @@ -14,6 +14,7 @@ #include "llvm/PassManagers.h" #include "llvm/PassManager.h" +#include "llvm/DebugInfoProbe.h" #include "llvm/Assembly/PrintModulePass.h" #include "llvm/Assembly/Writer.h" #include "llvm/Support/CommandLine.h" @@ -24,9 +25,9 @@ #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/PassNameParser.h" #include "llvm/Support/raw_ostream.h" -#include "llvm/System/Mutex.h" +#include "llvm/Support/Mutex.h" +#include "llvm/ADT/StringMap.h" #include -#include #include using namespace llvm; @@ -63,11 +64,13 @@ PassOptionList; // Print IR out before/after specified passes. static PassOptionList PrintBefore("print-before", - llvm::cl::desc("Print IR before specified passes")); + llvm::cl::desc("Print IR before specified passes"), + cl::Hidden); static PassOptionList PrintAfter("print-after", - llvm::cl::desc("Print IR after specified passes")); + llvm::cl::desc("Print IR after specified passes"), + cl::Hidden); static cl::opt PrintBeforeAll("print-before-all", @@ -163,8 +166,8 @@ class BBPassManager : public PMDataManager, public FunctionPass { public: static char ID; - explicit BBPassManager(int Depth) - : PMDataManager(Depth), FunctionPass(ID) {} + explicit BBPassManager() + : PMDataManager(), 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. @@ -189,7 +192,7 @@ public: // Print passes managed by this manager void dumpPassStructure(unsigned Offset) { - llvm::dbgs() << std::string(Offset*2, ' ') << "BasicBlockPass Manager\n"; + llvm::dbgs().indent(Offset*2) << "BasicBlockPass Manager\n"; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { BasicBlockPass *BP = getContainedPass(Index); BP->dumpPassStructure(Offset + 1); @@ -224,9 +227,9 @@ private: bool wasRun; public: static char ID; - explicit FunctionPassManagerImpl(int Depth) : - Pass(PT_PassManager, ID), PMDataManager(Depth), - PMTopLevelManager(new FPPassManager(1)), wasRun(false) {} + explicit FunctionPassManagerImpl() : + Pass(PT_PassManager, ID), PMDataManager(), + PMTopLevelManager(new FPPassManager()), wasRun(false) {} /// 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 @@ -266,7 +269,7 @@ public: Info.setPreservesAll(); } - inline void addTopLevelPass(Pass *P) { + void addTopLevelPass(Pass *P) { if (ImmutablePass *IP = P->getAsImmutablePass()) { // P is a immutable pass and it will be managed by this // top level manager. Set up analysis resolver to connect them. @@ -299,8 +302,8 @@ char FunctionPassManagerImpl::ID = 0; class MPPassManager : public Pass, public PMDataManager { public: static char ID; - explicit MPPassManager(int Depth) : - Pass(PT_PassManager, ID), PMDataManager(Depth) { } + explicit MPPassManager() : + Pass(PT_PassManager, ID), PMDataManager() { } // Delete on the fly managers. virtual ~MPPassManager() { @@ -345,7 +348,7 @@ public: // Print passes managed by this manager void dumpPassStructure(unsigned Offset) { - llvm::dbgs() << std::string(Offset*2, ' ') << "ModulePass Manager\n"; + llvm::dbgs().indent(Offset*2) << "ModulePass Manager\n"; for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { ModulePass *MP = getContainedPass(Index); MP->dumpPassStructure(Offset + 1); @@ -384,9 +387,9 @@ class PassManagerImpl : public Pass, public: static char ID; - explicit PassManagerImpl(int Depth) : - Pass(PT_PassManager, ID), PMDataManager(Depth), - PMTopLevelManager(new MPPassManager(1)) {} + explicit PassManagerImpl() : + Pass(PT_PassManager, ID), PMDataManager(), + PMTopLevelManager(new MPPassManager()) {} /// 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 @@ -410,7 +413,7 @@ public: Info.setPreservesAll(); } - inline void addTopLevelPass(Pass *P) { + void addTopLevelPass(Pass *P) { if (ImmutablePass *IP = P->getAsImmutablePass()) { // P is a immutable pass and it will be managed by this // top level manager. Set up analysis resolver to connect them. @@ -439,6 +442,20 @@ char PassManagerImpl::ID = 0; namespace { +//===----------------------------------------------------------------------===// +// DebugInfoProbe + +static DebugInfoProbeInfo *TheDebugProbe; +static void createDebugInfoProbe() { + if (TheDebugProbe) return; + + // Constructed the first time this is called. This guarantees that the + // object will be constructed, if -enable-debug-info-probe is set, + // before static globals, thus it will be destroyed before them. + static ManagedStatic DIP; + TheDebugProbe = &*DIP; +} + //===----------------------------------------------------------------------===// /// TimingInfo Class - This class is used to calculate information about the /// amount of time each pass takes to execute. This only happens when @@ -497,9 +514,14 @@ PMTopLevelManager::PMTopLevelManager(PMDataManager *PMDM) { } /// Set pass P as the last user of the given analysis passes. -void PMTopLevelManager::setLastUser(SmallVector &AnalysisPasses, - Pass *P) { - for (SmallVector::iterator I = AnalysisPasses.begin(), +void +PMTopLevelManager::setLastUser(const SmallVectorImpl &AnalysisPasses, + Pass *P) { + unsigned PDepth = 0; + if (P->getResolver()) + PDepth = P->getResolver()->getPMDataManager().getDepth(); + + for (SmallVectorImpl::const_iterator I = AnalysisPasses.begin(), E = AnalysisPasses.end(); I != E; ++I) { Pass *AP = *I; LastUser[AP] = P; @@ -507,20 +529,47 @@ void PMTopLevelManager::setLastUser(SmallVector &AnalysisPasses, if (P == AP) continue; + // Update the last users of passes that are required transitive by AP. + AnalysisUsage *AnUsage = findAnalysisUsage(AP); + const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet(); + SmallVector LastUses; + SmallVector LastPMUses; + for (AnalysisUsage::VectorType::const_iterator I = IDs.begin(), + E = IDs.end(); I != E; ++I) { + Pass *AnalysisPass = findAnalysisPass(*I); + assert(AnalysisPass && "Expected analysis pass to exist."); + AnalysisResolver *AR = AnalysisPass->getResolver(); + assert(AR && "Expected analysis resolver to exist."); + unsigned APDepth = AR->getPMDataManager().getDepth(); + + if (PDepth == APDepth) + LastUses.push_back(AnalysisPass); + else if (PDepth > APDepth) + LastPMUses.push_back(AnalysisPass); + } + + setLastUser(LastUses, P); + + // If this pass has a corresponding pass manager, push higher level + // analysis to this pass manager. + if (P->getResolver()) + setLastUser(LastPMUses, P->getResolver()->getPMDataManager().getAsPass()); + + // If AP is the last user of other passes then make P last user of // such passes. 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. + // this is just updating existing entries. LastUser[LUI->first] = P; } } } /// Collect passes whose last user is P -void PMTopLevelManager::collectLastUses(SmallVector &LastUses, +void PMTopLevelManager::collectLastUses(SmallVectorImpl &LastUses, Pass *P) { DenseMap >::iterator DMI = InversedLastUser.find(P); @@ -582,6 +631,7 @@ void PMTopLevelManager::schedulePass(Pass *P) { Pass *AnalysisPass = findAnalysisPass(*I); if (!AnalysisPass) { const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(*I); + assert(PI && "Expected required passes to be initialized"); AnalysisPass = PI->createPass(); if (P->getPotentialPassManagerType () == AnalysisPass->getPotentialPassManagerType()) @@ -591,7 +641,7 @@ void PMTopLevelManager::schedulePass(Pass *P) { AnalysisPass->getPotentialPassManagerType()) { // Schedule analysis pass that is managed by a new manager. schedulePass(AnalysisPass); - // Recheck analysis passes to ensure that required analysises that + // Recheck analysis passes to ensure that required analyses that // are already checked are still available. checkAnalysis = true; } @@ -612,41 +662,41 @@ void PMTopLevelManager::schedulePass(Pass *P) { /// then return NULL. Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { - Pass *P = NULL; // Check pass managers - for (SmallVector::iterator I = PassManagers.begin(), - E = PassManagers.end(); P == NULL && I != E; ++I) { - PMDataManager *PMD = *I; - P = PMD->findAnalysisPass(AID, false); - } + for (SmallVectorImpl::iterator I = PassManagers.begin(), + E = PassManagers.end(); I != E; ++I) + if (Pass *P = (*I)->findAnalysisPass(AID, false)) + return P; // Check other pass managers - for (SmallVector::iterator + for (SmallVectorImpl::iterator I = IndirectPassManagers.begin(), - E = IndirectPassManagers.end(); P == NULL && I != E; ++I) - P = (*I)->findAnalysisPass(AID, false); - - for (SmallVector::iterator I = ImmutablePasses.begin(), - E = ImmutablePasses.end(); P == NULL && I != E; ++I) { + E = IndirectPassManagers.end(); I != E; ++I) + if (Pass *P = (*I)->findAnalysisPass(AID, false)) + return P; + + // Check the immutable passes. Iterate in reverse order so that we find + // the most recently registered passes first. + for (SmallVector::reverse_iterator I = + ImmutablePasses.rbegin(), E = ImmutablePasses.rend(); I != E; ++I) { AnalysisID PI = (*I)->getPassID(); if (PI == AID) - P = *I; + return *I; // If Pass not found then check the interfaces implemented by Immutable Pass - if (!P) { - const PassInfo *PassInf = - PassRegistry::getPassRegistry()->getPassInfo(PI); - const std::vector &ImmPI = - PassInf->getInterfacesImplemented(); - for (std::vector::const_iterator II = ImmPI.begin(), - EE = ImmPI.end(); II != EE; ++II) { - if ((*II)->getTypeInfo() == AID) - P = *I; - } + const PassInfo *PassInf = + PassRegistry::getPassRegistry()->getPassInfo(PI); + assert(PassInf && "Expected all immutable passes to be initialized"); + const std::vector &ImmPI = + PassInf->getInterfacesImplemented(); + for (std::vector::const_iterator II = ImmPI.begin(), + EE = ImmPI.end(); II != EE; ++II) { + if ((*II)->getTypeInfo() == AID) + return *I; } } - return P; + return 0; } // Print passes managed by this top level manager. @@ -675,6 +725,14 @@ void PMTopLevelManager::dumpArguments() const { return; dbgs() << "Pass Arguments: "; + for (SmallVector::const_iterator I = + ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) + if (const PassInfo *PI = + PassRegistry::getPassRegistry()->getPassInfo((*I)->getPassID())) { + assert(PI && "Expected all immutable passes to be initialized"); + if (!PI->isAnalysisGroup()) + dbgs() << " -" << PI->getPassArgument(); + } for (SmallVector::const_iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) (*I)->dumpPassArguments(); @@ -682,12 +740,12 @@ void PMTopLevelManager::dumpArguments() const { } void PMTopLevelManager::initializeAllAnalysisInfo() { - for (SmallVector::iterator I = PassManagers.begin(), + for (SmallVectorImpl::iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) (*I)->initializeAnalysisInfo(); // Initailize other pass managers - for (SmallVector::iterator + for (SmallVectorImpl::iterator I = IndirectPassManagers.begin(), E = IndirectPassManagers.end(); I != E; ++I) (*I)->initializeAnalysisInfo(); @@ -708,11 +766,11 @@ void PMTopLevelManager::initializeAllAnalysisInfo() { /// Destructor PMTopLevelManager::~PMTopLevelManager() { - for (SmallVector::iterator I = PassManagers.begin(), + for (SmallVectorImpl::iterator I = PassManagers.begin(), E = PassManagers.end(); I != E; ++I) delete *I; - for (SmallVector::iterator + for (SmallVectorImpl::iterator I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) delete *I; @@ -749,7 +807,7 @@ bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { return true; const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); - for (SmallVector::iterator I = HigherLevelAnalysis.begin(), + for (SmallVectorImpl::iterator I = HigherLevelAnalysis.begin(), E = HigherLevelAnalysis.end(); I != E; ++I) { Pass *P1 = *I; if (P1->getAsImmutablePass() == 0 && @@ -849,7 +907,7 @@ void PMDataManager::removeDeadPasses(Pass *P, StringRef Msg, dbgs() << " Free these instances\n"; } - for (SmallVector::iterator I = DeadPasses.begin(), + for (SmallVectorImpl::iterator I = DeadPasses.begin(), E = DeadPasses.end(); I != E; ++I) freePass(*I, Msg, DBG_STR); } @@ -910,7 +968,7 @@ void PMDataManager::add(Pass *P, bool ProcessAnalysis) { collectRequiredAnalysis(RequiredPasses, ReqAnalysisNotAvailable, P); - for (SmallVector::iterator I = RequiredPasses.begin(), + for (SmallVectorImpl::iterator I = RequiredPasses.begin(), E = RequiredPasses.end(); I != E; ++I) { Pass *PRequired = *I; unsigned RDepth = 0; @@ -927,7 +985,7 @@ void PMDataManager::add(Pass *P, bool ProcessAnalysis) { // Keep track of higher level analysis used by this manager. HigherLevelAnalysis.push_back(PRequired); } else - llvm_unreachable("Unable to accomodate Required Pass"); + llvm_unreachable("Unable to accommodate Required Pass"); } // Set P as P's last user until someone starts using P. @@ -943,8 +1001,8 @@ void PMDataManager::add(Pass *P, bool ProcessAnalysis) { TransferLastUses.clear(); } - // Now, take care of required analysises that are not available. - for (SmallVector::iterator + // Now, take care of required analyses that are not available. + for (SmallVectorImpl::iterator I = ReqAnalysisNotAvailable.begin(), E = ReqAnalysisNotAvailable.end() ;I != E; ++I) { const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(*I); @@ -965,8 +1023,8 @@ void PMDataManager::add(Pass *P, bool ProcessAnalysis) { /// 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, +void PMDataManager::collectRequiredAnalysis(SmallVectorImpl &RP, + SmallVectorImpl &RP_NotAvail, Pass *P) { AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet(); @@ -1038,7 +1096,7 @@ void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ TPM->collectLastUses(LUses, P); - for (SmallVector::iterator I = LUses.begin(), + for (SmallVectorImpl::iterator I = LUses.begin(), E = LUses.end(); I != E; ++I) { llvm::dbgs() << "--" << std::string(Offset*2, ' '); (*I)->dumpPassStructure(0); @@ -1046,7 +1104,7 @@ void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ } void PMDataManager::dumpPassArguments() const { - for (SmallVector::const_iterator I = PassVector.begin(), + for (SmallVectorImpl::const_iterator I = PassVector.begin(), E = PassVector.end(); I != E; ++I) { if (PMDataManager *PMD = (*I)->getAsPMDataManager()) PMD->dumpPassArguments(); @@ -1087,6 +1145,9 @@ void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1, case ON_MODULE_MSG: dbgs() << "' on Module '" << Msg << "'...\n"; break; + case ON_REGION_MSG: + dbgs() << "' on Region '" << Msg << "'...\n"; + break; case ON_LOOP_MSG: dbgs() << "' on Loop '" << Msg << "'...\n"; break; @@ -1125,6 +1186,12 @@ void PMDataManager::dumpAnalysisUsage(StringRef Msg, const Pass *P, for (unsigned i = 0; i != Set.size(); ++i) { if (i) dbgs() << ','; const PassInfo *PInf = PassRegistry::getPassRegistry()->getPassInfo(Set[i]); + if (!PInf) { + // Some preserved passes, such as AliasAnalysis, may not be initialized by + // all drivers. + dbgs() << " Uninitialized Pass"; + continue; + } dbgs() << ' ' << PInf->getPassName(); } dbgs() << '\n'; @@ -1163,7 +1230,7 @@ Pass *PMDataManager::getOnTheFlyPass(Pass *P, AnalysisID PI, Function &F) { // Destructor PMDataManager::~PMDataManager() { - for (SmallVector::iterator I = PassVector.begin(), + for (SmallVectorImpl::iterator I = PassVector.begin(), E = PassVector.end(); I != E; ++I) delete *I; } @@ -1272,7 +1339,7 @@ bool BBPassManager::doFinalization(Function &F) { /// Create new Function pass manager FunctionPassManager::FunctionPassManager(Module *m) : M(m) { - FPM = new FunctionPassManagerImpl(0); + FPM = new FunctionPassManagerImpl(); // FPM is the top level manager. FPM->setTopLevelManager(FPM); @@ -1388,6 +1455,7 @@ void FunctionPassManagerImpl::releaseMemoryOnTheFly() { bool FunctionPassManagerImpl::run(Function &F) { bool Changed = false; TimingInfo::createTheTimeInfo(); + createDebugInfoProbe(); initializeAllAnalysisInfo(); for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) @@ -1435,13 +1503,16 @@ bool FPPassManager::runOnFunction(Function &F) { dumpRequiredSet(FP); initializeAnalysisImpl(FP); - + if (TheDebugProbe) + TheDebugProbe->initialize(FP, F); { PassManagerPrettyStackEntry X(FP, F); TimeRegion PassTimer(getPassTimer(FP)); LocalChanged |= FP->runOnFunction(F); } + if (TheDebugProbe) + TheDebugProbe->finalize(FP, F); Changed |= LocalChanged; if (LocalChanged) @@ -1460,7 +1531,7 @@ bool FPPassManager::runOnModule(Module &M) { bool Changed = doInitialization(M); for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - runOnFunction(*I); + Changed |= runOnFunction(*I); return doFinalization(M) || Changed; } @@ -1554,7 +1625,7 @@ void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; if (!FPP) { - FPP = new FunctionPassManagerImpl(0); + FPP = new FunctionPassManagerImpl(); // FPP is the top level manager. FPP->setTopLevelManager(FPP); @@ -1563,9 +1634,11 @@ void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { FPP->add(RequiredPass); // Register P as the last user of RequiredPass. - SmallVector LU; - LU.push_back(RequiredPass); - FPP->setLastUser(LU, P); + if (RequiredPass) { + SmallVector LU; + LU.push_back(RequiredPass); + FPP->setLastUser(LU, P); + } } /// Return function pass corresponding to PassInfo PI, that is @@ -1589,6 +1662,7 @@ Pass* MPPassManager::getOnTheFlyPass(Pass *MP, AnalysisID PI, Function &F){ bool PassManagerImpl::run(Module &M) { bool Changed = false; TimingInfo::createTheTimeInfo(); + createDebugInfoProbe(); dumpArguments(); dumpPasses(); @@ -1604,7 +1678,7 @@ bool PassManagerImpl::run(Module &M) { /// Create new pass manager PassManager::PassManager() { - PM = new PassManagerImpl(0); + PM = new PassManagerImpl(); // PM is the top level manager PM->setTopLevelManager(PM); } @@ -1688,13 +1762,23 @@ void PMStack::pop() { // Push PM on the stack and set its top level manager. void PMStack::push(PMDataManager *PM) { assert(PM && "Unable to push. Pass Manager expected"); + assert(PM->getDepth()==0 && "Pass Manager depth set too early"); if (!this->empty()) { + assert(PM->getPassManagerType() > this->top()->getPassManagerType() + && "pushing bad pass manager to PMStack"); PMTopLevelManager *TPM = this->top()->getTopLevelManager(); assert(TPM && "Unable to find top level manager"); TPM->addIndirectPassManager(PM); PM->setTopLevelManager(TPM); + PM->setDepth(this->top()->getDepth()+1); + } + else { + assert((PM->getPassManagerType() == PMT_ModulePassManager + || PM->getPassManagerType() == PMT_FunctionPassManager) + && "pushing bad pass manager to PMStack"); + PM->setDepth(1); } S.push_back(PM); @@ -1704,10 +1788,10 @@ void PMStack::push(PMDataManager *PM) { void PMStack::dump() const { for (std::vector::const_iterator I = S.begin(), E = S.end(); I != E; ++I) - printf("%s ", (*I)->getAsPass()->getPassName()); + dbgs() << (*I)->getAsPass()->getPassName() << ' '; if (!S.empty()) - printf("\n"); + dbgs() << '\n'; } /// Find appropriate Module Pass Manager in the PM Stack and @@ -1750,7 +1834,7 @@ void FunctionPass::assignPassManager(PMStack &PMS, PMDataManager *PMD = PMS.top(); // [1] Create new Function Pass Manager - FPP = new FPPassManager(PMD->getDepth() + 1); + FPP = new FPPassManager(); FPP->populateInheritedAnalysis(PMS); // [2] Set up new manager's top level manager @@ -1787,7 +1871,7 @@ void BasicBlockPass::assignPassManager(PMStack &PMS, PMDataManager *PMD = PMS.top(); // [1] Create new Basic Block Manager - BBP = new BBPassManager(PMD->getDepth() + 1); + BBP = new BBPassManager(); // [2] Set up new manager's top level manager // Basic Block Pass Manager does not live by itself