Make a few major changes to memdep and its clients:

1. Merge the 'None' result into 'Normal', making loads
   and stores return their dependencies on allocations as Normal.
2. Split the 'Normal' result into 'Clobber' and 'Def' to
   distinguish between the cases when memdep knows the value is
   produced from when we just know if may be changed.
3. Move some of the logic for determining whether readonly calls
   are CSEs into memdep instead of it being in GVN.  This still
   leaves verification that the arguments are hte same to GVN to
   let it know about value equivalences in different contexts.
4. Change memdep's call/call dependency analysis to use 
   getModRefInfo(CallSite,CallSite) instead of doing something 
   very weak.  This only really matters for things like DSA, but
   someday maybe we'll have some other decent context sensitive
   analyses :)
5. This reimplements the guts of memdep to handle the new results.
6. This simplifies GVN significantly:
   a) readonly call CSE is slightly simpler
   b) I eliminated the "getDependencyFrom" chaining for load 
      elimination and load CSE doesn't have to worry about 
      volatile (they are always clobbers) anymore.
   c) GVN no longer does any 'lastLoad' caching, leaving it to 
      memdep.
7. The logic in DSE is simplified a bit and sped up.  A potentially
   unsafe case was eliminated.

llvm-svn: 60607

1 files changed, 16 insertions, 14 deletions

diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
index 0acc995e872..fa6f10b6b99 100644
--- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
@@ -148,25 +148,27 @@ bool DSE::runOnBasicBlock(BasicBlock &BB) {
       // If we're storing the same value back to a pointer that we just
       // loaded from, then the store can be removed;
       if (LoadInst* L = dyn_cast<LoadInst>(S->getOperand(0))) {
-        // FIXME: Don't do dep query if Parents don't match and other stuff!
-        MemDepResult dep = MD.getDependency(S);
-        DominatorTree& DT = getAnalysis<DominatorTree>();
-        
         if (!S->isVolatile() && S->getParent() == L->getParent() &&
-            S->getPointerOperand() == L->getPointerOperand() &&
-            (!dep.isNormal() || DT.dominates(dep.getInst(), L))) {
-          
-          DeleteDeadInstruction(S);
-          if (BBI != BB.begin())
-            --BBI;
-          NumFastStores++;
-          MadeChange = true;
-        } else
+            S->getPointerOperand() == L->getPointerOperand()) {
+          MemDepResult dep = MD.getDependency(S);
+          if (dep.isDef() && dep.getInst() == L) {
+            DeleteDeadInstruction(S);
+            if (BBI != BB.begin())
+              --BBI;
+            NumFastStores++;
+            MadeChange = true;
+          } else {
+            // Update our most-recent-store map.
+            last = S;
+          }
+        } else {
           // Update our most-recent-store map.
           last = S;
-      } else
+        }
+      } else {
         // Update our most-recent-store map.
         last = S;
+      }
     }
   }