packet.cc (10563:755b18321206) packet.cc (10565:23593fdaadcd)
1/*
2 * Copyright (c) 2011-2014 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * Copyright (c) 2010 Advanced Micro Devices, Inc.
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Authors: Ali Saidi
42 * Steve Reinhardt
43 */
44
45/**
46 * @file
47 * Definition of the Packet Class, a packet is a transaction occuring
48 * between a single level of the memory heirarchy (ie L1->L2).
49 */
50
51#include <cstring>
52#include <iostream>
53
54#include "base/cprintf.hh"
55#include "base/misc.hh"
56#include "base/trace.hh"
57#include "mem/packet.hh"
58
59using namespace std;
60
61// The one downside to bitsets is that static initializers can get ugly.
62#define SET1(a1) (1 << (a1))
63#define SET2(a1, a2) (SET1(a1) | SET1(a2))
64#define SET3(a1, a2, a3) (SET2(a1, a2) | SET1(a3))
65#define SET4(a1, a2, a3, a4) (SET3(a1, a2, a3) | SET1(a4))
66#define SET5(a1, a2, a3, a4, a5) (SET4(a1, a2, a3, a4) | SET1(a5))
67#define SET6(a1, a2, a3, a4, a5, a6) (SET5(a1, a2, a3, a4, a5) | SET1(a6))
68
69const MemCmd::CommandInfo
70MemCmd::commandInfo[] =
71{
72 /* InvalidCmd */
73 { 0, InvalidCmd, "InvalidCmd" },
74 /* ReadReq */
75 { SET3(IsRead, IsRequest, NeedsResponse), ReadResp, "ReadReq" },
76 /* ReadResp */
77 { SET3(IsRead, IsResponse, HasData), InvalidCmd, "ReadResp" },
78 /* ReadRespWithInvalidate */
79 { SET4(IsRead, IsResponse, HasData, IsInvalidate),
80 InvalidCmd, "ReadRespWithInvalidate" },
81 /* WriteReq */
82 { SET5(IsWrite, NeedsExclusive, IsRequest, NeedsResponse, HasData),
83 WriteResp, "WriteReq" },
84 /* WriteResp */
85 { SET3(IsWrite, NeedsExclusive, IsResponse), InvalidCmd, "WriteResp" },
86 /* Writeback */
87 { SET4(IsWrite, NeedsExclusive, IsRequest, HasData),
88 InvalidCmd, "Writeback" },
89 /* SoftPFReq */
90 { SET4(IsRead, IsRequest, IsSWPrefetch, NeedsResponse),
91 SoftPFResp, "SoftPFReq" },
92 /* HardPFReq */
93 { SET4(IsRead, IsRequest, IsHWPrefetch, NeedsResponse),
94 HardPFResp, "HardPFReq" },
95 /* SoftPFResp */
96 { SET4(IsRead, IsResponse, IsSWPrefetch, HasData),
97 InvalidCmd, "SoftPFResp" },
98 /* HardPFResp */
99 { SET4(IsRead, IsResponse, IsHWPrefetch, HasData),
100 InvalidCmd, "HardPFResp" },
101 /* WriteInvalidateReq */
102 { SET6(IsWrite, NeedsExclusive, IsInvalidate,
103 IsRequest, HasData, NeedsResponse),
104 WriteInvalidateResp, "WriteInvalidateReq" },
105 /* WriteInvalidateResp */
106 { SET3(IsWrite, NeedsExclusive, IsResponse),
107 InvalidCmd, "WriteInvalidateResp" },
108 /* UpgradeReq */
109 { SET5(IsInvalidate, NeedsExclusive, IsUpgrade, IsRequest, NeedsResponse),
110 UpgradeResp, "UpgradeReq" },
111 /* SCUpgradeReq: response could be UpgradeResp or UpgradeFailResp */
112 { SET6(IsInvalidate, NeedsExclusive, IsUpgrade, IsLlsc,
113 IsRequest, NeedsResponse),
114 UpgradeResp, "SCUpgradeReq" },
115 /* UpgradeResp */
116 { SET3(NeedsExclusive, IsUpgrade, IsResponse),
117 InvalidCmd, "UpgradeResp" },
118 /* SCUpgradeFailReq: generates UpgradeFailResp but still gets the data */
119 { SET6(IsRead, NeedsExclusive, IsInvalidate,
120 IsLlsc, IsRequest, NeedsResponse),
121 UpgradeFailResp, "SCUpgradeFailReq" },
122 /* UpgradeFailResp - Behaves like a ReadExReq, but notifies an SC
123 * that it has failed, acquires line as Dirty*/
124 { SET4(IsRead, NeedsExclusive, IsResponse, HasData),
125 InvalidCmd, "UpgradeFailResp" },
126 /* ReadExReq */
127 { SET5(IsRead, NeedsExclusive, IsInvalidate, IsRequest, NeedsResponse),
128 ReadExResp, "ReadExReq" },
129 /* ReadExResp */
130 { SET4(IsRead, NeedsExclusive, IsResponse, HasData),
131 InvalidCmd, "ReadExResp" },
132 /* LoadLockedReq: note that we use plain ReadResp as response, so that
133 * we can also use ReadRespWithInvalidate when needed */
134 { SET4(IsRead, IsLlsc, IsRequest, NeedsResponse),
135 ReadResp, "LoadLockedReq" },
136 /* StoreCondReq */
137 { SET6(IsWrite, NeedsExclusive, IsLlsc,
138 IsRequest, NeedsResponse, HasData),
139 StoreCondResp, "StoreCondReq" },
140 /* StoreCondFailReq: generates failing StoreCondResp */
141 { SET6(IsWrite, NeedsExclusive, IsLlsc,
142 IsRequest, NeedsResponse, HasData),
143 StoreCondResp, "StoreCondFailReq" },
144 /* StoreCondResp */
145 { SET4(IsWrite, NeedsExclusive, IsLlsc, IsResponse),
146 InvalidCmd, "StoreCondResp" },
147 /* SwapReq -- for Swap ldstub type operations */
148 { SET6(IsRead, IsWrite, NeedsExclusive, IsRequest, HasData, NeedsResponse),
149 SwapResp, "SwapReq" },
150 /* SwapResp -- for Swap ldstub type operations */
151 { SET5(IsRead, IsWrite, NeedsExclusive, IsResponse, HasData),
152 InvalidCmd, "SwapResp" },
153 /* IntReq -- for interrupts */
154 { SET4(IsWrite, IsRequest, NeedsResponse, HasData),
155 MessageResp, "MessageReq" },
156 /* IntResp -- for interrupts */
157 { SET2(IsWrite, IsResponse), InvalidCmd, "MessageResp" },
158 /* InvalidDestError -- packet dest field invalid */
159 { SET2(IsResponse, IsError), InvalidCmd, "InvalidDestError" },
160 /* BadAddressError -- memory address invalid */
161 { SET2(IsResponse, IsError), InvalidCmd, "BadAddressError" },
162 /* FunctionalReadError */
163 { SET3(IsRead, IsResponse, IsError), InvalidCmd, "FunctionalReadError" },
164 /* FunctionalWriteError */
165 { SET3(IsWrite, IsResponse, IsError), InvalidCmd, "FunctionalWriteError" },
166 /* PrintReq */
167 { SET2(IsRequest, IsPrint), InvalidCmd, "PrintReq" },
168 /* Flush Request */
169 { SET3(IsRequest, IsFlush, NeedsExclusive), InvalidCmd, "FlushReq" },
170 /* Invalidation Request */
171 { SET3(NeedsExclusive, IsInvalidate, IsRequest),
172 InvalidCmd, "InvalidationReq" },
173};
174
175bool
176Packet::checkFunctional(Printable *obj, Addr addr, bool is_secure, int size,
177 uint8_t *data)
178{
179 Addr func_start = getAddr();
180 Addr func_end = getAddr() + getSize() - 1;
181 Addr val_start = addr;
182 Addr val_end = val_start + size - 1;
183
184 if (is_secure != _isSecure || func_start > val_end ||
185 val_start > func_end) {
186 // no intersection
187 return false;
188 }
189
190 // check print first since it doesn't require data
191 if (isPrint()) {
192 safe_cast<PrintReqState*>(senderState)->printObj(obj);
193 return false;
194 }
195
196 // if there's no data, there's no need to look further
197 if (!data) {
198 return false;
199 }
200
201 // offset of functional request into supplied value (could be
202 // negative if partial overlap)
203 int offset = func_start - val_start;
204
205 if (isRead()) {
206 if (func_start >= val_start && func_end <= val_end) {
1/*
2 * Copyright (c) 2011-2014 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * Copyright (c) 2010 Advanced Micro Devices, Inc.
16 * All rights reserved.
17 *
18 * Redistribution and use in source and binary forms, with or without
19 * modification, are permitted provided that the following conditions are
20 * met: redistributions of source code must retain the above copyright
21 * notice, this list of conditions and the following disclaimer;
22 * redistributions in binary form must reproduce the above copyright
23 * notice, this list of conditions and the following disclaimer in the
24 * documentation and/or other materials provided with the distribution;
25 * neither the name of the copyright holders nor the names of its
26 * contributors may be used to endorse or promote products derived from
27 * this software without specific prior written permission.
28 *
29 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
30 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
31 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
33 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
34 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
35 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
38 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
39 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Authors: Ali Saidi
42 * Steve Reinhardt
43 */
44
45/**
46 * @file
47 * Definition of the Packet Class, a packet is a transaction occuring
48 * between a single level of the memory heirarchy (ie L1->L2).
49 */
50
51#include <cstring>
52#include <iostream>
53
54#include "base/cprintf.hh"
55#include "base/misc.hh"
56#include "base/trace.hh"
57#include "mem/packet.hh"
58
59using namespace std;
60
61// The one downside to bitsets is that static initializers can get ugly.
62#define SET1(a1) (1 << (a1))
63#define SET2(a1, a2) (SET1(a1) | SET1(a2))
64#define SET3(a1, a2, a3) (SET2(a1, a2) | SET1(a3))
65#define SET4(a1, a2, a3, a4) (SET3(a1, a2, a3) | SET1(a4))
66#define SET5(a1, a2, a3, a4, a5) (SET4(a1, a2, a3, a4) | SET1(a5))
67#define SET6(a1, a2, a3, a4, a5, a6) (SET5(a1, a2, a3, a4, a5) | SET1(a6))
68
69const MemCmd::CommandInfo
70MemCmd::commandInfo[] =
71{
72 /* InvalidCmd */
73 { 0, InvalidCmd, "InvalidCmd" },
74 /* ReadReq */
75 { SET3(IsRead, IsRequest, NeedsResponse), ReadResp, "ReadReq" },
76 /* ReadResp */
77 { SET3(IsRead, IsResponse, HasData), InvalidCmd, "ReadResp" },
78 /* ReadRespWithInvalidate */
79 { SET4(IsRead, IsResponse, HasData, IsInvalidate),
80 InvalidCmd, "ReadRespWithInvalidate" },
81 /* WriteReq */
82 { SET5(IsWrite, NeedsExclusive, IsRequest, NeedsResponse, HasData),
83 WriteResp, "WriteReq" },
84 /* WriteResp */
85 { SET3(IsWrite, NeedsExclusive, IsResponse), InvalidCmd, "WriteResp" },
86 /* Writeback */
87 { SET4(IsWrite, NeedsExclusive, IsRequest, HasData),
88 InvalidCmd, "Writeback" },
89 /* SoftPFReq */
90 { SET4(IsRead, IsRequest, IsSWPrefetch, NeedsResponse),
91 SoftPFResp, "SoftPFReq" },
92 /* HardPFReq */
93 { SET4(IsRead, IsRequest, IsHWPrefetch, NeedsResponse),
94 HardPFResp, "HardPFReq" },
95 /* SoftPFResp */
96 { SET4(IsRead, IsResponse, IsSWPrefetch, HasData),
97 InvalidCmd, "SoftPFResp" },
98 /* HardPFResp */
99 { SET4(IsRead, IsResponse, IsHWPrefetch, HasData),
100 InvalidCmd, "HardPFResp" },
101 /* WriteInvalidateReq */
102 { SET6(IsWrite, NeedsExclusive, IsInvalidate,
103 IsRequest, HasData, NeedsResponse),
104 WriteInvalidateResp, "WriteInvalidateReq" },
105 /* WriteInvalidateResp */
106 { SET3(IsWrite, NeedsExclusive, IsResponse),
107 InvalidCmd, "WriteInvalidateResp" },
108 /* UpgradeReq */
109 { SET5(IsInvalidate, NeedsExclusive, IsUpgrade, IsRequest, NeedsResponse),
110 UpgradeResp, "UpgradeReq" },
111 /* SCUpgradeReq: response could be UpgradeResp or UpgradeFailResp */
112 { SET6(IsInvalidate, NeedsExclusive, IsUpgrade, IsLlsc,
113 IsRequest, NeedsResponse),
114 UpgradeResp, "SCUpgradeReq" },
115 /* UpgradeResp */
116 { SET3(NeedsExclusive, IsUpgrade, IsResponse),
117 InvalidCmd, "UpgradeResp" },
118 /* SCUpgradeFailReq: generates UpgradeFailResp but still gets the data */
119 { SET6(IsRead, NeedsExclusive, IsInvalidate,
120 IsLlsc, IsRequest, NeedsResponse),
121 UpgradeFailResp, "SCUpgradeFailReq" },
122 /* UpgradeFailResp - Behaves like a ReadExReq, but notifies an SC
123 * that it has failed, acquires line as Dirty*/
124 { SET4(IsRead, NeedsExclusive, IsResponse, HasData),
125 InvalidCmd, "UpgradeFailResp" },
126 /* ReadExReq */
127 { SET5(IsRead, NeedsExclusive, IsInvalidate, IsRequest, NeedsResponse),
128 ReadExResp, "ReadExReq" },
129 /* ReadExResp */
130 { SET4(IsRead, NeedsExclusive, IsResponse, HasData),
131 InvalidCmd, "ReadExResp" },
132 /* LoadLockedReq: note that we use plain ReadResp as response, so that
133 * we can also use ReadRespWithInvalidate when needed */
134 { SET4(IsRead, IsLlsc, IsRequest, NeedsResponse),
135 ReadResp, "LoadLockedReq" },
136 /* StoreCondReq */
137 { SET6(IsWrite, NeedsExclusive, IsLlsc,
138 IsRequest, NeedsResponse, HasData),
139 StoreCondResp, "StoreCondReq" },
140 /* StoreCondFailReq: generates failing StoreCondResp */
141 { SET6(IsWrite, NeedsExclusive, IsLlsc,
142 IsRequest, NeedsResponse, HasData),
143 StoreCondResp, "StoreCondFailReq" },
144 /* StoreCondResp */
145 { SET4(IsWrite, NeedsExclusive, IsLlsc, IsResponse),
146 InvalidCmd, "StoreCondResp" },
147 /* SwapReq -- for Swap ldstub type operations */
148 { SET6(IsRead, IsWrite, NeedsExclusive, IsRequest, HasData, NeedsResponse),
149 SwapResp, "SwapReq" },
150 /* SwapResp -- for Swap ldstub type operations */
151 { SET5(IsRead, IsWrite, NeedsExclusive, IsResponse, HasData),
152 InvalidCmd, "SwapResp" },
153 /* IntReq -- for interrupts */
154 { SET4(IsWrite, IsRequest, NeedsResponse, HasData),
155 MessageResp, "MessageReq" },
156 /* IntResp -- for interrupts */
157 { SET2(IsWrite, IsResponse), InvalidCmd, "MessageResp" },
158 /* InvalidDestError -- packet dest field invalid */
159 { SET2(IsResponse, IsError), InvalidCmd, "InvalidDestError" },
160 /* BadAddressError -- memory address invalid */
161 { SET2(IsResponse, IsError), InvalidCmd, "BadAddressError" },
162 /* FunctionalReadError */
163 { SET3(IsRead, IsResponse, IsError), InvalidCmd, "FunctionalReadError" },
164 /* FunctionalWriteError */
165 { SET3(IsWrite, IsResponse, IsError), InvalidCmd, "FunctionalWriteError" },
166 /* PrintReq */
167 { SET2(IsRequest, IsPrint), InvalidCmd, "PrintReq" },
168 /* Flush Request */
169 { SET3(IsRequest, IsFlush, NeedsExclusive), InvalidCmd, "FlushReq" },
170 /* Invalidation Request */
171 { SET3(NeedsExclusive, IsInvalidate, IsRequest),
172 InvalidCmd, "InvalidationReq" },
173};
174
175bool
176Packet::checkFunctional(Printable *obj, Addr addr, bool is_secure, int size,
177 uint8_t *data)
178{
179 Addr func_start = getAddr();
180 Addr func_end = getAddr() + getSize() - 1;
181 Addr val_start = addr;
182 Addr val_end = val_start + size - 1;
183
184 if (is_secure != _isSecure || func_start > val_end ||
185 val_start > func_end) {
186 // no intersection
187 return false;
188 }
189
190 // check print first since it doesn't require data
191 if (isPrint()) {
192 safe_cast<PrintReqState*>(senderState)->printObj(obj);
193 return false;
194 }
195
196 // if there's no data, there's no need to look further
197 if (!data) {
198 return false;
199 }
200
201 // offset of functional request into supplied value (could be
202 // negative if partial overlap)
203 int offset = func_start - val_start;
204
205 if (isRead()) {
206 if (func_start >= val_start && func_end <= val_end) {
207 allocate();
208 memcpy(getPtr<uint8_t>(), data + offset, getSize());
209 return true;
210 } else {
211 // Offsets and sizes to copy in case of partial overlap
212 int func_offset;
213 int val_offset;
214 int overlap_size;
215
216 // calculate offsets and copy sizes for the two byte arrays
217 if (val_start < func_start && val_end <= func_end) {
218 val_offset = func_start - val_start;
219 func_offset = 0;
220 overlap_size = val_end - func_start;
221 } else if (val_start >= func_start && val_end > func_end) {
222 val_offset = 0;
223 func_offset = val_start - func_start;
224 overlap_size = func_end - val_start;
225 } else if (val_start >= func_start && val_end <= func_end) {
226 val_offset = 0;
227 func_offset = val_start - func_start;
228 overlap_size = size;
229 } else {
230 panic("BUG: Missed a case for a partial functional request");
231 }
232
233 // Figure out how much of the partial overlap should be copied
234 // into the packet and not overwrite previously found bytes.
235 if (bytesValidStart == 0 && bytesValidEnd == 0) {
236 // No bytes have been copied yet, just set indices
237 // to found range
238 bytesValidStart = func_offset;
239 bytesValidEnd = func_offset + overlap_size;
240 } else {
241 // Some bytes have already been copied. Use bytesValid
242 // indices and offset values to figure out how much data
243 // to copy and where to copy it to.
244
245 // Indice overlap conditions to check
246 int a = func_offset - bytesValidStart;
247 int b = (func_offset + overlap_size) - bytesValidEnd;
248 int c = func_offset - bytesValidEnd;
249 int d = (func_offset + overlap_size) - bytesValidStart;
250
251 if (a >= 0 && b <= 0) {
252 // bytes already in pkt data array are superset of
253 // found bytes, will not copy any bytes
254 overlap_size = 0;
255 } else if (a < 0 && d >= 0 && b <= 0) {
256 // found bytes will move bytesValidStart towards 0
257 overlap_size = bytesValidStart - func_offset;
258 bytesValidStart = func_offset;
259 } else if (b > 0 && c <= 0 && a >= 0) {
260 // found bytes will move bytesValidEnd
261 // towards end of pkt data array
262 overlap_size =
263 (func_offset + overlap_size) - bytesValidEnd;
264 val_offset += bytesValidEnd - func_offset;
265 func_offset = bytesValidEnd;
266 bytesValidEnd += overlap_size;
267 } else if (a < 0 && b > 0) {
268 // Found bytes are superset of copied range. Will move
269 // bytesValidStart towards 0 and bytesValidEnd towards
270 // end of pkt data array. Need to break copy into two
271 // pieces so as to not overwrite previously found data.
272
273 // copy the first half
274 uint8_t *dest = getPtr<uint8_t>() + func_offset;
275 uint8_t *src = data + val_offset;
276 memcpy(dest, src, (bytesValidStart - func_offset));
277
278 // re-calc the offsets and indices to do the copy
279 // required for the second half
280 val_offset += (bytesValidEnd - func_offset);
281 bytesValidStart = func_offset;
282 overlap_size =
283 (func_offset + overlap_size) - bytesValidEnd;
284 func_offset = bytesValidEnd;
285 bytesValidEnd += overlap_size;
286 } else if ((c > 0 && b > 0)
287 || (a < 0 && d < 0)) {
288 // region to be copied is discontiguous! Not supported.
289 panic("BUG: Discontiguous bytes found"
290 "for functional copying!");
291 }
292 }
293 assert(bytesValidEnd <= getSize());
294
295 // copy partial data into the packet's data array
296 uint8_t *dest = getPtr<uint8_t>() + func_offset;
297 uint8_t *src = data + val_offset;
298 memcpy(dest, src, overlap_size);
299
300 // check if we're done filling the functional access
301 bool done = (bytesValidStart == 0) && (bytesValidEnd == getSize());
302 return done;
303 }
304 } else if (isWrite()) {
305 if (offset >= 0) {
306 memcpy(data + offset, getConstPtr<uint8_t>(),
307 (min(func_end, val_end) - func_start) + 1);
308 } else {
309 // val_start > func_start
310 memcpy(data, getConstPtr<uint8_t>() - offset,
311 (min(func_end, val_end) - val_start) + 1);
312 }
313 } else {
314 panic("Don't know how to handle command %s\n", cmdString());
315 }
316
317 // keep going with request by default
318 return false;
319}
320
321void
322Packet::pushSenderState(Packet::SenderState *sender_state)
323{
324 assert(sender_state != NULL);
325 sender_state->predecessor = senderState;
326 senderState = sender_state;
327}
328
329Packet::SenderState *
330Packet::popSenderState()
331{
332 assert(senderState != NULL);
333 SenderState *sender_state = senderState;
334 senderState = sender_state->predecessor;
335 sender_state->predecessor = NULL;
336 return sender_state;
337}
338
339void
340Packet::print(ostream &o, const int verbosity, const string &prefix) const
341{
342 ccprintf(o, "%s[%x:%x] %s\n", prefix,
343 getAddr(), getAddr() + getSize() - 1, cmdString());
344}
345
346std::string
347Packet::print() const {
348 ostringstream str;
349 print(str);
350 return str.str();
351}
352
353Packet::PrintReqState::PrintReqState(ostream &_os, int _verbosity)
354 : curPrefixPtr(new string("")), os(_os), verbosity(_verbosity)
355{
356 labelStack.push_back(LabelStackEntry("", curPrefixPtr));
357}
358
359Packet::PrintReqState::~PrintReqState()
360{
361 labelStack.pop_back();
362 assert(labelStack.empty());
363 delete curPrefixPtr;
364}
365
366Packet::PrintReqState::
367LabelStackEntry::LabelStackEntry(const string &_label, string *_prefix)
368 : label(_label), prefix(_prefix), labelPrinted(false)
369{
370}
371
372void
373Packet::PrintReqState::pushLabel(const string &lbl, const string &prefix)
374{
375 labelStack.push_back(LabelStackEntry(lbl, curPrefixPtr));
376 curPrefixPtr = new string(*curPrefixPtr);
377 *curPrefixPtr += prefix;
378}
379
380void
381Packet::PrintReqState::popLabel()
382{
383 delete curPrefixPtr;
384 curPrefixPtr = labelStack.back().prefix;
385 labelStack.pop_back();
386 assert(!labelStack.empty());
387}
388
389void
390Packet::PrintReqState::printLabels()
391{
392 if (!labelStack.back().labelPrinted) {
393 LabelStack::iterator i = labelStack.begin();
394 LabelStack::iterator end = labelStack.end();
395 while (i != end) {
396 if (!i->labelPrinted) {
397 ccprintf(os, "%s%s\n", *(i->prefix), i->label);
398 i->labelPrinted = true;
399 }
400 i++;
401 }
402 }
403}
404
405
406void
407Packet::PrintReqState::printObj(Printable *obj)
408{
409 printLabels();
410 obj->print(os, verbosity, curPrefix());
411}
207 memcpy(getPtr<uint8_t>(), data + offset, getSize());
208 return true;
209 } else {
210 // Offsets and sizes to copy in case of partial overlap
211 int func_offset;
212 int val_offset;
213 int overlap_size;
214
215 // calculate offsets and copy sizes for the two byte arrays
216 if (val_start < func_start && val_end <= func_end) {
217 val_offset = func_start - val_start;
218 func_offset = 0;
219 overlap_size = val_end - func_start;
220 } else if (val_start >= func_start && val_end > func_end) {
221 val_offset = 0;
222 func_offset = val_start - func_start;
223 overlap_size = func_end - val_start;
224 } else if (val_start >= func_start && val_end <= func_end) {
225 val_offset = 0;
226 func_offset = val_start - func_start;
227 overlap_size = size;
228 } else {
229 panic("BUG: Missed a case for a partial functional request");
230 }
231
232 // Figure out how much of the partial overlap should be copied
233 // into the packet and not overwrite previously found bytes.
234 if (bytesValidStart == 0 && bytesValidEnd == 0) {
235 // No bytes have been copied yet, just set indices
236 // to found range
237 bytesValidStart = func_offset;
238 bytesValidEnd = func_offset + overlap_size;
239 } else {
240 // Some bytes have already been copied. Use bytesValid
241 // indices and offset values to figure out how much data
242 // to copy and where to copy it to.
243
244 // Indice overlap conditions to check
245 int a = func_offset - bytesValidStart;
246 int b = (func_offset + overlap_size) - bytesValidEnd;
247 int c = func_offset - bytesValidEnd;
248 int d = (func_offset + overlap_size) - bytesValidStart;
249
250 if (a >= 0 && b <= 0) {
251 // bytes already in pkt data array are superset of
252 // found bytes, will not copy any bytes
253 overlap_size = 0;
254 } else if (a < 0 && d >= 0 && b <= 0) {
255 // found bytes will move bytesValidStart towards 0
256 overlap_size = bytesValidStart - func_offset;
257 bytesValidStart = func_offset;
258 } else if (b > 0 && c <= 0 && a >= 0) {
259 // found bytes will move bytesValidEnd
260 // towards end of pkt data array
261 overlap_size =
262 (func_offset + overlap_size) - bytesValidEnd;
263 val_offset += bytesValidEnd - func_offset;
264 func_offset = bytesValidEnd;
265 bytesValidEnd += overlap_size;
266 } else if (a < 0 && b > 0) {
267 // Found bytes are superset of copied range. Will move
268 // bytesValidStart towards 0 and bytesValidEnd towards
269 // end of pkt data array. Need to break copy into two
270 // pieces so as to not overwrite previously found data.
271
272 // copy the first half
273 uint8_t *dest = getPtr<uint8_t>() + func_offset;
274 uint8_t *src = data + val_offset;
275 memcpy(dest, src, (bytesValidStart - func_offset));
276
277 // re-calc the offsets and indices to do the copy
278 // required for the second half
279 val_offset += (bytesValidEnd - func_offset);
280 bytesValidStart = func_offset;
281 overlap_size =
282 (func_offset + overlap_size) - bytesValidEnd;
283 func_offset = bytesValidEnd;
284 bytesValidEnd += overlap_size;
285 } else if ((c > 0 && b > 0)
286 || (a < 0 && d < 0)) {
287 // region to be copied is discontiguous! Not supported.
288 panic("BUG: Discontiguous bytes found"
289 "for functional copying!");
290 }
291 }
292 assert(bytesValidEnd <= getSize());
293
294 // copy partial data into the packet's data array
295 uint8_t *dest = getPtr<uint8_t>() + func_offset;
296 uint8_t *src = data + val_offset;
297 memcpy(dest, src, overlap_size);
298
299 // check if we're done filling the functional access
300 bool done = (bytesValidStart == 0) && (bytesValidEnd == getSize());
301 return done;
302 }
303 } else if (isWrite()) {
304 if (offset >= 0) {
305 memcpy(data + offset, getConstPtr<uint8_t>(),
306 (min(func_end, val_end) - func_start) + 1);
307 } else {
308 // val_start > func_start
309 memcpy(data, getConstPtr<uint8_t>() - offset,
310 (min(func_end, val_end) - val_start) + 1);
311 }
312 } else {
313 panic("Don't know how to handle command %s\n", cmdString());
314 }
315
316 // keep going with request by default
317 return false;
318}
319
320void
321Packet::pushSenderState(Packet::SenderState *sender_state)
322{
323 assert(sender_state != NULL);
324 sender_state->predecessor = senderState;
325 senderState = sender_state;
326}
327
328Packet::SenderState *
329Packet::popSenderState()
330{
331 assert(senderState != NULL);
332 SenderState *sender_state = senderState;
333 senderState = sender_state->predecessor;
334 sender_state->predecessor = NULL;
335 return sender_state;
336}
337
338void
339Packet::print(ostream &o, const int verbosity, const string &prefix) const
340{
341 ccprintf(o, "%s[%x:%x] %s\n", prefix,
342 getAddr(), getAddr() + getSize() - 1, cmdString());
343}
344
345std::string
346Packet::print() const {
347 ostringstream str;
348 print(str);
349 return str.str();
350}
351
352Packet::PrintReqState::PrintReqState(ostream &_os, int _verbosity)
353 : curPrefixPtr(new string("")), os(_os), verbosity(_verbosity)
354{
355 labelStack.push_back(LabelStackEntry("", curPrefixPtr));
356}
357
358Packet::PrintReqState::~PrintReqState()
359{
360 labelStack.pop_back();
361 assert(labelStack.empty());
362 delete curPrefixPtr;
363}
364
365Packet::PrintReqState::
366LabelStackEntry::LabelStackEntry(const string &_label, string *_prefix)
367 : label(_label), prefix(_prefix), labelPrinted(false)
368{
369}
370
371void
372Packet::PrintReqState::pushLabel(const string &lbl, const string &prefix)
373{
374 labelStack.push_back(LabelStackEntry(lbl, curPrefixPtr));
375 curPrefixPtr = new string(*curPrefixPtr);
376 *curPrefixPtr += prefix;
377}
378
379void
380Packet::PrintReqState::popLabel()
381{
382 delete curPrefixPtr;
383 curPrefixPtr = labelStack.back().prefix;
384 labelStack.pop_back();
385 assert(!labelStack.empty());
386}
387
388void
389Packet::PrintReqState::printLabels()
390{
391 if (!labelStack.back().labelPrinted) {
392 LabelStack::iterator i = labelStack.begin();
393 LabelStack::iterator end = labelStack.end();
394 while (i != end) {
395 if (!i->labelPrinted) {
396 ccprintf(os, "%s%s\n", *(i->prefix), i->label);
397 i->labelPrinted = true;
398 }
399 i++;
400 }
401 }
402}
403
404
405void
406Packet::PrintReqState::printObj(Printable *obj)
407{
408 printLabels();
409 obj->print(os, verbosity, curPrefix());
410}