X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=e7d7c5bc7288d171602b34d0ee7925ec400811fe;hp=46ad33bf96489695eaff7cfdcf6efbfa5c53740e;hb=d78c0f5a7255e4347cbd82f7435c51401096652c;hpb=09e6e4303f1aac10fea6860e7736c234fcbf56cc diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index 46ad33bf964..e7d7c5bc728 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. // //===----------------------------------------------------------------------===// // @@ -12,85 +12,20 @@ //===----------------------------------------------------------------------===// -#include "llvm/PassManager.h" +#include "llvm/PassManagers.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/Timer.h" #include "llvm/Module.h" #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; -class llvm::PMDataManager; -//===----------------------------------------------------------------------===// -// Overview: -// The Pass Manager Infrastructure manages passes. It's responsibilities are: -// -// o Manage optimization pass execution order -// o Make required Analysis information available before pass P is run -// o Release memory occupied by dead passes -// o If Analysis information is dirtied by a pass then regenerate Analysis -// information before it is consumed by another pass. -// -// Pass Manager Infrastructure uses multiple pass managers. They are -// PassManager, FunctionPassManager, MPPassManager, FPPassManager, BBPassManager. -// This class hierarcy uses multiple inheritance but pass managers do not derive -// from another pass manager. -// -// PassManager and FunctionPassManager are two top-level pass manager that -// represents the external interface of this entire pass manager infrastucture. -// -// Important classes : -// -// [o] class PMTopLevelManager; -// -// Two top level managers, PassManager and FunctionPassManager, derive from -// PMTopLevelManager. PMTopLevelManager manages information used by top level -// managers such as last user info. -// -// [o] class PMDataManager; -// -// PMDataManager manages information, e.g. list of available analysis info, -// used by a pass manager to manage execution order of passes. It also provides -// a place to implement common pass manager APIs. All pass managers derive from -// PMDataManager. -// -// [o] class BBPassManager : public FunctionPass, public PMDataManager; -// -// BBPassManager manages BasicBlockPasses. -// -// [o] class FunctionPassManager; -// -// This is a external interface used by JIT to manage FunctionPasses. This -// interface relies on FunctionPassManagerImpl to do all the tasks. -// -// [o] class FunctionPassManagerImpl : public ModulePass, PMDataManager, -// public PMTopLevelManager; -// -// FunctionPassManagerImpl is a top level manager. It manages FPPassManagers -// -// [o] class FPPassManager : public ModulePass, public PMDataManager; -// -// FPPassManager manages FunctionPasses and BBPassManagers -// -// [o] class MPPassManager : public Pass, public PMDataManager; -// -// MPPassManager manages ModulePasses and FPPassManagers -// -// [o] class PassManager; -// -// This is a external interface used by various tools to manages passes. It -// relies on PassManagerImpl to do all the tasks. -// -// [o] class PassManagerImpl : public Pass, public PMDataManager, -// public PMDTopLevelManager -// -// PassManagerImpl is a top level pass manager responsible for managing -// MPPassManagers. -//===----------------------------------------------------------------------===// +// See PassManagers.h for Pass Manager infrastructure overview. namespace llvm { @@ -107,7 +42,7 @@ enum PassDebugLevel { }; static cl::opt -PassDebugging_New("debug-pass", cl::Hidden, +PassDebugging("debug-pass", cl::Hidden, cl::desc("Print PassManager debugging information"), cl::values( clEnumVal(None , "disable debug output"), @@ -120,201 +55,6 @@ PassDebugging_New("debug-pass", cl::Hidden, namespace { -//===----------------------------------------------------------------------===// -// PMTopLevelManager -// -/// PMTopLevelManager manages LastUser info and collects common APIs used by -/// top level pass managers. -class VISIBILITY_HIDDEN PMTopLevelManager { -public: - - virtual unsigned getNumContainedManagers() { - return PassManagers.size(); - } - - /// Schedule pass P for execution. Make sure that passes required by - /// P are run before P is run. Update analysis info maintained by - /// the manager. Remove dead passes. This is a recursive function. - void schedulePass(Pass *P); - - /// This is implemented by top level pass manager and used by - /// schedulePass() to add analysis info passes that are not available. - virtual void addTopLevelPass(Pass *P) = 0; - - /// Set pass P as the last user of the given analysis passes. - void setLastUser(std::vector &AnalysisPasses, Pass *P); - - /// Collect passes whose last user is P - void collectLastUses(std::vector &LastUses, Pass *P); - - /// Find the pass that implements Analysis AID. Search immutable - /// passes and all pass managers. If desired pass is not found - /// then return NULL. - Pass *findAnalysisPass(AnalysisID AID); - - virtual ~PMTopLevelManager() { - 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(); - } - - /// Add immutable pass and initialize it. - inline void addImmutablePass(ImmutablePass *P) { - P->initializePass(); - ImmutablePasses.push_back(P); - } - - inline std::vector& getImmutablePasses() { - return ImmutablePasses; - } - - void addPassManager(Pass *Manager) { - PassManagers.push_back(Manager); - } - - // Add Manager into the list of managers that are not directly - // maintained by this top level pass manager - inline void addIndirectPassManager(PMDataManager *Manager) { - IndirectPassManagers.push_back(Manager); - } - - // Print passes managed by this top level manager. - void dumpPasses() const; - void dumpArguments() const; - - void initializeAllAnalysisInfo(); - -protected: - - /// Collection of pass managers - std::vector PassManagers; - -private: - - /// Collection of pass managers that are not directly maintained - /// by this pass manager - std::vector IndirectPassManagers; - - // Map to keep track of last user of the analysis pass. - // LastUser->second is the last user of Lastuser->first. - std::map LastUser; - - /// Immutable passes are managed by top level manager. - std::vector ImmutablePasses; -}; - -} // End of anon namespace - -//===----------------------------------------------------------------------===// -// PMDataManager - -namespace llvm { -/// PMDataManager provides the common place to manage the analysis data -/// used by pass managers. -class PMDataManager { -public: - PMDataManager(int Depth) : TPM(NULL), Depth(Depth) { - initializeAnalysisInfo(); - } - - virtual ~PMDataManager() { - - for (std::vector::iterator I = PassVector.begin(), - E = PassVector.end(); I != E; ++I) - delete *I; - - PassVector.clear(); - } - - /// Return true IFF pass P's required analysis set does not required new - /// manager. - bool manageablePass(Pass *P); - - /// Augment AvailableAnalysis by adding analysis made available by pass P. - void recordAvailableAnalysis(Pass *P); - - /// Remove Analysis that is not preserved by the pass - void removeNotPreservedAnalysis(Pass *P); - - /// Remove dead passes - void removeDeadPasses(Pass *P, std::string &Msg); - - /// Add pass P into the PassVector. Update - /// AvailableAnalysis appropriately if ProcessAnalysis is true. - void addPassToManager(Pass *P, bool ProcessAnalysis = true); - - /// Initialize available analysis information. - void initializeAnalysisInfo() { - TransferLastUses.clear(); - AvailableAnalysis.clear(); - } - - /// Populate RequiredPasses with the analysis pass that are required by - /// pass P. - void collectRequiredAnalysisPasses(std::vector &RequiredPasses, - Pass *P); - - /// All Required analyses should be available to the pass as it runs! Here - /// we fill in the AnalysisImpls member of the pass so that it can - /// successfully use the getAnalysis() method to retrieve the - /// implementations it needs. - void initializeAnalysisImpl(Pass *P); - - /// Find the pass that implements Analysis AID. If desired pass is not found - /// then return NULL. - Pass *findAnalysisPass(AnalysisID AID, bool Direction); - - // Access toplevel manager - PMTopLevelManager *getTopLevelManager() { return TPM; } - void setTopLevelManager(PMTopLevelManager *T) { TPM = T; } - - unsigned getDepth() const { return Depth; } - - // Print routines used by debug-pass - void dumpLastUses(Pass *P, unsigned Offset) const; - void dumpPassArguments() const; - void dumpPassInfo(Pass *P, std::string &Msg1, std::string &Msg2) const; - void dumpAnalysisSetInfo(const char *Msg, Pass *P, - const std::vector &Set) const; - - std::vector& getTransferredLastUses() { - return TransferLastUses; - } - - virtual unsigned getNumContainedPasses() { - return PassVector.size(); - } - -protected: - - // 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. - // Current pass manage is requesting parent manager to record parent - // manager as the last user of these TrransferLastUses passes. - std::vector TransferLastUses; - - // Top level manager. - PMTopLevelManager *TPM; - - // Collection of pass that are managed by this manager - std::vector PassVector; - -private: - // Set of available Analysis. This information is used while scheduling - // pass. If a pass requires an analysis which is not not available then - // equired analysis pass is scheduled to run before the pass itself is - // scheduled to run. - std::map AvailableAnalysis; - - unsigned Depth; -}; - //===----------------------------------------------------------------------===// // BBPassManager // @@ -325,11 +65,10 @@ 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) {} - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - /// Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the function, and if so, return true. bool runOnFunction(Function &F); @@ -344,6 +83,10 @@ public: bool doFinalization(Module &M); bool doFinalization(Function &F); + virtual const char *getPassName() const { + return "BasicBlock Pass Manager"; + } + // Print passes managed by this manager void dumpPassStructure(unsigned Offset) { llvm::cerr << std::string(Offset*2, ' ') << "BasicBlockPass Manager\n"; @@ -359,78 +102,29 @@ public: BasicBlockPass *BP = static_cast(PassVector[N]); return BP; } -}; - -//===----------------------------------------------------------------------===// -// FPPassManager -// -/// FPPassManager manages BBPassManagers and FunctionPasses. -/// It batches all function passes and basic block pass managers together and -/// sequence them to process one function at a time before processing next -/// function. - -class FPPassManager : public ModulePass, public PMDataManager { - -public: - FPPassManager(int Depth) : PMDataManager(Depth) { - activeBBPassManager = NULL; - } - - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - - /// run - Execute all of the passes scheduled for execution. Keep track of - /// whether any of the passes modifies the module, and if so, return true. - bool runOnFunction(Function &F); - bool runOnModule(Module &M); - - /// doInitialization - Run all of the initializers for the function passes. - /// - bool doInitialization(Module &M); - - /// doFinalization - Run all of the initializers for the function passes. - /// - bool doFinalization(Module &M); - - /// Pass Manager itself does not invalidate any analysis info. - void getAnalysisUsage(AnalysisUsage &Info) const { - Info.setPreservesAll(); - } - // Print passes managed by this manager - void dumpPassStructure(unsigned Offset) { - llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; - for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { - FunctionPass *FP = getContainedPass(Index); - FP->dumpPassStructure(Offset + 1); - dumpLastUses(FP, Offset+1); - } + virtual PassManagerType getPassManagerType() const { + return PMT_BasicBlockPassManager; } +}; - FunctionPass *getContainedPass(unsigned N) { - assert ( N < PassVector.size() && "Pass number out of range!"); - FunctionPass *FP = static_cast(PassVector[N]); - return FP; - } +char BBPassManager::ID = 0; +} -private: - // Active Pass Manager - BBPassManager *activeBBPassManager; -}; +namespace llvm { //===----------------------------------------------------------------------===// // FunctionPassManagerImpl // /// FunctionPassManagerImpl manages FPPassManagers class FunctionPassManagerImpl : public Pass, - public PMDataManager, - public PMTopLevelManager { - + public PMDataManager, + public PMTopLevelManager { public: - - FunctionPassManagerImpl(int Depth) : PMDataManager(Depth) { - activeManager = NULL; - } + 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 @@ -448,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); @@ -468,9 +162,10 @@ public: initializeAnalysisImpl(P); addImmutablePass(IP); recordAvailableAnalysis(IP); + } else { + P->assignPassManager(activeStack); } - else - addPass(P); + } FPPassManager *getContainedManager(unsigned N) { @@ -478,32 +173,32 @@ public: FPPassManager *FP = static_cast(PassManagers[N]); return FP; } - - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - -private: - - // Active Pass Manager - FPPassManager *activeManager; }; +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) { - activeFunctionPassManager = NULL; + 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; + } } - - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - + /// run - Execute all of the passes scheduled for execution. Keep track of /// whether any of the passes modifies the module, and if so, return true. bool runOnModule(Module &M); @@ -513,12 +208,28 @@ 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"; + } + // Print passes managed by this manager void dumpPassStructure(unsigned Offset) { llvm::cerr << std::string(Offset*2, ' ') << "ModulePass Manager\n"; 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); } } @@ -529,24 +240,31 @@ public: return MP; } -private: - // Active Pass Manager - FPPassManager *activeFunctionPassManager; + 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 PMDataManager, + public PMTopLevelManager { public: - - PassManagerImpl(int Depth) : PMDataManager(Depth) { - activeManager = NULL; - } + 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 @@ -576,9 +294,10 @@ public: initializeAnalysisImpl(P); addImmutablePass(IP); recordAvailableAnalysis(IP); + } else { + P->assignPassManager(activeStack); } - else - addPass(P); + } MPPassManager *getContainedManager(unsigned N) { @@ -587,15 +306,9 @@ public: return MP; } -private: - - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - - // Active Pass Manager - MPPassManager *activeManager; }; +char PassManagerImpl::ID = 0; } // End of llvm namespace namespace { @@ -654,14 +367,35 @@ static TimingInfo *TheTimeInfo; //===----------------------------------------------------------------------===// // PMTopLevelManager implementation +/// Initialize top level manager. Create first pass manager. +PMTopLevelManager::PMTopLevelManager (enum TopLevelManagerType t) { + + if (t == TLM_Pass) { + MPPassManager *MPP = new MPPassManager(1); + MPP->setTopLevelManager(this); + addPassManager(MPP); + activeStack.push(MPP); + } + else if (t == TLM_Function) { + FPPassManager *FPP = new FPPassManager(1); + FPP->setTopLevelManager(this); + addPassManager(FPP); + activeStack.push(FPP); + } +} + /// 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(), @@ -673,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) @@ -689,6 +423,9 @@ void PMTopLevelManager::schedulePass(Pass *P) { // TODO : Allocate function manager for this pass, other wise required set // may be inserted into previous function manager + // Give pass a chance to prepare the stage. + P->preparePassManager(activeStack); + AnalysisUsage AnUsage; P->getAnalysisUsage(AnUsage); const std::vector &RequiredSet = AnUsage.getRequiredSet(); @@ -697,9 +434,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; } } @@ -714,10 +456,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); } @@ -734,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; } @@ -746,7 +488,7 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { // Print passes managed by this top level manager. void PMTopLevelManager::dumpPasses() const { - if (PassDebugging_New < Structure) + if (PassDebugging < Structure) return; // Print out the immutable passes @@ -754,21 +496,24 @@ 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 { - if (PassDebugging_New < Arguments) + if (PassDebugging < Arguments) 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"; @@ -776,10 +521,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(); } @@ -789,23 +533,20 @@ void PMTopLevelManager::initializeAllAnalysisInfo() { (*I)->initializeAnalysisInfo(); } +/// Destructor +PMTopLevelManager::~PMTopLevelManager() { + 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; +} + //===----------------------------------------------------------------------===// // 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) { @@ -820,11 +561,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; @@ -832,30 +612,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()); @@ -868,23 +672,30 @@ void PMDataManager::removeDeadPasses(Pass *P, std::string &Msg) { /// Add pass P into the PassVector. Update /// AvailableAnalysis appropriately if ProcessAnalysis is true. -void PMDataManager::addPassToManager(Pass *P, - bool ProcessAnalysis) { +void PMDataManager::add(Pass *P, + bool ProcessAnalysis) { // This manager is going to manage pass P. Set up analysis resolver // to connect them. 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; @@ -897,16 +708,33 @@ void PMDataManager::addPassToManager(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"); } - LastUses.push_back(P); + // Set P as P's last user until someone starts using P. + // However, if P is a Pass Manager then it does not need + // to record its last user. + if (!dynamic_cast(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); @@ -917,27 +745,34 @@ void PMDataManager::addPassToManager(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); } } @@ -955,7 +790,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); } @@ -981,12 +818,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); @@ -1005,20 +845,50 @@ void PMDataManager::dumpPassArguments() const { } } -void PMDataManager:: dumpPassInfo(Pass *P, std::string &Msg1, - std::string &Msg2) const { - if (PassDebugging_New < Executions) +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, const std::vector &Set) const { - if (PassDebugging_New >= Details && !Set.empty()) { + 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 << ","; @@ -1028,6 +898,37 @@ 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() { + + for (std::vector::iterator I = PassVector.begin(), + E = PassVector.end(); I != E; ++I) + delete *I; + +} + //===----------------------------------------------------------------------===// // NOTE: Is this the right place to define this method ? // getAnalysisToUpdate - Return an analysis result or null if it doesn't exist @@ -1035,50 +936,32 @@ 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 -/// Add pass P into PassVector and return true. If this pass is not -/// manageable by this manager then return false. -bool -BBPassManager::addPass(Pass *P) { - - BasicBlockPass *BP = dynamic_cast(P); - if (!BP) - return false; - - // If this pass does not preserve analysis that is used by other passes - // managed by this manager than it is not a suitable pass for this manager. - if (!manageablePass(P)) - return false; - - addPassToManager(BP); - - return true; -} - /// Execute all of the passes scheduled for execution by invoking /// runOnBasicBlock method. Keep track of whether any of the passes modifies /// the function, and if so, return true. bool BBPassManager::runOnFunction(Function &F) { - if (F.isExternal()) + if (F.isDeclaration()) return false; 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); @@ -1087,14 +970,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); } @@ -1153,8 +1039,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; @@ -1180,7 +1065,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); @@ -1193,7 +1078,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()); @@ -1202,26 +1087,6 @@ bool FunctionPassManager::doFinalization() { //===----------------------------------------------------------------------===// // FunctionPassManagerImpl implementation // -/// Add P into active pass manager or use new module pass manager to -/// manage it. -bool FunctionPassManagerImpl::addPass(Pass *P) { - - if (!activeManager || !activeManager->addPass(P)) { - activeManager = new FPPassManager(getDepth() + 1); - // Inherit top level manager - activeManager->setTopLevelManager(this->getTopLevelManager()); - - // This top level manager is going to manage activeManager. - // Set up analysis resolver to connect them. - AnalysisResolver *AR = new AnalysisResolver(*this); - activeManager->setResolver(AR); - - addPassManager(activeManager); - return activeManager->addPass(P); - } - return true; -} - inline bool FunctionPassManagerImpl::doInitialization(Module &M) { bool Changed = false; @@ -1266,68 +1131,18 @@ bool FunctionPassManagerImpl::run(Function &F) { //===----------------------------------------------------------------------===// // FPPassManager implementation -/// Add pass P into the pass manager queue. If P is a BasicBlockPass then -/// either use it into active basic block pass manager or create new basic -/// block pass manager to handle pass P. -bool -FPPassManager::addPass(Pass *P) { - - // If P is a BasicBlockPass then use BBPassManager. - if (BasicBlockPass *BP = dynamic_cast(P)) { - - if (!activeBBPassManager || !activeBBPassManager->addPass(BP)) { - - // If active manager exists then clear its analysis info. - if (activeBBPassManager) - activeBBPassManager->initializeAnalysisInfo(); - - // Create and add new manager - activeBBPassManager = new BBPassManager(getDepth() + 1); - // Inherit top level manager - activeBBPassManager->setTopLevelManager(this->getTopLevelManager()); - - // Add new manager into current manager's list. - addPassToManager(activeBBPassManager, false); - - // Add new manager into top level manager's indirect passes list - PMDataManager *PMD = dynamic_cast(activeBBPassManager); - assert (PMD && "Manager is not Pass Manager"); - TPM->addIndirectPassManager(PMD); - - // Add pass into new manager. This time it must succeed. - if (!activeBBPassManager->addPass(BP)) - assert(0 && "Unable to add Pass"); - - // If activeBBPassManager transfered any Last Uses then handle them here. - std::vector &TLU = activeBBPassManager->getTransferredLastUses(); - if (!TLU.empty()) - TPM->setLastUser(TLU, this); - - } - - return true; - } - - FunctionPass *FP = dynamic_cast(P); - if (!FP) - return false; - - // If this pass does not preserve analysis that is used by other passes - // managed by this manager than it is not a suitable pass for this manager. - if (!manageablePass(P)) - return false; - - addPassToManager (FP); - - // If active manager exists then clear its analysis info. - if (activeBBPassManager) { - activeBBPassManager->initializeAnalysisInfo(); - activeBBPassManager = NULL; +char FPPassManager::ID = 0; +/// Print passes managed by this manager +void FPPassManager::dumpPassStructure(unsigned Offset) { + llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n"; + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + FunctionPass *FP = getContainedPass(Index); + FP->dumpPassStructure(Offset + 1); + dumpLastUses(FP, Offset+1); } - - return true; } + /// Execute all of the passes scheduled for execution by invoking /// runOnFunction method. Keep track of whether any of the passes modifies /// the function, and if so, return true. @@ -1335,20 +1150,16 @@ bool FPPassManager::runOnFunction(Function &F) { bool Changed = false; - if (F.isExternal()) + 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); @@ -1357,13 +1168,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; } @@ -1403,72 +1215,6 @@ inline bool FPPassManager::doFinalization(Module &M) { //===----------------------------------------------------------------------===// // MPPassManager implementation -/// Add P into pass vector if it is manageble. If P is a FunctionPass -/// then use FPPassManager to manage it. Return false if P -/// is not manageable by this manager. -bool -MPPassManager::addPass(Pass *P) { - - // If P is FunctionPass then use function pass maanager. - if (FunctionPass *FP = dynamic_cast(P)) { - - if (!activeFunctionPassManager || !activeFunctionPassManager->addPass(P)) { - - // If active manager exists then clear its analysis info. - if (activeFunctionPassManager) - activeFunctionPassManager->initializeAnalysisInfo(); - - // Create and add new manager - activeFunctionPassManager = - new FPPassManager(getDepth() + 1); - - // Add new manager into current manager's list - addPassToManager(activeFunctionPassManager, false); - - // Inherit top level manager - activeFunctionPassManager->setTopLevelManager(this->getTopLevelManager()); - - // Add new manager into top level manager's indirect passes list - PMDataManager *PMD = - dynamic_cast(activeFunctionPassManager); - assert(PMD && "Manager is not Pass Manager"); - TPM->addIndirectPassManager(PMD); - - // Add pass into new manager. This time it must succeed. - if (!activeFunctionPassManager->addPass(FP)) - assert(0 && "Unable to add pass"); - - // If activeFunctionPassManager transfered any Last Uses then - // handle them here. - std::vector &TLU = - activeFunctionPassManager->getTransferredLastUses(); - if (!TLU.empty()) - TPM->setLastUser(TLU, this); - } - - return true; - } - - ModulePass *MP = dynamic_cast(P); - if (!MP) - return false; - - // If this pass does not preserve analysis that is used by other passes - // managed by this manager than it is not a suitable pass for this manager. - if (!manageablePass(P)) - return false; - - addPassToManager(MP); - // If active manager exists then clear its analysis info. - if (activeFunctionPassManager) { - activeFunctionPassManager->initializeAnalysisInfo(); - activeFunctionPassManager = NULL; - } - - return true; -} - - /// Execute all of the passes scheduled for execution by invoking /// runOnModule method. Keep track of whether any of the passes modifies /// the module, and if so, return true. @@ -1476,17 +1222,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); @@ -1495,42 +1238,63 @@ 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; } -//===----------------------------------------------------------------------===// -// PassManagerImpl implementation -// -/// Add P into active pass manager or use new module pass manager to -/// manage it. -bool PassManagerImpl::addPass(Pass *P) { - - if (!activeManager || !activeManager->addPass(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. +void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { - activeManager = new MPPassManager(getDepth() + 1); - - // Inherit top level manager - activeManager->setTopLevelManager(this->getTopLevelManager()); + 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"); - // This top level manager is going to manage activeManager. - // Set up analysis resolver to connect them. - AnalysisResolver *AR = new AnalysisResolver(*this); - activeManager->setResolver(AR); + FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; + if (!FPP) { + FPP = new FunctionPassManagerImpl(0); + // FPP is the top level manager. + FPP->setTopLevelManager(FPP); - addPassManager(activeManager); - return activeManager->addPass(P); + OnTheFlyManagers[P] = FPP; } - return true; + 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 +// /// 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 PassManagerImpl::run(Module &M) { @@ -1603,9 +1367,22 @@ void TimingInfo::createTheTimeInfo() { TheTimeInfo = &*TTI; } +/// If TimingInfo is enabled then start pass timer. +void StartPassTimer(Pass *P) { + if (TheTimeInfo) + TheTimeInfo->passStarted(P); +} + +/// If TimingInfo is enabled then stop pass timer. +void StopPassTimer(Pass *P) { + if (TheTimeInfo) + TheTimeInfo->passEnded(P); +} + //===----------------------------------------------------------------------===// // PMStack implementation // + // Pop Pass Manager from the stack and clear its analysis info. void PMStack::pop() { @@ -1618,125 +1395,165 @@ void PMStack::pop() { // Push PM on the stack and set its top level manager. void PMStack::push(PMDataManager *PM) { - PMDataManager *Top = this->top(); + PMDataManager *Top = NULL; + assert (PM && "Unable to push. Pass Manager expected"); - // Inherit top level manager - PMTopLevelManager *TPM = Top->getTopLevelManager(); - PM->setTopLevelManager(TPM); - TPM->addIndirectPassManager(PM); -} + if (this->empty()) { + Top = PM; + } + else { + Top = this->top(); + PMTopLevelManager *TPM = Top->getTopLevelManager(); -// Walk Pass Manager stack and set LastUse markers if any -// manager is transfering this priviledge to its parent manager -void PMStack::handleLastUserOverflow() { + assert (TPM && "Unable to find top level manager"); + TPM->addIndirectPassManager(PM); + PM->setTopLevelManager(TPM); + } - for(PMStack::iterator I = this->begin(), E = this->end(); I != E;) { + S.push_back(PM); +} - 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); - } - } +// Dump content of the pass manager stack. +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()); } + if (!S.empty()) + printf("\n"); } /// Find appropriate Module Pass Manager in the PM Stack and /// add self into that manager. -void ModulePass::assignPassManager(PMStack &PMS) { - - MPPassManager *MPP = NULL; +void ModulePass::assignPassManager(PMStack &PMS, + PassManagerType PreferredType) { // Find Module Pass Manager while(!PMS.empty()) { - - MPP = dynamic_cast(PMS.top()); - if (MPP) - break; // Found it - else + PassManagerType TopPMType = PMS.top()->getPassManagerType(); + if (TopPMType == PreferredType) + break; // We found desired pass manager + else if (TopPMType > PMT_ModulePassManager) PMS.pop(); // Pop children pass managers + else + break; } - assert(MPP && "Unable to find Module Pass Manager"); - - MPP->addPassToManager(this); + PMS.top()->add(this); } /// 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) { - - FPPassManager *FPP = NULL; +void FunctionPass::assignPassManager(PMStack &PMS, + PassManagerType PreferredType) { - // Find Module Pass Manager + // Find Module Pass Manager (TODO : Or Call Graph Pass Manager) while(!PMS.empty()) { - - FPP = dynamic_cast(PMS.top()); - if (FPP || dynamic_cast(PMS.top())) - break; // Found it or it is not here + if (PMS.top()->getPassManagerType() > PMT_FunctionPassManager) + PMS.pop(); else - PMS.pop(); // Pop children pass managers + break; } + FPPassManager *FPP = dynamic_cast(PMS.top()); + // Create new Function Pass Manager if (!FPP) { - /// Create new Function Pass Manager - - /// Function Pass Manager does not live by itself assert(!PMS.empty() && "Unable to create Function Pass Manager"); - PMDataManager *PMD = PMS.top(); - - /// PMD should be either Module Pass Manager or Call Graph Pass Manager - assert(dynamic_cast(PMD) && - "Unable to create Function Pass Manager"); + // [1] Create new Function Pass Manager FPP = new FPPassManager(PMD->getDepth() + 1); - PMD->addPassToManager(FPP, false); + + // [2] Set up new manager's top level manager + PMTopLevelManager *TPM = PMD->getTopLevelManager(); + TPM->addIndirectPassManager(FPP); + + // [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); + + // [4] Push new manager into PMS PMS.push(FPP); } - - FPP->addPassToManager(this); + // Assign FPP as the manager of this pass. + FPP->add(this); } /// 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) { +void BasicBlockPass::assignPassManager(PMStack &PMS, + PassManagerType PreferredType) { BBPassManager *BBP = NULL; - // Find Module Pass Manager - while(!PMS.empty()) { - + // Basic Pass Manager is a leaf pass manager. It does not handle + // any other pass manager. + if (!PMS.empty()) BBP = dynamic_cast(PMS.top()); - if (BBP || dynamic_cast(PMS.top())) - break; // Found it or it is not here - else - PMS.pop(); // Pop children pass managers - } - if (!BBP) { - /// Create new BasicBlock Pass Manager + // If leaf manager is not Basic Block Pass manager then create new + // basic Block Pass manager. - /// BasicBlock Pass Manager does not live by itself + if (!BBP) { assert(!PMS.empty() && "Unable to create BasicBlock Pass Manager"); - PMDataManager *PMD = PMS.top(); - - /// PMD should be Function Pass Manager - assert(dynamic_cast(PMD) && - "Unable to create BasicBlock Pass Manager"); + // [1] Create new Basic Block Manager BBP = new BBPassManager(PMD->getDepth() + 1); - PMD->addPassToManager(BBP, false); + + // [2] Set up new manager's top level manager + // Basic Block Pass Manager does not live by itself + PMTopLevelManager *TPM = PMD->getTopLevelManager(); + TPM->addIndirectPassManager(BBP); + + // [3] Assign manager to manage this new manager. This may create + // and push new managers into PMS + BBP->assignPassManager(PMS); + + // [4] Push new manager into PMS PMS.push(BBP); } - BBP->addPassToManager(this); + // Assign BBP as the manager of this pass. + 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); +}