[llvm-commits] [llvm] r120377 - in /llvm/trunk: include/llvm/Analysis/MemoryBuiltins.h lib/Transforms/Scalar/DeadStoreElimination.cpp

[Chris Lattner]

Author: lattner
Date: Mon Nov 29 19:28:33 2010
New Revision: 120377

URL: http://llvm.org/viewvc/llvm-project?rev=120377&view=rev
Log:
clean up handling of 'free', detangling it from everything else.
It can be seriously improved, but at least now it isn't intertwined
with the other logic.

Modified:
    llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h
    llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp

Modified: llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h?rev=120377&r1=120376&r2=120377&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h (original)
+++ llvm/trunk/include/llvm/Analysis/MemoryBuiltins.h Mon Nov 29 19:28:33 2010
@@ -74,6 +74,10 @@
 
 /// isFreeCall - Returns non-null if the value is a call to the builtin free()
 const CallInst *isFreeCall(const Value *I);
+  
+static inline CallInst *isFreeCall(Value *I) {
+  return const_cast<CallInst*>(isFreeCall((const Value*)I));
+}
 
 } // End llvm namespace
 

Modified: llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp?rev=120377&r1=120376&r2=120377&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/DeadStoreElimination.cpp Mon Nov 29 19:28:33 2010
@@ -58,9 +58,7 @@
     }
     
     bool runOnBasicBlock(BasicBlock &BB);
-    bool handleFreeWithNonTrivialDependency(const CallInst *F,
-                                            Instruction *Inst,
-                                            MemDepResult Dep);
+    bool HandleFree(CallInst *F);
     bool handleEndBlock(BasicBlock &BB);
     bool RemoveUndeadPointers(Value *Ptr, uint64_t killPointerSize,
                               BasicBlock::iterator &BBI,
@@ -124,7 +122,7 @@
   return true;
 }
 
-/// getPointerOperand - Return the pointer that is being clobbered.
+/// getPointerOperand - Return the pointer that is being written to.
 static Value *getPointerOperand(Instruction *I) {
   assert(doesClobberMemory(I));
   if (StoreInst *SI = dyn_cast<StoreInst>(I))
@@ -202,8 +200,14 @@
   for (BasicBlock::iterator BBI = BB.begin(), BBE = BB.end(); BBI != BBE; ) {
     Instruction *Inst = BBI++;
     
-    // If we find a store or a free, get its memory dependence.
-    if (!doesClobberMemory(Inst) && !isFreeCall(Inst))
+    // Handle 'free' calls specially.
+    if (CallInst *F = isFreeCall(Inst)) {
+      MadeChange |= HandleFree(F);
+      continue;
+    }
+    
+    // If we find a store, get its memory dependence.
+    if (!doesClobberMemory(Inst))
       continue;
 
     MemDepResult InstDep = MD.getDependency(Inst);
@@ -211,13 +215,7 @@
     // Ignore non-local store liveness.
     // FIXME: cross-block DSE would be fun. :)
     if (InstDep.isNonLocal()) continue;
-  
-    // Handle frees whose dependencies are non-trivial.
-    if (const CallInst *F = isFreeCall(Inst)) {
-      MadeChange |= handleFreeWithNonTrivialDependency(F, Inst, InstDep);
-      continue;
-    }
-
+     
     // If we're storing the same value back to a pointer that we just
     // loaded from, then the store can be removed.
     if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
@@ -292,24 +290,25 @@
   return MadeChange;
 }
 
-/// handleFreeWithNonTrivialDependency - Handle frees of entire structures whose
-/// dependency is a store to a field of that structure.
-bool DSE::handleFreeWithNonTrivialDependency(const CallInst *F,
-                                             Instruction *Inst,
-                                             MemDepResult Dep) {
+/// HandleFree - Handle frees of entire structures whose dependency is a store
+/// to a field of that structure.
+bool DSE::HandleFree(CallInst *F) {
   AliasAnalysis &AA = getAnalysis<AliasAnalysis>();
   MemoryDependenceAnalysis &MD = getAnalysis<MemoryDependenceAnalysis>();
-  
+
+  MemDepResult Dep = MD.getDependency(F);
   do {
+    if (Dep.isNonLocal()) return false;
+    
     Instruction *Dependency = Dep.getInst();
-    if (!Dependency || !doesClobberMemory(Dependency) || !isElidable(Dependency))
+    if (!doesClobberMemory(Dependency) || !isElidable(Dependency))
       return false;
   
     Value *DepPointer = getPointerOperand(Dependency)->getUnderlyingObject();
 
     // Check for aliasing.
     if (AA.alias(F->getArgOperand(0), 1, DepPointer, 1) !=
-           AliasAnalysis::MustAlias)
+          AliasAnalysis::MustAlias)
       return false;
   
     // DCE instructions only used to calculate that store
@@ -321,8 +320,9 @@
     //    s[0] = 0;
     //    s[1] = 0; // This has just been deleted.
     //    free(s);
-    Dep = MD.getDependency(Inst);
+    Dep = MD.getDependency(F);
   } while (!Dep.isNonLocal());
+  
   return true;
 }