Merge zeep.pool:/z/saidi/work/m5.newmem

into  zeep.pool:/z/saidi/work/m5.suncc

--HG--
extra : convert_revision : 20f61a524a3b53fc0afcf53a24b5a1fe1d96f579

8 files changed, 33 insertions, 24 deletions

diff --git a/src/mem/cache/cache_impl.hh b/src/mem/cache/cache_impl.hh
index 9c41983fc..b8c896498 100644
--- a/src/mem/cache/cache_impl.hh
+++ b/src/mem/cache/cache_impl.hh
@@ -40,6 +40,7 @@
 
 #include <cassert>
 #include <iostream>
+#include <cstring>
 #include <string>
 
 #include "sim/host.hh"
@@ -125,7 +126,7 @@ Cache<TagStore,Coherence>::handleAccess(PacketPtr &pkt, int & lat,
                 assert(offset < blkSize);
                 assert(pkt->getSize() <= blkSize);
                 assert(offset+pkt->getSize() <= blkSize);
-                memcpy(blk->data + offset, pkt->getPtr<uint8_t>(),
+                std::memcpy(blk->data + offset, pkt->getPtr<uint8_t>(),
                        pkt->getSize());
             } else if (!(pkt->flags & SATISFIED)) {
                 pkt->flags |= SATISFIED;
@@ -133,7 +134,7 @@ Cache<TagStore,Coherence>::handleAccess(PacketPtr &pkt, int & lat,
                 assert(offset < blkSize);
                 assert(pkt->getSize() <= blkSize);
                 assert(offset + pkt->getSize() <=blkSize);
-                memcpy(pkt->getPtr<uint8_t>(), blk->data + offset,
+                std::memcpy(pkt->getPtr<uint8_t>(), blk->data + offset,
                        pkt->getSize());
             }
             return blk;
@@ -176,7 +177,7 @@ Cache<TagStore,Coherence>::handleAccess(PacketPtr &pkt, int & lat,
                 if (blk->checkWrite(pkt->req)) {
                     write_data = true;
                     blk->status |= BlkDirty;
-                    memcpy(blk->data + offset, pkt->getPtr<uint8_t>(),
+                    std::memcpy(blk->data + offset, pkt->getPtr<uint8_t>(),
                            pkt->getSize());
                 }
             } else {
@@ -184,7 +185,7 @@ Cache<TagStore,Coherence>::handleAccess(PacketPtr &pkt, int & lat,
                 if (pkt->req->isLocked()) {
                     blk->trackLoadLocked(pkt->req);
                 }
-                memcpy(pkt->getPtr<uint8_t>(), blk->data + offset,
+                std::memcpy(pkt->getPtr<uint8_t>(), blk->data + offset,
                        pkt->getSize());
             }
 
@@ -228,7 +229,7 @@ Cache<TagStore,Coherence>::handleFill(BlkType *blk, PacketPtr &pkt,
 
 
     if (pkt->isRead()) {
-        memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
+        std::memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
     }
 
         blk->whenReady = pkt->finishTime;
@@ -249,14 +250,14 @@ Cache<TagStore,Coherence>::handleFill(BlkType *blk, PacketPtr &pkt,
             if (target->isWrite()) {
                 if (blk->checkWrite(pkt->req)) {
                     blk->status |= BlkDirty;
-                    memcpy(blk->data + target->getOffset(blkSize),
+                    std::memcpy(blk->data + target->getOffset(blkSize),
                            target->getPtr<uint8_t>(), target->getSize());
                 }
             } else {
                 if (pkt->req->isLocked()) {
                     blk->trackLoadLocked(pkt->req);
                 }
-                memcpy(target->getPtr<uint8_t>(),
+                std::memcpy(target->getPtr<uint8_t>(),
                        blk->data + target->getOffset(blkSize),
                        target->getSize());
             }
@@ -285,7 +286,7 @@ Cache<TagStore,Coherence>::handleFill(BlkType *blk, MSHR * mshr,
     blk = doReplacement(blk, pkt, new_state, writebacks);
 
     if (pkt->isRead()) {
-        memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
+        std::memcpy(blk->data, pkt->getPtr<uint8_t>(), blkSize);
     }
 
     blk->whenReady = pkt->finishTime;
@@ -337,14 +338,14 @@ Cache<TagStore,Coherence>::handleFill(BlkType *blk, MSHR * mshr,
             if (target->isWrite()) {
                 if (blk->checkWrite(pkt->req)) {
                     blk->status |= BlkDirty;
-                    memcpy(blk->data + target->getOffset(blkSize),
+                    std::memcpy(blk->data + target->getOffset(blkSize),
                            target->getPtr<uint8_t>(), target->getSize());
                 }
             } else {
                 if (pkt->req->isLocked()) {
                     blk->trackLoadLocked(pkt->req);
                 }
-                memcpy(target->getPtr<uint8_t>(),
+                std::memcpy(target->getPtr<uint8_t>(),
                        blk->data + target->getOffset(blkSize),
                        target->getSize());
             }
@@ -384,7 +385,7 @@ Cache<TagStore,Coherence>::handleSnoop(BlkType *blk,
     assert(offset < blkSize);
     assert(pkt->getSize() <= blkSize);
     assert(offset + pkt->getSize() <=blkSize);
-    memcpy(pkt->getPtr<uint8_t>(), blk->data + offset, pkt->getSize());
+    std::memcpy(pkt->getPtr<uint8_t>(), blk->data + offset, pkt->getSize());
 
     handleSnoop(blk, new_state);
 }
@@ -431,7 +432,7 @@ Cache<TagStore,Coherence>::writebackBlk(BlkType *blk)
         new Request(tags->regenerateBlkAddr(blk->tag, blk->set), blkSize, 0);
     PacketPtr writeback = new Packet(writebackReq, Packet::Writeback, -1);
     writeback->allocate();
-    memcpy(writeback->getPtr<uint8_t>(),blk->data,blkSize);
+    std::memcpy(writeback->getPtr<uint8_t>(),blk->data,blkSize);
 
     blk->status &= ~BlkDirty;
     return writeback;
@@ -463,7 +464,7 @@ Cache<TagStore,Coherence>::verifyData(BlkType *blk)
         assert(blkSize == blk->size);
     }
 
-    retval = memcmp(tmp_data, blk->data, blkSize) == 0;
+    retval = std::memcmp(tmp_data, blk->data, blkSize) == 0;
     delete [] tmp_data;
     return retval;
 }
@@ -664,7 +665,7 @@ Cache<TagStore,Coherence>::sendResult(PacketPtr &pkt, MSHR* mshr,
                 DPRINTF(Cache, "Block for blk addr %x moving from state "
                         "%i to %i\n", pkt->getAddr(), old_state, new_state);
             //Set the state on the upgrade
-            memcpy(pkt->getPtr<uint8_t>(), blk->data, blkSize);
+            std::memcpy(pkt->getPtr<uint8_t>(), blk->data, blkSize);
             PacketList writebacks;
             handleFill(blk, mshr, new_state, writebacks, pkt);
             assert(writebacks.empty());
@@ -839,7 +840,7 @@ Cache<TagStore,Coherence>::snoop(PacketPtr &pkt)
                         assert(offset < blkSize);
                         assert(pkt->getSize() <= blkSize);
                         assert(offset + pkt->getSize() <=blkSize);
-                        memcpy(pkt->getPtr<uint8_t>(), mshr->pkt->getPtr<uint8_t>() + offset, pkt->getSize());
+                        std::memcpy(pkt->getPtr<uint8_t>(), mshr->pkt->getPtr<uint8_t>() + offset, pkt->getSize());
 
                         respondToSnoop(pkt, curTick + hitLatency);
                     }
diff --git a/src/mem/cache/miss/blocking_buffer.cc b/src/mem/cache/miss/blocking_buffer.cc
index 4a431d82d..a1af88341 100644
--- a/src/mem/cache/miss/blocking_buffer.cc
+++ b/src/mem/cache/miss/blocking_buffer.cc
@@ -32,6 +32,7 @@
  * @file
  * Definitions of a simple buffer for a blocking cache.
  */
+#include <cstring>
 
 #include "mem/cache/base_cache.hh"
 #include "mem/cache/miss/blocking_buffer.hh"
@@ -60,7 +61,7 @@ BlockingBuffer::handleMiss(PacketPtr &pkt, int blk_size, Tick time)
             wb.allocate(pkt->cmd, blk_addr, blk_size, pkt);
         }
 
-        memcpy(wb.pkt->getPtr<uint8_t>(), pkt->getPtr<uint8_t>(), blk_size);
+        std::memcpy(wb.pkt->getPtr<uint8_t>(), pkt->getPtr<uint8_t>(), blk_size);
 
         cache->setBlocked(Blocked_NoWBBuffers);
         cache->setMasterRequest(Request_WB, time);
@@ -147,7 +148,7 @@ BlockingBuffer::handleResponse(PacketPtr &pkt, Tick time)
             PacketPtr target = ((MSHR*)(pkt->senderState))->getTarget();
             ((MSHR*)(pkt->senderState))->popTarget();
             if (pkt->isRead()) {
-                memcpy(target->getPtr<uint8_t>(), pkt->getPtr<uint8_t>(), target->getSize());
+                std::memcpy(target->getPtr<uint8_t>(), pkt->getPtr<uint8_t>(), target->getSize());
             }
             cache->respond(target, time);
             assert(!((MSHR*)(pkt->senderState))->hasTargets());
@@ -191,7 +192,7 @@ BlockingBuffer::doWriteback(Addr addr,
     PacketPtr pkt = new Packet(req, Packet::Writeback, -1);
     pkt->allocate();
     if (data) {
-        memcpy(pkt->getPtr<uint8_t>(), data, size);
+        std::memcpy(pkt->getPtr<uint8_t>(), data, size);
     }
 
     if (compressed) {
@@ -217,7 +218,7 @@ BlockingBuffer::doWriteback(PacketPtr &pkt)
 
     // Since allocate as buffer copies the request,
     // need to copy data here.
-        memcpy(wb.pkt->getPtr<uint8_t>(), pkt->getPtr<uint8_t>(), pkt->getSize());
+    std::memcpy(wb.pkt->getPtr<uint8_t>(), pkt->getPtr<uint8_t>(), pkt->getSize());
 
     cache->setBlocked(Blocked_NoWBBuffers);
     cache->setMasterRequest(Request_WB, curTick);
diff --git a/src/mem/cache/miss/blocking_buffer.hh b/src/mem/cache/miss/blocking_buffer.hh
index 205068a8c..24386a249 100644
--- a/src/mem/cache/miss/blocking_buffer.hh
+++ b/src/mem/cache/miss/blocking_buffer.hh
@@ -90,6 +90,7 @@ public:
                      PacketPtr &target)
     {
         fatal("Unimplemented");
+        M5_DUMMY_RETURN
     }
 
     /**
@@ -201,6 +202,7 @@ public:
     MSHR* allocateTargetList(Addr addr)
     {
         fatal("Unimplemented");
+        M5_DUMMY_RETURN
     }
 };
 
diff --git a/src/mem/cache/tags/iic.cc b/src/mem/cache/tags/iic.cc
index 38f9662ea..e547e112e 100644
--- a/src/mem/cache/tags/iic.cc
+++ b/src/mem/cache/tags/iic.cc
@@ -527,7 +527,7 @@ IIC::hash(Addr addr) const {
     tag = extractTag(addr);
     mask = hashSets-1; /* assumes iic_hash_size is a power of 2 */
     x = tag & mask;
-    y = (tag >> (int)(::log(hashSets)/::log(2))) & mask;
+    y = (tag >> (int)(::log((double)hashSets)/::log((double)2))) & mask;
     assert (x < hashSets && y < hashSets);
     return x ^ y;
 #endif
diff --git a/src/mem/cache/tags/lru.hh b/src/mem/cache/tags/lru.hh
index 4b94adca6..75272544c 100644
--- a/src/mem/cache/tags/lru.hh
+++ b/src/mem/cache/tags/lru.hh
@@ -36,6 +36,7 @@
 #ifndef __LRU_HH__
 #define __LRU_HH__
 
+#include <cstring>
 #include <list>
 
 #include "mem/cache/cache_blk.hh" // base class
@@ -273,7 +274,7 @@ public:
      */
     void readData(LRUBlk *blk, uint8_t *data)
     {
-        memcpy(data, blk->data, blk->size);
+        std::memcpy(data, blk->data, blk->size);
     }
 
     /**
diff --git a/src/mem/cache/tags/split.hh b/src/mem/cache/tags/split.hh
index e6ace0921..840b68940 100644
--- a/src/mem/cache/tags/split.hh
+++ b/src/mem/cache/tags/split.hh
@@ -36,6 +36,7 @@
 #ifndef __SPLIT_HH__
 #define __SPLIT_HH__
 
+#include <cstring>
 #include <list>
 
 #include "mem/cache/cache_blk.hh" // base class
@@ -234,6 +235,7 @@ class Split : public BaseTags
     int extractSet(Addr addr) const
     {
         panic("should never call this!\n");
+        M5_DUMMY_RETURN
     }
 
     /**
@@ -281,7 +283,7 @@ class Split : public BaseTags
      */
     void readData(SplitBlk *blk, uint8_t *data)
     {
-        memcpy(data, blk->data, blk->size);
+        std::memcpy(data, blk->data, blk->size);
     }
 
     /**
diff --git a/src/mem/cache/tags/split_lifo.hh b/src/mem/cache/tags/split_lifo.hh
index 9001cdb14..0f8adf18d 100644
--- a/src/mem/cache/tags/split_lifo.hh
+++ b/src/mem/cache/tags/split_lifo.hh
@@ -36,6 +36,7 @@
 #ifndef __SPLIT_LIFO_HH__
 #define __SPLIT_LIFO_HH__
 
+#include <cstring>
 #include <list>
 
 #include "mem/cache/cache_blk.hh" // base class
@@ -296,7 +297,7 @@ public:
      */
     void readData(SplitBlk *blk, uint8_t *data)
     {
-        memcpy(data, blk->data, blk->size);
+        std::memcpy(data, blk->data, blk->size);
     }
 
     /**
diff --git a/src/mem/cache/tags/split_lru.hh b/src/mem/cache/tags/split_lru.hh
index e17a478d3..eb65445ea 100644
--- a/src/mem/cache/tags/split_lru.hh
+++ b/src/mem/cache/tags/split_lru.hh
@@ -36,6 +36,7 @@
 #ifndef __SPLIT_LRU_HH__
 #define __SPLIT_LRU_HH__
 
+#include <cstring>
 #include <list>
 
 #include "mem/cache/cache_blk.hh" // base class
@@ -279,7 +280,7 @@ public:
      */
     void readData(SplitBlk *blk, uint8_t *data)
     {
-        memcpy(data, blk->data, blk->size);
+        std::memcpy(data, blk->data, blk->size);
     }
 
     /**