public:
static char ID;
explicit BBPassManager(int Depth)
- : PMDataManager(Depth), FunctionPass((intptr_t)&ID) {}
+ : PMDataManager(Depth), FunctionPass(&ID) {}
/// Execute all of the passes scheduled for execution. Keep track of
/// whether any of the passes modifies the function, and if so, return true.
public:
static char ID;
explicit FunctionPassManagerImpl(int Depth) :
- Pass((intptr_t)&ID), PMDataManager(Depth),
+ Pass(&ID), PMDataManager(Depth),
PMTopLevelManager(TLM_Function) { }
/// add - Add a pass to the queue of passes to run. This passes ownership of
public:
static char ID;
explicit MPPassManager(int Depth) :
- Pass((intptr_t)&ID), PMDataManager(Depth) { }
+ Pass(&ID), PMDataManager(Depth) { }
// Delete on the fly managers.
virtual ~MPPassManager() {
public:
static char ID;
explicit PassManagerImpl(int Depth) :
- Pass((intptr_t)&ID), PMDataManager(Depth),
- PMTopLevelManager(TLM_Pass) { }
+ Pass(&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
// 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(),
+ for (
DenseMap<Pass *, Pass *>::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(SmallVector<Pass *, 12> &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);
+ Pass *P) {
+ DenseMap<Pass *, SmallPtrSet<Pass *, 8> >::iterator DMI =
+ InversedLastUser.find(P);
+ if (DMI == InversedLastUser.end())
+ return;
+
+ SmallPtrSet<Pass *, 8> &LU = DMI->second;
+ for (SmallPtrSet<Pass *, 8>::iterator I = LU.begin(),
+ E = LU.end(); I != E; ++I) {
+ LastUses.push_back(*I);
+ }
+
}
AnalysisUsage *PMTopLevelManager::findAnalysisUsage(Pass *P) {
AnalysisUsage *AnUsage = findAnalysisUsage(P);
- 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();
- // Schedule this analysis run first only if it is not a lower level
- // analysis pass. Lower level analsyis passes are run on the fly.
- if (P->getPotentialPassManagerType () >=
- AnalysisPass->getPotentialPassManagerType())
- schedulePass(AnalysisPass);
- else
- delete AnalysisPass;
+ 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;
+ }
}
}
Pass *P = NULL;
// Check pass managers
- for (std::vector<PMDataManager *>::iterator I = PassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::iterator I = PassManagers.begin(),
E = PassManagers.end(); P == NULL && I != E; ++I) {
PMDataManager *PMD = *I;
P = PMD->findAnalysisPass(AID, false);
}
// Check other pass managers
- for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::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(),
+ for (SmallVector<ImmutablePass *, 8>::iterator I = ImmutablePasses.begin(),
E = ImmutablePasses.end(); P == NULL && I != E; ++I) {
const PassInfo *PI = (*I)->getPassInfo();
if (PI == AID)
// (sometimes indirectly), but there's no inheritance relationship
// between PMDataManager and Pass, so we have to dynamic_cast to get
// from a PMDataManager* to a Pass*.
- for (std::vector<PMDataManager *>::const_iterator I = PassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::const_iterator I = PassManagers.begin(),
E = PassManagers.end(); I != E; ++I)
dynamic_cast<Pass *>(*I)->dumpPassStructure(1);
}
return;
cerr << "Pass Arguments: ";
- for (std::vector<PMDataManager *>::const_iterator I = PassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::const_iterator I = PassManagers.begin(),
E = PassManagers.end(); I != E; ++I) {
PMDataManager *PMD = *I;
PMD->dumpPassArguments();
void PMTopLevelManager::initializeAllAnalysisInfo() {
- for (std::vector<PMDataManager *>::iterator I = PassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::iterator I = PassManagers.begin(),
E = PassManagers.end(); I != E; ++I) {
PMDataManager *PMD = *I;
PMD->initializeAnalysisInfo();
}
// Initailize other pass managers
- for (std::vector<PMDataManager *>::iterator I = IndirectPassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::iterator I = IndirectPassManagers.begin(),
E = IndirectPassManagers.end(); I != E; ++I)
(*I)->initializeAnalysisInfo();
+
+ for(DenseMap<Pass *, Pass *>::iterator DMI = LastUser.begin(),
+ DME = LastUser.end(); DMI != DME; ++DMI) {
+ DenseMap<Pass *, SmallPtrSet<Pass *, 8> >::iterator InvDMI =
+ InversedLastUser.find(DMI->second);
+ if (InvDMI != InversedLastUser.end()) {
+ SmallPtrSet<Pass *, 8> &L = InvDMI->second;
+ L.insert(DMI->first);
+ } else {
+ SmallPtrSet<Pass *, 8> L; L.insert(DMI->first);
+ InversedLastUser[DMI->second] = L;
+ }
+ }
}
/// Destructor
PMTopLevelManager::~PMTopLevelManager() {
- for (std::vector<PMDataManager *>::iterator I = PassManagers.begin(),
+ for (SmallVector<PMDataManager *, 8>::iterator I = PassManagers.begin(),
E = PassManagers.end(); I != E; ++I)
delete *I;
- for (std::vector<ImmutablePass *>::iterator
+ for (SmallVector<ImmutablePass *, 8>::iterator
I = ImmutablePasses.begin(), E = ImmutablePasses.end(); I != E; ++I)
delete *I;
return true;
const AnalysisUsage::VectorType &PreservedSet = AnUsage->getPreservedSet();
- for (std::vector<Pass *>::iterator I = HigherLevelAnalysis.begin(),
+ for (SmallVector<Pass *, 8>::iterator I = HigherLevelAnalysis.begin(),
E = HigherLevelAnalysis.end(); I != E; ++I) {
Pass *P1 = *I;
if (!dynamic_cast<ImmutablePass*>(P1) &&
}
void PMDataManager::dumpPassArguments() const {
- for(std::vector<Pass *>::const_iterator I = PassVector.begin(),
+ for(SmallVector<Pass *, 8>::const_iterator I = PassVector.begin(),
E = PassVector.end(); I != E; ++I) {
if (PMDataManager *PMD = dynamic_cast<PMDataManager *>(*I))
PMD->dumpPassArguments();
// Destructor
PMDataManager::~PMDataManager() {
- for (std::vector<Pass *>::iterator I = PassVector.begin(),
+ for (SmallVector<Pass *, 8>::iterator I = PassVector.begin(),
E = PassVector.end(); I != E; ++I)
delete *I;
else
break;
}
-
+ assert(!PMS.empty() && "Unable to find appropriate Pass Manager");
PMS.top()->add(this);
}
void FunctionPass::assignPassManager(PMStack &PMS,
PassManagerType PreferredType) {
- // Find Module Pass Manager (TODO : Or Call Graph Pass Manager)
+ // Find Module Pass Manager
while(!PMS.empty()) {
if (PMS.top()->getPassManagerType() > PMT_FunctionPassManager)
PMS.pop();
// [3] Assign manager to manage this new manager. This may create
// and push new managers into PMS
-
- // If Call Graph Pass Manager is active then use it to manage
- // this new Function Pass manager.
- if (PMD->getPassManagerType() == PMT_CallGraphPassManager)
- FPP->assignPassManager(PMS, PMT_CallGraphPassManager);
- else
- FPP->assignPassManager(PMS);
+ FPP->assignPassManager(PMS, PMD->getPassManagerType());
// [4] Push new manager into PMS
PMS.push(FPP);
projects / oota-llvm.git / blobdiff