diff -r f5ee56466b91 -r 71540b653e35 src/mem/cache/cache.hh
--- a/src/mem/cache/cache.hh	Tue Jun 05 13:52:30 2012 -0400
+++ b/src/mem/cache/cache.hh	Wed Jun 06 12:26:27 2012 -0400
@@ -191,6 +191,13 @@
     const bool prefetchOnAccess;
 
     /**
+     * @todo this is a temporary workaround until the 4-phase code is committed.
+     * upstream caches need this packet until true is returned, so hold it for
+     * deletion until a subsequent call
+     */
+    std::vector<PacketPtr> pendingDelete;
+
+    /**
      * Does all the processing necessary to perform the provided request.
      * @param pkt The memory request to perform.
      * @param lat The latency of the access.
diff -r f5ee56466b91 -r 71540b653e35 src/mem/cache/cache_impl.hh
--- a/src/mem/cache/cache_impl.hh	Tue Jun 05 13:52:30 2012 -0400
+++ b/src/mem/cache/cache_impl.hh	Wed Jun 06 12:26:27 2012 -0400
@@ -378,6 +378,13 @@
 //@todo Add back in MemDebug Calls
 //    MemDebug::cacheAccess(pkt);
 
+
+    /// @todo temporary hack to deal with memory corruption issue until
+    /// 4-phase transactions are complete
+    for (int x = 0; x < pendingDelete.size(); x++)
+        delete pendingDelete[x];
+    pendingDelete.clear();
+
     // we charge hitLatency for doing just about anything here
     Tick time =  curTick() + hitLatency;
 
@@ -421,7 +428,11 @@
         }
         // since we're the official target but we aren't responding,
         // delete the packet now.
-        delete pkt;
+
+        /// @todo nominally we should just delete the packet here,
+        /// however, until 4-phase stuff we can't because sending
+        /// cache is still relying on it
+        pendingDelete.push_back(pkt);
         return true;
     }
 
@@ -489,7 +500,10 @@
             pkt->makeTimingResponse();
             cpuSidePort->respond(pkt, curTick()+lat);
         } else {
-            delete pkt;
+            /// @todo nominally we should just delete the packet here,
+            /// however, until 4-phase stuff we can't because sending
+            /// cache is still relying on it
+            pendingDelete.push_back(pkt);
         }
     } else {
         // miss
diff -r f5ee56466b91 -r 71540b653e35 src/mem/tport.hh
--- a/src/mem/tport.hh	Tue Jun 05 13:52:30 2012 -0400
+++ b/src/mem/tport.hh	Wed Jun 06 12:26:27 2012 -0400
@@ -73,6 +73,14 @@
 
     virtual Tick recvAtomic(PacketPtr pkt) = 0;
 
+    /**
+     * @todo this is a temporary workaround until the 4-phase code is committed.
+     * upstream caches need this packet until true is returned, so hold it for
+     * deletion until a subsequent call
+     */
+    std::vector<PacketPtr> pendingDelete;
+
+
   public:
 
     /**
diff -r f5ee56466b91 -r 71540b653e35 src/mem/tport.cc
--- a/src/mem/tport.cc	Tue Jun 05 13:52:30 2012 -0400
+++ b/src/mem/tport.cc	Wed Jun 06 12:26:27 2012 -0400
@@ -62,6 +62,12 @@
 bool
 SimpleTimingPort::recvTimingReq(PacketPtr pkt)
 {
+    /// @todo temporary hack to deal with memory corruption issue until
+    /// 4-phase transactions are complete. Remove me later
+    for (int x = 0; x < pendingDelete.size(); x++)
+        delete pendingDelete[x];
+    pendingDelete.clear();
+
     if (pkt->memInhibitAsserted()) {
         // snooper will supply based on copy of packet
         // still target's responsibility to delete packet
@@ -78,7 +84,10 @@
         assert(pkt->isResponse());
         queue.schedSendTiming(pkt, curTick() + latency);
     } else {
-        delete pkt;
+        /// @todo nominally we should just delete the packet here.
+        /// Until 4-phase stuff we can't because the sending
+        /// cache is still relying on it
+        pendingDelete.push_back(pkt);
     }
 
     return true;