Revision c27004ec cpu-all.h
b/cpu-all.h | ||
---|---|---|
166 | 166 |
* user : user mode access using soft MMU |
167 | 167 |
* kernel : kernel mode access using soft MMU |
168 | 168 |
*/ |
169 |
static inline int ldub_raw(void *ptr)
|
|
169 |
static inline int ldub_p(void *ptr)
|
|
170 | 170 |
{ |
171 | 171 |
return *(uint8_t *)ptr; |
172 | 172 |
} |
173 | 173 |
|
174 |
static inline int ldsb_raw(void *ptr)
|
|
174 |
static inline int ldsb_p(void *ptr)
|
|
175 | 175 |
{ |
176 | 176 |
return *(int8_t *)ptr; |
177 | 177 |
} |
178 | 178 |
|
179 |
static inline void stb_raw(void *ptr, int v)
|
|
179 |
static inline void stb_p(void *ptr, int v)
|
|
180 | 180 |
{ |
181 | 181 |
*(uint8_t *)ptr = v; |
182 | 182 |
} |
... | ... | |
187 | 187 |
#if !defined(TARGET_WORDS_BIGENDIAN) && (defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)) |
188 | 188 |
|
189 | 189 |
/* conservative code for little endian unaligned accesses */ |
190 |
static inline int lduw_raw(void *ptr)
|
|
190 |
static inline int lduw_p(void *ptr)
|
|
191 | 191 |
{ |
192 | 192 |
#ifdef __powerpc__ |
193 | 193 |
int val; |
... | ... | |
199 | 199 |
#endif |
200 | 200 |
} |
201 | 201 |
|
202 |
static inline int ldsw_raw(void *ptr)
|
|
202 |
static inline int ldsw_p(void *ptr)
|
|
203 | 203 |
{ |
204 | 204 |
#ifdef __powerpc__ |
205 | 205 |
int val; |
... | ... | |
211 | 211 |
#endif |
212 | 212 |
} |
213 | 213 |
|
214 |
static inline int ldl_raw(void *ptr)
|
|
214 |
static inline int ldl_p(void *ptr)
|
|
215 | 215 |
{ |
216 | 216 |
#ifdef __powerpc__ |
217 | 217 |
int val; |
... | ... | |
223 | 223 |
#endif |
224 | 224 |
} |
225 | 225 |
|
226 |
static inline uint64_t ldq_raw(void *ptr)
|
|
226 |
static inline uint64_t ldq_p(void *ptr)
|
|
227 | 227 |
{ |
228 | 228 |
uint8_t *p = ptr; |
229 | 229 |
uint32_t v1, v2; |
230 |
v1 = ldl_raw(p);
|
|
231 |
v2 = ldl_raw(p + 4);
|
|
230 |
v1 = ldl_p(p);
|
|
231 |
v2 = ldl_p(p + 4);
|
|
232 | 232 |
return v1 | ((uint64_t)v2 << 32); |
233 | 233 |
} |
234 | 234 |
|
235 |
static inline void stw_raw(void *ptr, int v)
|
|
235 |
static inline void stw_p(void *ptr, int v)
|
|
236 | 236 |
{ |
237 | 237 |
#ifdef __powerpc__ |
238 | 238 |
__asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr)); |
... | ... | |
243 | 243 |
#endif |
244 | 244 |
} |
245 | 245 |
|
246 |
static inline void stl_raw(void *ptr, int v)
|
|
246 |
static inline void stl_p(void *ptr, int v)
|
|
247 | 247 |
{ |
248 | 248 |
#ifdef __powerpc__ |
249 | 249 |
__asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr)); |
... | ... | |
256 | 256 |
#endif |
257 | 257 |
} |
258 | 258 |
|
259 |
static inline void stq_raw(void *ptr, uint64_t v)
|
|
259 |
static inline void stq_p(void *ptr, uint64_t v)
|
|
260 | 260 |
{ |
261 | 261 |
uint8_t *p = ptr; |
262 |
stl_raw(p, (uint32_t)v);
|
|
263 |
stl_raw(p + 4, v >> 32);
|
|
262 |
stl_p(p, (uint32_t)v);
|
|
263 |
stl_p(p + 4, v >> 32);
|
|
264 | 264 |
} |
265 | 265 |
|
266 | 266 |
/* float access */ |
267 | 267 |
|
268 |
static inline float ldfl_raw(void *ptr)
|
|
268 |
static inline float ldfl_p(void *ptr)
|
|
269 | 269 |
{ |
270 | 270 |
union { |
271 | 271 |
float f; |
272 | 272 |
uint32_t i; |
273 | 273 |
} u; |
274 |
u.i = ldl_raw(ptr);
|
|
274 |
u.i = ldl_p(ptr);
|
|
275 | 275 |
return u.f; |
276 | 276 |
} |
277 | 277 |
|
278 |
static inline void stfl_raw(void *ptr, float v)
|
|
278 |
static inline void stfl_p(void *ptr, float v)
|
|
279 | 279 |
{ |
280 | 280 |
union { |
281 | 281 |
float f; |
282 | 282 |
uint32_t i; |
283 | 283 |
} u; |
284 | 284 |
u.f = v; |
285 |
stl_raw(ptr, u.i);
|
|
285 |
stl_p(ptr, u.i);
|
|
286 | 286 |
} |
287 | 287 |
|
288 |
static inline double ldfq_raw(void *ptr)
|
|
288 |
static inline double ldfq_p(void *ptr)
|
|
289 | 289 |
{ |
290 | 290 |
CPU_DoubleU u; |
291 |
u.l.lower = ldl_raw(ptr);
|
|
292 |
u.l.upper = ldl_raw(ptr + 4);
|
|
291 |
u.l.lower = ldl_p(ptr);
|
|
292 |
u.l.upper = ldl_p(ptr + 4);
|
|
293 | 293 |
return u.d; |
294 | 294 |
} |
295 | 295 |
|
296 |
static inline void stfq_raw(void *ptr, double v)
|
|
296 |
static inline void stfq_p(void *ptr, double v)
|
|
297 | 297 |
{ |
298 | 298 |
CPU_DoubleU u; |
299 | 299 |
u.d = v; |
300 |
stl_raw(ptr, u.l.lower);
|
|
301 |
stl_raw(ptr + 4, u.l.upper);
|
|
300 |
stl_p(ptr, u.l.lower);
|
|
301 |
stl_p(ptr + 4, u.l.upper);
|
|
302 | 302 |
} |
303 | 303 |
|
304 | 304 |
#elif defined(TARGET_WORDS_BIGENDIAN) && (!defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)) |
305 | 305 |
|
306 |
static inline int lduw_raw(void *ptr)
|
|
306 |
static inline int lduw_p(void *ptr)
|
|
307 | 307 |
{ |
308 | 308 |
#if defined(__i386__) |
309 | 309 |
int val; |
... | ... | |
318 | 318 |
#endif |
319 | 319 |
} |
320 | 320 |
|
321 |
static inline int ldsw_raw(void *ptr)
|
|
321 |
static inline int ldsw_p(void *ptr)
|
|
322 | 322 |
{ |
323 | 323 |
#if defined(__i386__) |
324 | 324 |
int val; |
... | ... | |
333 | 333 |
#endif |
334 | 334 |
} |
335 | 335 |
|
336 |
static inline int ldl_raw(void *ptr)
|
|
336 |
static inline int ldl_p(void *ptr)
|
|
337 | 337 |
{ |
338 | 338 |
#if defined(__i386__) || defined(__x86_64__) |
339 | 339 |
int val; |
... | ... | |
348 | 348 |
#endif |
349 | 349 |
} |
350 | 350 |
|
351 |
static inline uint64_t ldq_raw(void *ptr)
|
|
351 |
static inline uint64_t ldq_p(void *ptr)
|
|
352 | 352 |
{ |
353 | 353 |
uint32_t a,b; |
354 |
a = ldl_raw(ptr);
|
|
355 |
b = ldl_raw(ptr+4);
|
|
354 |
a = ldl_p(ptr);
|
|
355 |
b = ldl_p(ptr+4);
|
|
356 | 356 |
return (((uint64_t)a<<32)|b); |
357 | 357 |
} |
358 | 358 |
|
359 |
static inline void stw_raw(void *ptr, int v)
|
|
359 |
static inline void stw_p(void *ptr, int v)
|
|
360 | 360 |
{ |
361 | 361 |
#if defined(__i386__) |
362 | 362 |
asm volatile ("xchgb %b0, %h0\n" |
... | ... | |
370 | 370 |
#endif |
371 | 371 |
} |
372 | 372 |
|
373 |
static inline void stl_raw(void *ptr, int v)
|
|
373 |
static inline void stl_p(void *ptr, int v)
|
|
374 | 374 |
{ |
375 | 375 |
#if defined(__i386__) || defined(__x86_64__) |
376 | 376 |
asm volatile ("bswap %0\n" |
... | ... | |
386 | 386 |
#endif |
387 | 387 |
} |
388 | 388 |
|
389 |
static inline void stq_raw(void *ptr, uint64_t v)
|
|
389 |
static inline void stq_p(void *ptr, uint64_t v)
|
|
390 | 390 |
{ |
391 |
stl_raw(ptr, v >> 32);
|
|
392 |
stl_raw(ptr + 4, v);
|
|
391 |
stl_p(ptr, v >> 32);
|
|
392 |
stl_p(ptr + 4, v);
|
|
393 | 393 |
} |
394 | 394 |
|
395 | 395 |
/* float access */ |
396 | 396 |
|
397 |
static inline float ldfl_raw(void *ptr)
|
|
397 |
static inline float ldfl_p(void *ptr)
|
|
398 | 398 |
{ |
399 | 399 |
union { |
400 | 400 |
float f; |
401 | 401 |
uint32_t i; |
402 | 402 |
} u; |
403 |
u.i = ldl_raw(ptr);
|
|
403 |
u.i = ldl_p(ptr);
|
|
404 | 404 |
return u.f; |
405 | 405 |
} |
406 | 406 |
|
407 |
static inline void stfl_raw(void *ptr, float v)
|
|
407 |
static inline void stfl_p(void *ptr, float v)
|
|
408 | 408 |
{ |
409 | 409 |
union { |
410 | 410 |
float f; |
411 | 411 |
uint32_t i; |
412 | 412 |
} u; |
413 | 413 |
u.f = v; |
414 |
stl_raw(ptr, u.i);
|
|
414 |
stl_p(ptr, u.i);
|
|
415 | 415 |
} |
416 | 416 |
|
417 |
static inline double ldfq_raw(void *ptr)
|
|
417 |
static inline double ldfq_p(void *ptr)
|
|
418 | 418 |
{ |
419 | 419 |
CPU_DoubleU u; |
420 |
u.l.upper = ldl_raw(ptr);
|
|
421 |
u.l.lower = ldl_raw(ptr + 4);
|
|
420 |
u.l.upper = ldl_p(ptr);
|
|
421 |
u.l.lower = ldl_p(ptr + 4);
|
|
422 | 422 |
return u.d; |
423 | 423 |
} |
424 | 424 |
|
425 |
static inline void stfq_raw(void *ptr, double v)
|
|
425 |
static inline void stfq_p(void *ptr, double v)
|
|
426 | 426 |
{ |
427 | 427 |
CPU_DoubleU u; |
428 | 428 |
u.d = v; |
429 |
stl_raw(ptr, u.l.upper);
|
|
430 |
stl_raw(ptr + 4, u.l.lower);
|
|
429 |
stl_p(ptr, u.l.upper);
|
|
430 |
stl_p(ptr + 4, u.l.lower);
|
|
431 | 431 |
} |
432 | 432 |
|
433 | 433 |
#else |
434 | 434 |
|
435 |
static inline int lduw_raw(void *ptr)
|
|
435 |
static inline int lduw_p(void *ptr)
|
|
436 | 436 |
{ |
437 | 437 |
return *(uint16_t *)ptr; |
438 | 438 |
} |
439 | 439 |
|
440 |
static inline int ldsw_raw(void *ptr)
|
|
440 |
static inline int ldsw_p(void *ptr)
|
|
441 | 441 |
{ |
442 | 442 |
return *(int16_t *)ptr; |
443 | 443 |
} |
444 | 444 |
|
445 |
static inline int ldl_raw(void *ptr)
|
|
445 |
static inline int ldl_p(void *ptr)
|
|
446 | 446 |
{ |
447 | 447 |
return *(uint32_t *)ptr; |
448 | 448 |
} |
449 | 449 |
|
450 |
static inline uint64_t ldq_raw(void *ptr)
|
|
450 |
static inline uint64_t ldq_p(void *ptr)
|
|
451 | 451 |
{ |
452 | 452 |
return *(uint64_t *)ptr; |
453 | 453 |
} |
454 | 454 |
|
455 |
static inline void stw_raw(void *ptr, int v)
|
|
455 |
static inline void stw_p(void *ptr, int v)
|
|
456 | 456 |
{ |
457 | 457 |
*(uint16_t *)ptr = v; |
458 | 458 |
} |
459 | 459 |
|
460 |
static inline void stl_raw(void *ptr, int v)
|
|
460 |
static inline void stl_p(void *ptr, int v)
|
|
461 | 461 |
{ |
462 | 462 |
*(uint32_t *)ptr = v; |
463 | 463 |
} |
464 | 464 |
|
465 |
static inline void stq_raw(void *ptr, uint64_t v)
|
|
465 |
static inline void stq_p(void *ptr, uint64_t v)
|
|
466 | 466 |
{ |
467 | 467 |
*(uint64_t *)ptr = v; |
468 | 468 |
} |
469 | 469 |
|
470 | 470 |
/* float access */ |
471 | 471 |
|
472 |
static inline float ldfl_raw(void *ptr)
|
|
472 |
static inline float ldfl_p(void *ptr)
|
|
473 | 473 |
{ |
474 | 474 |
return *(float *)ptr; |
475 | 475 |
} |
476 | 476 |
|
477 |
static inline double ldfq_raw(void *ptr)
|
|
477 |
static inline double ldfq_p(void *ptr)
|
|
478 | 478 |
{ |
479 | 479 |
return *(double *)ptr; |
480 | 480 |
} |
481 | 481 |
|
482 |
static inline void stfl_raw(void *ptr, float v)
|
|
482 |
static inline void stfl_p(void *ptr, float v)
|
|
483 | 483 |
{ |
484 | 484 |
*(float *)ptr = v; |
485 | 485 |
} |
486 | 486 |
|
487 |
static inline void stfq_raw(void *ptr, double v)
|
|
487 |
static inline void stfq_p(void *ptr, double v)
|
|
488 | 488 |
{ |
489 | 489 |
*(double *)ptr = v; |
490 | 490 |
} |
... | ... | |
492 | 492 |
|
493 | 493 |
/* MMU memory access macros */ |
494 | 494 |
|
495 |
/* NOTE: we use double casts if pointers and target_ulong have |
|
496 |
different sizes */ |
|
497 |
#define ldub_raw(p) ldub_p((uint8_t *)(long)(p)) |
|
498 |
#define ldsb_raw(p) ldsb_p((uint8_t *)(long)(p)) |
|
499 |
#define lduw_raw(p) lduw_p((uint8_t *)(long)(p)) |
|
500 |
#define ldsw_raw(p) ldsw_p((uint8_t *)(long)(p)) |
|
501 |
#define ldl_raw(p) ldl_p((uint8_t *)(long)(p)) |
|
502 |
#define ldq_raw(p) ldq_p((uint8_t *)(long)(p)) |
|
503 |
#define ldfl_raw(p) ldfl_p((uint8_t *)(long)(p)) |
|
504 |
#define ldfq_raw(p) ldfq_p((uint8_t *)(long)(p)) |
|
505 |
#define stb_raw(p, v) stb_p((uint8_t *)(long)(p), v) |
|
506 |
#define stw_raw(p, v) stw_p((uint8_t *)(long)(p), v) |
|
507 |
#define stl_raw(p, v) stl_p((uint8_t *)(long)(p), v) |
|
508 |
#define stq_raw(p, v) stq_p((uint8_t *)(long)(p), v) |
|
509 |
#define stfl_raw(p, v) stfl_p((uint8_t *)(long)(p), v) |
|
510 |
#define stfq_raw(p, v) stfq_p((uint8_t *)(long)(p), v) |
|
511 |
|
|
512 |
|
|
495 | 513 |
#if defined(CONFIG_USER_ONLY) |
496 | 514 |
|
497 | 515 |
/* if user mode, no other memory access functions */ |
Also available in: Unified diff