]>
Commit | Line | Data |
---|---|---|
5a9fdfec FB |
1 | /* |
2 | * defines common to all virtual CPUs | |
3 | * | |
4 | * Copyright (c) 2003 Fabrice Bellard | |
5 | * | |
6 | * This library is free software; you can redistribute it and/or | |
7 | * modify it under the terms of the GNU Lesser General Public | |
8 | * License as published by the Free Software Foundation; either | |
9 | * version 2 of the License, or (at your option) any later version. | |
10 | * | |
11 | * This library is distributed in the hope that it will be useful, | |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 | * Lesser General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU Lesser General Public | |
17 | * License along with this library; if not, write to the Free Software | |
18 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
19 | */ | |
20 | #ifndef CPU_ALL_H | |
21 | #define CPU_ALL_H | |
22 | ||
0ac4bd56 FB |
23 | #if defined(__arm__) || defined(__sparc__) |
24 | #define WORDS_ALIGNED | |
25 | #endif | |
26 | ||
27 | /* some important defines: | |
28 | * | |
29 | * WORDS_ALIGNED : if defined, the host cpu can only make word aligned | |
30 | * memory accesses. | |
31 | * | |
32 | * WORDS_BIGENDIAN : if defined, the host cpu is big endian and | |
33 | * otherwise little endian. | |
34 | * | |
35 | * (TARGET_WORDS_ALIGNED : same for target cpu (not supported yet)) | |
36 | * | |
37 | * TARGET_WORDS_BIGENDIAN : same for target cpu | |
38 | */ | |
39 | ||
f193c797 FB |
40 | #include "bswap.h" |
41 | ||
42 | #if defined(WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN) | |
43 | #define BSWAP_NEEDED | |
44 | #endif | |
45 | ||
46 | #ifdef BSWAP_NEEDED | |
47 | ||
48 | static inline uint16_t tswap16(uint16_t s) | |
49 | { | |
50 | return bswap16(s); | |
51 | } | |
52 | ||
53 | static inline uint32_t tswap32(uint32_t s) | |
54 | { | |
55 | return bswap32(s); | |
56 | } | |
57 | ||
58 | static inline uint64_t tswap64(uint64_t s) | |
59 | { | |
60 | return bswap64(s); | |
61 | } | |
62 | ||
63 | static inline void tswap16s(uint16_t *s) | |
64 | { | |
65 | *s = bswap16(*s); | |
66 | } | |
67 | ||
68 | static inline void tswap32s(uint32_t *s) | |
69 | { | |
70 | *s = bswap32(*s); | |
71 | } | |
72 | ||
73 | static inline void tswap64s(uint64_t *s) | |
74 | { | |
75 | *s = bswap64(*s); | |
76 | } | |
77 | ||
78 | #else | |
79 | ||
80 | static inline uint16_t tswap16(uint16_t s) | |
81 | { | |
82 | return s; | |
83 | } | |
84 | ||
85 | static inline uint32_t tswap32(uint32_t s) | |
86 | { | |
87 | return s; | |
88 | } | |
89 | ||
90 | static inline uint64_t tswap64(uint64_t s) | |
91 | { | |
92 | return s; | |
93 | } | |
94 | ||
95 | static inline void tswap16s(uint16_t *s) | |
96 | { | |
97 | } | |
98 | ||
99 | static inline void tswap32s(uint32_t *s) | |
100 | { | |
101 | } | |
102 | ||
103 | static inline void tswap64s(uint64_t *s) | |
104 | { | |
105 | } | |
106 | ||
107 | #endif | |
108 | ||
109 | #if TARGET_LONG_SIZE == 4 | |
110 | #define tswapl(s) tswap32(s) | |
111 | #define tswapls(s) tswap32s((uint32_t *)(s)) | |
0a962c02 | 112 | #define bswaptls(s) bswap32s(s) |
f193c797 FB |
113 | #else |
114 | #define tswapl(s) tswap64(s) | |
115 | #define tswapls(s) tswap64s((uint64_t *)(s)) | |
0a962c02 | 116 | #define bswaptls(s) bswap64s(s) |
f193c797 FB |
117 | #endif |
118 | ||
832ed0fa FB |
119 | /* NOTE: arm FPA is horrible as double 32 bit words are stored in big |
120 | endian ! */ | |
0ac4bd56 FB |
121 | typedef union { |
122 | double d; | |
832ed0fa | 123 | #if defined(WORDS_BIGENDIAN) || (defined(__arm__) && !defined(__VFP_FP__)) |
0ac4bd56 | 124 | struct { |
0ac4bd56 | 125 | uint32_t upper; |
832ed0fa | 126 | uint32_t lower; |
0ac4bd56 FB |
127 | } l; |
128 | #else | |
129 | struct { | |
0ac4bd56 | 130 | uint32_t lower; |
832ed0fa | 131 | uint32_t upper; |
0ac4bd56 FB |
132 | } l; |
133 | #endif | |
134 | uint64_t ll; | |
135 | } CPU_DoubleU; | |
136 | ||
61382a50 FB |
137 | /* CPU memory access without any memory or io remapping */ |
138 | ||
83d73968 FB |
139 | /* |
140 | * the generic syntax for the memory accesses is: | |
141 | * | |
142 | * load: ld{type}{sign}{size}{endian}_{access_type}(ptr) | |
143 | * | |
144 | * store: st{type}{size}{endian}_{access_type}(ptr, val) | |
145 | * | |
146 | * type is: | |
147 | * (empty): integer access | |
148 | * f : float access | |
149 | * | |
150 | * sign is: | |
151 | * (empty): for floats or 32 bit size | |
152 | * u : unsigned | |
153 | * s : signed | |
154 | * | |
155 | * size is: | |
156 | * b: 8 bits | |
157 | * w: 16 bits | |
158 | * l: 32 bits | |
159 | * q: 64 bits | |
160 | * | |
161 | * endian is: | |
162 | * (empty): target cpu endianness or 8 bit access | |
163 | * r : reversed target cpu endianness (not implemented yet) | |
164 | * be : big endian (not implemented yet) | |
165 | * le : little endian (not implemented yet) | |
166 | * | |
167 | * access_type is: | |
168 | * raw : host memory access | |
169 | * user : user mode access using soft MMU | |
170 | * kernel : kernel mode access using soft MMU | |
171 | */ | |
c27004ec | 172 | static inline int ldub_p(void *ptr) |
5a9fdfec FB |
173 | { |
174 | return *(uint8_t *)ptr; | |
175 | } | |
176 | ||
c27004ec | 177 | static inline int ldsb_p(void *ptr) |
5a9fdfec FB |
178 | { |
179 | return *(int8_t *)ptr; | |
180 | } | |
181 | ||
c27004ec | 182 | static inline void stb_p(void *ptr, int v) |
5a9fdfec FB |
183 | { |
184 | *(uint8_t *)ptr = v; | |
185 | } | |
186 | ||
187 | /* NOTE: on arm, putting 2 in /proc/sys/debug/alignment so that the | |
188 | kernel handles unaligned load/stores may give better results, but | |
189 | it is a system wide setting : bad */ | |
0ac4bd56 | 190 | #if !defined(TARGET_WORDS_BIGENDIAN) && (defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)) |
5a9fdfec FB |
191 | |
192 | /* conservative code for little endian unaligned accesses */ | |
c27004ec | 193 | static inline int lduw_p(void *ptr) |
5a9fdfec FB |
194 | { |
195 | #ifdef __powerpc__ | |
196 | int val; | |
197 | __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr)); | |
198 | return val; | |
199 | #else | |
200 | uint8_t *p = ptr; | |
201 | return p[0] | (p[1] << 8); | |
202 | #endif | |
203 | } | |
204 | ||
c27004ec | 205 | static inline int ldsw_p(void *ptr) |
5a9fdfec FB |
206 | { |
207 | #ifdef __powerpc__ | |
208 | int val; | |
209 | __asm__ __volatile__ ("lhbrx %0,0,%1" : "=r" (val) : "r" (ptr)); | |
210 | return (int16_t)val; | |
211 | #else | |
212 | uint8_t *p = ptr; | |
213 | return (int16_t)(p[0] | (p[1] << 8)); | |
214 | #endif | |
215 | } | |
216 | ||
c27004ec | 217 | static inline int ldl_p(void *ptr) |
5a9fdfec FB |
218 | { |
219 | #ifdef __powerpc__ | |
220 | int val; | |
221 | __asm__ __volatile__ ("lwbrx %0,0,%1" : "=r" (val) : "r" (ptr)); | |
222 | return val; | |
223 | #else | |
224 | uint8_t *p = ptr; | |
225 | return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); | |
226 | #endif | |
227 | } | |
228 | ||
c27004ec | 229 | static inline uint64_t ldq_p(void *ptr) |
5a9fdfec FB |
230 | { |
231 | uint8_t *p = ptr; | |
232 | uint32_t v1, v2; | |
c27004ec FB |
233 | v1 = ldl_p(p); |
234 | v2 = ldl_p(p + 4); | |
5a9fdfec FB |
235 | return v1 | ((uint64_t)v2 << 32); |
236 | } | |
237 | ||
c27004ec | 238 | static inline void stw_p(void *ptr, int v) |
5a9fdfec FB |
239 | { |
240 | #ifdef __powerpc__ | |
241 | __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*(uint16_t *)ptr) : "r" (v), "r" (ptr)); | |
242 | #else | |
243 | uint8_t *p = ptr; | |
244 | p[0] = v; | |
245 | p[1] = v >> 8; | |
246 | #endif | |
247 | } | |
248 | ||
c27004ec | 249 | static inline void stl_p(void *ptr, int v) |
5a9fdfec FB |
250 | { |
251 | #ifdef __powerpc__ | |
252 | __asm__ __volatile__ ("stwbrx %1,0,%2" : "=m" (*(uint32_t *)ptr) : "r" (v), "r" (ptr)); | |
253 | #else | |
254 | uint8_t *p = ptr; | |
255 | p[0] = v; | |
256 | p[1] = v >> 8; | |
257 | p[2] = v >> 16; | |
258 | p[3] = v >> 24; | |
259 | #endif | |
260 | } | |
261 | ||
c27004ec | 262 | static inline void stq_p(void *ptr, uint64_t v) |
5a9fdfec FB |
263 | { |
264 | uint8_t *p = ptr; | |
c27004ec FB |
265 | stl_p(p, (uint32_t)v); |
266 | stl_p(p + 4, v >> 32); | |
5a9fdfec FB |
267 | } |
268 | ||
269 | /* float access */ | |
270 | ||
c27004ec | 271 | static inline float ldfl_p(void *ptr) |
5a9fdfec FB |
272 | { |
273 | union { | |
274 | float f; | |
275 | uint32_t i; | |
276 | } u; | |
c27004ec | 277 | u.i = ldl_p(ptr); |
5a9fdfec FB |
278 | return u.f; |
279 | } | |
280 | ||
c27004ec | 281 | static inline void stfl_p(void *ptr, float v) |
5a9fdfec FB |
282 | { |
283 | union { | |
284 | float f; | |
285 | uint32_t i; | |
286 | } u; | |
287 | u.f = v; | |
c27004ec | 288 | stl_p(ptr, u.i); |
5a9fdfec FB |
289 | } |
290 | ||
c27004ec | 291 | static inline double ldfq_p(void *ptr) |
5a9fdfec | 292 | { |
0ac4bd56 | 293 | CPU_DoubleU u; |
c27004ec FB |
294 | u.l.lower = ldl_p(ptr); |
295 | u.l.upper = ldl_p(ptr + 4); | |
5a9fdfec FB |
296 | return u.d; |
297 | } | |
298 | ||
c27004ec | 299 | static inline void stfq_p(void *ptr, double v) |
5a9fdfec | 300 | { |
0ac4bd56 | 301 | CPU_DoubleU u; |
5a9fdfec | 302 | u.d = v; |
c27004ec FB |
303 | stl_p(ptr, u.l.lower); |
304 | stl_p(ptr + 4, u.l.upper); | |
5a9fdfec FB |
305 | } |
306 | ||
0ac4bd56 | 307 | #elif defined(TARGET_WORDS_BIGENDIAN) && (!defined(WORDS_BIGENDIAN) || defined(WORDS_ALIGNED)) |
93ac68bc | 308 | |
c27004ec | 309 | static inline int lduw_p(void *ptr) |
93ac68bc | 310 | { |
83d73968 FB |
311 | #if defined(__i386__) |
312 | int val; | |
313 | asm volatile ("movzwl %1, %0\n" | |
314 | "xchgb %b0, %h0\n" | |
315 | : "=q" (val) | |
316 | : "m" (*(uint16_t *)ptr)); | |
317 | return val; | |
318 | #else | |
93ac68bc | 319 | uint8_t *b = (uint8_t *) ptr; |
83d73968 FB |
320 | return ((b[0] << 8) | b[1]); |
321 | #endif | |
93ac68bc FB |
322 | } |
323 | ||
c27004ec | 324 | static inline int ldsw_p(void *ptr) |
93ac68bc | 325 | { |
83d73968 FB |
326 | #if defined(__i386__) |
327 | int val; | |
328 | asm volatile ("movzwl %1, %0\n" | |
329 | "xchgb %b0, %h0\n" | |
330 | : "=q" (val) | |
331 | : "m" (*(uint16_t *)ptr)); | |
332 | return (int16_t)val; | |
333 | #else | |
334 | uint8_t *b = (uint8_t *) ptr; | |
335 | return (int16_t)((b[0] << 8) | b[1]); | |
336 | #endif | |
93ac68bc FB |
337 | } |
338 | ||
c27004ec | 339 | static inline int ldl_p(void *ptr) |
93ac68bc | 340 | { |
4f2ac237 | 341 | #if defined(__i386__) || defined(__x86_64__) |
83d73968 FB |
342 | int val; |
343 | asm volatile ("movl %1, %0\n" | |
344 | "bswap %0\n" | |
345 | : "=r" (val) | |
346 | : "m" (*(uint32_t *)ptr)); | |
347 | return val; | |
348 | #else | |
93ac68bc | 349 | uint8_t *b = (uint8_t *) ptr; |
83d73968 FB |
350 | return (b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]; |
351 | #endif | |
93ac68bc FB |
352 | } |
353 | ||
c27004ec | 354 | static inline uint64_t ldq_p(void *ptr) |
93ac68bc FB |
355 | { |
356 | uint32_t a,b; | |
c27004ec FB |
357 | a = ldl_p(ptr); |
358 | b = ldl_p(ptr+4); | |
93ac68bc FB |
359 | return (((uint64_t)a<<32)|b); |
360 | } | |
361 | ||
c27004ec | 362 | static inline void stw_p(void *ptr, int v) |
93ac68bc | 363 | { |
83d73968 FB |
364 | #if defined(__i386__) |
365 | asm volatile ("xchgb %b0, %h0\n" | |
366 | "movw %w0, %1\n" | |
367 | : "=q" (v) | |
368 | : "m" (*(uint16_t *)ptr), "0" (v)); | |
369 | #else | |
93ac68bc FB |
370 | uint8_t *d = (uint8_t *) ptr; |
371 | d[0] = v >> 8; | |
372 | d[1] = v; | |
83d73968 | 373 | #endif |
93ac68bc FB |
374 | } |
375 | ||
c27004ec | 376 | static inline void stl_p(void *ptr, int v) |
93ac68bc | 377 | { |
4f2ac237 | 378 | #if defined(__i386__) || defined(__x86_64__) |
83d73968 FB |
379 | asm volatile ("bswap %0\n" |
380 | "movl %0, %1\n" | |
381 | : "=r" (v) | |
382 | : "m" (*(uint32_t *)ptr), "0" (v)); | |
383 | #else | |
93ac68bc FB |
384 | uint8_t *d = (uint8_t *) ptr; |
385 | d[0] = v >> 24; | |
386 | d[1] = v >> 16; | |
387 | d[2] = v >> 8; | |
388 | d[3] = v; | |
83d73968 | 389 | #endif |
93ac68bc FB |
390 | } |
391 | ||
c27004ec | 392 | static inline void stq_p(void *ptr, uint64_t v) |
93ac68bc | 393 | { |
c27004ec FB |
394 | stl_p(ptr, v >> 32); |
395 | stl_p(ptr + 4, v); | |
0ac4bd56 FB |
396 | } |
397 | ||
398 | /* float access */ | |
399 | ||
c27004ec | 400 | static inline float ldfl_p(void *ptr) |
0ac4bd56 FB |
401 | { |
402 | union { | |
403 | float f; | |
404 | uint32_t i; | |
405 | } u; | |
c27004ec | 406 | u.i = ldl_p(ptr); |
0ac4bd56 FB |
407 | return u.f; |
408 | } | |
409 | ||
c27004ec | 410 | static inline void stfl_p(void *ptr, float v) |
0ac4bd56 FB |
411 | { |
412 | union { | |
413 | float f; | |
414 | uint32_t i; | |
415 | } u; | |
416 | u.f = v; | |
c27004ec | 417 | stl_p(ptr, u.i); |
0ac4bd56 FB |
418 | } |
419 | ||
c27004ec | 420 | static inline double ldfq_p(void *ptr) |
0ac4bd56 FB |
421 | { |
422 | CPU_DoubleU u; | |
c27004ec FB |
423 | u.l.upper = ldl_p(ptr); |
424 | u.l.lower = ldl_p(ptr + 4); | |
0ac4bd56 FB |
425 | return u.d; |
426 | } | |
427 | ||
c27004ec | 428 | static inline void stfq_p(void *ptr, double v) |
0ac4bd56 FB |
429 | { |
430 | CPU_DoubleU u; | |
431 | u.d = v; | |
c27004ec FB |
432 | stl_p(ptr, u.l.upper); |
433 | stl_p(ptr + 4, u.l.lower); | |
93ac68bc FB |
434 | } |
435 | ||
5a9fdfec FB |
436 | #else |
437 | ||
c27004ec | 438 | static inline int lduw_p(void *ptr) |
5a9fdfec FB |
439 | { |
440 | return *(uint16_t *)ptr; | |
441 | } | |
442 | ||
c27004ec | 443 | static inline int ldsw_p(void *ptr) |
5a9fdfec FB |
444 | { |
445 | return *(int16_t *)ptr; | |
446 | } | |
447 | ||
c27004ec | 448 | static inline int ldl_p(void *ptr) |
5a9fdfec FB |
449 | { |
450 | return *(uint32_t *)ptr; | |
451 | } | |
452 | ||
c27004ec | 453 | static inline uint64_t ldq_p(void *ptr) |
5a9fdfec FB |
454 | { |
455 | return *(uint64_t *)ptr; | |
456 | } | |
457 | ||
c27004ec | 458 | static inline void stw_p(void *ptr, int v) |
5a9fdfec FB |
459 | { |
460 | *(uint16_t *)ptr = v; | |
461 | } | |
462 | ||
c27004ec | 463 | static inline void stl_p(void *ptr, int v) |
5a9fdfec FB |
464 | { |
465 | *(uint32_t *)ptr = v; | |
466 | } | |
467 | ||
c27004ec | 468 | static inline void stq_p(void *ptr, uint64_t v) |
5a9fdfec FB |
469 | { |
470 | *(uint64_t *)ptr = v; | |
471 | } | |
472 | ||
473 | /* float access */ | |
474 | ||
c27004ec | 475 | static inline float ldfl_p(void *ptr) |
5a9fdfec FB |
476 | { |
477 | return *(float *)ptr; | |
478 | } | |
479 | ||
c27004ec | 480 | static inline double ldfq_p(void *ptr) |
5a9fdfec FB |
481 | { |
482 | return *(double *)ptr; | |
483 | } | |
484 | ||
c27004ec | 485 | static inline void stfl_p(void *ptr, float v) |
5a9fdfec FB |
486 | { |
487 | *(float *)ptr = v; | |
488 | } | |
489 | ||
c27004ec | 490 | static inline void stfq_p(void *ptr, double v) |
5a9fdfec FB |
491 | { |
492 | *(double *)ptr = v; | |
493 | } | |
494 | #endif | |
495 | ||
61382a50 FB |
496 | /* MMU memory access macros */ |
497 | ||
c27004ec FB |
498 | /* NOTE: we use double casts if pointers and target_ulong have |
499 | different sizes */ | |
500 | #define ldub_raw(p) ldub_p((uint8_t *)(long)(p)) | |
501 | #define ldsb_raw(p) ldsb_p((uint8_t *)(long)(p)) | |
502 | #define lduw_raw(p) lduw_p((uint8_t *)(long)(p)) | |
503 | #define ldsw_raw(p) ldsw_p((uint8_t *)(long)(p)) | |
504 | #define ldl_raw(p) ldl_p((uint8_t *)(long)(p)) | |
505 | #define ldq_raw(p) ldq_p((uint8_t *)(long)(p)) | |
506 | #define ldfl_raw(p) ldfl_p((uint8_t *)(long)(p)) | |
507 | #define ldfq_raw(p) ldfq_p((uint8_t *)(long)(p)) | |
508 | #define stb_raw(p, v) stb_p((uint8_t *)(long)(p), v) | |
509 | #define stw_raw(p, v) stw_p((uint8_t *)(long)(p), v) | |
510 | #define stl_raw(p, v) stl_p((uint8_t *)(long)(p), v) | |
511 | #define stq_raw(p, v) stq_p((uint8_t *)(long)(p), v) | |
512 | #define stfl_raw(p, v) stfl_p((uint8_t *)(long)(p), v) | |
513 | #define stfq_raw(p, v) stfq_p((uint8_t *)(long)(p), v) | |
514 | ||
515 | ||
61382a50 FB |
516 | #if defined(CONFIG_USER_ONLY) |
517 | ||
518 | /* if user mode, no other memory access functions */ | |
519 | #define ldub(p) ldub_raw(p) | |
520 | #define ldsb(p) ldsb_raw(p) | |
521 | #define lduw(p) lduw_raw(p) | |
522 | #define ldsw(p) ldsw_raw(p) | |
523 | #define ldl(p) ldl_raw(p) | |
524 | #define ldq(p) ldq_raw(p) | |
525 | #define ldfl(p) ldfl_raw(p) | |
526 | #define ldfq(p) ldfq_raw(p) | |
527 | #define stb(p, v) stb_raw(p, v) | |
528 | #define stw(p, v) stw_raw(p, v) | |
529 | #define stl(p, v) stl_raw(p, v) | |
530 | #define stq(p, v) stq_raw(p, v) | |
531 | #define stfl(p, v) stfl_raw(p, v) | |
532 | #define stfq(p, v) stfq_raw(p, v) | |
533 | ||
534 | #define ldub_code(p) ldub_raw(p) | |
535 | #define ldsb_code(p) ldsb_raw(p) | |
536 | #define lduw_code(p) lduw_raw(p) | |
537 | #define ldsw_code(p) ldsw_raw(p) | |
538 | #define ldl_code(p) ldl_raw(p) | |
539 | ||
540 | #define ldub_kernel(p) ldub_raw(p) | |
541 | #define ldsb_kernel(p) ldsb_raw(p) | |
542 | #define lduw_kernel(p) lduw_raw(p) | |
543 | #define ldsw_kernel(p) ldsw_raw(p) | |
544 | #define ldl_kernel(p) ldl_raw(p) | |
0ac4bd56 FB |
545 | #define ldfl_kernel(p) ldfl_raw(p) |
546 | #define ldfq_kernel(p) ldfq_raw(p) | |
61382a50 FB |
547 | #define stb_kernel(p, v) stb_raw(p, v) |
548 | #define stw_kernel(p, v) stw_raw(p, v) | |
549 | #define stl_kernel(p, v) stl_raw(p, v) | |
550 | #define stq_kernel(p, v) stq_raw(p, v) | |
0ac4bd56 FB |
551 | #define stfl_kernel(p, v) stfl_raw(p, v) |
552 | #define stfq_kernel(p, vt) stfq_raw(p, v) | |
61382a50 FB |
553 | |
554 | #endif /* defined(CONFIG_USER_ONLY) */ | |
555 | ||
5a9fdfec FB |
556 | /* page related stuff */ |
557 | ||
558 | #define TARGET_PAGE_SIZE (1 << TARGET_PAGE_BITS) | |
559 | #define TARGET_PAGE_MASK ~(TARGET_PAGE_SIZE - 1) | |
560 | #define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK) | |
561 | ||
83fb7adf FB |
562 | extern unsigned long qemu_real_host_page_size; |
563 | extern unsigned long qemu_host_page_bits; | |
564 | extern unsigned long qemu_host_page_size; | |
565 | extern unsigned long qemu_host_page_mask; | |
5a9fdfec | 566 | |
83fb7adf | 567 | #define HOST_PAGE_ALIGN(addr) (((addr) + qemu_host_page_size - 1) & qemu_host_page_mask) |
5a9fdfec FB |
568 | |
569 | /* same as PROT_xxx */ | |
570 | #define PAGE_READ 0x0001 | |
571 | #define PAGE_WRITE 0x0002 | |
572 | #define PAGE_EXEC 0x0004 | |
573 | #define PAGE_BITS (PAGE_READ | PAGE_WRITE | PAGE_EXEC) | |
574 | #define PAGE_VALID 0x0008 | |
575 | /* original state of the write flag (used when tracking self-modifying | |
576 | code */ | |
577 | #define PAGE_WRITE_ORG 0x0010 | |
578 | ||
579 | void page_dump(FILE *f); | |
580 | int page_get_flags(unsigned long address); | |
581 | void page_set_flags(unsigned long start, unsigned long end, int flags); | |
582 | void page_unprotect_range(uint8_t *data, unsigned long data_size); | |
583 | ||
584 | #define SINGLE_CPU_DEFINES | |
585 | #ifdef SINGLE_CPU_DEFINES | |
586 | ||
587 | #if defined(TARGET_I386) | |
588 | ||
589 | #define CPUState CPUX86State | |
590 | #define cpu_init cpu_x86_init | |
591 | #define cpu_exec cpu_x86_exec | |
592 | #define cpu_gen_code cpu_x86_gen_code | |
5a9fdfec FB |
593 | #define cpu_signal_handler cpu_x86_signal_handler |
594 | ||
595 | #elif defined(TARGET_ARM) | |
596 | ||
597 | #define CPUState CPUARMState | |
598 | #define cpu_init cpu_arm_init | |
599 | #define cpu_exec cpu_arm_exec | |
600 | #define cpu_gen_code cpu_arm_gen_code | |
5a9fdfec FB |
601 | #define cpu_signal_handler cpu_arm_signal_handler |
602 | ||
93ac68bc FB |
603 | #elif defined(TARGET_SPARC) |
604 | ||
605 | #define CPUState CPUSPARCState | |
606 | #define cpu_init cpu_sparc_init | |
607 | #define cpu_exec cpu_sparc_exec | |
608 | #define cpu_gen_code cpu_sparc_gen_code | |
93ac68bc FB |
609 | #define cpu_signal_handler cpu_sparc_signal_handler |
610 | ||
67867308 FB |
611 | #elif defined(TARGET_PPC) |
612 | ||
613 | #define CPUState CPUPPCState | |
614 | #define cpu_init cpu_ppc_init | |
615 | #define cpu_exec cpu_ppc_exec | |
616 | #define cpu_gen_code cpu_ppc_gen_code | |
67867308 FB |
617 | #define cpu_signal_handler cpu_ppc_signal_handler |
618 | ||
5a9fdfec FB |
619 | #else |
620 | ||
621 | #error unsupported target CPU | |
622 | ||
623 | #endif | |
624 | ||
972ddf78 FB |
625 | #endif /* SINGLE_CPU_DEFINES */ |
626 | ||
7fe48483 FB |
627 | void cpu_dump_state(CPUState *env, FILE *f, |
628 | int (*cpu_fprintf)(FILE *f, const char *fmt, ...), | |
629 | int flags); | |
630 | ||
972ddf78 | 631 | void cpu_abort(CPUState *env, const char *fmt, ...); |
e2f22898 | 632 | extern CPUState *cpu_single_env; |
9acbed06 | 633 | extern int code_copy_enabled; |
5a9fdfec | 634 | |
9acbed06 FB |
635 | #define CPU_INTERRUPT_EXIT 0x01 /* wants exit from main loop */ |
636 | #define CPU_INTERRUPT_HARD 0x02 /* hardware interrupt pending */ | |
637 | #define CPU_INTERRUPT_EXITTB 0x04 /* exit the current TB (use for x86 a20 case) */ | |
ef792f9d | 638 | #define CPU_INTERRUPT_TIMER 0x08 /* internal timer exception pending */ |
4690764b | 639 | void cpu_interrupt(CPUState *s, int mask); |
b54ad049 | 640 | void cpu_reset_interrupt(CPUState *env, int mask); |
68a79315 | 641 | |
2e12669a FB |
642 | int cpu_breakpoint_insert(CPUState *env, target_ulong pc); |
643 | int cpu_breakpoint_remove(CPUState *env, target_ulong pc); | |
c33a346e | 644 | void cpu_single_step(CPUState *env, int enabled); |
d95dc32d | 645 | void cpu_reset(CPUState *s); |
4c3a88a2 | 646 | |
13eb76e0 FB |
647 | /* Return the physical page corresponding to a virtual one. Use it |
648 | only for debugging because no protection checks are done. Return -1 | |
649 | if no page found. */ | |
650 | target_ulong cpu_get_phys_page_debug(CPUState *env, target_ulong addr); | |
651 | ||
9fddaa0c FB |
652 | #define CPU_LOG_TB_OUT_ASM (1 << 0) |
653 | #define CPU_LOG_TB_IN_ASM (1 << 1) | |
f193c797 FB |
654 | #define CPU_LOG_TB_OP (1 << 2) |
655 | #define CPU_LOG_TB_OP_OPT (1 << 3) | |
656 | #define CPU_LOG_INT (1 << 4) | |
657 | #define CPU_LOG_EXEC (1 << 5) | |
658 | #define CPU_LOG_PCALL (1 << 6) | |
fd872598 | 659 | #define CPU_LOG_IOPORT (1 << 7) |
9fddaa0c | 660 | #define CPU_LOG_TB_CPU (1 << 8) |
f193c797 FB |
661 | |
662 | /* define log items */ | |
663 | typedef struct CPULogItem { | |
664 | int mask; | |
665 | const char *name; | |
666 | const char *help; | |
667 | } CPULogItem; | |
668 | ||
669 | extern CPULogItem cpu_log_items[]; | |
670 | ||
34865134 FB |
671 | void cpu_set_log(int log_flags); |
672 | void cpu_set_log_filename(const char *filename); | |
f193c797 | 673 | int cpu_str_to_log_mask(const char *str); |
34865134 | 674 | |
09683d35 FB |
675 | /* IO ports API */ |
676 | ||
677 | /* NOTE: as these functions may be even used when there is an isa | |
678 | brige on non x86 targets, we always defined them */ | |
679 | #ifndef NO_CPU_IO_DEFS | |
680 | void cpu_outb(CPUState *env, int addr, int val); | |
681 | void cpu_outw(CPUState *env, int addr, int val); | |
682 | void cpu_outl(CPUState *env, int addr, int val); | |
683 | int cpu_inb(CPUState *env, int addr); | |
684 | int cpu_inw(CPUState *env, int addr); | |
685 | int cpu_inl(CPUState *env, int addr); | |
686 | #endif | |
687 | ||
33417e70 FB |
688 | /* memory API */ |
689 | ||
edf75d59 FB |
690 | extern int phys_ram_size; |
691 | extern int phys_ram_fd; | |
692 | extern uint8_t *phys_ram_base; | |
1ccde1cb | 693 | extern uint8_t *phys_ram_dirty; |
edf75d59 FB |
694 | |
695 | /* physical memory access */ | |
696 | #define IO_MEM_NB_ENTRIES 256 | |
697 | #define TLB_INVALID_MASK (1 << 3) | |
698 | #define IO_MEM_SHIFT 4 | |
699 | ||
700 | #define IO_MEM_RAM (0 << IO_MEM_SHIFT) /* hardcoded offset */ | |
701 | #define IO_MEM_ROM (1 << IO_MEM_SHIFT) /* hardcoded offset */ | |
702 | #define IO_MEM_UNASSIGNED (2 << IO_MEM_SHIFT) | |
1ccde1cb FB |
703 | #define IO_MEM_CODE (3 << IO_MEM_SHIFT) /* used internally, never use directly */ |
704 | #define IO_MEM_NOTDIRTY (4 << IO_MEM_SHIFT) /* used internally, never use directly */ | |
edf75d59 | 705 | |
7727994d FB |
706 | typedef void CPUWriteMemoryFunc(void *opaque, target_phys_addr_t addr, uint32_t value); |
707 | typedef uint32_t CPUReadMemoryFunc(void *opaque, target_phys_addr_t addr); | |
33417e70 | 708 | |
2e12669a FB |
709 | void cpu_register_physical_memory(target_phys_addr_t start_addr, |
710 | unsigned long size, | |
711 | unsigned long phys_offset); | |
33417e70 FB |
712 | int cpu_register_io_memory(int io_index, |
713 | CPUReadMemoryFunc **mem_read, | |
7727994d FB |
714 | CPUWriteMemoryFunc **mem_write, |
715 | void *opaque); | |
8926b517 FB |
716 | CPUWriteMemoryFunc **cpu_get_io_memory_write(int io_index); |
717 | CPUReadMemoryFunc **cpu_get_io_memory_read(int io_index); | |
33417e70 | 718 | |
2e12669a | 719 | void cpu_physical_memory_rw(target_phys_addr_t addr, uint8_t *buf, |
13eb76e0 | 720 | int len, int is_write); |
2e12669a FB |
721 | static inline void cpu_physical_memory_read(target_phys_addr_t addr, |
722 | uint8_t *buf, int len) | |
8b1f24b0 FB |
723 | { |
724 | cpu_physical_memory_rw(addr, buf, len, 0); | |
725 | } | |
2e12669a FB |
726 | static inline void cpu_physical_memory_write(target_phys_addr_t addr, |
727 | const uint8_t *buf, int len) | |
8b1f24b0 FB |
728 | { |
729 | cpu_physical_memory_rw(addr, (uint8_t *)buf, len, 1); | |
730 | } | |
8df1cd07 FB |
731 | uint32_t ldl_phys(target_phys_addr_t addr); |
732 | void stl_phys_notdirty(target_phys_addr_t addr, uint32_t val); | |
733 | void stl_phys(target_phys_addr_t addr, uint32_t val); | |
8b1f24b0 FB |
734 | |
735 | int cpu_memory_rw_debug(CPUState *env, target_ulong addr, | |
736 | uint8_t *buf, int len, int is_write); | |
13eb76e0 | 737 | |
0a962c02 FB |
738 | #define VGA_DIRTY_FLAG 0x01 |
739 | ||
1ccde1cb FB |
740 | /* read dirty bit (return 0 or 1) */ |
741 | static inline int cpu_physical_memory_is_dirty(target_ulong addr) | |
742 | { | |
0a962c02 FB |
743 | return phys_ram_dirty[addr >> TARGET_PAGE_BITS] == 0xff; |
744 | } | |
745 | ||
746 | static inline int cpu_physical_memory_get_dirty(target_ulong addr, | |
747 | int dirty_flags) | |
748 | { | |
749 | return phys_ram_dirty[addr >> TARGET_PAGE_BITS] & dirty_flags; | |
1ccde1cb FB |
750 | } |
751 | ||
752 | static inline void cpu_physical_memory_set_dirty(target_ulong addr) | |
753 | { | |
0a962c02 | 754 | phys_ram_dirty[addr >> TARGET_PAGE_BITS] = 0xff; |
1ccde1cb FB |
755 | } |
756 | ||
0a962c02 FB |
757 | void cpu_physical_memory_reset_dirty(target_ulong start, target_ulong end, |
758 | int dirty_flags); | |
1ccde1cb | 759 | |
e3db7226 FB |
760 | void dump_exec_info(FILE *f, |
761 | int (*cpu_fprintf)(FILE *f, const char *fmt, ...)); | |
762 | ||
5a9fdfec | 763 | #endif /* CPU_ALL_H */ |