X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FPassManager.cpp;h=edcdf7ffe390adb963fa9247990481af6fbe7a73;hb=7ee5d354938b231b1d01a76f686ee4dcbfa27600;hp=bc469d33115d6d4589f19b1826d727852f5ebe4e;hpb=b920bd85adba95553568cef6a7078ee2509ab804;p=oota-llvm.git diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp index bc469d33115..4cf5501379c 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,263 +12,159 @@ //===----------------------------------------------------------------------===// -#include "llvm/PassManager.h" +#include "llvm/PassManagers.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "llvm/Assembly/Writer.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/Timer.h" #include "llvm/Module.h" -#include "llvm/ModuleProvider.h" -#include "llvm/Support/Streams.h" -#include +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PassNameParser.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/System/Mutex.h" +#include "llvm/System/Threading.h" +#include "llvm-c/Core.h" +#include +#include #include using namespace llvm; -//===----------------------------------------------------------------------===// -// 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 multipe pass managers. They are PassManager, -// FunctionPassManager, ModulePassManager, BasicBlockPassManager. 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 BasicBlockPassManager : public FunctionPass, public PMDataManager; -// -// BasicBlockPassManager 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 FunctionPasses -// and BasicBlockPassManagers. -// -// [o] class ModulePassManager : public Pass, public PMDataManager; -// -// ModulePassManager manages ModulePasses and FunctionPassManagerImpls. -// -// [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 -// ModulePassManagers. -//===----------------------------------------------------------------------===// +// See PassManagers.h for Pass Manager infrastructure overview. namespace llvm { -class PMDataManager; - //===----------------------------------------------------------------------===// -// PMTopLevelManager +// Pass debugging information. Often it is useful to find out what pass is +// running when a crash occurs in a utility. When this library is compiled with +// debugging on, a command line option (--debug-pass) is enabled that causes the +// pass name to be printed before it executes. // -/// PMTopLevelManager manages LastUser info and collects common APIs used by -/// top level pass managers. -class PMTopLevelManager { - -public: - - inline std::vector::iterator passManagersBegin() { - return PassManagers.begin(); - } - - inline std::vector::iterator passManagersEnd() { - return PassManagers.end(); - } - - /// 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() { - 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); - } +// Different debug levels that can be enabled... +enum PassDebugLevel { + None, Arguments, Structure, Executions, Details +}; - // 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); +static cl::opt +PassDebugging("debug-pass", cl::Hidden, + cl::desc("Print PassManager debugging information"), + cl::values( + clEnumVal(None , "disable debug output"), + clEnumVal(Arguments , "print pass arguments to pass to 'opt'"), + clEnumVal(Structure , "print pass structure before run()"), + clEnumVal(Executions, "print pass name before it is executed"), + clEnumVal(Details , "print pass details when it is executed"), + clEnumValEnd)); + +typedef llvm::cl::list +PassOptionList; + +// Print IR out before/after specified passes. +static PassOptionList +PrintBefore("print-before", + llvm::cl::desc("Print IR before specified passes")); + +static PassOptionList +PrintAfter("print-after", + llvm::cl::desc("Print IR after specified passes")); + +static cl::opt +PrintBeforeAll("print-before-all", + llvm::cl::desc("Print IR before each pass"), + cl::init(false)); +static cl::opt +PrintAfterAll("print-after-all", + llvm::cl::desc("Print IR after each pass"), + cl::init(false)); + +/// This is a helper to determine whether to print IR before or +/// after a pass. + +static bool ShouldPrintBeforeOrAfterPass(Pass *P, + PassOptionList &PassesToPrint) { + for (unsigned i = 0, ie = PassesToPrint.size(); i < ie; ++i) { + const llvm::PassInfo *PassInf = PassesToPrint[i]; + if (PassInf && P->getPassInfo()) + if (PassInf->getPassArgument() == + P->getPassInfo()->getPassArgument()) { + return true; + } } - -private: + return false; +} - /// Collection of pass managers - std::vector PassManagers; - /// 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; +/// This is a utility to check whether a pass should have IR dumped +/// before it. +static bool ShouldPrintBeforePass(Pass *P) { + return PrintBeforeAll || ShouldPrintBeforeOrAfterPass(P, PrintBefore); +} - /// Immutable passes are managed by top level manager. - std::vector ImmutablePasses; -}; - -//===----------------------------------------------------------------------===// -// PMDataManager +/// This is a utility to check whether a pass should have IR dumped +/// after it. +static bool ShouldPrintAfterPass(Pass *P) { + return PrintAfterAll || ShouldPrintBeforeOrAfterPass(P, PrintAfter); +} -/// PMDataManager provides the common place to manage the analysis data -/// used by pass managers. -class PMDataManager { +} // End of llvm namespace -public: +/// isPassDebuggingExecutionsOrMore - Return true if -debug-pass=Executions +/// or higher is specified. +bool PMDataManager::isPassDebuggingExecutionsOrMore() const { + return PassDebugging >= Executions; +} - PMDataManager(int D) : TPM(NULL), Depth(D) { - initializeAnalysisInfo(); - } - /// 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); +void PassManagerPrettyStackEntry::print(raw_ostream &OS) const { + if (V == 0 && M == 0) + OS << "Releasing pass '"; + else + OS << "Running pass '"; - /// Remove dead passes - void removeDeadPasses(Pass *P); - - /// 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() { - ForcedLastUses.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); - - inline std::vector::iterator passVectorBegin() { - return PassVector.begin(); + OS << P->getPassName() << "'"; + + if (M) { + OS << " on module '" << M->getModuleIdentifier() << "'.\n"; + return; } - - inline std::vector::iterator passVectorEnd() { - return PassVector.end(); + if (V == 0) { + OS << '\n'; + return; } - // Access toplevel manager - PMTopLevelManager *getTopLevelManager() { return TPM; } - void setTopLevelManager(PMTopLevelManager *T) { TPM = T; } - - unsigned getDepth() { return Depth; } - -protected: - - // Collection of pass whose last user asked this manager to claim - // last use. 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 ForcedLastUses; - - // Top level manager. - PMTopLevelManager *TPM; - -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; + OS << " on "; + if (isa(V)) + OS << "function"; + else if (isa(V)) + OS << "basic block"; + else + OS << "value"; + + OS << " '"; + WriteAsOperand(OS, V, /*PrintTy=*/false, M); + OS << "'\n"; +} - // Collection of pass that are managed by this manager - std::vector PassVector; - unsigned Depth; -}; +namespace { //===----------------------------------------------------------------------===// -// BasicBlockPassManager_New +// BBPassManager // -/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the +/// BBPassManager manages BasicBlockPass. It batches all the /// pass together and sequence them to process one basic block before /// processing next basic block. -class BasicBlockPassManager_New : public PMDataManager, - public FunctionPass { +class BBPassManager : public PMDataManager, public FunctionPass { public: - BasicBlockPassManager_New(int D) : PMDataManager(D) { } + static char ID; + explicit BBPassManager(int Depth) + : PMDataManager(Depth), FunctionPass(&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); @@ -283,94 +179,142 @@ public: bool doFinalization(Module &M); bool doFinalization(Function &F); -}; + virtual PMDataManager *getAsPMDataManager() { return this; } + virtual Pass *getAsPass() { return this; } -//===----------------------------------------------------------------------===// -// FunctionPassManagerImpl_New -// -/// FunctionPassManagerImpl_New manages FunctionPasses and BasicBlockPassManagers. -/// 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 FunctionPassManagerImpl_New : public ModulePass, - public PMDataManager, - public PMTopLevelManager { -public: - FunctionPassManagerImpl_New(int D) : PMDataManager(D) { - activeBBPassManager = NULL; + virtual const char *getPassName() const { + return "BasicBlock Pass Manager"; } - ~FunctionPassManagerImpl_New() { /* TODO */ }; - - inline void addTopLevelPass(Pass *P) { - if (ImmutablePass *IP = dynamic_cast (P)) { + // Print passes managed by this manager + void dumpPassStructure(unsigned Offset) { + llvm::dbgs() << std::string(Offset*2, ' ') << "BasicBlockPass Manager\n"; + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + BasicBlockPass *BP = getContainedPass(Index); + BP->dumpPassStructure(Offset + 1); + dumpLastUses(BP, Offset+1); + } + } - // P is a immutable pass then it will be managed by this - // top level manager. Set up analysis resolver to connect them. - AnalysisResolver_New *AR = new AnalysisResolver_New(*this); - P->setResolver(AR); - initializeAnalysisImpl(P); - addImmutablePass(IP); - recordAvailableAnalysis(IP); - } - else - addPass(P); + BasicBlockPass *getContainedPass(unsigned N) { + assert(N < PassVector.size() && "Pass number out of range!"); + BasicBlockPass *BP = static_cast(PassVector[N]); + return BP; + } + + virtual PassManagerType getPassManagerType() const { + return PMT_BasicBlockPassManager; } +}; + +char BBPassManager::ID = 0; +} - /// add - Add a pass to the queue of passes to run. This passes - /// ownership of the Pass to the PassManager. When the - /// PassManager_X is destroyed, the pass will be destroyed as well, so - /// there is no need to delete the pass. (TODO delete passes.) - /// This implies that all passes MUST be allocated with 'new'. - void add(Pass *P) { +namespace llvm { + +//===----------------------------------------------------------------------===// +// FunctionPassManagerImpl +// +/// FunctionPassManagerImpl manages FPPassManagers +class FunctionPassManagerImpl : public Pass, + public PMDataManager, + public PMTopLevelManager { +private: + bool wasRun; +public: + static char ID; + explicit FunctionPassManagerImpl(int Depth) : + Pass(PT_PassManager, &ID), PMDataManager(Depth), + PMTopLevelManager(TLM_Function), 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 + /// will be destroyed as well, so there is no need to delete the pass. This + /// implies that all passes MUST be allocated with 'new'. + void add(Pass *P) { schedulePass(P); } + + /// createPrinterPass - Get a function printer pass. + Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const { + return createPrintFunctionPass(Banner, &O); + } - /// Add pass into the pass manager queue. - bool addPass(Pass *P); + // Prepare for running an on the fly pass, freeing memory if needed + // from a previous run. + void releaseMemoryOnTheFly(); - /// 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 runOnModule(Module &M); - bool runOnFunction(Function &F); + /// 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 run(Function &F); /// doInitialization - Run all of the initializers for the function passes. /// 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); + + virtual PMDataManager *getAsPMDataManager() { return this; } + virtual Pass *getAsPass() { return this; } + /// Pass Manager itself does not invalidate any analysis info. void getAnalysisUsage(AnalysisUsage &Info) const { Info.setPreservesAll(); } -private: - // Active Pass Managers - BasicBlockPassManager_New *activeBBPassManager; + inline 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. + AnalysisResolver *AR = new AnalysisResolver(*this); + P->setResolver(AR); + initializeAnalysisImpl(P); + addImmutablePass(IP); + recordAvailableAnalysis(IP); + } else { + P->assignPassManager(activeStack, PMT_FunctionPassManager); + } + + } + + FPPassManager *getContainedManager(unsigned N) { + assert(N < PassManagers.size() && "Pass number out of range!"); + FPPassManager *FP = static_cast(PassManagers[N]); + return FP; + } }; +char FunctionPassManagerImpl::ID = 0; //===----------------------------------------------------------------------===// -// ModulePassManager_New +// MPPassManager // -/// ModulePassManager_New manages ModulePasses and function pass managers. -/// It batches all Module passes passes and function pass managers together and -/// sequence them to process one module. -class ModulePassManager_New : public Pass, - public PMDataManager { - +/// MPPassManager manages ModulePasses and function pass managers. +/// It batches all Module passes and function pass managers together and +/// sequences them to process one module. +class MPPassManager : public Pass, public PMDataManager { public: - ModulePassManager_New(int D) : PMDataManager(D) { - activeFunctionPassManager = NULL; + static char ID; + explicit MPPassManager(int Depth) : + Pass(PT_PassManager, &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); - + + /// createPrinterPass - Get a module printer pass. + Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const { + return createPrintModulePass(&O, false, Banner); + } + /// 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); @@ -380,24 +324,67 @@ public: Info.setPreservesAll(); } -private: - // Active Pass Manager - FunctionPassManagerImpl_New *activeFunctionPassManager; + /// 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"; + } + + virtual PMDataManager *getAsPMDataManager() { return this; } + virtual Pass *getAsPass() { return this; } + + // Print passes managed by this manager + void dumpPassStructure(unsigned Offset) { + llvm::dbgs() << std::string(Offset*2, ' ') << "ModulePass Manager\n"; + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + ModulePass *MP = getContainedPass(Index); + MP->dumpPassStructure(Offset + 1); + std::map::const_iterator I = + OnTheFlyManagers.find(MP); + if (I != OnTheFlyManagers.end()) + I->second->dumpPassStructure(Offset + 2); + dumpLastUses(MP, Offset+1); + } + } + + ModulePass *getContainedPass(unsigned N) { + assert(N < PassVector.size() && "Pass number out of range!"); + return static_cast(PassVector[N]); + } + + 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_New +// PassManagerImpl // -/// PassManagerImpl_New manages ModulePassManagers -class PassManagerImpl_New : public Pass, - public PMDataManager, - public PMTopLevelManager { -public: +/// PassManagerImpl manages MPPassManagers +class PassManagerImpl : public Pass, + public PMDataManager, + public PMTopLevelManager { - PassManagerImpl_New(int D) : PMDataManager(D) { - activeManager = NULL; - } +public: + static char ID; + explicit PassManagerImpl(int Depth) : + Pass(PT_PassManager, &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 @@ -407,6 +394,11 @@ public: schedulePass(P); } + /// createPrinterPass - Get a module printer pass. + Pass *createPrinterPass(raw_ostream &O, const std::string &Banner) const { + return createPrintModulePass(&O, false, Banner); + } + /// 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 run(Module &M); @@ -417,61 +409,149 @@ public: } inline void addTopLevelPass(Pass *P) { - - if (ImmutablePass *IP = dynamic_cast (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. - AnalysisResolver_New *AR = new AnalysisResolver_New(*this); + AnalysisResolver *AR = new AnalysisResolver(*this); P->setResolver(AR); initializeAnalysisImpl(P); addImmutablePass(IP); recordAvailableAnalysis(IP); + } else { + P->assignPassManager(activeStack, PMT_ModulePassManager); } - else - addPass(P); } -private: + virtual PMDataManager *getAsPMDataManager() { return this; } + virtual Pass *getAsPass() { return this; } - /// Add a pass into a passmanager queue. - bool addPass(Pass *p); - - // Active Pass Manager - ModulePassManager_New *activeManager; + MPPassManager *getContainedManager(unsigned N) { + assert(N < PassManagers.size() && "Pass number out of range!"); + MPPassManager *MP = static_cast(PassManagers[N]); + return MP; + } }; +char PassManagerImpl::ID = 0; } // End of llvm namespace +namespace { + +//===----------------------------------------------------------------------===// +/// TimingInfo Class - This class is used to calculate information about the +/// amount of time each pass takes to execute. This only happens when +/// -time-passes is enabled on the command line. +/// + +static ManagedStatic > TimingInfoMutex; + +class TimingInfo { + DenseMap TimingData; + TimerGroup TG; +public: + // Use 'create' member to get this. + TimingInfo() : TG("... Pass execution timing report ...") {} + + // TimingDtor - Print out information about timing information + ~TimingInfo() { + // Delete all of the timers, which accumulate their info into the + // TimerGroup. + for (DenseMap::iterator I = TimingData.begin(), + E = TimingData.end(); I != E; ++I) + delete I->second; + // TimerGroup is deleted next, printing the report. + } + + // createTheTimeInfo - This method either initializes the TheTimeInfo pointer + // to a non null value (if the -time-passes option is enabled) or it leaves it + // null. It may be called multiple times. + static void createTheTimeInfo(); + + /// getPassTimer - Return the timer for the specified pass if it exists. + Timer *getPassTimer(Pass *P) { + if (P->getAsPMDataManager()) + return 0; + + sys::SmartScopedLock Lock(*TimingInfoMutex); + Timer *&T = TimingData[P]; + if (T == 0) + T = new Timer(P->getPassName(), TG); + return T; + } +}; + +} // End of anon namespace + +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(), + for (DenseMap::iterator LUI = LastUser.begin(), LUE = LastUser.end(); LUI != LUE; ++LUI) { if (LUI->second == AP) + // DenseMap iterator is not invalidated here because + // this is just updating exisitng entry. LastUser[LUI->first] = P; } } - } /// Collect passes whose last user is P -void PMTopLevelManager::collectLastUses(std::vector &LastUses, - Pass *P) { - for (std::map::iterator LUI = LastUser.begin(), - LUE = LastUser.end(); LUI != LUE; ++LUI) - if (LUI->second == P) - LastUses.push_back(LUI->first); +void PMTopLevelManager::collectLastUses(SmallVector &LastUses, + Pass *P) { + DenseMap >::iterator DMI = + InversedLastUser.find(P); + if (DMI == InversedLastUser.end()) + return; + + SmallPtrSet &LU = DMI->second; + for (SmallPtrSet::iterator I = LU.begin(), + E = LU.end(); I != E; ++I) { + LastUses.push_back(*I); + } + +} + +AnalysisUsage *PMTopLevelManager::findAnalysisUsage(Pass *P) { + AnalysisUsage *AnUsage = NULL; + DenseMap::iterator DMI = AnUsageMap.find(P); + if (DMI != AnUsageMap.end()) + AnUsage = DMI->second; + else { + AnUsage = new AnalysisUsage(); + P->getAnalysisUsage(*AnUsage); + AnUsageMap[P] = AnUsage; + } + return AnUsage; } /// Schedule pass P for execution. Make sure that passes required by @@ -482,17 +562,48 @@ void PMTopLevelManager::schedulePass(Pass *P) { // TODO : Allocate function manager for this pass, other wise required set // may be inserted into previous function manager - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - const std::vector &RequiredSet = AnUsage.getRequiredSet(); - for (std::vector::const_iterator I = RequiredSet.begin(), - E = RequiredSet.end(); I != E; ++I) { - - Pass *AnalysisPass = findAnalysisPass(*I); - if (!AnalysisPass) { - // Schedule this analysis run first. - AnalysisPass = (*I)->createPass(); - schedulePass(AnalysisPass); + // 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())) { + delete P; + return; + } + + AnalysisUsage *AnUsage = findAnalysisUsage(P); + + bool checkAnalysis = true; + while (checkAnalysis) { + checkAnalysis = false; + + const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet(); + for (AnalysisUsage::VectorType::const_iterator I = RequiredSet.begin(), + E = RequiredSet.end(); I != E; ++I) { + + Pass *AnalysisPass = findAnalysisPass(*I); + if (!AnalysisPass) { + AnalysisPass = (*I)->createPass(); + if (P->getPotentialPassManagerType () == + AnalysisPass->getPotentialPassManagerType()) + // Schedule analysis pass that is managed by the same pass manager. + schedulePass(AnalysisPass); + else if (P->getPotentialPassManagerType () > + AnalysisPass->getPotentialPassManagerType()) { + // Schedule analysis pass that is managed by a new manager. + schedulePass(AnalysisPass); + // Recheck analysis passes to ensure that required analysises that + // are already checked are still available. + checkAnalysis = true; + } + else + // Do not schedule this analysis. Lower level analsyis + // passes are run on the fly. + delete AnalysisPass; + } } } @@ -507,19 +618,19 @@ Pass *PMTopLevelManager::findAnalysisPass(AnalysisID AID) { Pass *P = NULL; // Check pass managers - for (std::vector::iterator I = PassManagers.begin(), + for (SmallVector::iterator I = PassManagers.begin(), E = PassManagers.end(); P == NULL && I != E; ++I) { - PMDataManager *PMD = dynamic_cast(*I); - assert(PMD && "This is not a PassManager"); + PMDataManager *PMD = *I; P = PMD->findAnalysisPass(AID, false); } // Check other pass managers - for (std::vector::iterator I = IndirectPassManagers.begin(), + for (SmallVector::iterator + I = IndirectPassManagers.begin(), E = IndirectPassManagers.end(); P == NULL && I != E; ++I) P = (*I)->findAnalysisPass(AID, false); - for (std::vector::iterator I = ImmutablePasses.begin(), + for (SmallVector::iterator I = ImmutablePasses.begin(), E = ImmutablePasses.end(); P == NULL && I != E; ++I) { const PassInfo *PI = (*I)->getPassInfo(); if (PI == AID) @@ -527,164 +638,353 @@ 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(); - for (unsigned Index = 0, End = ImmPI.size(); - P == NULL && Index != End; ++Index) - if (ImmPI[Index] == AID) + const PassInfo::InterfaceInfo *ImmPI = PI->getInterfacesImplemented(); + while (ImmPI) { + if (ImmPI->interface == AID) { P = *I; + break; + } else + ImmPI = ImmPI->next; + } } } return P; } -//===----------------------------------------------------------------------===// -// PMDataManager implementation +// Print passes managed by this top level manager. +void PMTopLevelManager::dumpPasses() const { -/// 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; + if (PassDebugging < Structure) + return; + + // Print out the immutable passes + for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) { + ImmutablePasses[i]->dumpPassStructure(0); + } + + // 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 getAsPass to get + // from a PMDataManager* to a Pass*. + for (SmallVector::const_iterator I = PassManagers.begin(), + E = PassManagers.end(); I != E; ++I) + (*I)->getAsPass()->dumpPassStructure(1); } +void PMTopLevelManager::dumpArguments() const { + + if (PassDebugging < Arguments) + return; + + dbgs() << "Pass Arguments: "; + for (SmallVector::const_iterator I = PassManagers.begin(), + E = PassManagers.end(); I != E; ++I) + (*I)->dumpPassArguments(); + dbgs() << "\n"; +} + +void PMTopLevelManager::initializeAllAnalysisInfo() { + for (SmallVector::iterator I = PassManagers.begin(), + E = PassManagers.end(); I != E; ++I) + (*I)->initializeAnalysisInfo(); + + // Initailize other pass managers + for (SmallVector::iterator I = IndirectPassManagers.begin(), + E = IndirectPassManagers.end(); I != E; ++I) + (*I)->initializeAnalysisInfo(); + + for (DenseMap::iterator DMI = LastUser.begin(), + DME = LastUser.end(); DMI != DME; ++DMI) { + DenseMap >::iterator InvDMI = + InversedLastUser.find(DMI->second); + if (InvDMI != InversedLastUser.end()) { + SmallPtrSet &L = InvDMI->second; + L.insert(DMI->first); + } else { + SmallPtrSet L; L.insert(DMI->first); + InversedLastUser[DMI->second] = L; + } + } +} + +/// Destructor +PMTopLevelManager::~PMTopLevelManager() { + for (SmallVector::iterator I = PassManagers.begin(), + E = PassManagers.end(); I != E; ++I) + delete *I; + + for (SmallVector::iterator + I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I) + delete *I; + + for (DenseMap::iterator DMI = AnUsageMap.begin(), + DME = AnUsageMap.end(); DMI != DME; ++DMI) + delete DMI->second; +} + +//===----------------------------------------------------------------------===// +// PMDataManager implementation + /// Augement AvailableAnalysis by adding analysis made available by pass P. void PMDataManager::recordAvailableAnalysis(Pass *P) { - - if (const PassInfo *PI = P->getPassInfo()) { - AvailableAnalysis[PI] = P; + const PassInfo *PI = P->getPassInfo(); + if (PI == 0) return; + + AvailableAnalysis[PI] = P; + + //This pass is the current implementation of all of the interfaces it + //implements as well. + const PassInfo::InterfaceInfo *II = PI->getInterfacesImplemented(); + while (II) { + AvailableAnalysis[II->interface] = P; + II = II->next; + } +} - //This pass is the current implementation of all of the interfaces it - //implements as well. - const std::vector &II = PI->getInterfacesImplemented(); - for (unsigned i = 0, e = II.size(); i != e; ++i) - AvailableAnalysis[II[i]] = P; +// Return true if P preserves high level analysis used by other +// passes managed by this manager +bool PMDataManager::preserveHigherLevelAnalysis(Pass *P) { + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + if (AnUsage->getPreservesAll()) + return true; + + const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); + for (SmallVector::iterator I = HigherLevelAnalysis.begin(), + E = HigherLevelAnalysis.end(); I != E; ++I) { + Pass *P1 = *I; + if (P1->getAsImmutablePass() == 0 && + std::find(PreservedSet.begin(), PreservedSet.end(), + P1->getPassInfo()) == + PreservedSet.end()) + return false; } + + return true; } -/// Remove Analyss not preserved by Pass P -void PMDataManager::removeNotPreservedAnalysis(Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); +/// verifyPreservedAnalysis -- Verify analysis preserved by pass P. +void PMDataManager::verifyPreservedAnalysis(Pass *P) { + // Don't do this unless assertions are enabled. +#ifdef NDEBUG + return; +#endif + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); + + // Verify preserved analysis + for (AnalysisUsage::VectorType::const_iterator I = PreservedSet.begin(), + E = PreservedSet.end(); I != E; ++I) { + AnalysisID AID = *I; + if (Pass *AP = findAnalysisPass(AID, true)) { + TimeRegion PassTimer(getPassTimer(AP)); + AP->verifyAnalysis(); + } + } +} - if (AnUsage.getPreservesAll()) +/// Remove Analysis not preserved by Pass P +void PMDataManager::removeNotPreservedAnalysis(Pass *P) { + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + if (AnUsage->getPreservesAll()) return; - const std::vector &PreservedSet = AnUsage.getPreservedSet(); + const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet(); for (std::map::iterator I = AvailableAnalysis.begin(), E = AvailableAnalysis.end(); I != E; ) { - if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) == + std::map::iterator Info = I++; + if (Info->second->getAsImmutablePass() == 0 && + std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == PreservedSet.end()) { // Remove this analysis - if (!dynamic_cast(I->second)) { - std::map::iterator J = I++; - AvailableAnalysis.erase(J); - } else - ++I; - } else - ++I; + if (PassDebugging >= Details) { + Pass *S = Info->second; + dbgs() << " -- '" << P->getPassName() << "' is not preserving '"; + dbgs() << S->getPassName() << "'\n"; + } + 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 (Info->second->getAsImmutablePass() == 0 && + std::find(PreservedSet.begin(), PreservedSet.end(), Info->first) == + PreservedSet.end()) { + // Remove this analysis + if (PassDebugging >= Details) { + Pass *S = Info->second; + dbgs() << " -- '" << P->getPassName() << "' is not preserving '"; + dbgs() << S->getPassName() << "'\n"; + } + InheritedAnalysis[Index]->erase(Info); + } + } } } /// Remove analysis passes that are not used any longer -void PMDataManager::removeDeadPasses(Pass *P) { +void PMDataManager::removeDeadPasses(Pass *P, StringRef 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(), - E = DeadPasses.end(); I != E; ++I) { - (*I)->releaseMemory(); - - std::map::iterator Pos = - AvailableAnalysis.find((*I)->getPassInfo()); - - // It is possible that pass is already removed from the AvailableAnalysis - if (Pos != AvailableAnalysis.end()) - AvailableAnalysis.erase(Pos); + if (PassDebugging >= Details && !DeadPasses.empty()) { + dbgs() << " -*- '" << P->getPassName(); + dbgs() << "' is the last user of following pass instances."; + dbgs() << " Free these instances\n"; + } + + for (SmallVector::iterator I = DeadPasses.begin(), + E = DeadPasses.end(); I != E; ++I) + freePass(*I, Msg, DBG_STR); +} + +void PMDataManager::freePass(Pass *P, StringRef Msg, + enum PassDebuggingString DBG_STR) { + dumpPassInfo(P, FREEING_MSG, DBG_STR, Msg); + + { + // If the pass crashes releasing memory, remember this. + PassManagerPrettyStackEntry X(P); + TimeRegion PassTimer(getPassTimer(P)); + + P->releaseMemory(); + } + + if (const PassInfo *PI = P->getPassInfo()) { + // Remove the pass itself (if it is not already removed). + AvailableAnalysis.erase(PI); + + // Remove all interfaces this pass implements, for which it is also + // listed as the available implementation. + const PassInfo::InterfaceInfo *II = PI->getInterfacesImplemented(); + while (II) { + std::map::iterator Pos = + AvailableAnalysis.find(II->interface); + if (Pos != AvailableAnalysis.end() && Pos->second == P) + AvailableAnalysis.erase(Pos); + II = II->next; + } } } /// 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_New *AR = new AnalysisResolver_New(*this); + AnalysisResolver *AR = new AnalysisResolver(*this); P->setResolver(AR); - if (ProcessAnalysis) { - - // At the moment, this pass is the last user of all required passes. - std::vector LastUses; - std::vector RequiredPasses; - unsigned PDepth = this->getDepth(); - - collectRequiredAnalysisPasses(RequiredPasses, P); - for (std::vector::iterator I = RequiredPasses.begin(), - E = RequiredPasses.end(); I != E; ++I) { - Pass *PRequired = *I; - unsigned RDepth = 0; - - PMDataManager &DM = PRequired->getResolver()->getPMDataManager(); - RDepth = DM.getDepth(); - - if (PDepth == RDepth) - LastUses.push_back(PRequired); - else if (PDepth > RDepth) { - // Let the parent claim responsibility of last use - ForcedLastUses.push_back(PRequired); - } else { - // Note : This feature is not yet implemented - assert (0 && - "Unable to handle Pass that requires lower level Analysis pass"); - } - } + // 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) { + // Add pass + PassVector.push_back(P); + return; + } - if (!LastUses.empty()) - TPM->setLastUser(LastUses, P); + // At the moment, this pass is the last user of all required passes. + SmallVector LastUses; + SmallVector RequiredPasses; + SmallVector ReqAnalysisNotAvailable; + + unsigned PDepth = this->getDepth(); + + collectRequiredAnalysis(RequiredPasses, + ReqAnalysisNotAvailable, P); + for (SmallVector::iterator I = RequiredPasses.begin(), + E = RequiredPasses.end(); I != E; ++I) { + Pass *PRequired = *I; + unsigned RDepth = 0; + + assert(PRequired->getResolver() && "Analysis Resolver is not set"); + PMDataManager &DM = PRequired->getResolver()->getPMDataManager(); + RDepth = DM.getDepth(); + + if (PDepth == RDepth) + LastUses.push_back(PRequired); + else if (PDepth > RDepth) { + // Let the parent claim responsibility of last use + TransferLastUses.push_back(PRequired); + // Keep track of higher level analysis used by this manager. + HigherLevelAnalysis.push_back(PRequired); + } else + llvm_unreachable("Unable to accomodate Required Pass"); + } + + // 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 (P->getAsPMDataManager() == 0) + LastUses.push_back(P); + TPM->setLastUser(LastUses, P); + + if (!TransferLastUses.empty()) { + Pass *My_PM = getAsPass(); + TPM->setLastUser(TransferLastUses, My_PM); + TransferLastUses.clear(); + } - // Take a note of analysis required and made available by this pass. - // Remove the analysis not preserved by this pass - removeNotPreservedAnalysis(P); - recordAvailableAnalysis(P); + // 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); + recordAvailableAnalysis(P); + // Add pass PassVector.push_back(P); } -/// Populate RequiredPasses with the analysis pass that are required by -/// pass P. -void PMDataManager::collectRequiredAnalysisPasses(std::vector &RP, - 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); + +/// 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 = TPM->findAnalysisUsage(P); + const AnalysisUsage::VectorType &RequiredSet = AnUsage->getRequiredSet(); + for (AnalysisUsage::VectorType::const_iterator + I = RequiredSet.begin(), E = RequiredSet.end(); I != E; ++I) { + if (Pass *AnalysisPass = findAnalysisPass(*I, true)) + RP.push_back(AnalysisPass); + else + RP_NotAvail.push_back(*I); } - const std::vector &IDs = AnUsage.getRequiredTransitiveSet(); - for (std::vector::const_iterator I = IDs.begin(), + const AnalysisUsage::VectorType &IDs = AnUsage->getRequiredTransitiveSet(); + for (AnalysisUsage::VectorType::const_iterator I = IDs.begin(), E = IDs.end(); I != E; ++I) { - Pass *AnalysisPass = findAnalysisPass(*I, true); - assert (AnalysisPass && "Analysis pass is not available"); - RP.push_back(AnalysisPass); + if (Pass *AnalysisPass = findAnalysisPass(*I, true)) + RP.push_back(AnalysisPass); + else + RP_NotAvail.push_back(*I); } } @@ -694,16 +994,18 @@ void PMDataManager::collectRequiredAnalysisPasses(std::vector &RP, // implementations it needs. // void PMDataManager::initializeAnalysisImpl(Pass *P) { - AnalysisUsage AnUsage; - P->getAnalysisUsage(AnUsage); - - for (std::vector::const_iterator - I = AnUsage.getRequiredSet().begin(), - E = AnUsage.getRequiredSet().end(); I != E; ++I) { + AnalysisUsage *AnUsage = TPM->findAnalysisUsage(P); + + for (AnalysisUsage::VectorType::const_iterator + I = AnUsage->getRequiredSet().begin(), + E = AnUsage->getRequiredSet().end(); I != E; ++I) { Pass *Impl = findAnalysisPass(*I, true); if (Impl == 0) - assert(0 && "Analysis used but not available!"); - AnalysisResolver_New *AR = P->getResolver(); + // 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(); + assert(AR && "Analysis Resolver is not set"); AR->addAnalysisImplsPair(*I, Impl); } } @@ -725,109 +1027,237 @@ Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) { return NULL; } +// Print list of passes that are last used by P. +void PMDataManager::dumpLastUses(Pass *P, unsigned Offset) const{ -//===----------------------------------------------------------------------===// -// NOTE: Is this the right place to define this method ? -// getAnalysisToUpdate - Return an analysis result or null if it doesn't exist -Pass *AnalysisResolver_New::getAnalysisToUpdate(AnalysisID ID, bool dir) const { - return PM.findAnalysisPass(ID, dir); + SmallVector LUses; + + // If this is a on the fly manager then it does not have TPM. + if (!TPM) + return; + + TPM->collectLastUses(LUses, P); + + for (SmallVector::iterator I = LUses.begin(), + E = LUses.end(); I != E; ++I) { + llvm::dbgs() << "--" << std::string(Offset*2, ' '); + (*I)->dumpPassStructure(0); + } } -//===----------------------------------------------------------------------===// -// BasicBlockPassManager_New implementation +void PMDataManager::dumpPassArguments() const { + for (SmallVector::const_iterator I = PassVector.begin(), + E = PassVector.end(); I != E; ++I) { + if (PMDataManager *PMD = (*I)->getAsPMDataManager()) + PMD->dumpPassArguments(); + else + if (const PassInfo *PI = (*I)->getPassInfo()) + if (!PI->isAnalysisGroup()) + dbgs() << " -" << PI->getPassArgument(); + } +} -/// Add pass P into PassVector and return true. If this pass is not -/// manageable by this manager then return false. -bool -BasicBlockPassManager_New::addPass(Pass *P) { +void PMDataManager::dumpPassInfo(Pass *P, enum PassDebuggingString S1, + enum PassDebuggingString S2, + StringRef Msg) { + if (PassDebugging < Executions) + return; + dbgs() << (void*)this << std::string(getDepth()*2+1, ' '); + switch (S1) { + case EXECUTION_MSG: + dbgs() << "Executing Pass '" << P->getPassName(); + break; + case MODIFICATION_MSG: + dbgs() << "Made Modification '" << P->getPassName(); + break; + case FREEING_MSG: + dbgs() << " Freeing Pass '" << P->getPassName(); + break; + default: + break; + } + switch (S2) { + case ON_BASICBLOCK_MSG: + dbgs() << "' on BasicBlock '" << Msg << "'...\n"; + break; + case ON_FUNCTION_MSG: + dbgs() << "' on Function '" << Msg << "'...\n"; + break; + case ON_MODULE_MSG: + dbgs() << "' on Module '" << Msg << "'...\n"; + break; + case ON_LOOP_MSG: + dbgs() << "' on Loop '" << Msg << "'...\n"; + break; + case ON_CG_MSG: + dbgs() << "' on Call Graph Nodes '" << Msg << "'...\n"; + break; + default: + break; + } +} - BasicBlockPass *BP = dynamic_cast(P); - if (!BP) - return false; +void PMDataManager::dumpRequiredSet(const Pass *P) const { + if (PassDebugging < Details) + return; + + AnalysisUsage analysisUsage; + P->getAnalysisUsage(analysisUsage); + dumpAnalysisUsage("Required", P, analysisUsage.getRequiredSet()); +} - // If this pass does not preserve anlysis that is used by other passes - // managed by this manager than it is not a suiable pass for this manager. - if (!manageablePass(P)) - return false; +void PMDataManager::dumpPreservedSet(const Pass *P) const { + if (PassDebugging < Details) + return; + + AnalysisUsage analysisUsage; + P->getAnalysisUsage(analysisUsage); + dumpAnalysisUsage("Preserved", P, analysisUsage.getPreservedSet()); +} + +void PMDataManager::dumpAnalysisUsage(StringRef Msg, const Pass *P, + const AnalysisUsage::VectorType &Set) const { + assert(PassDebugging >= Details); + if (Set.empty()) + return; + dbgs() << (void*)P << std::string(getDepth()*2+3, ' ') << Msg << " Analyses:"; + for (unsigned i = 0; i != Set.size(); ++i) { + if (i) dbgs() << ','; + dbgs() << ' ' << Set[i]->getPassName(); + } + dbgs() << '\n'; +} - addPassToManager (BP); +/// 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(); + } - return true; + // 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 + dbgs() << "Unable to schedule '" << RequiredPass->getPassName(); + dbgs() << "' required by '" << P->getPassName() << "'\n"; +#endif + llvm_unreachable("Unable to schedule pass"); } +Pass *PMDataManager::getOnTheFlyPass(Pass *P, const PassInfo *PI, Function &F) { + assert(0 && "Unable to find on the fly pass"); + return NULL; +} + +// Destructor +PMDataManager::~PMDataManager() { + for (SmallVector::iterator I = PassVector.begin(), + E = PassVector.end(); I != E; ++I) + delete *I; +} + +//===----------------------------------------------------------------------===// +// NOTE: Is this the right place to define this method ? +// getAnalysisIfAvailable - Return analysis result or null if it doesn't exist. +Pass *AnalysisResolver::getAnalysisIfAvailable(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 + /// 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 -BasicBlockPassManager_New::runOnFunction(Function &F) { - - if (F.isExternal()) +bool BBPassManager::runOnFunction(Function &F) { + if (F.isDeclaration()) return false; bool Changed = doInitialization(F); - initializeAnalysisInfo(); for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - initializeAnalysisImpl(P); - BasicBlockPass *BP = dynamic_cast(P); - Changed |= BP->runOnBasicBlock(*I); - removeNotPreservedAnalysis(P); - recordAvailableAnalysis(P); - removeDeadPasses(P); + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + BasicBlockPass *BP = getContainedPass(Index); + bool LocalChanged = false; + + dumpPassInfo(BP, EXECUTION_MSG, ON_BASICBLOCK_MSG, I->getName()); + dumpRequiredSet(BP); + + initializeAnalysisImpl(BP); + + { + // If the pass crashes, remember this. + PassManagerPrettyStackEntry X(BP, *I); + TimeRegion PassTimer(getPassTimer(BP)); + + LocalChanged |= BP->runOnBasicBlock(*I); + } + + Changed |= LocalChanged; + if (LocalChanged) + dumpPassInfo(BP, MODIFICATION_MSG, ON_BASICBLOCK_MSG, + I->getName()); + dumpPreservedSet(BP); + + verifyPreservedAnalysis(BP); + removeNotPreservedAnalysis(BP); + recordAvailableAnalysis(BP); + removeDeadPasses(BP, I->getName(), ON_BASICBLOCK_MSG); } - return Changed | doFinalization(F); + + return doFinalization(F) || Changed; } // Implement doInitialization and doFinalization -inline bool BasicBlockPassManager_New::doInitialization(Module &M) { +bool BBPassManager::doInitialization(Module &M) { bool Changed = false; - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - BasicBlockPass *BP = dynamic_cast(P); - Changed |= BP->doInitialization(M); - } + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) + Changed |= getContainedPass(Index)->doInitialization(M); return Changed; } -inline bool BasicBlockPassManager_New::doFinalization(Module &M) { +bool BBPassManager::doFinalization(Module &M) { bool Changed = false; - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - BasicBlockPass *BP = dynamic_cast(P); - Changed |= BP->doFinalization(M); - } + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) + Changed |= getContainedPass(Index)->doFinalization(M); return Changed; } -inline bool BasicBlockPassManager_New::doInitialization(Function &F) { +bool BBPassManager::doInitialization(Function &F) { bool Changed = false; - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - BasicBlockPass *BP = dynamic_cast(P); + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + BasicBlockPass *BP = getContainedPass(Index); Changed |= BP->doInitialization(F); } return Changed; } -inline bool BasicBlockPassManager_New::doFinalization(Function &F) { +bool BBPassManager::doFinalization(Function &F) { bool Changed = false; - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - BasicBlockPass *BP = dynamic_cast(P); + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + BasicBlockPass *BP = getContainedPass(Index); Changed |= BP->doFinalization(F); } @@ -836,24 +1266,26 @@ inline bool BasicBlockPassManager_New::doFinalization(Function &F) { //===----------------------------------------------------------------------===// -// FunctionPassManager_New implementation +// FunctionPassManager implementation /// Create new Function pass manager -FunctionPassManager_New::FunctionPassManager_New() { - FPM = new FunctionPassManagerImpl_New(0); -} - -FunctionPassManager_New::FunctionPassManager_New(ModuleProvider *P) { - FPM = new FunctionPassManagerImpl_New(0); +FunctionPassManager::FunctionPassManager(Module *m) : M(m) { + FPM = new FunctionPassManagerImpl(0); // FPM is the top level manager. FPM->setTopLevelManager(FPM); - PMDataManager *PMD = dynamic_cast(FPM); - AnalysisResolver_New *AR = new AnalysisResolver_New(*PMD); + AnalysisResolver *AR = new AnalysisResolver(*FPM); FPM->setResolver(AR); - - FPM->addPassManager(FPM); - MP = P; +} + +FunctionPassManager::~FunctionPassManager() { + delete FPM; +} + +/// addImpl - Add a pass to the queue of passes to run, without +/// checking whether to add a printer pass. +void FunctionPassManager::addImpl(Pass *P) { + FPM->add(P); } /// add - Add a pass to the queue of passes to run. This passes @@ -861,26 +1293,30 @@ FunctionPassManager_New::FunctionPassManager_New(ModuleProvider *P) { /// PassManager_X is destroyed, the pass will be destroyed as well, so /// there is no need to delete the pass. (TODO delete passes.) /// This implies that all passes MUST be allocated with 'new'. -void FunctionPassManager_New::add(Pass *P) { - FPM->add(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 FunctionPassManager_New::runOnModule(Module &M) { - return FPM->runOnModule(M); +void FunctionPassManager::add(Pass *P) { + // If this is a not a function pass, don't add a printer for it. + if (P->getPassKind() == PT_Function) + if (ShouldPrintBeforePass(P)) + addImpl(P->createPrinterPass(dbgs(), std::string("*** IR Dump Before ") + + P->getPassName() + " ***")); + + addImpl(P); + + if (P->getPassKind() == PT_Function) + if (ShouldPrintAfterPass(P)) + addImpl(P->createPrinterPass(dbgs(), std::string("*** IR Dump After ") + + P->getPassName() + " ***")); } /// run - 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 FunctionPassManager_New::run(Function &F) { - std::string errstr; - if (MP->materializeFunction(&F, &errstr)) { - cerr << "Error reading bytecode file: " << errstr << "\n"; - abort(); +bool FunctionPassManager::run(Function &F) { + if (F.isMaterializable()) { + std::string errstr; + if (F.Materialize(&errstr)) + report_fatal_error("Error reading bitcode file: " + Twine(errstr)); } return FPM->run(F); } @@ -888,279 +1324,275 @@ bool FunctionPassManager_New::run(Function &F) { /// doInitialization - Run all of the initializers for the function passes. /// -bool FunctionPassManager_New::doInitialization() { - return FPM->doInitialization(*MP->getModule()); +bool FunctionPassManager::doInitialization() { + return FPM->doInitialization(*M); } -/// doFinalization - Run all of the initializers for the function passes. +/// doFinalization - Run all of the finalizers for the function passes. /// -bool FunctionPassManager_New::doFinalization() { - return FPM->doFinalization(*MP->getModule()); +bool FunctionPassManager::doFinalization() { + return FPM->doFinalization(*M); } //===----------------------------------------------------------------------===// -// FunctionPassManagerImpl_New implementation +// FunctionPassManagerImpl implementation +// +bool FunctionPassManagerImpl::doInitialization(Module &M) { + bool Changed = false; -/// 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 -FunctionPassManagerImpl_New::addPass(Pass *P) { + dumpArguments(); + dumpPasses(); - // If P is a BasicBlockPass then use BasicBlockPassManager_New. - if (BasicBlockPass *BP = dynamic_cast(P)) { + for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) + Changed |= getContainedManager(Index)->doInitialization(M); - if (!activeBBPassManager || !activeBBPassManager->addPass(BP)) { + return Changed; +} - // If active manager exists then clear its analysis info. - if (activeBBPassManager) - activeBBPassManager->initializeAnalysisInfo(); +bool FunctionPassManagerImpl::doFinalization(Module &M) { + bool Changed = false; - // Create and add new manager - activeBBPassManager = - new BasicBlockPassManager_New(getDepth() + 1); - // Inherit top level manager - activeBBPassManager->setTopLevelManager(this->getTopLevelManager()); + for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) + Changed |= getContainedManager(Index)->doFinalization(M); - // Add new manager into current manager's list. - addPassToManager(activeBBPassManager, false); + return Changed; +} - // 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); +/// cleanup - After running all passes, clean up pass manager cache. +void FPPassManager::cleanup() { + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + FunctionPass *FP = getContainedPass(Index); + AnalysisResolver *AR = FP->getResolver(); + assert(AR && "Analysis Resolver is not set"); + AR->clearAnalysisImpls(); + } +} - // Add pass into new manager. This time it must succeed. - if (!activeBBPassManager->addPass(BP)) - assert(0 && "Unable to add Pass"); +void FunctionPassManagerImpl::releaseMemoryOnTheFly() { + if (!wasRun) + return; + for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) { + FPPassManager *FPPM = getContainedManager(Index); + for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) { + FPPM->getContainedPass(Index)->releaseMemory(); } - - if (!ForcedLastUses.empty()) - TPM->setLastUser(ForcedLastUses, this); - - return true; } + wasRun = false; +} - FunctionPass *FP = dynamic_cast(P); - if (!FP) - return false; +// Execute all the passes managed by this top level manager. +// Return true if any function is modified by a pass. +bool FunctionPassManagerImpl::run(Function &F) { + bool Changed = false; + TimingInfo::createTheTimeInfo(); - // If this pass does not preserve anlysis that is used by other passes - // managed by this manager than it is not a suiable pass for this manager. - if (!manageablePass(P)) - return false; + initializeAllAnalysisInfo(); + for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) + Changed |= getContainedManager(Index)->runOnFunction(F); - addPassToManager (FP); + for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) + getContainedManager(Index)->cleanup(); - // If active manager exists then clear its analysis info. - if (activeBBPassManager) { - activeBBPassManager->initializeAnalysisInfo(); - activeBBPassManager = NULL; - } + wasRun = true; + return Changed; +} - return true; +//===----------------------------------------------------------------------===// +// FPPassManager implementation + +char FPPassManager::ID = 0; +/// Print passes managed by this manager +void FPPassManager::dumpPassStructure(unsigned Offset) { + llvm::dbgs() << 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); + } } + /// 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. -bool FunctionPassManagerImpl_New::runOnModule(Module &M) { +bool FPPassManager::runOnFunction(Function &F) { + if (F.isDeclaration()) + return false; - bool Changed = doInitialization(M); - initializeAnalysisInfo(); + bool Changed = false; - for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) - this->runOnFunction(*I); + // Collect inherited analysis from Module level pass manager. + populateInheritedAnalysis(TPM->activeStack); - return Changed | doFinalization(M); -} + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + FunctionPass *FP = getContainedPass(Index); + bool LocalChanged = false; -/// 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. -bool FunctionPassManagerImpl_New::runOnFunction(Function &F) { + dumpPassInfo(FP, EXECUTION_MSG, ON_FUNCTION_MSG, F.getName()); + dumpRequiredSet(FP); - bool Changed = false; + initializeAnalysisImpl(FP); - if (F.isExternal()) - return false; + { + PassManagerPrettyStackEntry X(FP, F); + TimeRegion PassTimer(getPassTimer(FP)); - initializeAnalysisInfo(); + LocalChanged |= FP->runOnFunction(F); + } - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - initializeAnalysisImpl(P); - FunctionPass *FP = dynamic_cast(P); - Changed |= FP->runOnFunction(F); - removeNotPreservedAnalysis(P); - recordAvailableAnalysis(P); - removeDeadPasses(P); + Changed |= LocalChanged; + if (LocalChanged) + dumpPassInfo(FP, MODIFICATION_MSG, ON_FUNCTION_MSG, F.getName()); + dumpPreservedSet(FP); + + verifyPreservedAnalysis(FP); + removeNotPreservedAnalysis(FP); + recordAvailableAnalysis(FP); + removeDeadPasses(FP, F.getName(), ON_FUNCTION_MSG); } return Changed; } +bool FPPassManager::runOnModule(Module &M) { + bool Changed = doInitialization(M); -inline bool FunctionPassManagerImpl_New::doInitialization(Module &M) { - bool Changed = false; - - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - - FunctionPass *FP = dynamic_cast(P); - Changed |= FP->doInitialization(M); - } + for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) + runOnFunction(*I); - return Changed; + return doFinalization(M) || Changed; } -inline bool FunctionPassManagerImpl_New::doFinalization(Module &M) { +bool FPPassManager::doInitialization(Module &M) { bool Changed = false; - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - - FunctionPass *FP = dynamic_cast(P); - Changed |= FP->doFinalization(M); - } + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) + Changed |= getContainedPass(Index)->doInitialization(M); return Changed; } -// Execute all the passes managed by this top level manager. -// Return true if any function is modified by a pass. -bool FunctionPassManagerImpl_New::run(Function &F) { - +bool FPPassManager::doFinalization(Module &M) { bool Changed = false; - for (std::vector::iterator I = passManagersBegin(), - E = passManagersEnd(); I != E; ++I) { - FunctionPass *FP = dynamic_cast(*I); - Changed |= FP->runOnFunction(F); - } + + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) + Changed |= getContainedPass(Index)->doFinalization(M); + return Changed; } //===----------------------------------------------------------------------===// -// ModulePassManager implementation +// MPPassManager implementation -/// Add P into pass vector if it is manageble. If P is a FunctionPass -/// then use FunctionPassManagerImpl_New to manage it. Return false if P -/// is not manageable by this manager. +/// 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. bool -ModulePassManager_New::addPass(Pass *P) { +MPPassManager::runOnModule(Module &M) { + bool Changed = false; - // If P is FunctionPass then use function pass maanager. - if (FunctionPass *FP = dynamic_cast(P)) { + // Initialize on-the-fly passes + for (std::map::iterator + I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end(); + I != E; ++I) { + FunctionPassManagerImpl *FPP = I->second; + Changed |= FPP->doInitialization(M); + } - if (!activeFunctionPassManager || !activeFunctionPassManager->addPass(P)) { + for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { + ModulePass *MP = getContainedPass(Index); + bool LocalChanged = false; - // If active manager exists then clear its analysis info. - if (activeFunctionPassManager) - activeFunctionPassManager->initializeAnalysisInfo(); + dumpPassInfo(MP, EXECUTION_MSG, ON_MODULE_MSG, M.getModuleIdentifier()); + dumpRequiredSet(MP); - // Create and add new manager - activeFunctionPassManager = - new FunctionPassManagerImpl_New(getDepth() + 1); - - // Add new manager into current manager's list - addPassToManager(activeFunctionPassManager, false); + initializeAnalysisImpl(MP); - // Inherit top level manager - activeFunctionPassManager->setTopLevelManager(this->getTopLevelManager()); + { + PassManagerPrettyStackEntry X(MP, M); + TimeRegion PassTimer(getPassTimer(MP)); - // 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"); + LocalChanged |= MP->runOnModule(M); } - if (!ForcedLastUses.empty()) - TPM->setLastUser(ForcedLastUses, this); - - return true; + Changed |= LocalChanged; + if (LocalChanged) + dumpPassInfo(MP, MODIFICATION_MSG, ON_MODULE_MSG, + M.getModuleIdentifier()); + dumpPreservedSet(MP); + + verifyPreservedAnalysis(MP); + removeNotPreservedAnalysis(MP); + recordAvailableAnalysis(MP); + removeDeadPasses(MP, M.getModuleIdentifier(), ON_MODULE_MSG); } - ModulePass *MP = dynamic_cast(P); - if (!MP) - return false; - - // If this pass does not preserve anlysis that is used by other passes - // managed by this manager than it is not a suiable pass for this manager. - if (!manageablePass(P)) - return false; + // Finalize on-the-fly passes + for (std::map::iterator + I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end(); + I != E; ++I) { + FunctionPassManagerImpl *FPP = I->second; + // We don't know when is the last time an on-the-fly pass is run, + // so we need to releaseMemory / finalize here + FPP->releaseMemoryOnTheFly(); + Changed |= FPP->doFinalization(M); + } + return Changed; +} - addPassToManager(MP); - // If active manager exists then clear its analysis info. - if (activeFunctionPassManager) { - activeFunctionPassManager->initializeAnalysisInfo(); - activeFunctionPassManager = NULL; +/// Add RequiredPass into list of lower level passes required by pass P. +/// RequiredPass is run on the fly by Pass Manager when P requests it +/// through getAnalysis interface. +void MPPassManager::addLowerLevelRequiredPass(Pass *P, Pass *RequiredPass) { + assert(P->getPotentialPassManagerType() == PMT_ModulePassManager && + "Unable to handle Pass that requires lower level Analysis pass"); + assert((P->getPotentialPassManagerType() < + RequiredPass->getPotentialPassManagerType()) && + "Unable to handle Pass that requires lower level Analysis pass"); + + FunctionPassManagerImpl *FPP = OnTheFlyManagers[P]; + if (!FPP) { + FPP = new FunctionPassManagerImpl(0); + // FPP is the top level manager. + FPP->setTopLevelManager(FPP); + + OnTheFlyManagers[P] = FPP; } + FPP->add(RequiredPass); - return true; + // Register P as the last user of RequiredPass. + SmallVector LU; + LU.push_back(RequiredPass); + FPP->setLastUser(LU, P); } - -/// 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. -bool -ModulePassManager_New::runOnModule(Module &M) { - bool Changed = false; - initializeAnalysisInfo(); - - for (std::vector::iterator itr = passVectorBegin(), - e = passVectorEnd(); itr != e; ++itr) { - Pass *P = *itr; - initializeAnalysisImpl(P); - ModulePass *MP = dynamic_cast(P); - Changed |= MP->runOnModule(M); - removeNotPreservedAnalysis(P); - recordAvailableAnalysis(P); - removeDeadPasses(P); - } - return Changed; +/// 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){ + FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP]; + assert(FPP && "Unable to find on the fly pass"); + + FPP->releaseMemoryOnTheFly(); + FPP->run(F); + return ((PMTopLevelManager*)FPP)->findAnalysisPass(PI); } + //===----------------------------------------------------------------------===// // PassManagerImpl implementation - -// PassManager_New implementation -/// Add P into active pass manager or use new module pass manager to -/// manage it. -bool PassManagerImpl_New::addPass(Pass *P) { - - if (!activeManager || !activeManager->addPass(P)) { - activeManager = new ModulePassManager_New(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_New *AR = new AnalysisResolver_New(*this); - activeManager->setResolver(AR); - - addPassManager(activeManager); - return activeManager->addPass(P); - } - return true; -} - +// /// 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_New::run(Module &M) { - +bool PassManagerImpl::run(Module &M) { bool Changed = false; - for (std::vector::iterator I = passManagersBegin(), - E = passManagersEnd(); I != E; ++I) { - ModulePassManager_New *MP = dynamic_cast(*I); - Changed |= MP->runOnModule(M); - } + TimingInfo::createTheTimeInfo(); + + dumpArguments(); + dumpPasses(); + + initializeAllAnalysisInfo(); + for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) + Changed |= getContainedManager(Index)->runOnModule(M); return Changed; } @@ -1168,25 +1600,241 @@ bool PassManagerImpl_New::run(Module &M) { // PassManager implementation /// Create new pass manager -PassManager_New::PassManager_New() { - PM = new PassManagerImpl_New(0); +PassManager::PassManager() { + PM = new PassManagerImpl(0); // PM is the top level manager PM->setTopLevelManager(PM); } +PassManager::~PassManager() { + delete PM; +} + +/// addImpl - Add a pass to the queue of passes to run, without +/// checking whether to add a printer pass. +void PassManager::addImpl(Pass *P) { + PM->add(P); +} + /// 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 /// will be destroyed as well, so there is no need to delete the pass. This /// implies that all passes MUST be allocated with 'new'. -void -PassManager_New::add(Pass *P) { - PM->add(P); +void PassManager::add(Pass *P) { + if (ShouldPrintBeforePass(P)) + addImpl(P->createPrinterPass(dbgs(), std::string("*** IR Dump Before ") + + P->getPassName() + " ***")); + + addImpl(P); + + if (ShouldPrintAfterPass(P)) + addImpl(P->createPrinterPass(dbgs(), std::string("*** IR Dump After ") + + P->getPassName() + " ***")); } /// 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 -PassManager_New::run(Module &M) { +bool PassManager::run(Module &M) { return PM->run(M); } +//===----------------------------------------------------------------------===// +// TimingInfo Class - This class is used to calculate information about the +// amount of time each pass takes to execute. This only happens with +// -time-passes is enabled on the command line. +// +bool llvm::TimePassesIsEnabled = false; +static cl::opt +EnableTiming("time-passes", cl::location(TimePassesIsEnabled), + cl::desc("Time each pass, printing elapsed time for each on exit")); + +// createTheTimeInfo - This method either initializes the TheTimeInfo pointer to +// a non null value (if the -time-passes option is enabled) or it leaves it +// null. It may be called multiple times. +void TimingInfo::createTheTimeInfo() { + if (!TimePassesIsEnabled || TheTimeInfo) return; + + // Constructed the first time this is called, iff -time-passes is enabled. + // This guarantees that the object will be constructed before static globals, + // thus it will be destroyed before them. + static ManagedStatic TTI; + TheTimeInfo = &*TTI; +} + +/// If TimingInfo is enabled then start pass timer. +Timer *llvm::getPassTimer(Pass *P) { + if (TheTimeInfo) + return TheTimeInfo->getPassTimer(P); + return 0; +} + +//===----------------------------------------------------------------------===// +// PMStack implementation +// + +// Pop Pass Manager from the stack and clear its analysis info. +void PMStack::pop() { + + PMDataManager *Top = this->top(); + Top->initializeAnalysisInfo(); + + S.pop_back(); +} + +// Push PM on the stack and set its top level manager. +void PMStack::push(PMDataManager *PM) { + assert(PM && "Unable to push. Pass Manager expected"); + + if (!this->empty()) { + PMTopLevelManager *TPM = this->top()->getTopLevelManager(); + + assert(TPM && "Unable to find top level manager"); + TPM->addIndirectPassManager(PM); + PM->setTopLevelManager(TPM); + } + + S.push_back(PM); +} + +// Dump content of the pass manager stack. +void PMStack::dump() { + for (std::deque::iterator I = S.begin(), + E = S.end(); I != E; ++I) + printf("%s ", (*I)->getAsPass()->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, + PassManagerType PreferredType) { + // Find Module Pass Manager + while(!PMS.empty()) { + 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(!PMS.empty() && "Unable to find appropriate Pass Manager"); + 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, + PassManagerType PreferredType) { + + // Find Module Pass Manager + while (!PMS.empty()) { + if (PMS.top()->getPassManagerType() > PMT_FunctionPassManager) + PMS.pop(); + else + break; + } + + // Create new Function Pass Manager if needed. + FPPassManager *FPP; + if (PMS.top()->getPassManagerType() == PMT_FunctionPassManager) { + FPP = (FPPassManager *)PMS.top(); + } else { + assert(!PMS.empty() && "Unable to create Function Pass Manager"); + PMDataManager *PMD = PMS.top(); + + // [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(); + TPM->addIndirectPassManager(FPP); + + // [3] Assign manager to manage this new manager. This may create + // and push new managers into PMS + FPP->assignPassManager(PMS, PMD->getPassManagerType()); + + // [4] Push new manager into PMS + PMS.push(FPP); + } + + // 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, + PassManagerType PreferredType) { + BBPassManager *BBP; + + // Basic Pass Manager is a leaf pass manager. It does not handle + // any other pass manager. + if (!PMS.empty() && + PMS.top()->getPassManagerType() == PMT_BasicBlockPassManager) { + BBP = (BBPassManager *)PMS.top(); + } else { + // If leaf manager is not Basic Block Pass manager then create new + // basic Block Pass manager. + assert(!PMS.empty() && "Unable to create BasicBlock Pass Manager"); + PMDataManager *PMD = PMS.top(); + + // [1] Create new Basic Block Manager + BBP = new BBPassManager(PMD->getDepth() + 1); + + // [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, PreferredType); + + // [4] Push new manager into PMS + PMS.push(BBP); + } + + // Assign BBP as the manager of this pass. + BBP->add(this); +} + +PassManagerBase::~PassManagerBase() {} + +/*===-- C Bindings --------------------------------------------------------===*/ + +LLVMPassManagerRef LLVMCreatePassManager() { + return wrap(new PassManager()); +} + +LLVMPassManagerRef LLVMCreateFunctionPassManagerForModule(LLVMModuleRef M) { + return wrap(new FunctionPassManager(unwrap(M))); +} + +LLVMPassManagerRef LLVMCreateFunctionPassManager(LLVMModuleProviderRef P) { + return LLVMCreateFunctionPassManagerForModule( + reinterpret_cast(P)); +} + +LLVMBool LLVMRunPassManager(LLVMPassManagerRef PM, LLVMModuleRef M) { + return unwrap(PM)->run(*unwrap(M)); +} + +LLVMBool LLVMInitializeFunctionPassManager(LLVMPassManagerRef FPM) { + return unwrap(FPM)->doInitialization(); +} + +LLVMBool LLVMRunFunctionPassManager(LLVMPassManagerRef FPM, LLVMValueRef F) { + return unwrap(FPM)->run(*unwrap(F)); +} + +LLVMBool LLVMFinalizeFunctionPassManager(LLVMPassManagerRef FPM) { + return unwrap(FPM)->doFinalization(); +} + +void LLVMDisposePassManager(LLVMPassManagerRef PM) { + delete unwrap(PM); +}