mem: Add const getters for write packet data

This patch takes a first step in tightening up how we use the data
pointer in write packets. A const getter is added for the pointer
itself (getConstPtr), and a number of member functions are also made
const accordingly. In a range of places throughout the memory system
the new member is used.

The patch also removes the unused isReadWrite function.

src/cpu/inorder/resources/cache_unit.cc

@@ -68,7 +68,7 @@ using namespace ThePipeline;
 
 #if TRACING_ON
 static std::string
-printMemData(uint8_t *data, unsigned size)
+printMemData(const uint8_t *data, unsigned size)
 {
     std::stringstream dataStr;
     for (unsigned pos = 0; pos < size; pos++) {
@@ -855,7 +855,7 @@ CacheUnit::doCacheAccess(DynInstPtr inst, uint64_t *write_res,
          DPRINTF(InOrderCachePort,
                  "[tid:%u]: [sn:%i]: Storing data: %s\n",
                  tid, inst->seqNum,
-                 printMemData(cache_req->dataPkt->getPtr<uint8_t>(),
+                 printMemData(cache_req->dataPkt->getConstPtr<uint8_t>(),
                               cache_req->dataPkt->getSize()));
 
         if (mem_req->isCondSwap()) {
@@ -1061,9 +1061,9 @@ CacheUnit::processCacheCompletion(PacketPtr pkt)
         DPRINTF(InOrderCachePort,
                 "[tid:%u]: [sn:%i]: Bytes loaded were: %s\n",
                 tid, inst->seqNum,
-                (split_pkt) ? printMemData(split_pkt->getPtr<uint8_t>(),
+                (split_pkt) ? printMemData(split_pkt->getConstPtr<uint8_t>(),
                                            split_pkt->getSize()) :
-                              printMemData(cache_pkt->getPtr<uint8_t>(),
+                              printMemData(cache_pkt->getConstPtr<uint8_t>(),
                                            cache_pkt->getSize()));
     } else if(inst->isStore()) {
         assert(cache_pkt->isWrite());
@@ -1071,9 +1071,9 @@ CacheUnit::processCacheCompletion(PacketPtr pkt)
         DPRINTF(InOrderCachePort,
                 "[tid:%u]: [sn:%i]: Bytes stored were: %s\n",
                 tid, inst->seqNum,
-                (split_pkt) ? printMemData(split_pkt->getPtr<uint8_t>(),
+                (split_pkt) ? printMemData(split_pkt->getConstPtr<uint8_t>(),
                                            split_pkt->getSize()) :
-                              printMemData(cache_pkt->getPtr<uint8_t>(),
+                              printMemData(cache_pkt->getConstPtr<uint8_t>(),
                                            cache_pkt->getSize()));
     }
 

src/cpu/inorder/resources/fetch_unit.cc

@@ -503,7 +503,7 @@ FetchUnit::processCacheCompletion(PacketPtr pkt)
 
     // Copy Data to pendingFetch queue...
     (*pend_it)->block = new uint8_t[cacheBlkSize];
-    memcpy((*pend_it)->block, cache_pkt->getPtr<uint8_t>(), cacheBlkSize);
+    memcpy((*pend_it)->block, cache_pkt->getConstPtr<uint8_t>(), cacheBlkSize);
     (*pend_it)->valid = true;
 
     cache_req->setMemAccPending(false);

src/cpu/minor/execute.cc

@@ -355,7 +355,7 @@ Execute::handleMemResponse(MinorDynInstPtr inst,
 
         if (is_load && packet->getSize() > 0) {
             DPRINTF(MinorMem, "Memory data[0]: 0x%x\n",
-                static_cast<unsigned int>(packet->getPtr<uint8_t>()[0]));
+                static_cast<unsigned int>(packet->getConstPtr<uint8_t>()[0]));
         }
 
         /* Complete the memory access instruction */

src/cpu/minor/lsq.cc

@@ -560,7 +560,7 @@ LSQ::SplitDataRequest::retireResponse(PacketPtr response)
              *  by the response fragment */
             std::memcpy(
                 data + (response->req->getVaddr() - request.getVaddr()),
-                response->getPtr<uint8_t>(),
+                response->getConstPtr<uint8_t>(),
                 response->req->getSize());
         }
     }

src/cpu/o3/fetch_impl.hh

@@ -388,7 +388,7 @@ DefaultFetch<Impl>::processCacheCompletion(PacketPtr pkt)
         return;
     }
 
-    memcpy(fetchBuffer[tid], pkt->getPtr<uint8_t>(), fetchBufferSize);
+    memcpy(fetchBuffer[tid], pkt->getConstPtr<uint8_t>(), fetchBufferSize);
     fetchBufferValid[tid] = true;
 
     // Wake up the CPU (if it went to sleep and was waiting on

src/cpu/simple/atomic.cc

@@ -469,7 +469,7 @@ AtomicSimpleCPU::writeMem(uint8_t *data, unsigned size,
 
                 if (req->isSwap()) {
                     assert(res);
-                    memcpy(res, pkt.getPtr<uint8_t>(), fullSize);
+                    memcpy(res, pkt.getConstPtr<uint8_t>(), fullSize);
                 }
             }
 

src/cpu/testers/memtest/memtest.cc

@@ -173,6 +173,7 @@ MemTest::completeRequest(PacketPtr pkt)
         safe_cast<MemTestSenderState *>(pkt->senderState);
 
     uint8_t *data = state->data;
+    // @todo: This should really be a const pointer
     uint8_t *pkt_data = pkt->getPtr<uint8_t>();
 
     //Remove the address from the list of outstanding

src/cpu/testers/rubytest/Check.cc

@@ -197,7 +197,7 @@ Check::initiateAction()
     pkt->dataDynamic(writeData);
 
     DPRINTF(RubyTest, "data 0x%x check 0x%x\n",
-            *(pkt->getPtr<uint8_t>()), *writeData);
+            *(pkt->getConstPtr<uint8_t>()), *writeData);
 
     // push the subblock onto the sender state.  The sequencer will
     // update the subblock on the return