#include "llvm/PassManager.h"
+#include "llvm/Support/CommandLine.h"
#include "llvm/Module.h"
#include "llvm/ModuleProvider.h"
#include "llvm/Support/Streams.h"
namespace llvm {
+//===----------------------------------------------------------------------===//
+// 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.
+//
+
+// Different debug levels that can be enabled...
+enum PassDebugLevel {
+ None, Arguments, Structure, Executions, Details
+};
+
+static cl::opt<enum PassDebugLevel>
+PassDebugging_New("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));
+} // End of llvm namespace
+
+#ifndef USE_OLD_PASSMANAGER
+namespace llvm {
+
+class PMDataManager;
+
//===----------------------------------------------------------------------===//
// PMTopLevelManager
//
/// 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, Pass *PM);
+ 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.
/// Collect passes whose last user is P
void collectLastUses(std::vector<Pass *> &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);
+
+ inline void clearManagers() {
+ PassManagers.clear();
+ }
+
virtual ~PMTopLevelManager() {
+
+ for (std::vector<Pass *>::iterator I = PassManagers.begin(),
+ E = PassManagers.end(); I != E; ++I)
+ delete *I;
+
+ for (std::vector<ImmutablePass *>::iterator
+ I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I)
+ delete *I;
+
PassManagers.clear();
}
+ /// Add immutable pass and initialize it.
+ inline void addImmutablePass(ImmutablePass *P) {
+ P->initializePass();
+ ImmutablePasses.push_back(P);
+ }
+
+ inline std::vector<ImmutablePass *>& getImmutablePasses() {
+ return ImmutablePasses;
+ }
+
+ void addPassManager(Pass *Manager) {
+ PassManagers.push_back(Manager);
+ }
+
+ // Add Manager into the list of managers that are not directly
+ // maintained by this top level pass manager
+ inline void addIndirectPassManager(PMDataManager *Manager) {
+ IndirectPassManagers.push_back(Manager);
+ }
+
+ // Print passes managed by this top level manager.
+ void dumpPasses();
+ void dumpArguments();
+
private:
/// Collection of pass managers
std::vector<Pass *> PassManagers;
+ /// Collection of pass managers that are not directly maintained
+ /// by this pass manager
+ std::vector<PMDataManager *> IndirectPassManagers;
+
// Map to keep track of last user of the analysis pass.
// LastUser->second is the last user of Lastuser->first.
std::map<Pass *, Pass *> LastUser;
+
+ /// Immutable passes are managed by top level manager.
+ std::vector<ImmutablePass *> ImmutablePasses;
};
-/// Set pass P as the last user of the given analysis passes.
-void PMTopLevelManager::setLastUser(std::vector<Pass *> &AnalysisPasses,
- Pass *P) {
-
- for (std::vector<Pass *>::iterator I = AnalysisPasses.begin(),
- E = AnalysisPasses.end(); I != E; ++I) {
- Pass *AP = *I;
- LastUser[AP] = P;
- // If AP is the last user of other passes then make P last user of
- // such passes.
- for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(),
- LUE = LastUser.end(); LUI != LUE; ++LUI) {
- if (LUI->second == AP)
- LastUser[LUI->first] = P;
- }
- }
-
-}
-
-/// Collect passes whose last user is P
-void PMTopLevelManager::collectLastUses(std::vector<Pass *> &LastUses,
- Pass *P) {
- for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(),
- LUE = LastUser.end(); LUI != LUE; ++LUI)
- if (LUI->second == P)
- LastUses.push_back(LUI->first);
-}
-
-
+//===----------------------------------------------------------------------===//
+// PMDataManager
/// PMDataManager provides the common place to manage the analysis data
/// used by pass managers.
public:
- /// Return true IFF pass P's required analysis set does not required new
- /// manager.
- bool manageablePass(Pass *P);
+ PMDataManager(int D) : TPM(NULL), Depth(D) {
+ initializeAnalysisInfo();
+ }
- Pass *getAnalysisPass(AnalysisID AID) const {
+ virtual ~PMDataManager() {
- std::map<AnalysisID, Pass*>::const_iterator I =
- AvailableAnalysis.find(AID);
+ for (std::vector<Pass *>::iterator I = PassVector.begin(),
+ E = PassVector.end(); I != E; ++I)
+ delete *I;
- if (I != AvailableAnalysis.end())
- return NULL;
- else
- return I->second;
+ PassVector.clear();
}
+ /// Return true IFF pass P's required analysis set does not required new
+ /// manager.
+ bool manageablePass(Pass *P);
+
/// Augment AvailableAnalysis by adding analysis made available by pass P.
- void noteDownAvailableAnalysis(Pass *P);
+ void recordAvailableAnalysis(Pass *P);
/// Remove Analysis that is not preserved by the pass
void removeNotPreservedAnalysis(Pass *P);
/// Remove dead passes
- void removeDeadPasses(Pass *P);
+ void removeDeadPasses(Pass *P, std::string &Msg);
/// Add pass P into the PassVector. Update
/// AvailableAnalysis appropriately if ProcessAnalysis is true.
void addPassToManager (Pass *P, bool ProcessAnalysis = true);
- // Initialize available analysis information.
+ /// Initialize available analysis information.
void initializeAnalysisInfo() {
+ ForcedLastUses.clear();
AvailableAnalysis.clear();
- LastUser.clear();
}
- // 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);
+ /// Populate RequiredPasses with the analysis pass that are required by
+ /// pass P.
+ void collectRequiredAnalysisPasses(std::vector<Pass *> &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<Pass *>::iterator passVectorBegin() {
return PassVector.begin();
return PassVector.end();
}
- inline void setLastUser(Pass *P, Pass *LU) {
- LastUser[P] = LU;
- // TODO : Check if pass P is available.
+ // Access toplevel manager
+ PMTopLevelManager *getTopLevelManager() { return TPM; }
+ void setTopLevelManager(PMTopLevelManager *T) { TPM = T; }
+
+ unsigned getDepth() { return Depth; }
+
+ // Print list of passes that are last used by P.
+ void dumpLastUses(Pass *P, unsigned Offset) {
+
+ std::vector<Pass *> LUses;
+
+ assert (TPM && "Top Level Manager is missing");
+ TPM->collectLastUses(LUses, P);
+
+ for (std::vector<Pass *>::iterator I = LUses.begin(),
+ E = LUses.end(); I != E; ++I) {
+ llvm::cerr << "--" << std::string(Offset*2, ' ');
+ (*I)->dumpPassStructure(0);
+ }
+ }
+
+ void dumpPassArguments() {
+ for(std::vector<Pass *>::iterator I = PassVector.begin(),
+ E = PassVector.end(); I != E; ++I) {
+ if (PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I))
+ PMD->dumpPassArguments();
+ else
+ if (const PassInfo *PI = (*I)->getPassInfo())
+ if (!PI->isAnalysisGroup())
+ cerr << " -" << PI->getPassArgument();
+ }
+ }
+
+ void dumpPassInfo(Pass *P, std::string &Msg1, std::string &Msg2) {
+ if (PassDebugging_New < Executions)
+ return;
+ cerr << (void*)this << std::string(getDepth()*2+1, ' ');
+ cerr << Msg1;
+ cerr << P->getPassName();
+ cerr << Msg2;
}
+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<Pass *> 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
// scheduled to run.
std::map<AnalysisID, Pass*> AvailableAnalysis;
- // Map to keep track of last user of the analysis pass.
- // LastUser->second is the last user of Lastuser->first.
- std::map<Pass *, Pass *> LastUser;
-
// Collection of pass that are managed by this manager
std::vector<Pass *> PassVector;
+
+ unsigned Depth;
};
-/// BasicBlockPassManager_New manages BasicBlockPass. It batches all the
+//===----------------------------------------------------------------------===//
+// BasicBlockPassManager
+//
+/// BasicBlockPassManager 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,
+class BasicBlockPassManager : public PMDataManager,
public FunctionPass {
public:
- BasicBlockPassManager_New() { }
+ BasicBlockPassManager(int D) : PMDataManager(D) { }
/// Add a pass into a passmanager queue.
bool addPass(Pass *p);
/// whether any of the passes modifies the function, and if so, return true.
bool runOnFunction(Function &F);
- /// Return true IFF AnalysisID AID is currently available.
- Pass *getAnalysisPassFromManager(AnalysisID AID);
+ /// Pass Manager itself does not invalidate any analysis info.
+ void getAnalysisUsage(AnalysisUsage &Info) const {
+ Info.setPreservesAll();
+ }
-private:
+ bool doInitialization(Module &M);
+ bool doInitialization(Function &F);
+ bool doFinalization(Module &M);
+ bool doFinalization(Function &F);
+
+ // Print passes managed by this manager
+ void dumpPassStructure(unsigned Offset) {
+ llvm::cerr << std::string(Offset*2, ' ') << "BasicBLockPass Manager\n";
+ for (std::vector<Pass *>::iterator I = passVectorBegin(),
+ E = passVectorEnd(); I != E; ++I) {
+ (*I)->dumpPassStructure(Offset + 1);
+ dumpLastUses(*I, Offset+1);
+ }
+ }
};
-/// 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 PMDataManager,
- public ModulePass {
+//===----------------------------------------------------------------------===//
+// 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(ModuleProvider *P) { /* TODO */ }
- FunctionPassManagerImpl_New() {
+ FunctionPassManagerImpl_New(int D) : PMDataManager(D) {
activeBBPassManager = NULL;
}
~FunctionPassManagerImpl_New() { /* TODO */ };
+ inline void addTopLevelPass(Pass *P) {
+
+ if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) {
+
+ // 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);
+ }
+
/// 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) { /* TODO*/ }
+ void add(Pass *P) {
+ schedulePass(P);
+ }
/// Add pass into the pass manager queue.
bool addPass(Pass *P);
/// so, return true.
bool runOnModule(Module &M);
bool runOnFunction(Function &F);
-
- /// Return true IFF AnalysisID AID is currently available.
- Pass *getAnalysisPassFromManager(AnalysisID AID);
+ bool run(Function &F);
/// doInitialization - Run all of the initializers for the function passes.
///
/// doFinalization - Run all of the initializers for the function passes.
///
bool doFinalization(Module &M);
+
+ /// Pass Manager itself does not invalidate any analysis info.
+ void getAnalysisUsage(AnalysisUsage &Info) const {
+ Info.setPreservesAll();
+ }
+
+ // Print passes managed by this manager
+ void dumpPassStructure(unsigned Offset) {
+ llvm::cerr << std::string(Offset*2, ' ') << "FunctionPass Manager\n";
+ for (std::vector<Pass *>::iterator I = passVectorBegin(),
+ E = passVectorEnd(); I != E; ++I) {
+ (*I)->dumpPassStructure(Offset + 1);
+ dumpLastUses(*I, Offset+1);
+ }
+ }
+
private:
// Active Pass Managers
- BasicBlockPassManager_New *activeBBPassManager;
+ BasicBlockPassManager *activeBBPassManager;
};
-/// ModulePassManager_New manages ModulePasses and function pass managers.
+//===----------------------------------------------------------------------===//
+// ModulePassManager
+//
+/// ModulePassManager 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 PMDataManager {
+class ModulePassManager : public Pass,
+ public PMDataManager {
public:
- ModulePassManager_New() { activeFunctionPassManager = NULL; }
+ ModulePassManager(int D) : PMDataManager(D) {
+ activeFunctionPassManager = NULL;
+ }
/// Add a pass into a passmanager queue.
bool addPass(Pass *p);
/// whether any of the passes modifies the module, and if so, return true.
bool runOnModule(Module &M);
- /// Return true IFF AnalysisID AID is currently available.
- Pass *getAnalysisPassFromManager(AnalysisID AID);
-
+ /// Pass Manager itself does not invalidate any analysis info.
+ void getAnalysisUsage(AnalysisUsage &Info) const {
+ Info.setPreservesAll();
+ }
+
+ // Print passes managed by this manager
+ void dumpPassStructure(unsigned Offset) {
+ llvm::cerr << std::string(Offset*2, ' ') << "ModulePass Manager\n";
+ for (std::vector<Pass *>::iterator I = passVectorBegin(),
+ E = passVectorEnd(); I != E; ++I) {
+ (*I)->dumpPassStructure(Offset + 1);
+ dumpLastUses(*I, Offset+1);
+ }
+ }
+
private:
// Active Pass Manager
FunctionPassManagerImpl_New *activeFunctionPassManager;
};
-/// PassManager_New manages ModulePassManagers
-class PassManagerImpl_New : public PMDataManager {
+//===----------------------------------------------------------------------===//
+// PassManagerImpl_New
+//
+/// PassManagerImpl_New manages ModulePassManagers
+class PassManagerImpl_New : public Pass,
+ public PMDataManager,
+ public PMTopLevelManager {
public:
+ PassManagerImpl_New(int D) : PMDataManager(D) {
+ activeManager = NULL;
+ }
+
/// 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);
+ void add(Pass *P) {
+ schedulePass(P);
+ }
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
bool run(Module &M);
- /// Return true IFF AnalysisID AID is currently available.
- Pass *getAnalysisPassFromManager(AnalysisID AID);
-
-private:
+ /// Pass Manager itself does not invalidate any analysis info.
+ void getAnalysisUsage(AnalysisUsage &Info) const {
+ Info.setPreservesAll();
+ }
- /// Add a pass into a passmanager queue. This is used by schedulePasses
- bool addPass(Pass *p);
+ inline void addTopLevelPass(Pass *P) {
- /// 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);
+ if (ImmutablePass *IP = dynamic_cast<ImmutablePass *> (P)) {
+
+ // 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);
+ P->setResolver(AR);
+ initializeAnalysisImpl(P);
+ addImmutablePass(IP);
+ recordAvailableAnalysis(IP);
+ }
+ else
+ addPass(P);
+ }
- /// Schedule all passes collected in pass queue using add(). Add all the
- /// schedule passes into various manager's queue using addPass().
- void schedulePasses();
+private:
- // Collection of pass managers
- std::vector<ModulePassManager_New *> PassManagers;
+ /// Add a pass into a passmanager queue.
+ bool addPass(Pass *p);
// Active Pass Manager
- ModulePassManager_New *activeManager;
+ ModulePassManager *activeManager;
};
} // End of llvm namespace
+//===----------------------------------------------------------------------===//
+// PMTopLevelManager implementation
+
+/// Set pass P as the last user of the given analysis passes.
+void PMTopLevelManager::setLastUser(std::vector<Pass *> &AnalysisPasses,
+ Pass *P) {
+
+ for (std::vector<Pass *>::iterator I = AnalysisPasses.begin(),
+ E = AnalysisPasses.end(); I != E; ++I) {
+ Pass *AP = *I;
+ LastUser[AP] = P;
+ // If AP is the last user of other passes then make P last user of
+ // such passes.
+ for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(),
+ LUE = LastUser.end(); LUI != LUE; ++LUI) {
+ if (LUI->second == AP)
+ LastUser[LUI->first] = P;
+ }
+ }
+}
+
+/// Collect passes whose last user is P
+void PMTopLevelManager::collectLastUses(std::vector<Pass *> &LastUses,
+ Pass *P) {
+ for (std::map<Pass *, Pass *>::iterator LUI = LastUser.begin(),
+ LUE = LastUser.end(); LUI != LUE; ++LUI)
+ if (LUI->second == P)
+ LastUses.push_back(LUI->first);
+}
+
+/// 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 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<AnalysisID> &RequiredSet = AnUsage.getRequiredSet();
+ for (std::vector<AnalysisID>::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);
+ }
+ }
+
+ // Now all required passes are available.
+ addTopLevelPass(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 *PMTopLevelManager::findAnalysisPass(AnalysisID AID) {
+
+ Pass *P = NULL;
+ // Check pass managers
+ for (std::vector<Pass *>::iterator I = PassManagers.begin(),
+ E = PassManagers.end(); P == NULL && I != E; ++I) {
+ PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I);
+ assert(PMD && "This is not a PassManager");
+ P = PMD->findAnalysisPass(AID, false);
+ }
+
+ // Check other pass managers
+ for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(),
+ E = IndirectPassManagers.end(); P == NULL && I != E; ++I)
+ P = (*I)->findAnalysisPass(AID, false);
+
+ for (std::vector<ImmutablePass *>::iterator I = ImmutablePasses.begin(),
+ E = ImmutablePasses.end(); P == NULL && I != E; ++I) {
+ const PassInfo *PI = (*I)->getPassInfo();
+ if (PI == AID)
+ P = *I;
+
+ // If Pass not found then check the interfaces implemented by Immutable Pass
+ if (!P) {
+ const std::vector<const PassInfo*> &ImmPI =
+ PI->getInterfacesImplemented();
+ for (unsigned Index = 0, End = ImmPI.size();
+ P == NULL && Index != End; ++Index)
+ if (ImmPI[Index] == AID)
+ P = *I;
+ }
+ }
+
+ return P;
+}
+
+// Print passes managed by this top level manager.
+void PMTopLevelManager::dumpPasses() {
+
+ // Print out the immutable passes
+ for (unsigned i = 0, e = ImmutablePasses.size(); i != e; ++i) {
+ ImmutablePasses[i]->dumpPassStructure(0);
+ }
+
+ for (std::vector<Pass *>::iterator I = PassManagers.begin(),
+ E = PassManagers.end(); I != E; ++I)
+ (*I)->dumpPassStructure(1);
+
+}
+
+void PMTopLevelManager::dumpArguments() {
+
+ if (PassDebugging_New < Arguments)
+ return;
+
+ cerr << "Pass Arguments: ";
+ for (std::vector<Pass *>::iterator I = PassManagers.begin(),
+ E = PassManagers.end(); I != E; ++I) {
+ PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I);
+ assert(PMD && "This is not a PassManager");
+ PMD->dumpPassArguments();
+ }
+ cerr << "\n";
+}
+
+//===----------------------------------------------------------------------===//
// PMDataManager implementation
/// Return true IFF pass P's required analysis set does not required new
}
/// Augement AvailableAnalysis by adding analysis made available by pass P.
-void PMDataManager::noteDownAvailableAnalysis(Pass *P) {
+void PMDataManager::recordAvailableAnalysis(Pass *P) {
if (const PassInfo *PI = P->getPassInfo()) {
AvailableAnalysis[PI] = P;
- //TODO This pass is the current implementation of all of the interfaces it
- //TODO implements as well.
- //TODO
- //TODO const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented();
- //TODO for (unsigned i = 0, e = II.size(); i != e; ++i)
- //TODO CurrentAnalyses[II[i]] = P;
+ //This pass is the current implementation of all of the interfaces it
+ //implements as well.
+ const std::vector<const PassInfo*> &II = PI->getInterfacesImplemented();
+ for (unsigned i = 0, e = II.size(); i != e; ++i)
+ AvailableAnalysis[II[i]] = P;
}
}
void PMDataManager::removeNotPreservedAnalysis(Pass *P) {
AnalysisUsage AnUsage;
P->getAnalysisUsage(AnUsage);
- const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet();
+ if (AnUsage.getPreservesAll())
+ return;
+
+ const std::vector<AnalysisID> &PreservedSet = AnUsage.getPreservedSet();
for (std::map<AnalysisID, Pass*>::iterator I = AvailableAnalysis.begin(),
- E = AvailableAnalysis.end(); I != E; ++I ) {
+ E = AvailableAnalysis.end(); I != E; ) {
if (std::find(PreservedSet.begin(), PreservedSet.end(), I->first) ==
PreservedSet.end()) {
// Remove this analysis
- std::map<AnalysisID, Pass*>::iterator J = I++;
- AvailableAnalysis.erase(J);
- }
+ if (!dynamic_cast<ImmutablePass*>(I->second)) {
+ std::map<AnalysisID, Pass*>::iterator J = I++;
+ AvailableAnalysis.erase(J);
+ } else
+ ++I;
+ } else
+ ++I;
}
}
/// Remove analysis passes that are not used any longer
-void PMDataManager::removeDeadPasses(Pass *P) {
+void PMDataManager::removeDeadPasses(Pass *P, std::string &Msg) {
- for (std::map<Pass *, Pass *>::iterator I = LastUser.begin(),
- E = LastUser.end(); I !=E; ++I) {
- if (I->second == P) {
- Pass *deadPass = I->first;
- deadPass->releaseMemory();
+ std::vector<Pass *> DeadPasses;
+ TPM->collectLastUses(DeadPasses, P);
- std::map<AnalysisID, Pass*>::iterator Pos =
- AvailableAnalysis.find(deadPass->getPassInfo());
-
- assert (Pos != AvailableAnalysis.end() &&
- "Pass is not available");
+ for (std::vector<Pass *>::iterator I = DeadPasses.begin(),
+ E = DeadPasses.end(); I != E; ++I) {
+
+ std::string Msg1 = " Freeing Pass '";
+ dumpPassInfo(*I, Msg1, Msg);
+
+ (*I)->releaseMemory();
+
+ std::map<AnalysisID, Pass*>::iterator Pos =
+ AvailableAnalysis.find((*I)->getPassInfo());
+
+ // It is possible that pass is already removed from the AvailableAnalysis
+ if (Pos != AvailableAnalysis.end())
AvailableAnalysis.erase(Pos);
- }
}
}
/// Add pass P into the PassVector. Update
/// AvailableAnalysis appropriately if ProcessAnalysis is true.
-void PMDataManager::addPassToManager (Pass *P,
- bool ProcessAnalysis) {
+void PMDataManager::addPassToManager(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);
+ P->setResolver(AR);
if (ProcessAnalysis) {
- // Take a note of analysis required and made available by this pass
- initializeAnalysisImpl(P);
- noteDownAvailableAnalysis(P);
+ // At the moment, this pass is the last user of all required passes.
+ std::vector<Pass *> LastUses;
+ std::vector<Pass *> RequiredPasses;
+ unsigned PDepth = this->getDepth();
+
+ collectRequiredAnalysisPasses(RequiredPasses, P);
+ for (std::vector<Pass *>::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 (!LastUses.empty())
+ TPM->setLastUser(LastUses, P);
+
+ // 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<Pass *> &RP,
+ Pass *P) {
+ AnalysisUsage AnUsage;
+ P->getAnalysisUsage(AnUsage);
+ const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet();
+ for (std::vector<AnalysisID>::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);
+ }
+
+ const std::vector<AnalysisID> &IDs = AnUsage.getRequiredTransitiveSet();
+ for (std::vector<AnalysisID>::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);
+ }
+}
+
// 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
for (std::vector<const PassInfo *>::const_iterator
I = AnUsage.getRequiredSet().begin(),
E = AnUsage.getRequiredSet().end(); I != E; ++I) {
- Pass *Impl = getAnalysisPass(*I);
+ Pass *Impl = findAnalysisPass(*I, true);
if (Impl == 0)
assert(0 && "Analysis used but not available!");
- // TODO: P->AnalysisImpls.push_back(std::make_pair(*I, Impl));
+ AnalysisResolver_New *AR = P->getResolver();
+ AR->addAnalysisImplsPair(*I, Impl);
}
}
-/// BasicBlockPassManager implementation
+/// Find the pass that implements Analysis AID. If desired pass is not found
+/// then return NULL.
+Pass *PMDataManager::findAnalysisPass(AnalysisID AID, bool SearchParent) {
+
+ // Check if AvailableAnalysis map has one entry.
+ std::map<AnalysisID, Pass*>::const_iterator I = AvailableAnalysis.find(AID);
+
+ if (I != AvailableAnalysis.end())
+ return I->second;
+
+ // Search Parents through TopLevelManager
+ if (SearchParent)
+ return TPM->findAnalysisPass(AID);
+
+ return NULL;
+}
+
+
+//===----------------------------------------------------------------------===//
+// 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);
+}
+
+//===----------------------------------------------------------------------===//
+// BasicBlockPassManager implementation
/// 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) {
+BasicBlockPassManager::addPass(Pass *P) {
BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
if (!BP)
/// runOnBasicBlock method. Keep track of whether any of the passes modifies
/// the function, and if so, return true.
bool
-BasicBlockPassManager_New::runOnFunction(Function &F) {
+BasicBlockPassManager::runOnFunction(Function &F) {
- bool Changed = false;
+ if (F.isExternal())
+ return false;
+
+ bool Changed = doInitialization(F);
initializeAnalysisInfo();
+ std::string Msg1 = "Executing Pass '";
+ std::string Msg3 = "' Made Modification '";
+
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
e = passVectorEnd(); itr != e; ++itr) {
Pass *P = *itr;
-
- noteDownAvailableAnalysis(P);
+ std::string Msg2 = "' on BasicBlock '" + (*I).getName() + "'...\n";
+ dumpPassInfo(P, Msg1, Msg2);
+ initializeAnalysisImpl(P);
+
BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
Changed |= BP->runOnBasicBlock(*I);
+
+ if (Changed)
+ dumpPassInfo(P, Msg3, Msg2);
+
removeNotPreservedAnalysis(P);
- removeDeadPasses(P);
+ recordAvailableAnalysis(P);
+ removeDeadPasses(P, Msg2);
}
+ return Changed | doFinalization(F);
+}
+
+// Implement doInitialization and doFinalization
+inline bool BasicBlockPassManager::doInitialization(Module &M) {
+ bool Changed = false;
+
+ for (std::vector<Pass *>::iterator itr = passVectorBegin(),
+ e = passVectorEnd(); itr != e; ++itr) {
+ Pass *P = *itr;
+ BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
+ Changed |= BP->doInitialization(M);
+ }
+
+ return Changed;
+}
+
+inline bool BasicBlockPassManager::doFinalization(Module &M) {
+ bool Changed = false;
+
+ for (std::vector<Pass *>::iterator itr = passVectorBegin(),
+ e = passVectorEnd(); itr != e; ++itr) {
+ Pass *P = *itr;
+ BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
+ Changed |= BP->doFinalization(M);
+ }
+
+ return Changed;
+}
+
+inline bool BasicBlockPassManager::doInitialization(Function &F) {
+ bool Changed = false;
+
+ for (std::vector<Pass *>::iterator itr = passVectorBegin(),
+ e = passVectorEnd(); itr != e; ++itr) {
+ Pass *P = *itr;
+ BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
+ Changed |= BP->doInitialization(F);
+ }
+
return Changed;
}
-/// Return true IFF AnalysisID AID is currently available.
-Pass * BasicBlockPassManager_New::getAnalysisPassFromManager(AnalysisID AID) {
- return getAnalysisPass(AID);
+inline bool BasicBlockPassManager::doFinalization(Function &F) {
+ bool Changed = false;
+
+ for (std::vector<Pass *>::iterator itr = passVectorBegin(),
+ e = passVectorEnd(); itr != e; ++itr) {
+ Pass *P = *itr;
+ BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P);
+ Changed |= BP->doFinalization(F);
+ }
+
+ return Changed;
}
-// FunctionPassManager_New implementation
+
+//===----------------------------------------------------------------------===//
+// FunctionPassManager implementation
+
/// Create new Function pass manager
-FunctionPassManager_New::FunctionPassManager_New() {
- FPM = new FunctionPassManagerImpl_New();
+FunctionPassManager::FunctionPassManager(ModuleProvider *P) {
+ FPM = new FunctionPassManagerImpl_New(0);
+ // FPM is the top level manager.
+ FPM->setTopLevelManager(FPM);
+
+ PMDataManager *PMD = dynamic_cast<PMDataManager *>(FPM);
+ AnalysisResolver_New *AR = new AnalysisResolver_New(*PMD);
+ FPM->setResolver(AR);
+
+ FPM->addPassManager(FPM);
+ MP = P;
+}
+
+FunctionPassManager::~FunctionPassManager() {
+ // Note : FPM maintains one entry in PassManagers vector.
+ // This one entry is FPM itself. This is not ideal. One
+ // alternative is have one additional layer between
+ // FunctionPassManager and FunctionPassManagerImpl.
+ // Meanwhile, to avoid going into infinte loop, first
+ // remove FPM from its PassMangers vector.
+ FPM->clearManagers();
+ delete FPM;
}
/// add - Add a pass to the queue of passes to run. This passes
/// 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) {
+void FunctionPassManager::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);
-}
-
/// 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) {
+bool FunctionPassManager::run(Function &F) {
std::string errstr;
if (MP->materializeFunction(&F, &errstr)) {
cerr << "Error reading bytecode file: " << errstr << "\n";
abort();
}
- return FPM->runOnFunction(F);
+ return FPM->run(F);
}
/// doInitialization - Run all of the initializers for the function passes.
///
-bool FunctionPassManager_New::doInitialization() {
+bool FunctionPassManager::doInitialization() {
return FPM->doInitialization(*MP->getModule());
}
/// doFinalization - Run all of the initializers for the function passes.
///
-bool FunctionPassManager_New::doFinalization() {
+bool FunctionPassManager::doFinalization() {
return FPM->doFinalization(*MP->getModule());
}
+//===----------------------------------------------------------------------===//
// FunctionPassManagerImpl_New implementation
-// FunctionPassManager
-
/// 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) {
- // If P is a BasicBlockPass then use BasicBlockPassManager_New.
+ // If P is a BasicBlockPass then use BasicBlockPassManager.
if (BasicBlockPass *BP = dynamic_cast<BasicBlockPass*>(P)) {
- if (!activeBBPassManager
- || !activeBBPassManager->addPass(BP)) {
+ if (!activeBBPassManager || !activeBBPassManager->addPass(BP)) {
+
+ // If active manager exists then clear its analysis info.
+ if (activeBBPassManager)
+ activeBBPassManager->initializeAnalysisInfo();
+
+ // Create and add new manager
+ activeBBPassManager =
+ new BasicBlockPassManager(getDepth() + 1);
+ // Inherit top level manager
+ activeBBPassManager->setTopLevelManager(this->getTopLevelManager());
- activeBBPassManager = new BasicBlockPassManager_New();
+ // Add new manager into current manager's list.
addPassToManager(activeBBPassManager, false);
+
+ // Add new manager into top level manager's indirect passes list
+ PMDataManager *PMD = dynamic_cast<PMDataManager *>(activeBBPassManager);
+ assert (PMD && "Manager is not Pass Manager");
+ TPM->addIndirectPassManager(PMD);
+
+ // Add pass into new manager. This time it must succeed.
if (!activeBBPassManager->addPass(BP))
assert(0 && "Unable to add Pass");
}
+
+ if (!ForcedLastUses.empty())
+ TPM->setLastUser(ForcedLastUses, this);
+
return true;
}
return false;
addPassToManager (FP);
- activeBBPassManager = NULL;
+
+ // If active manager exists then clear its analysis info.
+ if (activeBBPassManager) {
+ activeBBPassManager->initializeAnalysisInfo();
+ activeBBPassManager = NULL;
+ }
+
return true;
}
/// the function, and if so, return true.
bool FunctionPassManagerImpl_New::runOnModule(Module &M) {
- bool Changed = false;
+ bool Changed = doInitialization(M);
initializeAnalysisInfo();
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
- for (std::vector<Pass *>::iterator itr = passVectorBegin(),
- e = passVectorEnd(); itr != e; ++itr) {
- Pass *P = *itr;
-
- noteDownAvailableAnalysis(P);
- FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
- Changed |= FP->runOnFunction(*I);
- removeNotPreservedAnalysis(P);
- removeDeadPasses(P);
- }
- return Changed;
+ this->runOnFunction(*I);
+
+ return Changed | doFinalization(M);
}
/// Execute all of the passes scheduled for execution by invoking
bool FunctionPassManagerImpl_New::runOnFunction(Function &F) {
bool Changed = false;
+
+ if (F.isExternal())
+ return false;
+
initializeAnalysisInfo();
+ std::string Msg1 = "Executing Pass '";
+ std::string Msg3 = "' Made Modification '";
+
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
e = passVectorEnd(); itr != e; ++itr) {
Pass *P = *itr;
-
- noteDownAvailableAnalysis(P);
+
+ std::string Msg2 = "' on Function '" + F.getName() + "'...\n";
+ dumpPassInfo(P, Msg1, Msg2);
+
+ initializeAnalysisImpl(P);
FunctionPass *FP = dynamic_cast<FunctionPass*>(P);
Changed |= FP->runOnFunction(F);
+
+ if (Changed)
+ dumpPassInfo(P, Msg3, Msg2);
+
removeNotPreservedAnalysis(P);
- removeDeadPasses(P);
+ recordAvailableAnalysis(P);
+ removeDeadPasses(P, Msg2);
}
return Changed;
}
-/// Return true IFF AnalysisID AID is currently available.
-Pass *FunctionPassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) {
-
- Pass *P = getAnalysisPass(AID);
- if (P)
- return P;
-
- if (activeBBPassManager &&
- activeBBPassManager->getAnalysisPass(AID) != 0)
- return activeBBPassManager->getAnalysisPass(AID);
-
- // TODO : Check inactive managers
- return NULL;
-}
-
inline bool FunctionPassManagerImpl_New::doInitialization(Module &M) {
bool Changed = false;
Changed |= FP->doFinalization(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 Changed = false;
+ for (std::vector<Pass *>::iterator I = passManagersBegin(),
+ E = passManagersEnd(); I != E; ++I) {
+ FunctionPassManagerImpl_New *FP =
+ dynamic_cast<FunctionPassManagerImpl_New *>(*I);
+ Changed |= FP->runOnFunction(F);
+ }
+ return Changed;
+}
+
+//===----------------------------------------------------------------------===//
// ModulePassManager 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.
bool
-ModulePassManager_New::addPass(Pass *P) {
+ModulePassManager::addPass(Pass *P) {
// If P is FunctionPass then use function pass maanager.
if (FunctionPass *FP = dynamic_cast<FunctionPass*>(P)) {
- activeFunctionPassManager = NULL;
+ if (!activeFunctionPassManager || !activeFunctionPassManager->addPass(P)) {
- if (!activeFunctionPassManager
- || !activeFunctionPassManager->addPass(P)) {
+ // If active manager exists then clear its analysis info.
+ if (activeFunctionPassManager)
+ activeFunctionPassManager->initializeAnalysisInfo();
- activeFunctionPassManager = new FunctionPassManagerImpl_New();
+ // Create and add new manager
+ activeFunctionPassManager =
+ new FunctionPassManagerImpl_New(getDepth() + 1);
+
+ // Add new manager into current manager's list
addPassToManager(activeFunctionPassManager, false);
+
+ // Inherit top level manager
+ activeFunctionPassManager->setTopLevelManager(this->getTopLevelManager());
+
+ // Add new manager into top level manager's indirect passes list
+ PMDataManager *PMD =
+ dynamic_cast<PMDataManager *>(activeFunctionPassManager);
+ assert(PMD && "Manager is not Pass Manager");
+ TPM->addIndirectPassManager(PMD);
+
+ // Add pass into new manager. This time it must succeed.
if (!activeFunctionPassManager->addPass(FP))
assert(0 && "Unable to add pass");
}
+
+ if (!ForcedLastUses.empty())
+ TPM->setLastUser(ForcedLastUses, this);
+
return true;
}
return false;
addPassToManager(MP);
- activeFunctionPassManager = NULL;
+ // If active manager exists then clear its analysis info.
+ if (activeFunctionPassManager) {
+ activeFunctionPassManager->initializeAnalysisInfo();
+ activeFunctionPassManager = NULL;
+ }
+
return true;
}
/// runOnModule method. Keep track of whether any of the passes modifies
/// the module, and if so, return true.
bool
-ModulePassManager_New::runOnModule(Module &M) {
+ModulePassManager::runOnModule(Module &M) {
bool Changed = false;
initializeAnalysisInfo();
+ std::string Msg1 = "Executing Pass '";
+ std::string Msg3 = "' Made Modification '";
+
for (std::vector<Pass *>::iterator itr = passVectorBegin(),
e = passVectorEnd(); itr != e; ++itr) {
Pass *P = *itr;
- noteDownAvailableAnalysis(P);
+ std::string Msg2 = "' on Module '" + M.getModuleIdentifier() + "'...\n";
+ dumpPassInfo(P, Msg1, Msg2);
+
+ initializeAnalysisImpl(P);
ModulePass *MP = dynamic_cast<ModulePass*>(P);
Changed |= MP->runOnModule(M);
- removeNotPreservedAnalysis(P);
- removeDeadPasses(P);
- }
- return Changed;
-}
-
-/// Return true IFF AnalysisID AID is currently available.
-Pass *ModulePassManager_New::getAnalysisPassFromManager(AnalysisID AID) {
-
-
- Pass *P = getAnalysisPass(AID);
- if (P)
- return P;
- if (activeFunctionPassManager &&
- activeFunctionPassManager->getAnalysisPass(AID) != 0)
- return activeFunctionPassManager->getAnalysisPass(AID);
-
- // TODO : Check inactive managers
- return NULL;
-}
-
-/// Return true IFF AnalysisID AID is currently available.
-Pass *PassManagerImpl_New::getAnalysisPassFromManager(AnalysisID AID) {
-
- Pass *P = NULL;
- for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(),
- e = PassManagers.end(); !P && itr != e; ++itr)
- P = (*itr)->getAnalysisPassFromManager(AID);
- return P;
-}
-
-/// 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 PassManagerImpl_New::schedulePass(Pass *P) {
-
- AnalysisUsage AnUsage;
- P->getAnalysisUsage(AnUsage);
- const std::vector<AnalysisID> &RequiredSet = AnUsage.getRequiredSet();
- for (std::vector<AnalysisID>::const_iterator I = RequiredSet.begin(),
- E = RequiredSet.end(); I != E; ++I) {
+ if (Changed)
+ dumpPassInfo(P, Msg3, Msg2);
- Pass *AnalysisPass = getAnalysisPassFromManager(*I);
- if (!AnalysisPass) {
- // Schedule this analysis run first.
- AnalysisPass = (*I)->createPass();
- schedulePass(AnalysisPass);
- }
- setLastUser (AnalysisPass, P);
-
- // Prolong live range of analyses that are needed after an analysis pass
- // is destroyed, for querying by subsequent passes
- const std::vector<AnalysisID> &IDs = AnUsage.getRequiredTransitiveSet();
- for (std::vector<AnalysisID>::const_iterator I = IDs.begin(),
- E = IDs.end(); I != E; ++I) {
- Pass *AP = getAnalysisPassFromManager(*I);
- assert (AP && "Analysis pass is not available");
- setLastUser(AP, P);
- }
+ removeNotPreservedAnalysis(P);
+ recordAvailableAnalysis(P);
+ removeDeadPasses(P, Msg2);
}
- addPass(P);
-}
-
-/// Schedule all passes from the queue by adding them in their
-/// respective manager's queue.
-void PassManagerImpl_New::schedulePasses() {
- for (std::vector<Pass *>::iterator I = passVectorBegin(),
- E = passVectorEnd(); I != E; ++I)
- schedulePass (*I);
-}
-
-/// Add pass P to the queue of passes to run.
-void PassManagerImpl_New::add(Pass *P) {
- // Do not process Analysis now. Analysis is process while scheduling
- // the pass vector.
- addPassToManager(P, false);
+ return Changed;
}
-// PassManager_New implementation
+//===----------------------------------------------------------------------===//
+// PassManagerImpl 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();
- PassManagers.push_back(activeManager);
- }
+ activeManager = new ModulePassManager(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);
- return activeManager->addPass(P);
+ 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) {
- schedulePasses();
bool Changed = false;
- for (std::vector<ModulePassManager_New *>::iterator itr = PassManagers.begin(),
- e = PassManagers.end(); itr != e; ++itr) {
- ModulePassManager_New *pm = *itr;
- Changed |= pm->runOnModule(M);
+
+ dumpArguments();
+ if (PassDebugging_New >= Structure)
+ dumpPasses();
+
+ for (std::vector<Pass *>::iterator I = passManagersBegin(),
+ E = passManagersEnd(); I != E; ++I) {
+ ModulePassManager *MP = dynamic_cast<ModulePassManager *>(*I);
+ Changed |= MP->runOnModule(M);
}
return Changed;
}
+//===----------------------------------------------------------------------===//
+// PassManager implementation
+
/// Create new pass manager
-PassManager_New::PassManager_New() {
- PM = new PassManagerImpl_New();
+PassManager::PassManager() {
+ PM = new PassManagerImpl_New(0);
+ // PM is the top level manager
+ PM->setTopLevelManager(PM);
+}
+
+PassManager::~PassManager() {
+ delete PM;
}
/// add - Add a pass to the queue of passes to run. This passes ownership of
/// 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) {
+PassManager::add(Pass *P) {
PM->add(P);
}
/// run - Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the module, and if so, return true.
bool
-PassManager_New::run(Module &M) {
+PassManager::run(Module &M) {
return PM->run(M);
}
+#endif