memhelpers.hh (12234:78ece221f9f5) memhelpers.hh (12384:481add71d2e4)
1/*
2 * Copyright (c) 2011 Google
3 * Copyright (c) 2015 Advanced Micro Devices, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright

--- 60 unchanged lines hidden (view full) ---

69 break;
70 default:
71 panic("Unhandled size in getMem.\n");
72 }
73 if (traceData)
74 traceData->setData(mem);
75}
76
1/*
2 * Copyright (c) 2011 Google
3 * Copyright (c) 2015 Advanced Micro Devices, Inc.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are
8 * met: redistributions of source code must retain the above copyright

--- 60 unchanged lines hidden (view full) ---

69 break;
70 default:
71 panic("Unhandled size in getMem.\n");
72 }
73 if (traceData)
74 traceData->setData(mem);
75}
76
77template <typename T, size_t N>
78static void
79getPackedMem(PacketPtr pkt, std::array<uint64_t, N> &mem, unsigned dataSize)
80{
81 std::array<T, N> real_mem = pkt->get<std::array<T, N> >();
82 for (int i = 0; i < N; i++)
83 mem[i] = real_mem[i];
84}
77
78template <size_t N>
85
86template <size_t N>
79void
87static void
80getMem(PacketPtr pkt, std::array<uint64_t, N> &mem, unsigned dataSize,
81 Trace::InstRecord *traceData)
82{
88getMem(PacketPtr pkt, std::array<uint64_t, N> &mem, unsigned dataSize,
89 Trace::InstRecord *traceData)
90{
83 assert(dataSize >= 8);
84 assert((dataSize % 8) == 0);
85
86 int num_words = dataSize / 8;
87 assert(num_words <= N);
88
89 auto pkt_data = pkt->getConstPtr<const uint64_t>();
90 for (int i = 0; i < num_words; ++i)
91 mem[i] = gtoh(pkt_data[i]);
92
93 // traceData record only has space for 64 bits, so we just record
94 // the first qword
91 switch (dataSize) {
92 case 4:
93 getPackedMem<uint32_t, N>(pkt, mem, dataSize);
94 break;
95 case 8:
96 getPackedMem<uint64_t, N>(pkt, mem, dataSize);
97 break;
98 default:
99 panic("Unhandled element size in getMem.\n");
100 }
95 if (traceData)
96 traceData->setData(mem[0]);
97}
98
99
100static Fault
101readMemAtomic(ExecContext *xc, Trace::InstRecord *traceData, Addr addr,
102 uint64_t &mem, unsigned dataSize, Request::Flags flags)

--- 6 unchanged lines hidden (view full) ---

109 // access. This doesn't work for BE guests.
110 mem = gtoh(mem);
111 if (traceData)
112 traceData->setData(mem);
113 }
114 return fault;
115}
116
101 if (traceData)
102 traceData->setData(mem[0]);
103}
104
105
106static Fault
107readMemAtomic(ExecContext *xc, Trace::InstRecord *traceData, Addr addr,
108 uint64_t &mem, unsigned dataSize, Request::Flags flags)

--- 6 unchanged lines hidden (view full) ---

115 // access. This doesn't work for BE guests.
116 mem = gtoh(mem);
117 if (traceData)
118 traceData->setData(mem);
119 }
120 return fault;
121}
122
123template <typename T, size_t N>
124static Fault
125readPackedMemAtomic(ExecContext *xc, Addr addr, std::array<uint64_t, N> &mem,
126 unsigned flags)
127{
128 std::array<T, N> real_mem;
129 Fault fault = xc->readMem(addr, (uint8_t *)&real_mem,
130 sizeof(T) * N, flags);
131 if (fault == NoFault) {
132 real_mem = gtoh(real_mem);
133 for (int i = 0; i < N; i++)
134 mem[i] = real_mem[i];
135 }
136 return fault;
137}
138
117template <size_t N>
139template <size_t N>
118Fault
140static Fault
119readMemAtomic(ExecContext *xc, Trace::InstRecord *traceData, Addr addr,
120 std::array<uint64_t, N> &mem, unsigned dataSize,
121 unsigned flags)
122{
141readMemAtomic(ExecContext *xc, Trace::InstRecord *traceData, Addr addr,
142 std::array<uint64_t, N> &mem, unsigned dataSize,
143 unsigned flags)
144{
123 assert(dataSize >= 8);
124 assert((dataSize % 8) == 0);
145 Fault fault = NoFault;
125
146
126 Fault fault = xc->readMem(addr, (uint8_t *)&mem, dataSize, flags);
127
128 if (fault == NoFault) {
129 int num_words = dataSize / 8;
130 assert(num_words <= N);
131
132 for (int i = 0; i < num_words; ++i)
133 mem[i] = gtoh(mem[i]);
134
135 if (traceData)
136 traceData->setData(mem[0]);
147 switch (dataSize) {
148 case 4:
149 fault = readPackedMemAtomic<uint32_t, N>(xc, addr, mem, flags);
150 break;
151 case 8:
152 fault = readPackedMemAtomic<uint64_t, N>(xc, addr, mem, flags);
153 break;
154 default:
155 panic("Unhandled element size in readMemAtomic\n");
137 }
156 }
157 if (fault == NoFault && traceData)
158 traceData->setData(mem[0]);
138 return fault;
139}
140
159 return fault;
160}
161
162template <typename T, size_t N>
141static Fault
163static Fault
164writePackedMem(ExecContext *xc, std::array<uint64_t, N> &mem, Addr addr,
165 unsigned flags, uint64_t *res)
166{
167 std::array<T, N> real_mem;
168 for (int i = 0; i < N; i++)
169 real_mem[i] = mem[i];
170 real_mem = htog(real_mem);
171 return xc->writeMem((uint8_t *)&real_mem, sizeof(T) * N,
172 addr, flags, res);
173}
174
175static Fault
142writeMemTiming(ExecContext *xc, Trace::InstRecord *traceData, uint64_t mem,
143 unsigned dataSize, Addr addr, Request::Flags flags,
144 uint64_t *res)
145{
176writeMemTiming(ExecContext *xc, Trace::InstRecord *traceData, uint64_t mem,
177 unsigned dataSize, Addr addr, Request::Flags flags,
178 uint64_t *res)
179{
146 if (traceData) {
180 if (traceData)
147 traceData->setData(mem);
181 traceData->setData(mem);
148 }
149 mem = TheISA::htog(mem);
150 return xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
151}
152
153template <size_t N>
182 mem = TheISA::htog(mem);
183 return xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
184}
185
186template <size_t N>
154Fault
187static Fault
155writeMemTiming(ExecContext *xc, Trace::InstRecord *traceData,
156 std::array<uint64_t, N> &mem, unsigned dataSize,
157 Addr addr, unsigned flags, uint64_t *res)
158{
188writeMemTiming(ExecContext *xc, Trace::InstRecord *traceData,
189 std::array<uint64_t, N> &mem, unsigned dataSize,
190 Addr addr, unsigned flags, uint64_t *res)
191{
159 assert(dataSize >= 8);
160 assert((dataSize % 8) == 0);
161
162 if (traceData) {
192 if (traceData)
163 traceData->setData(mem[0]);
193 traceData->setData(mem[0]);
164 }
165
194
166 int num_words = dataSize / 8;
167 assert(num_words <= N);
168
169 for (int i = 0; i < num_words; ++i)
170 mem[i] = htog(mem[i]);
171
172 return xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
195 switch (dataSize) {
196 case 4:
197 return writePackedMem<uint32_t, N>(xc, mem, addr, flags, res);
198 case 8:
199 return writePackedMem<uint64_t, N>(xc, mem, addr, flags, res);
200 default:
201 panic("Unhandled element size in writeMemTiming.\n");
202 }
173}
174
175static Fault
176writeMemAtomic(ExecContext *xc, Trace::InstRecord *traceData, uint64_t mem,
177 unsigned dataSize, Addr addr, Request::Flags flags,
178 uint64_t *res)
179{
203}
204
205static Fault
206writeMemAtomic(ExecContext *xc, Trace::InstRecord *traceData, uint64_t mem,
207 unsigned dataSize, Addr addr, Request::Flags flags,
208 uint64_t *res)
209{
180 if (traceData) {
210 if (traceData)
181 traceData->setData(mem);
211 traceData->setData(mem);
182 }
183 uint64_t host_mem = TheISA::htog(mem);
184 Fault fault =
185 xc->writeMem((uint8_t *)&host_mem, dataSize, addr, flags, res);
212 uint64_t host_mem = TheISA::htog(mem);
213 Fault fault =
214 xc->writeMem((uint8_t *)&host_mem, dataSize, addr, flags, res);
186 if (fault == NoFault && res != NULL) {
215 if (fault == NoFault && res)
187 *res = gtoh(*res);
216 *res = gtoh(*res);
188 }
189 return fault;
190}
191
192template <size_t N>
217 return fault;
218}
219
220template <size_t N>
193Fault
221static Fault
194writeMemAtomic(ExecContext *xc, Trace::InstRecord *traceData,
195 std::array<uint64_t, N> &mem, unsigned dataSize,
196 Addr addr, unsigned flags, uint64_t *res)
197{
222writeMemAtomic(ExecContext *xc, Trace::InstRecord *traceData,
223 std::array<uint64_t, N> &mem, unsigned dataSize,
224 Addr addr, unsigned flags, uint64_t *res)
225{
198 if (traceData) {
226 if (traceData)
199 traceData->setData(mem[0]);
227 traceData->setData(mem[0]);
228
229 Fault fault;
230 switch (dataSize) {
231 case 4:
232 fault = writePackedMem<uint32_t, N>(xc, mem, addr, flags, res);
233 break;
234 case 8:
235 fault = writePackedMem<uint64_t, N>(xc, mem, addr, flags, res);
236 break;
237 default:
238 panic("Unhandled element size in writeMemAtomic.\n");
200 }
201
239 }
240
202 int num_words = dataSize / 8;
203 assert(num_words <= N);
204
205 for (int i = 0; i < num_words; ++i)
206 mem[i] = htog(mem[i]);
207
208 Fault fault = xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
209
210 if (fault == NoFault && res != NULL) {
241 if (fault == NoFault && res)
211 *res = gtoh(*res);
242 *res = gtoh(*res);
212 }
213
214 return fault;
215}
216
217}
218
219#endif
243
244 return fault;
245}
246
247}
248
249#endif