X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FPassManagers.h;h=5bf4dfb0a1047a6a20d37a03de5c0c878add1b64;hb=b43e9c196542acc80c9e4643809661065710848f;hp=cb94406957d2e94ff33a4f0feb067859f1a76a0c;hpb=e24e0e1244dc273016e541948086a89ffce1f7e4;p=oota-llvm.git diff --git a/include/llvm/PassManagers.h b/include/llvm/PassManagers.h index cb94406957d..5bf4dfb0a10 100644 --- a/include/llvm/PassManagers.h +++ b/include/llvm/PassManagers.h @@ -1,21 +1,20 @@ -//===- PassManager.cpp - LLVM Pass Infrastructure Implementation ----------===// +//===- llvm/PassManager.h - Pass Inftrastructre classes --------*- C++ -*-===// // // 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. // //===----------------------------------------------------------------------===// // -// This file implements the LLVM Pass Manager infrastructure. +// This file declares the LLVM Pass Manager infrastructure. // //===----------------------------------------------------------------------===// #include "llvm/PassManager.h" - -using namespace llvm; -class llvm::PMDataManager; -class llvm::PMStack; +#include "llvm/ADT/SmallVector.h" +#include +#include //===----------------------------------------------------------------------===// // Overview: @@ -84,8 +83,60 @@ class llvm::PMStack; // MPPassManagers. //===----------------------------------------------------------------------===// +#ifndef PASSMANAGERS_H +#define PASSMANAGERS_H + namespace llvm { +/// FunctionPassManager and PassManager, two top level managers, serve +/// as the public interface of pass manager infrastructure. +enum TopLevelManagerType { + TLM_Function, // FunctionPassManager + TLM_Pass // PassManager +}; + +// enums for debugging strings +enum PassDebuggingString { + EXECUTION_MSG, // "Executing Pass '" + MODIFICATION_MSG, // "' Made Modification '" + FREEING_MSG, // " Freeing Pass '" + ON_BASICBLOCK_MSG, // "' on BasicBlock '" + PassName + "'...\n" + ON_FUNCTION_MSG, // "' on Function '" + FunctionName + "'...\n" + ON_MODULE_MSG, // "' on Module '" + ModuleName + "'...\n" + ON_LOOP_MSG, // " 'on Loop ...\n'" + ON_CG_MSG // "' on Call Graph ...\n'" +}; + +//===----------------------------------------------------------------------===// +// PMStack +// +/// PMStack +/// Top level pass managers (see PassManager.cpp) maintain active Pass Managers +/// using PMStack. Each Pass implements assignPassManager() to connect itself +/// with appropriate manager. assignPassManager() walks PMStack to find +/// suitable manager. +/// +/// PMStack is just a wrapper around standard deque that overrides pop() and +/// push() methods. +class PMStack { +public: + typedef std::deque::reverse_iterator iterator; + iterator begin() { return S.rbegin(); } + iterator end() { return S.rend(); } + + void handleLastUserOverflow(); + + void pop(); + inline PMDataManager *top() { return S.back(); } + void push(PMDataManager *PM); + inline bool empty() { return S.empty(); } + + void dump(); +private: + std::deque S; +}; + + //===----------------------------------------------------------------------===// // PMTopLevelManager // @@ -95,7 +146,7 @@ class PMTopLevelManager { public: virtual unsigned getNumContainedManagers() { - return PassManagers.size(); + return (unsigned)PassManagers.size(); } /// Schedule pass P for execution. Make sure that passes required by @@ -108,16 +159,17 @@ public: 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); + void setLastUser(SmallVector &AnalysisPasses, Pass *P); /// Collect passes whose last user is P - void collectLastUses(std::vector &LastUses, Pass *P); + void collectLastUses(SmallVector &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); + explicit PMTopLevelManager(enum TopLevelManagerType t); virtual ~PMTopLevelManager(); /// Add immutable pass and initialize it. @@ -130,7 +182,7 @@ public: return ImmutablePasses; } - void addPassManager(Pass *Manager) { + void addPassManager(PMDataManager *Manager) { PassManagers.push_back(Manager); } @@ -152,7 +204,7 @@ public: protected: /// Collection of pass managers - std::vector PassManagers; + std::vector PassManagers; private: @@ -177,39 +229,57 @@ private: /// used by pass managers. class PMDataManager { public: - PMDataManager(int Depth) : TPM(NULL), Depth(Depth) { + + explicit PMDataManager(int Depth) : TPM(NULL), Depth(Depth) { initializeAnalysisInfo(); } virtual ~PMDataManager(); - /// 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); + /// verifyPreservedAnalysis -- Verify analysis presreved by pass P. + void verifyPreservedAnalysis(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); + void removeDeadPasses(Pass *P, const char *Msg, enum PassDebuggingString); /// Add pass P into the PassVector. Update /// AvailableAnalysis appropriately if ProcessAnalysis is true. void add(Pass *P, bool ProcessAnalysis = true); + /// 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); + + virtual Pass * getOnTheFlyPass(Pass *P, const PassInfo *PI, Function &F) { + assert (0 && "Unable to find on the fly pass"); + return NULL; + } + /// Initialize available analysis information. void initializeAnalysisInfo() { - TransferLastUses.clear(); AvailableAnalysis.clear(); + for (unsigned i = 0; i < PMT_Last; ++i) + InheritedAnalysis[i] = NULL; } - /// Populate RequiredPasses with the analysis pass that are required by - /// pass P. - void collectRequiredAnalysisPasses(std::vector &RequiredPasses, - Pass *P); + // Return true if P preserves high level analysis used by other + // passes that are managed by this manager. + bool preserveHigherLevelAnalysis(Pass *P); + + + /// Populate RequiredPasses with analysis pass that are required by + /// pass P and are available. Populate ReqPassNotAvailable with analysis + /// pass that are required by pass P but are not available. + void collectRequiredAnalysis(SmallVector &RequiredPasses, + SmallVector &ReqPassNotAvailable, + 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 @@ -230,29 +300,33 @@ public: // 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 dumpPassInfo(Pass *P, enum PassDebuggingString S1, + enum PassDebuggingString S2, const char *Msg); void dumpAnalysisSetInfo(const char *Msg, Pass *P, const std::vector &Set) const; - std::vector& getTransferredLastUses() { - return TransferLastUses; - } - virtual unsigned getNumContainedPasses() { - return PassVector.size(); + return (unsigned)PassVector.size(); } - virtual PassManagerType getPassManagerType() { + virtual PassManagerType getPassManagerType() const { assert ( 0 && "Invalid use of getPassManagerType"); return PMT_Unknown; } -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; + std::map *getAvailableAnalysis() { + return &AvailableAnalysis; + } + + // Collect AvailableAnalysis from all the active Pass Managers. + void populateInheritedAnalysis(PMStack &PMS) { + unsigned Index = 0; + for (PMStack::iterator I = PMS.begin(), E = PMS.end(); + I != E; ++I) + InheritedAnalysis[Index++] = (*I)->getAvailableAnalysis(); + } + +protected: // Top level manager. PMTopLevelManager *TPM; @@ -260,6 +334,11 @@ protected: // Collection of pass that are managed by this manager std::vector PassVector; + // Collection of Analysis provided by Parent pass manager and + // used by current pass manager. At at time there can not be more + // then PMT_Last active pass mangers. + std::map *InheritedAnalysis[PMT_Last]; + private: // Set of available Analysis. This information is used while scheduling // pass. If a pass requires an analysis which is not not available then @@ -267,6 +346,10 @@ private: // scheduled to run. std::map AvailableAnalysis; + // Collection of higher level analysis used by the pass managed by + // this manager. + std::vector HigherLevelAnalysis; + unsigned Depth; }; @@ -281,7 +364,9 @@ private: class FPPassManager : public ModulePass, public PMDataManager { public: - FPPassManager(int Depth) : PMDataManager(Depth) { } + static char ID; + explicit FPPassManager(int Depth) + : ModulePass(intptr_t(&ID)), PMDataManager(Depth) { } /// 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. @@ -292,7 +377,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); @@ -304,16 +389,25 @@ public: // Print passes managed by this manager void dumpPassStructure(unsigned Offset); + virtual const char *getPassName() const { + return "Function Pass Manager"; + } + FunctionPass *getContainedPass(unsigned N) { assert ( N < PassVector.size() && "Pass number out of range!"); FunctionPass *FP = static_cast(PassVector[N]); return FP; } - virtual PassManagerType getPassManagerType() { + virtual PassManagerType getPassManagerType() const { return PMT_FunctionPassManager; } }; } +extern void StartPassTimer(llvm::Pass *); +extern void StopPassTimer(llvm::Pass *); + +#endif +