[llvm-commits] [llvm] r60267 - in /llvm/trunk/lib: Analysis/MemoryDependenceAnalysis.cpp Transforms/Scalar/GVN.cpp

[Chris Lattner]

Author: lattner
Date: Sat Nov 29 19:39:32 2008
New Revision: 60267

URL: http://llvm.org/viewvc/llvm-project?rev=60267&view=rev
Log:
Fix a fixme by making memdep's handling of allocations more logical.
If we see that a load depends on the allocation of its memory with no
intervening stores, we now return a 'None' depedency instead of "Normal".
This tweaks GVN to do its optimization with the new result.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/lib/Transforms/Scalar/GVN.cpp

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=60267&r1=60266&r2=60267&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Sat Nov 29 19:39:32 2008
@@ -159,29 +159,19 @@
         continue;
       return DepResultTy(Inst, Normal);
     }
-    
-    // FIXME: This claims that an access depends on the allocation.  This may
-    // make sense, but is dubious at best.  It would be better to fix GVN to
-    // handle a 'None' Query.
+
+    // If this is an allocation, and if we know that the accessed pointer is to
+    // the allocation, return None.  This means that there is no dependence and
+    // the access can be optimized based on that.  For example, a load could
+    // turn into undef.
     if (AllocationInst *AI = dyn_cast<AllocationInst>(Inst)) {
-      Value *Pointer = AI;
-      uint64_t PointerSize;
-      if (ConstantInt *C = dyn_cast<ConstantInt>(AI->getArraySize()))
-        // Use ABI size (size between elements), not store size (size of one
-        // element without padding).
-        PointerSize = C->getZExtValue() * 
-          TD.getABITypeSize(AI->getAllocatedType());
-      else
-        PointerSize = ~0UL;
+      Value *AccessPtr = MemPtr->getUnderlyingObject();
       
-      AliasAnalysis::AliasResult R =
-        AA.alias(Pointer, PointerSize, MemPtr, MemSize);
-      
-      if (R == AliasAnalysis::NoAlias)
-        continue;
-      return DepResultTy(Inst, Normal);
+      if (AccessPtr == AI ||
+          AA.alias(AI, 1, AccessPtr, 1) == AliasAnalysis::MustAlias)
+        return DepResultTy(0, None);
+      continue;
     }
-      
     
     // See if this instruction mod/ref's the pointer.
     AliasAnalysis::ModRefResult MRR = AA.getModRefInfo(Inst, MemPtr, MemSize);

Modified: llvm/trunk/lib/Transforms/Scalar/GVN.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GVN.cpp?rev=60267&r1=60266&r2=60267&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/GVN.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/GVN.cpp Sat Nov 29 19:39:32 2008
@@ -1004,27 +1004,24 @@
       toErase.push_back(L);
       deletedLoad = true;
       NumGVNLoad++;
-        
       break;
     } else {
       dep = MD.getDependencyFrom(L, DepInst, DepInst->getParent());
     }
   }
 
-  if (AllocationInst *DepAI = dyn_cast_or_null<AllocationInst>(dep.getInst())) {
-    // Check that this load is actually from the
-    // allocation we found
-    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.
-      MD.removeInstruction(L);
-
-      L->replaceAllUsesWith(UndefValue::get(L->getType()));
-      toErase.push_back(L);
-      deletedLoad = true;
-      NumGVNLoad++;
-    }
+  // If this load really doesn't depend on anything, then we must be loading an
+  // undef value.  This can happen when loading for a fresh allocation with no
+  // intervening stores, for example.
+  if (dep.isNone()) {
+    // If this load depends directly on an allocation, there isn't
+    // anything stored there; therefore, we can optimize this load
+    // to undef.
+    MD.removeInstruction(L);
+    L->replaceAllUsesWith(UndefValue::get(L->getType()));
+    toErase.push_back(L);
+    deletedLoad = true;
+    NumGVNLoad++;
   }
 
   if (!deletedLoad)