namespace {
// FIXME: This should not be a FunctionPass.
struct VISIBILITY_HIDDEN LoadVN : public FunctionPass, public ValueNumbering {
+ static char ID; // Class identification, replacement for typeinfo
+ LoadVN() : FunctionPass((intptr_t)&ID) {}
/// Pass Implementation stuff. This doesn't do any analysis.
///
std::vector<Value*> &RetVals) const;
};
+ char LoadVN::ID = 0;
// Register this pass...
RegisterPass<LoadVN> X("load-vn", "Load Value Numbering");
AU.setPreservesAll();
AU.addRequiredTransitive<AliasAnalysis>();
AU.addRequired<ValueNumbering>();
- AU.addRequiredTransitive<ETForest>();
+ AU.addRequiredTransitive<DominatorTree>();
AU.addRequiredTransitive<TargetData>();
}
// ANY memory.
//
if (MRB == AliasAnalysis::OnlyReadsMemory) {
- ETForest &EF = getAnalysis<ETForest>();
+ DominatorTree &DT = getAnalysis<DominatorTree>();
BasicBlock *CIBB = CI->getParent();
for (unsigned i = 0; i != IdenticalCalls.size(); ++i) {
CallInst *C = IdenticalCalls[i];
bool CantEqual = false;
- if (EF.dominates(CIBB, C->getParent())) {
+ if (DT.dominates(CIBB, C->getParent())) {
// FIXME: we currently only handle the case where both calls are in the
// same basic block.
if (CIBB != C->getParent()) {
CantEqual = true;
} else {
Instruction *First = CI, *Second = C;
- if (!EF.dominates(CI, C))
+ if (!DT.dominates(CI, C))
std::swap(First, Second);
// Scan the instructions between the calls, checking for stores or
}
}
- } else if (EF.dominates(C->getParent(), CIBB)) {
+ } else if (DT.dominates(C->getParent(), CIBB)) {
// FIXME: We could implement this, but we don't for now.
CantEqual = true;
} else {
}
// Get dominators.
- ETForest &EF = getAnalysis<ETForest>();
+ DominatorTree &DT = getAnalysis<DominatorTree>();
// TransparentBlocks - For each basic block the load/store is alive across,
// figure out if the pointer is invalidated or not. If it is invalidated, the
// Right now we only can handle cases where one load dominates the other.
// FIXME: generalize this!
BasicBlock *BB1 = I->first, *BB2 = LoadBB;
- if (EF.dominates(BB1, BB2)) {
+ if (DT.dominates(BB1, BB2)) {
// The other load dominates LI. If the loaded value is killed entering
// the LoadBB block, we know the load is not live.
if (LoadInvalidatedInBBBefore)
CantEqual = true;
- } else if (EF.dominates(BB2, BB1)) {
+ } else if (DT.dominates(BB2, BB1)) {
std::swap(BB1, BB2); // Canonicalize
// LI dominates the other load. If the loaded value is killed exiting
// the LoadBB block, we know the load is not live.
for (std::set<BasicBlock*>::iterator I = CandidateStores.begin(),
E = CandidateStores.end(); I != E; ++I)
- if (EF.dominates(*I, LoadBB)) {
+ if (DT.dominates(*I, LoadBB)) {
BasicBlock *StoreBB = *I;
// Check to see if the path from the store to the load is transparent