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 |