00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef CPU_ALL_H
00021 #define CPU_ALL_H
00022
00023 #include "qemu-common.h"
00024
00025 #if defined(__arm__) || defined(__sparc__) || defined(__mips__) || defined(__hppa__)
00026 #define WORDS_ALIGNED
00027 #endif
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #include "bswap.h"
00043 #include "softfloat.h"
00044
00045 #if defined(WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
00046 #define BSWAP_NEEDED
00047 #endif
00048
00049 #ifdef BSWAP_NEEDED
00050
00051 static inline uint16_t tswap16(uint16_t s)
00052 {
00053 return bswap16(s);
00054 }
00055
00056 static inline uint32_t tswap32(uint32_t s)
00057 {
00058 return bswap32(s);
00059 }
00060
00061 static inline uint64_t tswap64(uint64_t s)
00062 {
00063 return bswap64(s);
00064 }
00065
00066 static inline void tswap16s(uint16_t *s)
00067 {
00068 *s = bswap16(*s);
00069 }
00070
00071 static inline void tswap32s(uint32_t *s)
00072 {
00073 *s = bswap32(*s);
00074 }
00075
00076 static inline void tswap64s(uint64_t *s)
00077 {
00078 *s = bswap64(*s);
00079 }
00080
00081 #else
00082
00083 static inline uint16_t tswap16(uint16_t s)
00084 {
00085 return s;
00086 }
00087
00088 static inline uint32_t tswap32(uint32_t s)
00089 {
00090 return s;
00091 }
00092
00093 static inline uint64_t tswap64(uint64_t s)
00094 {
00095 return s;
00096 }
00097
00098 static inline void tswap16s(uint16_t *s)
00099 {
00100 }
00101
00102 static inline void tswap32s(uint32_t *s)
00103 {
00104 }
00105
00106 static inline void tswap64s(uint64_t *s)
00107 {
00108 }
00109
00110 #endif
00111
00112 #if TARGET_LONG_SIZE == 4
00113 #define tswapl(s) tswap32(s)
00114 #define tswapls(s) tswap32s((uint32_t *)(s))
00115 #define bswaptls(s) bswap32s(s)
00116 #else
00117 #define tswapl(s) tswap64(s)
00118 #define tswapls(s) tswap64s((uint64_t *)(s))
00119 #define bswaptls(s) bswap64s(s)
00120 #endif
00121
00122 typedef union {
00123 float32 f;
00124 uint32_t l;
00125 } CPU_FloatU;
00126
00127
00128
00129 typedef union {
00130 float64 d;
00131 #if defined(WORDS_BIGENDIAN) \
00132 || (defined(__arm__) && !defined(__VFP_FP__) && !defined(CONFIG_SOFTFLOAT))
00133 struct {
00134 uint32_t upper;
00135 uint32_t lower;
00136 } l;
00137 #else
00138 struct {
00139 uint32_t lower;
00140 uint32_t upper;
00141 } l;
00142 #endif
00143 uint64_t ll;
00144 } CPU_DoubleU;
00145
00146 #ifdef TARGET_SPARC
00147 typedef union {
00148 float128 q;
00149 #if defined(WORDS_BIGENDIAN) \
00150 || (defined(__arm__) && !defined(__VFP_FP__) && !defined(CONFIG_SOFTFLOAT))
00151 struct {
00152 uint32_t upmost;
00153 uint32_t upper;
00154 uint32_t lower;
00155 uint32_t lowest;
00156 } l;
00157 struct {
00158 uint64_t upper;
00159 uint64_t lower;
00160 } ll;
00161 #else
00162 struct {
00163 uint32_t lowest;
00164 uint32_t lower;
00165 uint32_t upper;
00166 uint32_t upmost;
00167 } l;
00168 struct {
00169 uint64_t lower;
00170 uint64_t upper;
00171 } ll;
00172 #endif
00173 } CPU_QuadU;
00174 #endif
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211 static inline int ldub_p(const void *ptr)
00212 {
00213 return *(uint8_t *)ptr;
00214 }
00215
00216 static inline int ldsb_p(const void *ptr)
00217 {
00218 return *(int8_t *)ptr;
00219 }
00220
00221 static inline void stb_p(void *ptr, int v)
00222 {
00223 *(uint8_t *)ptr = v;
00224 }
00225
00226
00227
00228
00229 #if defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)
00230
00231
00232 static inline int lduw_le_p(const void *ptr)
00233 {
00234 #ifdef _ARCH_PPC
00235 int val;
00236 __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr));
00237 return val;
00238 #else
00239 const uint8_t *p = ptr;
00240 return p[0] | (p[1] << 8);
00241 #endif
00242 }
00243
00244 static inline int ldsw_le_p(const void *ptr)
00245 {
00246 #ifdef _ARCH_PPC
00247 int val;
00248 __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr));
00249 return (int16_t)val;
00250 #else
00251 const uint8_t *p = ptr;
00252 return (int16_t)(p[0] | (p[1] << 8));
00253 #endif
00254 }
00255
00256 static inline int ldl_le_p(const void *ptr)
00257 {
00258 #ifdef _ARCH_PPC
00259 int val;
00260 __asm__ __volatile__ ("lwbrx %0,0,%1" : "=r" (val) : "r" (ptr));
00261 return val;
00262 #else
00263 const uint8_t *p = ptr;
00264 return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24);
00265 #endif
00266 }
00267
00268 static inline uint64_t ldq_le_p(const void *ptr)
00269 {
00270 const uint8_t *p = ptr;
00271 uint32_t v1, v2;
00272 v1 = ldl_le_p(p);
00273 v2 = ldl_le_p(p + 4);
00274 return v1 | ((uint64_t)v2 << 32);
00275 }
00276
00277 static inline void stw_le_p(void *ptr, int v)
00278 {
00279 #ifdef _ARCH_PPC
00280 __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr));
00281 #else
00282 uint8_t *p = ptr;
00283 p[0] = v;
00284 p[1] = v >> 8;
00285 #endif
00286 }
00287
00288 static inline void stl_le_p(void *ptr, int v)
00289 {
00290 #ifdef _ARCH_PPC
00291 __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr));
00292 #else
00293 uint8_t *p = ptr;
00294 p[0] = v;
00295 p[1] = v >> 8;
00296 p[2] = v >> 16;
00297 p[3] = v >> 24;
00298 #endif
00299 }
00300
00301 static inline void stq_le_p(void *ptr, uint64_t v)
00302 {
00303 uint8_t *p = ptr;
00304 stl_le_p(p, (uint32_t)v);
00305 stl_le_p(p + 4, v >> 32);
00306 }
00307
00308
00309
00310 static inline float32 ldfl_le_p(const void *ptr)
00311 {
00312 union {
00313 float32 f;
00314 uint32_t i;
00315 } u;
00316 u.i = ldl_le_p(ptr);
00317 return u.f;
00318 }
00319
00320 static inline void stfl_le_p(void *ptr, float32 v)
00321 {
00322 union {
00323 float32 f;
00324 uint32_t i;
00325 } u;
00326 u.f = v;
00327 stl_le_p(ptr, u.i);
00328 }
00329
00330 static inline float64 ldfq_le_p(const void *ptr)
00331 {
00332 CPU_DoubleU u;
00333 u.l.lower = ldl_le_p(ptr);
00334 u.l.upper = ldl_le_p(ptr + 4);
00335 return u.d;
00336 }
00337
00338 static inline void stfq_le_p(void *ptr, float64 v)
00339 {
00340 CPU_DoubleU u;
00341 u.d = v;
00342 stl_le_p(ptr, u.l.lower);
00343 stl_le_p(ptr + 4, u.l.upper);
00344 }
00345
00346 #else
00347
00348 static inline int lduw_le_p(const void *ptr)
00349 {
00350 return *(uint16_t *)ptr;
00351 }
00352
00353 static inline int ldsw_le_p(const void *ptr)
00354 {
00355 return *(int16_t *)ptr;
00356 }
00357
00358 static inline int ldl_le_p(const void *ptr)
00359 {
00360 return *(uint32_t *)ptr;
00361 }
00362
00363 static inline uint64_t ldq_le_p(const void *ptr)
00364 {
00365 return *(uint64_t *)ptr;
00366 }
00367
00368 static inline void stw_le_p(void *ptr, int v)
00369 {
00370 *(uint16_t *)ptr = v;
00371 }
00372
00373 static inline void stl_le_p(void *ptr, int v)
00374 {
00375 *(uint32_t *)ptr = v;
00376 }
00377
00378 static inline void stq_le_p(void *ptr, uint64_t v)
00379 {
00380 *(uint64_t *)ptr = v;
00381 }
00382
00383
00384
00385 static inline float32 ldfl_le_p(const void *ptr)
00386 {
00387 return *(float32 *)ptr;
00388 }
00389
00390 static inline float64 ldfq_le_p(const void *ptr)
00391 {
00392 return *(float64 *)ptr;
00393 }
00394
00395 static inline void stfl_le_p(void *ptr, float32 v)
00396 {
00397 *(float32 *)ptr = v;
00398 }
00399
00400 static inline void stfq_le_p(void *ptr, float64 v)
00401 {
00402 *(float64 *)ptr = v;
00403 }
00404 #endif
00405
00406 #if !defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)
00407
00408 static inline int lduw_be_p(const void *ptr)
00409 {
00410 #if defined(__i386__)
00411 int val;
00412 asm volatile ("movzwl %1, %0\n"
00413 "xchgb %b0, %h0\n"
00414 : "=q" (val)
00415 : "m" (*(uint16_t *)ptr));
00416 return val;
00417 #else
00418 const uint8_t *b = ptr;
00419 return ((b[0] << 8) | b[1]);
00420 #endif
00421 }
00422
00423 static inline int ldsw_be_p(const void *ptr)
00424 {
00425 #if defined(__i386__)
00426 int val;
00427 asm volatile ("movzwl %1, %0\n"
00428 "xchgb %b0, %h0\n"
00429 : "=q" (val)
00430 : "m" (*(uint16_t *)ptr));
00431 return (int16_t)val;
00432 #else
00433 const uint8_t *b = ptr;
00434 return (int16_t)((b[0] << 8) | b[1]);
00435 #endif
00436 }
00437
00438 static inline int ldl_be_p(const void *ptr)
00439 {
00440 #if defined(__i386__) || defined(__x86_64__)
00441 int val;
00442 asm volatile ("movl %1, %0\n"
00443 "bswap %0\n"
00444 : "=r" (val)
00445 : "m" (*(uint32_t *)ptr));
00446 return val;
00447 #else
00448 const uint8_t *b = ptr;
00449 return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3];
00450 #endif
00451 }
00452
00453 static inline uint64_t ldq_be_p(const void *ptr)
00454 {
00455 uint32_t a,b;
00456 a = ldl_be_p(ptr);
00457 b = ldl_be_p((uint8_t *)ptr + 4);
00458 return (((uint64_t)a<<32)|b);
00459 }
00460
00461 static inline void stw_be_p(void *ptr, int v)
00462 {
00463 #if defined(__i386__)
00464 asm volatile ("xchgb %b0, %h0\n"
00465 "movw %w0, %1\n"
00466 : "=q" (v)
00467 : "m" (*(uint16_t *)ptr), "0" (v));
00468 #else
00469 uint8_t *d = (uint8_t *) ptr;
00470 d[0] = v >> 8;
00471 d[1] = v;
00472 #endif
00473 }
00474
00475 static inline void stl_be_p(void *ptr, int v)
00476 {
00477 #if defined(__i386__) || defined(__x86_64__)
00478 asm volatile ("bswap %0\n"
00479 "movl %0, %1\n"
00480 : "=r" (v)
00481 : "m" (*(uint32_t *)ptr), "0" (v));
00482 #else
00483 uint8_t *d = (uint8_t *) ptr;
00484 d[0] = v >> 24;
00485 d[1] = v >> 16;
00486 d[2] = v >> 8;
00487 d[3] = v;
00488 #endif
00489 }
00490
00491 static inline void stq_be_p(void *ptr, uint64_t v)
00492 {
00493 stl_be_p(ptr, v >> 32);
00494 stl_be_p((uint8_t *)ptr + 4, v);
00495 }
00496
00497
00498
00499 static inline float32 ldfl_be_p(const void *ptr)
00500 {
00501 union {
00502 float32 f;
00503 uint32_t i;
00504 } u;
00505 u.i = ldl_be_p(ptr);
00506 return u.f;
00507 }
00508
00509 static inline void stfl_be_p(void *ptr, float32 v)
00510 {
00511 union {
00512 float32 f;
00513 uint32_t i;
00514 } u;
00515 u.f = v;
00516 stl_be_p(ptr, u.i);
00517 }
00518
00519 static inline float64 ldfq_be_p(const void *ptr)
00520 {
00521 CPU_DoubleU u;
00522 u.l.upper = ldl_be_p(ptr);
00523 u.l.lower = ldl_be_p((uint8_t *)ptr + 4);
00524 return u.d;
00525 }
00526
00527 static inline void stfq_be_p(void *ptr, float64 v)
00528 {
00529 CPU_DoubleU u;
00530 u.d = v;
00531 stl_be_p(ptr, u.l.upper);
00532 stl_be_p((uint8_t *)ptr + 4, u.l.lower);
00533 }
00534
00535 #else
00536
00537 static inline int lduw_be_p(const void *ptr)
00538 {
00539 return *(uint16_t *)ptr;
00540 }
00541
00542 static inline int ldsw_be_p(const void *ptr)
00543 {
00544 return *(int16_t *)ptr;
00545 }
00546
00547 static inline int ldl_be_p(const void *ptr)
00548 {
00549 return *(uint32_t *)ptr;
00550 }
00551
00552 static inline uint64_t ldq_be_p(const void *ptr)
00553 {
00554 return *(uint64_t *)ptr;
00555 }
00556
00557 static inline void stw_be_p(void *ptr, int v)
00558 {
00559 *(uint16_t *)ptr = v;
00560 }
00561
00562 static inline void stl_be_p(void *ptr, int v)
00563 {
00564 *(uint32_t *)ptr = v;
00565 }
00566
00567 static inline void stq_be_p(void *ptr, uint64_t v)
00568 {
00569 *(uint64_t *)ptr = v;
00570 }
00571
00572
00573
00574 static inline float32 ldfl_be_p(const void *ptr)
00575 {
00576 return *(float32 *)ptr;
00577 }
00578
00579 static inline float64 ldfq_be_p(const void *ptr)
00580 {
00581 return *(float64 *)ptr;
00582 }
00583
00584 static inline void stfl_be_p(void *ptr, float32 v)
00585 {
00586 *(float32 *)ptr = v;
00587 }
00588
00589 static inline void stfq_be_p(void *ptr, float64 v)
00590 {
00591 *(float64 *)ptr = v;
00592 }
00593
00594 #endif
00595
00596
00597 #if defined(TARGET_WORDS_BIGENDIAN)
00598 #define lduw_p(p) lduw_be_p(p)
00599 #define ldsw_p(p) ldsw_be_p(p)
00600 #define ldl_p(p) ldl_be_p(p)
00601 #define ldq_p(p) ldq_be_p(p)
00602 #define ldfl_p(p) ldfl_be_p(p)
00603 #define ldfq_p(p) ldfq_be_p(p)
00604 #define stw_p(p, v) stw_be_p(p, v)
00605 #define stl_p(p, v) stl_be_p(p, v)
00606 #define stq_p(p, v) stq_be_p(p, v)
00607 #define stfl_p(p, v) stfl_be_p(p, v)
00608 #define stfq_p(p, v) stfq_be_p(p, v)
00609 #else
00610 #define lduw_p(p) lduw_le_p(p)
00611 #define ldsw_p(p) ldsw_le_p(p)
00612 #define ldl_p(p) ldl_le_p(p)
00613 #define ldq_p(p) ldq_le_p(p)
00614 #define ldfl_p(p) ldfl_le_p(p)
00615 #define ldfq_p(p) ldfq_le_p(p)
00616 #define stw_p(p, v) stw_le_p(p, v)
00617 #define stl_p(p, v) stl_le_p(p, v)
00618 #define stq_p(p, v) stq_le_p(p, v)
00619 #define stfl_p(p, v) stfl_le_p(p, v)
00620 #define stfq_p(p, v) stfq_le_p(p, v)
00621 #endif
00622
00623
00624
00625 #if defined(CONFIG_USER_ONLY)
00626 #include <assert.h>
00627 #include "qemu-types.h"
00628
00629
00630
00631
00632
00633 #define GUEST_BASE 0
00634
00635
00636 #define g2h(x) ((void *)((unsigned long)(x) + GUEST_BASE))
00637 #define h2g(x) ({ \
00638 unsigned long __ret = (unsigned long)(x) - GUEST_BASE; \
00639 \
00640 assert(__ret == (abi_ulong)__ret); \
00641 (abi_ulong)__ret; \
00642 })
00643 #define h2g_valid(x) ({ \
00644 unsigned long __guest = (unsigned long)(x) - GUEST_BASE; \
00645 (__guest == (abi_ulong)__guest); \
00646 })
00647
00648 #define saddr(x) g2h(x)
00649 #define laddr(x) g2h(x)
00650
00651 #else
00652
00653
00654 #define saddr(x) (uint8_t *)(long)(x)
00655 #define laddr(x) (uint8_t *)(long)(x)
00656 #endif
00657
00658 #define ldub_raw(p) ldub_p(laddr((p)))
00659 #define ldsb_raw(p) ldsb_p(laddr((p)))
00660 #define lduw_raw(p) lduw_p(laddr((p)))
00661 #define ldsw_raw(p) ldsw_p(laddr((p)))
00662 #define ldl_raw(p) ldl_p(laddr((p)))
00663 #define ldq_raw(p) ldq_p(laddr((p)))
00664 #define ldfl_raw(p) ldfl_p(laddr((p)))
00665 #define ldfq_raw(p) ldfq_p(laddr((p)))
00666 #define stb_raw(p, v) stb_p(saddr((p)), v)
00667 #define stw_raw(p, v) stw_p(saddr((p)), v)
00668 #define stl_raw(p, v) stl_p(saddr((p)), v)
00669 #define stq_raw(p, v) stq_p(saddr((p)), v)
00670 #define stfl_raw(p, v) stfl_p(saddr((p)), v)
00671 #define stfq_raw(p, v) stfq_p(saddr((p)), v)
00672
00673
00674 #if defined(CONFIG_USER_ONLY)
00675
00676
00677 #define ldub(p) ldub_raw(p)
00678 #define ldsb(p) ldsb_raw(p)
00679 #define lduw(p) lduw_raw(p)
00680 #define ldsw(p) ldsw_raw(p)
00681 #define ldl(p) ldl_raw(p)
00682 #define ldq(p) ldq_raw(p)
00683 #define ldfl(p) ldfl_raw(p)
00684 #define ldfq(p) ldfq_raw(p)
00685 #define stb(p, v) stb_raw(p, v)
00686 #define stw(p, v) stw_raw(p, v)
00687 #define stl(p, v) stl_raw(p, v)
00688 #define stq(p, v) stq_raw(p, v)
00689 #define stfl(p, v) stfl_raw(p, v)
00690 #define stfq(p, v) stfq_raw(p, v)
00691
00692 #define ldub_code(p) ldub_raw(p)
00693 #define ldsb_code(p) ldsb_raw(p)
00694 #define lduw_code(p) lduw_raw(p)
00695 #define ldsw_code(p) ldsw_raw(p)
00696 #define ldl_code(p) ldl_raw(p)
00697 #define ldq_code(p) ldq_raw(p)
00698
00699 #define ldub_kernel(p) ldub_raw(p)
00700 #define ldsb_kernel(p) ldsb_raw(p)
00701 #define lduw_kernel(p) lduw_raw(p)
00702 #define ldsw_kernel(p) ldsw_raw(p)
00703 #define ldl_kernel(p) ldl_raw(p)
00704 #define ldq_kernel(p) ldq_raw(p)
00705 #define ldfl_kernel(p) ldfl_raw(p)
00706 #define ldfq_kernel(p) ldfq_raw(p)
00707 #define stb_kernel(p, v) stb_raw(p, v)
00708 #define stw_kernel(p, v) stw_raw(p, v)
00709 #define stl_kernel(p, v) stl_raw(p, v)
00710 #define stq_kernel(p, v) stq_raw(p, v)
00711 #define stfl_kernel(p, v) stfl_raw(p, v)
00712 #define stfq_kernel(p, vt) stfq_raw(p, v)
00713
00714 #endif
00715
00716
00717
00718 #define TARGET_PAGE_SIZE (1 << TARGET_PAGE_BITS)
00719 #define TARGET_PAGE_MASK ~(TARGET_PAGE_SIZE - 1)
00720 #define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK)
00721
00722
00723 extern unsigned long qemu_real_host_page_size;
00724 extern unsigned long qemu_host_page_bits;
00725 extern unsigned long qemu_host_page_size;
00726 extern unsigned long qemu_host_page_mask;
00727
00728 #define HOST_PAGE_ALIGN(addr) (((addr) + qemu_host_page_size - 1) & qemu_host_page_mask)
00729
00730
00731 #define PAGE_READ 0x0001
00732 #define PAGE_WRITE 0x0002
00733 #define PAGE_EXEC 0x0004
00734 #define PAGE_BITS (PAGE_READ | PAGE_WRITE | PAGE_EXEC)
00735 #define PAGE_VALID 0x0008
00736
00737
00738 #define PAGE_WRITE_ORG 0x0010
00739 #define PAGE_RESERVED 0x0020
00740
00741 void page_dump(FILE *f);
00742 int page_get_flags(target_ulong address);
00743 void page_set_flags(target_ulong start, target_ulong end, int flags);
00744 int page_check_range(target_ulong start, target_ulong len, int flags);
00745
00746 void cpu_exec_init_all(unsigned long tb_size);
00747 CPUState *cpu_copy(CPUState *env);
00748
00749 void cpu_dump_state(CPUState *env, FILE *f,
00750 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
00751 int flags);
00752 void cpu_dump_statistics (CPUState *env, FILE *f,
00753 int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
00754 int flags);
00755
00756 void QEMU_NORETURN cpu_abort(CPUState *env, const char *fmt, ...)
00757 __attribute__ ((__format__ (__printf__, 2, 3)));
00758 extern CPUState *first_cpu;
00759 extern CPUState *cpu_single_env;
00760 extern int64_t qemu_icount;
00761 extern int use_icount;
00762
00763 #define CPU_INTERRUPT_EXIT 0x01
00764 #define CPU_INTERRUPT_HARD 0x02
00765 #define CPU_INTERRUPT_EXITTB 0x04
00766 #define CPU_INTERRUPT_TIMER 0x08
00767 #define CPU_INTERRUPT_FIQ 0x10
00768 #define CPU_INTERRUPT_HALT 0x20
00769 #define CPU_INTERRUPT_SMI 0x40
00770 #define CPU_INTERRUPT_DEBUG 0x80
00771 #define CPU_INTERRUPT_VIRQ 0x100
00772 #define CPU_INTERRUPT_NMI 0x200
00773
00774 void cpu_interrupt(CPUState *s, int mask);
00775 void cpu_reset_interrupt(CPUState *env, int mask);
00776
00777
00778 #define BP_MEM_READ 0x01
00779 #define BP_MEM_WRITE 0x02
00780 #define BP_MEM_ACCESS (BP_MEM_READ | BP_MEM_WRITE)
00781 #define BP_STOP_BEFORE_ACCESS 0x04
00782 #define BP_WATCHPOINT_HIT 0x08
00783 #define BP_GDB 0x10
00784 #define BP_CPU 0x20
00785
00786 int cpu_breakpoint_insert(CPUState *env, target_ulong pc, int flags,
00787 CPUBreakpoint **breakpoint);
00788 int cpu_breakpoint_remove(CPUState *env, target_ulong pc, int flags);
00789 void cpu_breakpoint_remove_by_ref(CPUState *env, CPUBreakpoint *breakpoint);
00790 void cpu_breakpoint_remove_all(CPUState *env, int mask);
00791 int cpu_watchpoint_insert(CPUState *env, target_ulong addr, target_ulong len,
00792 int flags, CPUWatchpoint **watchpoint);
00793 int cpu_watchpoint_remove(CPUState *env, target_ulong addr,
00794 target_ulong len, int flags);
00795 void cpu_watchpoint_remove_by_ref(CPUState *env, CPUWatchpoint *watchpoint);
00796 void cpu_watchpoint_remove_all(CPUState *env, int mask);
00797
00798 #define SSTEP_ENABLE 0x1
00799 #define SSTEP_NOIRQ 0x2
00800 #define SSTEP_NOTIMER 0x4
00801
00802 void cpu_single_step(CPUState *env, int enabled);
00803 void cpu_reset(CPUState *s);
00804
00805
00806
00807
00808 target_phys_addr_t cpu_get_phys_page_debug(CPUState *env, target_ulong addr);
00809
00810 #define CPU_LOG_TB_OUT_ASM (1 << 0)
00811 #define CPU_LOG_TB_IN_ASM (1 << 1)
00812 #define CPU_LOG_TB_OP (1 << 2)
00813 #define CPU_LOG_TB_OP_OPT (1 << 3)
00814 #define CPU_LOG_INT (1 << 4)
00815 #define CPU_LOG_EXEC (1 << 5)
00816 #define CPU_LOG_PCALL (1 << 6)
00817 #define CPU_LOG_IOPORT (1 << 7)
00818 #define CPU_LOG_TB_CPU (1 << 8)
00819 #define CPU_LOG_RESET (1 << 9)
00820
00821
00822 typedef struct CPULogItem {
00823 int mask;
00824 const char *name;
00825 const char *help;
00826 } CPULogItem;
00827
00828 extern const CPULogItem cpu_log_items[];
00829
00830 void cpu_set_log(int log_flags);
00831 void cpu_set_log_filename(const char *filename);
00832 int cpu_str_to_log_mask(const char *str);
00833
00834
00835
00836
00837
00838 #ifndef NO_CPU_IO_DEFS
00839 void cpu_outb(CPUState *env, int addr, int val);
00840 void cpu_outw(CPUState *env, int addr, int val);
00841 void cpu_outl(CPUState *env, int addr, int val);
00842 int cpu_inb(CPUState *env, int addr);
00843 int cpu_inw(CPUState *env, int addr);
00844 int cpu_inl(CPUState *env, int addr);
00845 #endif
00846
00847
00848 #ifdef USE_KQEMU
00849 typedef uint32_t ram_addr_t;
00850 #else
00851 typedef unsigned long ram_addr_t;
00852 #endif
00853
00854
00855
00856 extern ram_addr_t phys_ram_size;
00857 extern int phys_ram_fd;
00858 extern uint8_t *phys_ram_base;
00859 extern uint8_t *phys_ram_dirty;
00860 extern ram_addr_t ram_size;
00861
00862
00863
00864
00865
00866
00867
00868 #define IO_MEM_SHIFT 3
00869 #define IO_MEM_NB_ENTRIES (1 << (TARGET_PAGE_BITS - IO_MEM_SHIFT))
00870
00871 #define IO_MEM_RAM (0 << IO_MEM_SHIFT)
00872 #define IO_MEM_ROM (1 << IO_MEM_SHIFT)
00873 #define IO_MEM_UNASSIGNED (2 << IO_MEM_SHIFT)
00874 #define IO_MEM_NOTDIRTY (3 << IO_MEM_SHIFT)
00875
00876
00877 #define IO_MEM_ROMD (1)
00878 #define IO_MEM_SUBPAGE (2)
00879 #define IO_MEM_SUBWIDTH (4)
00880
00881
00882
00883
00884 #define TLB_INVALID_MASK (1 << 3)
00885
00886
00887 #define TLB_NOTDIRTY (1 << 4)
00888
00889 #define TLB_MMIO (1 << 5)
00890
00891 typedef void CPUWriteMemoryFunc(void *opaque, target_phys_addr_t addr, uint32_t value);
00892 typedef uint32_t CPUReadMemoryFunc(void *opaque, target_phys_addr_t addr);
00893
00894 void cpu_register_physical_memory_offset(target_phys_addr_t start_addr,
00895 ram_addr_t size,
00896 ram_addr_t phys_offset,
00897 ram_addr_t region_offset);
00898 static inline void cpu_register_physical_memory(target_phys_addr_t start_addr,
00899 ram_addr_t size,
00900 ram_addr_t phys_offset)
00901 {
00902 cpu_register_physical_memory_offset(start_addr, size, phys_offset, 0);
00903 }
00904
00905 ram_addr_t cpu_get_physical_page_desc(target_phys_addr_t addr);
00906 ram_addr_t qemu_ram_alloc(ram_addr_t);
00907 void qemu_ram_free(ram_addr_t addr);
00908 int cpu_register_io_memory(int io_index,
00909 CPUReadMemoryFunc **mem_read,
00910 CPUWriteMemoryFunc **mem_write,
00911 void *opaque);
00912 void cpu_unregister_io_memory(int table_address);
00913 CPUWriteMemoryFunc **cpu_get_io_memory_write(int io_index);
00914 CPUReadMemoryFunc **cpu_get_io_memory_read(int io_index);
00915
00916 void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf,
00917 int len, int is_write);
00918 static inline void cpu_physical_memory_read(target_phys_addr_t addr,
00919 uint8_t *buf, int len)
00920 {
00921 cpu_physical_memory_rw(addr, buf, len, 0);
00922 }
00923 static inline void cpu_physical_memory_write(target_phys_addr_t addr,
00924 const uint8_t *buf, int len)
00925 {
00926 cpu_physical_memory_rw(addr, (uint8_t *)buf, len, 1);
00927 }
00928 void *cpu_physical_memory_map(target_phys_addr_t addr,
00929 target_phys_addr_t *plen,
00930 int is_write);
00931 void cpu_physical_memory_unmap(void *buffer, target_phys_addr_t len,
00932 int is_write, target_phys_addr_t access_len);
00933 void *cpu_register_map_client(void *opaque, void (*callback)(void *opaque));
00934 void cpu_unregister_map_client(void *cookie);
00935
00936 uint32_t ldub_phys(target_phys_addr_t addr);
00937 uint32_t lduw_phys(target_phys_addr_t addr);
00938 uint32_t ldl_phys(target_phys_addr_t addr);
00939 uint64_t ldq_phys(target_phys_addr_t addr);
00940 void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val);
00941 void stq_phys_notdirty(target_phys_addr_t addr, uint64_t val);
00942 void stb_phys(target_phys_addr_t addr, uint32_t val);
00943 void stw_phys(target_phys_addr_t addr, uint32_t val);
00944 void stl_phys(target_phys_addr_t addr, uint32_t val);
00945 void stq_phys(target_phys_addr_t addr, uint64_t val);
00946
00947 void cpu_physical_memory_write_rom(target_phys_addr_t addr,
00948 const uint8_t *buf, int len);
00949 int cpu_memory_rw_debug(CPUState *env, target_ulong addr,
00950 uint8_t *buf, int len, int is_write);
00951
00952 #define VGA_DIRTY_FLAG 0x01
00953 #define CODE_DIRTY_FLAG 0x02
00954 #define KQEMU_DIRTY_FLAG 0x04
00955 #define MIGRATION_DIRTY_FLAG 0x08
00956
00957
00958 static inline int cpu_physical_memory_is_dirty(ram_addr_t addr)
00959 {
00960 return phys_ram_dirty[addr >> TARGET_PAGE_BITS] == 0xff;
00961 }
00962
00963 static inline int cpu_physical_memory_get_dirty(ram_addr_t addr,
00964 int dirty_flags)
00965 {
00966 return phys_ram_dirty[addr >> TARGET_PAGE_BITS] & dirty_flags;
00967 }
00968
00969 static inline void cpu_physical_memory_set_dirty(ram_addr_t addr)
00970 {
00971 phys_ram_dirty[addr >> TARGET_PAGE_BITS] = 0xff;
00972 }
00973
00974 void cpu_physical_memory_reset_dirty(ram_addr_t start, ram_addr_t end,
00975 int dirty_flags);
00976 void cpu_tlb_update_dirty(CPUState *env);
00977
00978 int cpu_physical_memory_set_dirty_tracking(int enable);
00979
00980 int cpu_physical_memory_get_dirty_tracking(void);
00981
00982 void cpu_physical_sync_dirty_bitmap(target_phys_addr_t start_addr, target_phys_addr_t end_addr);
00983
00984 void dump_exec_info(FILE *f,
00985 int (*cpu_fprintf)(FILE *f, const char *fmt, ...));
00986
00987
00988
00989
00990
00991
00992 void qemu_register_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size);
00993
00994 void qemu_unregister_coalesced_mmio(target_phys_addr_t addr, ram_addr_t size);
00995
00996
00997
00998
00999 #if defined(_ARCH_PPC)
01000
01001 static inline int64_t cpu_get_real_ticks(void)
01002 {
01003 int64_t retval;
01004 #ifdef _ARCH_PPC64
01005
01006
01007
01008 __asm__ __volatile__ (
01009 "mftb %0\n\t"
01010 "cmpwi %0,0\n\t"
01011 "beq- $-8"
01012 : "=r" (retval));
01013 #else
01014
01015 unsigned long junk;
01016 __asm__ __volatile__ (
01017 "mftbu %1\n\t"
01018 "mftb %L0\n\t"
01019 "mftbu %0\n\t"
01020 "cmpw %0,%1\n\t"
01021 "bne $-16"
01022 : "=r" (retval), "=r" (junk));
01023 #endif
01024 return retval;
01025 }
01026
01027 #elif defined(__i386__)
01028
01029 static inline int64_t cpu_get_real_ticks(void)
01030 {
01031 int64_t val;
01032 asm volatile ("rdtsc" : "=A" (val));
01033 return val;
01034 }
01035
01036 #elif defined(__x86_64__)
01037
01038 static inline int64_t cpu_get_real_ticks(void)
01039 {
01040 uint32_t low,high;
01041 int64_t val;
01042 asm volatile("rdtsc" : "=a" (low), "=d" (high));
01043 val = high;
01044 val <<= 32;
01045 val |= low;
01046 return val;
01047 }
01048
01049 #elif defined(__hppa__)
01050
01051 static inline int64_t cpu_get_real_ticks(void)
01052 {
01053 int val;
01054 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
01055 return val;
01056 }
01057
01058 #elif defined(__ia64)
01059
01060 static inline int64_t cpu_get_real_ticks(void)
01061 {
01062 int64_t val;
01063 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
01064 return val;
01065 }
01066
01067 #elif defined(__s390__)
01068
01069 static inline int64_t cpu_get_real_ticks(void)
01070 {
01071 int64_t val;
01072 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
01073 return val;
01074 }
01075
01076 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
01077
01078 static inline int64_t cpu_get_real_ticks (void)
01079 {
01080 #if defined(_LP64)
01081 uint64_t rval;
01082 asm volatile("rd %%tick,%0" : "=r"(rval));
01083 return rval;
01084 #else
01085 union {
01086 uint64_t i64;
01087 struct {
01088 uint32_t high;
01089 uint32_t low;
01090 } i32;
01091 } rval;
01092 asm volatile("rd %%tick,%1; srlx %1,32,%0"
01093 : "=r"(rval.i32.high), "=r"(rval.i32.low));
01094 return rval.i64;
01095 #endif
01096 }
01097
01098 #elif defined(__mips__)
01099
01100 static inline int64_t cpu_get_real_ticks(void)
01101 {
01102 #if __mips_isa_rev >= 2
01103 uint32_t count;
01104 static uint32_t cyc_per_count = 0;
01105
01106 if (!cyc_per_count)
01107 __asm__ __volatile__("rdhwr %0, $3" : "=r" (cyc_per_count));
01108
01109 __asm__ __volatile__("rdhwr %1, $2" : "=r" (count));
01110 return (int64_t)(count * cyc_per_count);
01111 #else
01112
01113 static int64_t ticks = 0;
01114 return ticks++;
01115 #endif
01116 }
01117
01118 #else
01119
01120
01121
01122 static inline int64_t cpu_get_real_ticks (void)
01123 {
01124 static int64_t ticks = 0;
01125 return ticks++;
01126 }
01127 #endif
01128
01129
01130 #ifdef CONFIG_PROFILER
01131 static inline int64_t profile_getclock(void)
01132 {
01133 return cpu_get_real_ticks();
01134 }
01135
01136 extern int64_t kqemu_time, kqemu_time_start;
01137 extern int64_t qemu_time, qemu_time_start;
01138 extern int64_t tlb_flush_time;
01139 extern int64_t kqemu_exec_count;
01140 extern int64_t dev_time;
01141 extern int64_t kqemu_ret_int_count;
01142 extern int64_t kqemu_ret_excp_count;
01143 extern int64_t kqemu_ret_intr_count;
01144 #endif
01145
01146 #endif