From 7f9c8a0f05166e7ac7c295e6b32d8315bf8f30a0 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sat, 29 Nov 2008 02:29:27 +0000 Subject: Introduce and use a new MemDepResult class to hold the results of a memdep query. This makes it crystal clear what cases can escape from MemDep that the clients have to handle. This also gives the clients a nice simplified interface to it that is easy to poke at. This patch also makes DepResultTy and MemoryDependenceAnalysis::DepType private, yay. llvm-svn: 60231 --- .../lib/Transforms/Scalar/DeadStoreElimination.cpp | 31 +++++------- llvm/lib/Transforms/Scalar/GVN.cpp | 56 +++++++++++----------- llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp | 11 ++--- 3 files changed, 44 insertions(+), 54 deletions(-) (limited to 'llvm/lib/Transforms') diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp index 8217a44c6f4..c06015a18b0 100644 --- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -47,10 +47,8 @@ namespace { return Changed; } - typedef MemoryDependenceAnalysis::DepResultTy DepResultTy; - bool runOnBasicBlock(BasicBlock &BB); - bool handleFreeWithNonTrivialDependency(FreeInst *F, DepResultTy Dep); + bool handleFreeWithNonTrivialDependency(FreeInst *F, MemDepResult Dep); bool handleEndBlock(BasicBlock &BB); bool RemoveUndeadPointers(Value* pointer, uint64_t killPointerSize, BasicBlock::iterator& BBI, @@ -110,16 +108,15 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) { // ... to a pointer that has been stored to before... if (last) { - DepResultTy dep = MD.getDependency(Inst); + MemDepResult dep = MD.getDependency(Inst); bool deletedStore = false; // ... and no other memory dependencies are between them.... - while (dep.getInt() == MemoryDependenceAnalysis::Normal && - isa(dep.getPointer())) { - if (dep.getPointer() != last || - TD.getTypeStoreSize(last->getOperand(0)->getType()) > - TD.getTypeStoreSize(Inst->getOperand(0)->getType())) { - dep = MD.getDependency(Inst, dep.getPointer()); + while (StoreInst *DepStore = dyn_cast_or_null(dep.getInst())) { + if (DepStore != last || + TD.getTypeStoreSize(last->getOperand(0)->getType()) > + TD.getTypeStoreSize(Inst->getOperand(0)->getType())) { + dep = MD.getDependency(Inst, DepStore); continue; } @@ -152,14 +149,12 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) { // loaded from, then the store can be removed; if (LoadInst* L = dyn_cast(S->getOperand(0))) { // FIXME: Don't do dep query if Parents don't match and other stuff! - DepResultTy dep = MD.getDependency(S); + MemDepResult dep = MD.getDependency(S); DominatorTree& DT = getAnalysis(); if (!S->isVolatile() && S->getParent() == L->getParent() && S->getPointerOperand() == L->getPointerOperand() && - (dep.getInt() == MemoryDependenceAnalysis::None || - dep.getInt() == MemoryDependenceAnalysis::NonLocal || - DT.dominates(dep.getPointer(), L))) { + (!dep.isNormal() || DT.dominates(dep.getInst(), L))) { DeleteDeadInstruction(S); if (!isa(BB.begin())) @@ -185,15 +180,11 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) { /// handleFreeWithNonTrivialDependency - Handle frees of entire structures whose /// dependency is a store to a field of that structure. -bool DSE::handleFreeWithNonTrivialDependency(FreeInst* F, DepResultTy dep) { +bool DSE::handleFreeWithNonTrivialDependency(FreeInst* F, MemDepResult dep) { TargetData &TD = getAnalysis(); AliasAnalysis &AA = getAnalysis(); - if (dep.getInt() == MemoryDependenceAnalysis::None || - dep.getInt() == MemoryDependenceAnalysis::NonLocal) - return false; - - StoreInst* dependency = dyn_cast(dep.getPointer()); + StoreInst* dependency = dyn_cast_or_null(dep.getInst()); if (!dependency) return false; else if (dependency->isVolatile()) diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index 64cac8f0644..63fabc6de48 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -456,19 +456,19 @@ uint32_t ValueTable::lookup_or_add(Value* V) { return nextValueNumber++; } - MemoryDependenceAnalysis::DepResultTy local_dep = MD->getDependency(C); + MemDepResult local_dep = MD->getDependency(C); - if (local_dep.getInt() == MemoryDependenceAnalysis::None) { + if (local_dep.isNone()) { valueNumbering.insert(std::make_pair(V, nextValueNumber)); return nextValueNumber++; - } else if (local_dep.getInt() != MemoryDependenceAnalysis::NonLocal) { + } else if (Instruction *LocalDepInst = local_dep.getInst()) { // FIXME: INDENT PROPERLY! - if (!isa(local_dep.getPointer())) { + if (!isa(LocalDepInst)) { valueNumbering.insert(std::make_pair(V, nextValueNumber)); return nextValueNumber++; } - CallInst* local_cdep = cast(local_dep.getPointer()); + CallInst* local_cdep = cast(LocalDepInst); // FIXME: INDENT PROPERLY. if (local_cdep->getCalledFunction() != C->getCalledFunction() || @@ -495,20 +495,21 @@ uint32_t ValueTable::lookup_or_add(Value* V) { } - DenseMap deps; + DenseMap deps; MD->getNonLocalDependency(C, deps); CallInst* cdep = 0; - for (DenseMap + for (DenseMap ::iterator I = deps.begin(), E = deps.end(); I != E; ++I) { - if (I->second.getInt() == MemoryDependenceAnalysis::None) { + if (I->second.isNone()) { valueNumbering.insert(std::make_pair(V, nextValueNumber)); return nextValueNumber++; - } else if (I->second.getInt() != MemoryDependenceAnalysis::NonLocal) { + } else if (Instruction *NonLocalDepInst = I->second.getInst()) { // FIXME: INDENT PROPERLY + // FIXME: All duplicated with non-local case. if (DT->properlyDominates(I->first, C->getParent())) { - if (CallInst* CD = dyn_cast(I->second.getPointer())) + if (CallInst* CD = dyn_cast(NonLocalDepInst)) cdep = CD; else { valueNumbering.insert(std::make_pair(V, nextValueNumber)); @@ -721,8 +722,6 @@ namespace { AU.addPreserved(); } - typedef MemoryDependenceAnalysis::DepResultTy DepResultTy; - // Helper fuctions // FIXME: eliminate or document these better bool processLoad(LoadInst* L, @@ -866,7 +865,7 @@ bool GVN::processNonLocalLoad(LoadInst* L, MemoryDependenceAnalysis& MD = getAnalysis(); // Find the non-local dependencies of the load - DenseMap deps; + DenseMap deps; MD.getNonLocalDependency(L, deps); // If we had to process more than one hundred blocks to find the @@ -878,19 +877,19 @@ bool GVN::processNonLocalLoad(LoadInst* L, DenseMap repl; // Filter out useless results (non-locals, etc) - for (DenseMap::iterator I = deps.begin(), + for (DenseMap::iterator I = deps.begin(), E = deps.end(); I != E; ++I) { - if (I->second.getInt() == MemoryDependenceAnalysis::None) + if (I->second.isNone()) return false; - if (I->second.getInt() == MemoryDependenceAnalysis::NonLocal) + if (I->second.isNonLocal()) continue; - if (StoreInst* S = dyn_cast(I->second.getPointer())) { + if (StoreInst* S = dyn_cast(I->second.getInst())) { if (S->getPointerOperand() != L->getPointerOperand()) return false; repl[I->first] = S->getOperand(0); - } else if (LoadInst* LD = dyn_cast(I->second.getPointer())) { + } else if (LoadInst* LD = dyn_cast(I->second.getInst())) { if (LD->getPointerOperand() != L->getPointerOperand()) return false; repl[I->first] = LD; @@ -941,8 +940,8 @@ bool GVN::processLoad(LoadInst *L, DenseMap &lastLoad, // ... to a pointer that has been loaded from before... MemoryDependenceAnalysis& MD = getAnalysis(); bool removedNonLocal = false; - DepResultTy dep = MD.getDependency(L); - if (dep.getInt() == MemoryDependenceAnalysis::NonLocal && + MemDepResult dep = MD.getDependency(L); + if (dep.isNonLocal() && L->getParent() != &L->getParent()->getParent()->getEntryBlock()) { removedNonLocal = processNonLocalLoad(L, toErase); @@ -957,10 +956,9 @@ bool GVN::processLoad(LoadInst *L, DenseMap &lastLoad, // Walk up the dependency chain until we either find // a dependency we can use, or we can't walk any further - while (dep.getInt() == MemoryDependenceAnalysis::Normal && - (isa(dep.getPointer()) || isa(dep.getPointer()))){ + while (Instruction *DepInst = dep.getInst()) { // ... that depends on a store ... - if (StoreInst* S = dyn_cast(dep.getPointer())) { + if (StoreInst* S = dyn_cast(DepInst)) { if (S->getPointerOperand() == pointer) { // Remove it! MD.removeInstruction(L); @@ -974,11 +972,14 @@ bool GVN::processLoad(LoadInst *L, DenseMap &lastLoad, // Whether we removed it or not, we can't // go any further break; + } else if (!isa(DepInst)) { + // Only want to handle loads below. + break; } else if (!last) { // If we don't depend on a store, and we haven't // been loaded before, bail. break; - } else if (dep.getPointer() == last) { + } else if (DepInst == last) { // Remove it! MD.removeInstruction(L); @@ -989,15 +990,14 @@ bool GVN::processLoad(LoadInst *L, DenseMap &lastLoad, break; } else { - dep = MD.getDependency(L, dep.getPointer()); + dep = MD.getDependency(L, DepInst); } } - if (dep.getInt() == MemoryDependenceAnalysis::Normal && - isa(dep.getPointer())) { + if (AllocationInst *DepAI = dyn_cast_or_null(dep.getInst())) { // Check that this load is actually from the // allocation we found - if (L->getOperand(0)->getUnderlyingObject() == dep.getPointer()) { + if (L->getOperand(0)->getUnderlyingObject() == DepAI) { // If this load depends directly on an allocation, there isn't // anything stored there; therefore, we can optimize this load // to undef. diff --git a/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp b/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp index acc6630d429..40eaa1d47c3 100644 --- a/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp +++ b/llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp @@ -629,18 +629,17 @@ bool MemCpyOpt::processMemCpy(MemCpyInst* M) { // The are two possible optimizations we can do for memcpy: // a) memcpy-memcpy xform which exposes redundance for DSE // b) call-memcpy xform for return slot optimization - MemoryDependenceAnalysis::DepResultTy dep = MD.getDependency(M); - if (dep.getInt() == MemoryDependenceAnalysis::None || - dep.getInt() == MemoryDependenceAnalysis::NonLocal) + MemDepResult dep = MD.getDependency(M); + if (!dep.isNormal()) return false; - else if (!isa(dep.getPointer())) { - if (CallInst* C = dyn_cast(dep.getPointer())) + else if (!isa(dep.getInst())) { + if (CallInst* C = dyn_cast(dep.getInst())) return performCallSlotOptzn(M, C); else return false; } - MemCpyInst* MDep = cast(dep.getPointer()); + MemCpyInst* MDep = cast(dep.getInst()); // We can only transforms memcpy's where the dest of one is the source of the // other -- cgit v1.2.3