mem: Use const pointers for port proxy write functions

This patch changes the various write functions in the port proxies
to use const pointers for all sources (similar to how memcpy works).

The one unfortunate aspect is the need for a const_cast in the packet,
to avoid having to juggle a const and a non-const data pointer. This
design decision can always be re-evaluated at a later stage.

diff --git a/src/mem/fs_translating_port_proxy.cc b/src/mem/fs_translating_port_proxy.cc
index 52e8b49d812bdb26c0f998bf118d3d13c5dbe3fe..a3229d7d1ef431dbff18aedcf1aa2b1b5503267d 100644 (file)
--- a/src/mem/fs_translating_port_proxy.cc
+++ b/src/mem/fs_translating_port_proxy.cc
@@ -89,7 +89,7 @@ FSTranslatingPortProxy::readBlob(Addr addr, uint8_t *p, int size) const
 }
 
 void
-FSTranslatingPortProxy::writeBlob(Addr addr, uint8_t *p, int size) const
+FSTranslatingPortProxy::writeBlob(Addr addr, const uint8_t *p, int size) const
 {
     Addr paddr;
     for (ChunkGenerator gen(addr, size, TheISA::PageBytes); !gen.done();
@@ -129,7 +129,7 @@ CopyOut(ThreadContext *tc, void *dest, Addr src, size_t cplen)
 }
 
 void
-CopyIn(ThreadContext *tc, Addr dest, void *source, size_t cplen)
+CopyIn(ThreadContext *tc, Addr dest, const void *source, size_t cplen)
 {
     uint8_t *src = (uint8_t *)source;
     tc->getVirtProxy().writeBlob(dest, src, cplen);
@@ -154,7 +154,7 @@ CopyStringOut(ThreadContext *tc, char *dst, Addr vaddr, size_t maxlen)
 }
 
 void
-CopyStringIn(ThreadContext *tc, char *src, Addr vaddr)
+CopyStringIn(ThreadContext *tc, const char *src, Addr vaddr)
 {
     FSTranslatingPortProxy &vp = tc->getVirtProxy();
     for (ChunkGenerator gen(vaddr, strlen(src), TheISA::PageBytes); !gen.done();

diff --git a/src/mem/fs_translating_port_proxy.hh b/src/mem/fs_translating_port_proxy.hh
index c8f099d2c978266ea08bffa990e069f818daedd3..8120f96ea1caf3d5932196e7d35b2dc54ba37100 100644 (file)
--- a/src/mem/fs_translating_port_proxy.hh
+++ b/src/mem/fs_translating_port_proxy.hh
@@ -89,7 +89,7 @@ class FSTranslatingPortProxy : public PortProxy
 
     /** Version of writeBlob that translates virt->phys and deals
       * with page boundries. */
-    virtual void writeBlob(Addr addr, uint8_t *p, int size) const;
+    virtual void writeBlob(Addr addr, const uint8_t *p, int size) const;
 
     /**
      * Fill size bytes starting at addr with byte value val.
@@ -98,8 +98,8 @@ class FSTranslatingPortProxy : public PortProxy
 };
 
 void CopyOut(ThreadContext *tc, void *dest, Addr src, size_t cplen);
-void CopyIn(ThreadContext *tc, Addr dest, void *source, size_t cplen);
+void CopyIn(ThreadContext *tc, Addr dest, const void *source, size_t cplen);
 void CopyStringOut(ThreadContext *tc, char *dst, Addr vaddr, size_t maxlen);
-void CopyStringIn(ThreadContext *tc, char *src, Addr vaddr);
+void CopyStringIn(ThreadContext *tc, const char *src, Addr vaddr);
 
 #endif //__MEM_FS_PORT_PROXY_HH__

diff --git a/src/mem/packet.hh b/src/mem/packet.hh
index fea9dbaae0c4925398f307c5ca69466b5368e725..b540ef6cad19e5702f7116f6825fd15140d1ab49 100644 (file)
--- a/src/mem/packet.hh
+++ b/src/mem/packet.hh
@@ -813,6 +813,23 @@ class Packet : public Printable
         flags.set(STATIC_DATA);
     }
 
+    /**
+     * Set the data pointer to the following value that should not be
+     * freed. This version of the function allows the pointer passed
+     * to us to be const. To avoid issues down the line we cast the
+     * constness away, the alternative would be to keep both a const
+     * and non-const data pointer and cleverly choose between
+     * them. Note that this is only allowed for static data.
+     */
+    template <typename T>
+    void
+    dataStaticConst(const T *p)
+    {
+        assert(flags.noneSet(STATIC_DATA|DYNAMIC_DATA|ARRAY_DATA));
+        data = const_cast<PacketDataPtr>(p);
+        flags.set(STATIC_DATA);
+    }
+
     /**
      * Set the data pointer to a value that should have delete []
      * called on it.

diff --git a/src/mem/port_proxy.cc b/src/mem/port_proxy.cc
index ea6dd0fc268d11e58e385fcfe1cd4f277d386ac4..cce8f6ff4c7e2064a86b50d37dc1cd8a6fc1802b 100644 (file)
--- a/src/mem/port_proxy.cc
+++ b/src/mem/port_proxy.cc
@@ -41,20 +41,35 @@
 #include "mem/port_proxy.hh"
 
 void
-PortProxy::blobHelper(Addr addr, uint8_t *p, int size, MemCmd cmd) const
+PortProxy::readBlob(Addr addr, uint8_t *p, int size) const
 {
     Request req;
 
-    for (ChunkGenerator gen(addr, size, _cacheLineSize);
-         !gen.done(); gen.next()) {
+    for (ChunkGenerator gen(addr, size, _cacheLineSize); !gen.done();
+         gen.next()) {
         req.setPhys(gen.addr(), gen.size(), 0, Request::funcMasterId);
-        Packet pkt(&req, cmd);
+        Packet pkt(&req, MemCmd::ReadReq);
         pkt.dataStatic(p);
         _port.sendFunctional(&pkt);
         p += gen.size();
     }
 }
 
+void
+PortProxy::writeBlob(Addr addr, const uint8_t *p, int size) const
+{
+    Request req;
+
+    for (ChunkGenerator gen(addr, size, _cacheLineSize); !gen.done();
+         gen.next()) {
+        req.setPhys(gen.addr(), gen.size(), 0, Request::funcMasterId);
+        Packet pkt(&req, MemCmd::WriteReq);
+        pkt.dataStaticConst(p);
+        _port.sendFunctional(&pkt);
+        p += gen.size();
+    }
+}
+
 void
 PortProxy::memsetBlob(Addr addr, uint8_t v, int size) const
 {
@@ -62,7 +77,7 @@ PortProxy::memsetBlob(Addr addr, uint8_t v, int size) const
     uint8_t *buf = new uint8_t[size];
 
     std::memset(buf, v, size);
-    blobHelper(addr, buf, size, MemCmd::WriteReq);
+    PortProxy::writeBlob(addr, buf, size);
 
     delete [] buf;
 }

diff --git a/src/mem/port_proxy.hh b/src/mem/port_proxy.hh
index 1213daafa51181ee94d0b6543c4da7b8f848223c..e9ddeecbf536ccb1c47df44b13a2568cc6f3f5ad 100644 (file)
--- a/src/mem/port_proxy.hh
+++ b/src/mem/port_proxy.hh
@@ -91,8 +91,6 @@ class PortProxy
     /** Granularity of any transactions issued through this proxy. */
     const unsigned int _cacheLineSize;
 
-    void blobHelper(Addr addr, uint8_t *p, int size, MemCmd cmd) const;
-
   public:
     PortProxy(MasterPort &port, unsigned int cacheLineSize) :
         _port(port), _cacheLineSize(cacheLineSize) { }
@@ -101,14 +99,12 @@ class PortProxy
     /**
      * Read size bytes memory at address and store in p.
      */
-    virtual void readBlob(Addr addr, uint8_t* p, int size) const
-    { blobHelper(addr, p, size, MemCmd::ReadReq); }
+    virtual void readBlob(Addr addr, uint8_t* p, int size) const;
 
     /**
      * Write size bytes from p to address.
      */
-    virtual void writeBlob(Addr addr, uint8_t* p, int size) const
-    { blobHelper(addr, p, size, MemCmd::WriteReq); }
+    virtual void writeBlob(Addr addr, const uint8_t* p, int size) const;
 
     /**
      * Fill size bytes starting at addr with byte value val.

diff --git a/src/mem/se_translating_port_proxy.cc b/src/mem/se_translating_port_proxy.cc
index ef9ce585011f2066d3827507fbe1ba9cbc4ebaab..7dfeb934383887df80d892c1e12f5a8e0b7956cc 100644 (file)
--- a/src/mem/se_translating_port_proxy.cc
+++ b/src/mem/se_translating_port_proxy.cc
@@ -90,7 +90,8 @@ SETranslatingPortProxy::readBlob(Addr addr, uint8_t *p, int size) const
 
 
 bool
-SETranslatingPortProxy::tryWriteBlob(Addr addr, uint8_t *p, int size) const
+SETranslatingPortProxy::tryWriteBlob(Addr addr, const uint8_t *p,
+                                     int size) const
 {
     int prevSize = 0;
 
@@ -121,7 +122,7 @@ SETranslatingPortProxy::tryWriteBlob(Addr addr, uint8_t *p, int size) const
 
 
 void
-SETranslatingPortProxy::writeBlob(Addr addr, uint8_t *p, int size) const
+SETranslatingPortProxy::writeBlob(Addr addr, const uint8_t *p, int size) const
 {
     if (!tryWriteBlob(addr, p, size))
         fatal("writeBlob(0x%x, ...) failed", addr);

diff --git a/src/mem/se_translating_port_proxy.hh b/src/mem/se_translating_port_proxy.hh
index 99973a6e95c88fd18c52c7d230309984e9d5bba9..58d0c9bcdff71507f6dc9cfec7c19f8f32c87cf6 100644 (file)
--- a/src/mem/se_translating_port_proxy.hh
+++ b/src/mem/se_translating_port_proxy.hh
@@ -84,13 +84,13 @@ class SETranslatingPortProxy : public PortProxy
     virtual ~SETranslatingPortProxy();
 
     bool tryReadBlob(Addr addr, uint8_t *p, int size) const;
-    bool tryWriteBlob(Addr addr, uint8_t *p, int size) const;
+    bool tryWriteBlob(Addr addr, const uint8_t *p, int size) const;
     bool tryMemsetBlob(Addr addr, uint8_t val, int size) const;
     bool tryWriteString(Addr addr, const char *str) const;
     bool tryReadString(std::string &str, Addr addr) const;
 
     virtual void readBlob(Addr addr, uint8_t *p, int size) const;
-    virtual void writeBlob(Addr addr, uint8_t *p, int size) const;
+    virtual void writeBlob(Addr addr, const uint8_t *p, int size) const;
     virtual void memsetBlob(Addr addr, uint8_t val, int size) const;
 
     void writeString(Addr addr, const char *str) const;