src/mem/packet.hh

95         WriteClean,            // writes dirty data below without evicting
170      * Structure that defines attributes and other data associated
212      * A writeback is an eviction that carries data.
218      * Check if this particular packet type carries payload data. Note
219      * that this does not reflect if the data pointer of the packet is
301         /// Is the data pointer set to a value that shouldn't be freed
304         /// The data pointer points to a value that should be freed when
333     * A pointer to the data being transferred. It can be different
339     PacketDataPtr data;
800            data(nullptr), addr(0), _isSecure(false), size(0),
822            data(nullptr), addr(0), _isSecure(false),
837      * *except* if the original packet's data was dynamic, don't copy
840      * packet should allocate its own data.
844            data(nullptr),
858         // should we allocate space for data, or not, the express
859         // snoops do not need to carry any data as they only serve to
862             // even if asked to allocate data, if the original packet
863             // holds static data, then the sender will not be doing
867                 data = pkt->data;
1030      * Set the data pointer to the following value that should not be
1031      * freed. Static data allows us to do a single memcpy even if
1036      * eventually reaches the destination holding the data, it is
1045         data = (PacketDataPtr)p;
1050      * Set the data pointer to the following value that should not be
1054      * and non-const data pointer and cleverly choose between
1055      * them. Note that this is only allowed for static data.
1062         data = const_cast<PacketDataPtr>(p);
1067      * Set the data pointer to a value that should have delete []
1068      * called on it. Dynamic data is local to this packet, and as the
1070      * will allocate their own data. When a packet reaches the final
1071      * destination it will populate the dynamic data of that specific
1075      * final memcpy is needed to extract the data from the packet
1083         data = (PacketDataPtr)p;
1088      * get a pointer to the data ptr.
1096         return (T*)data;
1104         return (const T*)data;
1108      * Get the data in the packet byte swapped from big endian to
1115      * Get the data in the packet byte swapped from little endian to
1122      * Get the data in the packet byte swapped from the specified
1130      * Get the data in the packet byte swapped from guest to host
1138     /** Set the value in the data pointer to v as big endian. */
1142     /** Set the value in the data pointer to v as little endian. */
1147      * Set the value in the data pointer to v using the specified
1154     /** Set the value in the data pointer to v as guest endian. */
1161      * Get the data in the packet byte swapped from the specified
1174      * Copy data into the packet from the provided pointer.
1179         // we should never be copying data onto itself, which means we
1180         // must idenfity packets with static data, as they carry the
1185             // for packet with allocated dynamic data, we copy data from
1192      * Copy data into the packet from the provided block pointer,
1202      * Copy data from the packet to the memory at the provided pointer.
1203      * @param p Pointer to which data will be copied.
1224      * Copy data from the packet to the provided block pointer, which
1226      * @param blk_data Pointer to block to which data will be copied.
1236      * delete the data pointed to in the data pointer. Ok to call to
1237      * matter how data was allocted.
1243             delete [] data;
1246         data = NULL;
1253         // if either this command or the response command has a data
1258             data = new uint8_t[getSize()];
1264     /** Get the data in the packet without byte swapping. */
1268     /** Set the value in the data pointer to v without byte swapping. */
1277      * the other packet provides the data, which is then copied to the
1279      * packet intersects this one, then we update the data
1286             // Do not forward data if overlapping with a masked write
1297         // data pointer
1332      * by a base/size pair and an associated data array. If the