Change Packet parameters on Port methods from references to pointers.

--HG--
extra : convert_revision : 7193e70304d4cbe1e4cbe16ce0d8527b2754d066

10 files changed, 81 insertions, 81 deletions

diff --git a/mem/bridge.cc b/mem/bridge.cc
index d358ef77b..c4b137869 100644
--- a/mem/bridge.cc
+++ b/mem/bridge.cc
@@ -48,7 +48,7 @@ Bridge::init()
 /** Function called by the port when the bus is recieving a Timing
  * transaction.*/
 bool
-Bridge::recvTiming(Packet &pkt, Side id)
+Bridge::recvTiming(Packet *pkt, Side id)
 {
     if (blockedA && id == SideA)
         return false;
@@ -59,10 +59,10 @@ Bridge::recvTiming(Packet &pkt, Side id)
         if (!sendEvent.scheduled())
             sendEvent.schedule(curTick + delay);
         if (id == SideA) {
-            inboundA.push_back(std::make_pair<Packet*, Tick>(&pkt, curTick));
+            inboundA.push_back(std::make_pair<Packet*, Tick>(pkt, curTick));
             blockCheck(SideA);
         } else {
-            inboundB.push_back(std::make_pair<Packet*, Tick>(&pkt, curTick));
+            inboundB.push_back(std::make_pair<Packet*, Tick>(pkt, curTick));
             blockCheck(SideB);
         }
     } else {
@@ -134,16 +134,16 @@ void Bridge::timerEvent()
 
 
 void
-Bridge::BridgePort::sendPkt(Packet &pkt)
+Bridge::BridgePort::sendPkt(Packet *pkt)
 {
     if (!sendTiming(pkt))
-        outbound.push_back(std::make_pair<Packet*,Tick>(&pkt, curTick));
+        outbound.push_back(std::make_pair<Packet*,Tick>(pkt, curTick));
 }
 
 void
 Bridge::BridgePort::sendPkt(std::pair<Packet*, Tick> p)
 {
-    if (!sendTiming(*p.first))
+    if (!sendTiming(p.first))
         outbound.push_back(p);
 }
 
@@ -163,9 +163,9 @@ Bridge::BridgePort::recvRetry()
 /** Function called by the port when the bus is recieving a Atomic
  * transaction.*/
 Tick
-Bridge::recvAtomic(Packet &pkt, Side id)
+Bridge::recvAtomic(Packet *pkt, Side id)
 {
-    pkt.time += delay;
+    pkt->time += delay;
 
     if (id == SideA)
         return sideB->sendAtomic(pkt);
@@ -176,33 +176,33 @@ Bridge::recvAtomic(Packet &pkt, Side id)
 /** Function called by the port when the bus is recieving a Functional
  * transaction.*/
 void
-Bridge::recvFunctional(Packet &pkt, Side id)
+Bridge::recvFunctional(Packet *pkt, Side id)
 {
-    pkt.time += delay;
+    pkt->time += delay;
     std::list<std::pair<Packet*, Tick> >::iterator i;
     bool pktContinue = true;
 
     for(i = inboundA.begin();  i != inboundA.end(); ++i) {
-        if (pkt.intersect(i->first)) {
-            pktContinue &= fixPacket(pkt, *i->first);
+        if (pkt->intersect(i->first)) {
+            pktContinue &= fixPacket(pkt, i->first);
         }
     }
 
     for(i = inboundB.begin();  i != inboundB.end(); ++i) {
-        if (pkt.intersect(i->first)) {
-            pktContinue &= fixPacket(pkt, *i->first);
+        if (pkt->intersect(i->first)) {
+            pktContinue &= fixPacket(pkt, i->first);
         }
     }
 
     for(i = sideA->outbound.begin();  i != sideA->outbound.end(); ++i) {
-        if (pkt.intersect(i->first)) {
-            pktContinue &= fixPacket(pkt, *i->first);
+        if (pkt->intersect(i->first)) {
+            pktContinue &= fixPacket(pkt, i->first);
         }
     }
 
     for(i = sideB->outbound.begin();  i != sideB->outbound.end(); ++i) {
-        if (pkt.intersect(i->first)) {
-            pktContinue &= fixPacket(pkt, *i->first);
+        if (pkt->intersect(i->first)) {
+            pktContinue &= fixPacket(pkt, i->first);
         }
     }
 
diff --git a/mem/bridge.hh b/mem/bridge.hh
index 6bd4d81ab..5f19ded40 100644
--- a/mem/bridge.hh
+++ b/mem/bridge.hh
@@ -56,15 +56,15 @@ class Bridge : public MemObject
   protected:
     /** Function called by the port when the bus is recieving a Timing
         transaction.*/
-    bool recvTiming(Packet &pkt, Side id);
+    bool recvTiming(Packet *pkt, Side id);
 
     /** Function called by the port when the bus is recieving a Atomic
         transaction.*/
-    Tick recvAtomic(Packet &pkt, Side id);
+    Tick recvAtomic(Packet *pkt, Side id);
 
     /** Function called by the port when the bus is recieving a Functional
         transaction.*/
-    void recvFunctional(Packet &pkt, Side id);
+    void recvFunctional(Packet *pkt, Side id);
 
     /** Function called by the port when the bus is recieving a status change.*/
     void recvStatusChange(Port::Status status, Side id);
@@ -104,12 +104,12 @@ class Bridge : public MemObject
         /** Data this is waiting to be transmitted. */
         std::list<std::pair<Packet*, Tick> > outbound;
 
-        void sendPkt(Packet &pkt);
+        void sendPkt(Packet *pkt);
         void sendPkt(std::pair<Packet*, Tick> p);
 
         /** When reciving a timing request from the peer port,
             pass it to the bridge. */
-        virtual bool recvTiming(Packet &pkt)
+        virtual bool recvTiming(Packet *pkt)
         { return bridge->recvTiming(pkt, side); }
 
         /** When reciving a retry request from the peer port,
@@ -118,12 +118,12 @@ class Bridge : public MemObject
 
         /** When reciving a Atomic requestfrom the peer port,
             pass it to the bridge. */
-        virtual Tick recvAtomic(Packet &pkt)
+        virtual Tick recvAtomic(Packet *pkt)
         { return bridge->recvAtomic(pkt, side); }
 
         /** When reciving a Functional request from the peer port,
             pass it to the bridge. */
-        virtual void recvFunctional(Packet &pkt)
+        virtual void recvFunctional(Packet *pkt)
         { bridge->recvFunctional(pkt, side); }
 
         /** When reciving a status changefrom the peer port,
diff --git a/mem/bus.cc b/mem/bus.cc
index f84e38301..f7c2b874a 100644
--- a/mem/bus.cc
+++ b/mem/bus.cc
@@ -48,14 +48,14 @@ Bus::init()
 /** Function called by the port when the bus is recieving a Timing
  * transaction.*/
 bool
-Bus::recvTiming(Packet &pkt)
+Bus::recvTiming(Packet *pkt)
 {
     Port *port;
-    if (pkt.dest == Packet::Broadcast) {
-        port = findPort(pkt.addr, pkt.src);
+    if (pkt->dest == Packet::Broadcast) {
+        port = findPort(pkt->addr, pkt->src);
     } else {
-        assert(pkt.dest > 0 && pkt.dest < interfaces.size());
-        port = interfaces[pkt.dest];
+        assert(pkt->dest > 0 && pkt->dest < interfaces.size());
+        port = interfaces[pkt->dest];
     }
     return port->sendTiming(pkt);
 }
@@ -89,19 +89,19 @@ Bus::findPort(Addr addr, int id)
 /** Function called by the port when the bus is recieving a Atomic
  * transaction.*/
 Tick
-Bus::recvAtomic(Packet &pkt)
+Bus::recvAtomic(Packet *pkt)
 {
-    assert(pkt.dest == Packet::Broadcast);
-    return findPort(pkt.addr, pkt.src)->sendAtomic(pkt);
+    assert(pkt->dest == Packet::Broadcast);
+    return findPort(pkt->addr, pkt->src)->sendAtomic(pkt);
 }
 
 /** Function called by the port when the bus is recieving a Functional
  * transaction.*/
 void
-Bus::recvFunctional(Packet &pkt)
+Bus::recvFunctional(Packet *pkt)
 {
-    assert(pkt.dest == Packet::Broadcast);
-    findPort(pkt.addr, pkt.src)->sendFunctional(pkt);
+    assert(pkt->dest == Packet::Broadcast);
+    findPort(pkt->addr, pkt->src)->sendFunctional(pkt);
 }
 
 /** Function called by the port when the bus is recieving a status change.*/
diff --git a/mem/bus.hh b/mem/bus.hh
index 40d274037..38573e514 100644
--- a/mem/bus.hh
+++ b/mem/bus.hh
@@ -57,15 +57,15 @@ class Bus : public MemObject
 
     /** Function called by the port when the bus is recieving a Timing
         transaction.*/
-    bool recvTiming(Packet &pkt);
+    bool recvTiming(Packet *pkt);
 
     /** Function called by the port when the bus is recieving a Atomic
         transaction.*/
-    Tick recvAtomic(Packet &pkt);
+    Tick recvAtomic(Packet *pkt);
 
     /** Function called by the port when the bus is recieving a Functional
         transaction.*/
-    void recvFunctional(Packet &pkt);
+    void recvFunctional(Packet *pkt);
 
     /** Function called by the port when the bus is recieving a status change.*/
     void recvStatusChange(Port::Status status, int id);
@@ -108,18 +108,18 @@ class Bus : public MemObject
 
         /** When reciving a timing request from the peer port (at id),
             pass it to the bus. */
-        virtual bool recvTiming(Packet &pkt)
-        { pkt.src = id; return bus->recvTiming(pkt); }
+        virtual bool recvTiming(Packet *pkt)
+        { pkt->src = id; return bus->recvTiming(pkt); }
 
         /** When reciving a Atomic requestfrom the peer port (at id),
             pass it to the bus. */
-        virtual Tick recvAtomic(Packet &pkt)
-        { pkt.src = id; return bus->recvAtomic(pkt); }
+        virtual Tick recvAtomic(Packet *pkt)
+        { pkt->src = id; return bus->recvAtomic(pkt); }
 
         /** When reciving a Functional requestfrom the peer port (at id),
             pass it to the bus. */
-        virtual void recvFunctional(Packet &pkt)
-        { pkt.src = id; bus->recvFunctional(pkt); }
+        virtual void recvFunctional(Packet *pkt)
+        { pkt->src = id; bus->recvFunctional(pkt); }
 
         /** When reciving a status changefrom the peer port (at id),
             pass it to the bus. */
diff --git a/mem/packet.cc b/mem/packet.cc
index ecd2a7be1..a9be7ac51 100644
--- a/mem/packet.cc
+++ b/mem/packet.cc
@@ -90,5 +90,5 @@ Packet::reset() {
 
 
 
-bool fixPacket(Packet &func, Packet &timing)
+bool fixPacket(Packet *func, Packet *timing)
 { panic("Need to implement!"); }
diff --git a/mem/packet.hh b/mem/packet.hh
index ab961e304..e8a7b0c73 100644
--- a/mem/packet.hh
+++ b/mem/packet.hh
@@ -190,5 +190,5 @@ struct Packet
     bool intersect(Packet *p);
 };
 
-bool fixPacket(Packet &func, Packet &timing);
+bool fixPacket(Packet *func, Packet *timing);
 #endif //__MEM_PACKET_HH
diff --git a/mem/physical.cc b/mem/physical.cc
index d0409995b..8de9c3203 100644
--- a/mem/physical.cc
+++ b/mem/physical.cc
@@ -50,7 +50,7 @@
 using namespace std;
 using namespace TheISA;
 
-PhysicalMemory::MemResponseEvent::MemResponseEvent(Packet &pkt, MemoryPort* _m)
+PhysicalMemory::MemResponseEvent::MemResponseEvent(Packet *pkt, MemoryPort* _m)
     : Event(&mainEventQueue, CPU_Tick_Pri), pkt(pkt), memoryPort(_m)
 {
 
@@ -123,11 +123,11 @@ PhysicalMemory::deviceBlockSize()
 }
 
 bool
-PhysicalMemory::doTimingAccess (Packet &pkt, MemoryPort* memoryPort)
+PhysicalMemory::doTimingAccess (Packet *pkt, MemoryPort* memoryPort)
 {
     doFunctionalAccess(pkt);
 
-    pkt.dest = pkt.src;
+    pkt->dest = pkt->src;
     MemResponseEvent* response = new MemResponseEvent(pkt, memoryPort);
     response->schedule(curTick + lat);
 
@@ -135,32 +135,32 @@ PhysicalMemory::doTimingAccess (Packet &pkt, MemoryPort* memoryPort)
 }
 
 Tick
-PhysicalMemory::doAtomicAccess(Packet &pkt)
+PhysicalMemory::doAtomicAccess(Packet *pkt)
 {
     doFunctionalAccess(pkt);
-    pkt.time = curTick + lat;
+    pkt->time = curTick + lat;
     return curTick + lat;
 }
 
 void
-PhysicalMemory::doFunctionalAccess(Packet &pkt)
+PhysicalMemory::doFunctionalAccess(Packet *pkt)
 {
-    assert(pkt.addr + pkt.size < pmem_size);
+    assert(pkt->addr + pkt->size < pmem_size);
 
-    switch (pkt.cmd) {
+    switch (pkt->cmd) {
       case Read:
-        memcpy(pkt.getPtr<uint8_t>(), pmem_addr + pkt.addr - base_addr,
-                pkt.size);
+        memcpy(pkt->getPtr<uint8_t>(), pmem_addr + pkt->addr - base_addr,
+                pkt->size);
         break;
       case Write:
-        memcpy(pmem_addr + pkt.addr - base_addr, pkt.getPtr<uint8_t>(),
-                pkt.size);
+        memcpy(pmem_addr + pkt->addr - base_addr, pkt->getPtr<uint8_t>(),
+                pkt->size);
         break;
       default:
         panic("unimplemented");
     }
 
-    pkt.result = Success;
+    pkt->result = Success;
 }
 
 Port *
@@ -216,19 +216,19 @@ PhysicalMemory::MemoryPort::deviceBlockSize()
 }
 
 bool
-PhysicalMemory::MemoryPort::recvTiming(Packet &pkt)
+PhysicalMemory::MemoryPort::recvTiming(Packet *pkt)
 {
     return memory->doTimingAccess(pkt, this);
 }
 
 Tick
-PhysicalMemory::MemoryPort::recvAtomic(Packet &pkt)
+PhysicalMemory::MemoryPort::recvAtomic(Packet *pkt)
 {
     return memory->doAtomicAccess(pkt);
 }
 
 void
-PhysicalMemory::MemoryPort::recvFunctional(Packet &pkt)
+PhysicalMemory::MemoryPort::recvFunctional(Packet *pkt)
 {
     memory->doFunctionalAccess(pkt);
 }
diff --git a/mem/physical.hh b/mem/physical.hh
index f87683c45..1cf5444ab 100644
--- a/mem/physical.hh
+++ b/mem/physical.hh
@@ -55,11 +55,11 @@ class PhysicalMemory : public MemObject
 
       protected:
 
-        virtual bool recvTiming(Packet &pkt);
+        virtual bool recvTiming(Packet *pkt);
 
-        virtual Tick recvAtomic(Packet &pkt);
+        virtual Tick recvAtomic(Packet *pkt);
 
-        virtual void recvFunctional(Packet &pkt);
+        virtual void recvFunctional(Packet *pkt);
 
         virtual void recvStatusChange(Status status);
 
@@ -74,10 +74,10 @@ class PhysicalMemory : public MemObject
 
     struct MemResponseEvent : public Event
     {
-        Packet &pkt;
+        Packet *pkt;
         MemoryPort *memoryPort;
 
-        MemResponseEvent(Packet &pkt, MemoryPort *memoryPort);
+        MemResponseEvent(Packet *pkt, MemoryPort *memoryPort);
         void process();
         const char *description();
     };
@@ -112,9 +112,9 @@ class PhysicalMemory : public MemObject
     // fast back-door memory access for vtophys(), remote gdb, etc.
     // uint64_t phys_read_qword(Addr addr) const;
   private:
-    bool doTimingAccess(Packet &pkt, MemoryPort *memoryPort);
-    Tick doAtomicAccess(Packet &pkt);
-    void doFunctionalAccess(Packet &pkt);
+    bool doTimingAccess(Packet *pkt, MemoryPort *memoryPort);
+    Tick doAtomicAccess(Packet *pkt);
+    void doFunctionalAccess(Packet *pkt);
 
     void recvStatusChange(Port::Status status);
 
diff --git a/mem/port.cc b/mem/port.cc
index 5b1f634d6..fb3103ed1 100644
--- a/mem/port.cc
+++ b/mem/port.cc
@@ -48,7 +48,7 @@ Port::blobHelper(Addr addr, uint8_t *p, int size, Command cmd)
         req.setPaddr(pkt.addr = gen.addr());
         req.setSize(pkt.size = gen.size());
         pkt.dataStatic(p);
-        sendFunctional(pkt);
+        sendFunctional(&pkt);
         p += gen.size();
     }
 }
diff --git a/mem/port.hh b/mem/port.hh
index 2ab2806c9..1b1920c03 100644
--- a/mem/port.hh
+++ b/mem/port.hh
@@ -106,13 +106,13 @@ class Port
      * called by a peer port, never directly by any outside object. */
 
     /** Called to recive a timing call from the peer port. */
-    virtual bool recvTiming(Packet &pkt) = 0;
+    virtual bool recvTiming(Packet *pkt) = 0;
 
     /** Called to recive a atomic call from the peer port. */
-    virtual Tick recvAtomic(Packet &pkt) = 0;
+    virtual Tick recvAtomic(Packet *pkt) = 0;
 
     /** Called to recive a functional call from the peer port. */
-    virtual void recvFunctional(Packet &pkt) = 0;
+    virtual void recvFunctional(Packet *pkt) = 0;
 
     /** Called to recieve a status change from the peer port. */
     virtual void recvStatusChange(Status status) = 0;
@@ -150,13 +150,13 @@ class Port
         case a cache has a higher priority request come in while waiting for
         the bus to arbitrate.
     */
-    bool sendTiming(Packet &pkt) { return peer->recvTiming(pkt); }
+    bool sendTiming(Packet *pkt) { return peer->recvTiming(pkt); }
 
     /** Function called by the associated device to send an atomic access,
         an access in which the data is moved and the state is updated in one
         cycle, without interleaving with other memory accesses.
     */
-    Tick sendAtomic(Packet &pkt)
+    Tick sendAtomic(Packet *pkt)
         { return peer->recvAtomic(pkt); }
 
     /** Function called by the associated device to send a functional access,
@@ -164,7 +164,7 @@ class Port
         memory system, without affecting the current state of any block or
         moving the block.
     */
-    void sendFunctional(Packet &pkt)
+    void sendFunctional(Packet *pkt)
         { return peer->recvFunctional(pkt); }
 
     /** Called by the associated device to send a status change to the device
@@ -224,9 +224,9 @@ class Port
 class FunctionalPort : public Port
 {
   public:
-    virtual bool recvTiming(Packet &pkt) { panic("FuncPort is UniDir"); }
-    virtual Tick recvAtomic(Packet &pkt) { panic("FuncPort is UniDir"); }
-    virtual void recvFunctional(Packet &pkt) { panic("FuncPort is UniDir"); }
+    virtual bool recvTiming(Packet *pkt) { panic("FuncPort is UniDir"); }
+    virtual Tick recvAtomic(Packet *pkt) { panic("FuncPort is UniDir"); }
+    virtual void recvFunctional(Packet *pkt) { panic("FuncPort is UniDir"); }
     virtual void recvStatusChange(Status status) {}
 
     template <typename T>