Annotation of qemu/cpu-all.h, revision 1.1.1.15

1.1       root        1: /*
                      2:  * defines common to all virtual CPUs
1.1.1.6   root        3:  *
1.1       root        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
1.1.1.8   root       17:  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
1.1       root       18:  */
                     19: #ifndef CPU_ALL_H
                     20: #define CPU_ALL_H
                     21: 
1.1.1.7   root       22: #include "qemu-common.h"
1.1.1.14  root       23: #include "qemu-tls.h"
1.1.1.8   root       24: #include "cpu-common.h"
1.1       root       25: 
1.1.1.6   root       26: /* some important defines:
                     27:  *
1.1       root       28:  * WORDS_ALIGNED : if defined, the host cpu can only make word aligned
                     29:  * memory accesses.
1.1.1.6   root       30:  *
1.1.1.9   root       31:  * HOST_WORDS_BIGENDIAN : if defined, the host cpu is big endian and
1.1       root       32:  * otherwise little endian.
1.1.1.6   root       33:  *
1.1       root       34:  * (TARGET_WORDS_ALIGNED : same for target cpu (not supported yet))
1.1.1.6   root       35:  *
1.1       root       36:  * TARGET_WORDS_BIGENDIAN : same for target cpu
                     37:  */
                     38: 
1.1.1.9   root       39: #if defined(HOST_WORDS_BIGENDIAN) != defined(TARGET_WORDS_BIGENDIAN)
1.1       root       40: #define BSWAP_NEEDED
                     41: #endif
                     42: 
                     43: #ifdef BSWAP_NEEDED
                     44: 
                     45: static inline uint16_t tswap16(uint16_t s)
                     46: {
                     47:     return bswap16(s);
                     48: }
                     49: 
                     50: static inline uint32_t tswap32(uint32_t s)
                     51: {
                     52:     return bswap32(s);
                     53: }
                     54: 
                     55: static inline uint64_t tswap64(uint64_t s)
                     56: {
                     57:     return bswap64(s);
                     58: }
                     59: 
                     60: static inline void tswap16s(uint16_t *s)
                     61: {
                     62:     *s = bswap16(*s);
                     63: }
                     64: 
                     65: static inline void tswap32s(uint32_t *s)
                     66: {
                     67:     *s = bswap32(*s);
                     68: }
                     69: 
                     70: static inline void tswap64s(uint64_t *s)
                     71: {
                     72:     *s = bswap64(*s);
                     73: }
                     74: 
                     75: #else
                     76: 
                     77: static inline uint16_t tswap16(uint16_t s)
                     78: {
                     79:     return s;
                     80: }
                     81: 
                     82: static inline uint32_t tswap32(uint32_t s)
                     83: {
                     84:     return s;
                     85: }
                     86: 
                     87: static inline uint64_t tswap64(uint64_t s)
                     88: {
                     89:     return s;
                     90: }
                     91: 
                     92: static inline void tswap16s(uint16_t *s)
                     93: {
                     94: }
                     95: 
                     96: static inline void tswap32s(uint32_t *s)
                     97: {
                     98: }
                     99: 
                    100: static inline void tswap64s(uint64_t *s)
                    101: {
                    102: }
                    103: 
                    104: #endif
                    105: 
                    106: #if TARGET_LONG_SIZE == 4
                    107: #define tswapl(s) tswap32(s)
                    108: #define tswapls(s) tswap32s((uint32_t *)(s))
                    109: #define bswaptls(s) bswap32s(s)
                    110: #else
                    111: #define tswapl(s) tswap64(s)
                    112: #define tswapls(s) tswap64s((uint64_t *)(s))
                    113: #define bswaptls(s) bswap64s(s)
                    114: #endif
                    115: 
                    116: /* CPU memory access without any memory or io remapping */
                    117: 
                    118: /*
                    119:  * the generic syntax for the memory accesses is:
                    120:  *
                    121:  * load: ld{type}{sign}{size}{endian}_{access_type}(ptr)
                    122:  *
                    123:  * store: st{type}{size}{endian}_{access_type}(ptr, val)
                    124:  *
                    125:  * type is:
                    126:  * (empty): integer access
                    127:  *   f    : float access
1.1.1.6   root      128:  *
1.1       root      129:  * sign is:
                    130:  * (empty): for floats or 32 bit size
                    131:  *   u    : unsigned
                    132:  *   s    : signed
                    133:  *
                    134:  * size is:
                    135:  *   b: 8 bits
                    136:  *   w: 16 bits
                    137:  *   l: 32 bits
                    138:  *   q: 64 bits
1.1.1.6   root      139:  *
1.1       root      140:  * endian is:
                    141:  * (empty): target cpu endianness or 8 bit access
                    142:  *   r    : reversed target cpu endianness (not implemented yet)
                    143:  *   be   : big endian (not implemented yet)
                    144:  *   le   : little endian (not implemented yet)
                    145:  *
                    146:  * access_type is:
                    147:  *   raw    : host memory access
                    148:  *   user   : user mode access using soft MMU
                    149:  *   kernel : kernel mode access using soft MMU
                    150:  */
1.1.1.2   root      151: 
1.1.1.14  root      152: /* target-endianness CPU memory access functions */
1.1.1.2   root      153: #if defined(TARGET_WORDS_BIGENDIAN)
                    154: #define lduw_p(p) lduw_be_p(p)
                    155: #define ldsw_p(p) ldsw_be_p(p)
                    156: #define ldl_p(p) ldl_be_p(p)
                    157: #define ldq_p(p) ldq_be_p(p)
                    158: #define ldfl_p(p) ldfl_be_p(p)
                    159: #define ldfq_p(p) ldfq_be_p(p)
                    160: #define stw_p(p, v) stw_be_p(p, v)
                    161: #define stl_p(p, v) stl_be_p(p, v)
                    162: #define stq_p(p, v) stq_be_p(p, v)
                    163: #define stfl_p(p, v) stfl_be_p(p, v)
                    164: #define stfq_p(p, v) stfq_be_p(p, v)
                    165: #else
                    166: #define lduw_p(p) lduw_le_p(p)
                    167: #define ldsw_p(p) ldsw_le_p(p)
                    168: #define ldl_p(p) ldl_le_p(p)
                    169: #define ldq_p(p) ldq_le_p(p)
                    170: #define ldfl_p(p) ldfl_le_p(p)
                    171: #define ldfq_p(p) ldfq_le_p(p)
                    172: #define stw_p(p, v) stw_le_p(p, v)
                    173: #define stl_p(p, v) stl_le_p(p, v)
                    174: #define stq_p(p, v) stq_le_p(p, v)
                    175: #define stfl_p(p, v) stfl_le_p(p, v)
                    176: #define stfq_p(p, v) stfq_le_p(p, v)
1.1       root      177: #endif
                    178: 
                    179: /* MMU memory access macros */
                    180: 
1.1.1.3   root      181: #if defined(CONFIG_USER_ONLY)
1.1.1.7   root      182: #include <assert.h>
                    183: #include "qemu-types.h"
                    184: 
1.1.1.3   root      185: /* On some host systems the guest address space is reserved on the host.
                    186:  * This allows the guest address space to be offset to a convenient location.
                    187:  */
1.1.1.9   root      188: #if defined(CONFIG_USE_GUEST_BASE)
                    189: extern unsigned long guest_base;
                    190: extern int have_guest_base;
1.1.1.11  root      191: extern unsigned long reserved_va;
1.1.1.9   root      192: #define GUEST_BASE guest_base
1.1.1.11  root      193: #define RESERVED_VA reserved_va
1.1.1.9   root      194: #else
                    195: #define GUEST_BASE 0ul
1.1.1.11  root      196: #define RESERVED_VA 0ul
1.1.1.9   root      197: #endif
1.1.1.3   root      198: 
                    199: /* All direct uses of g2h and h2g need to go away for usermode softmmu.  */
1.1.1.15! root      200: #define g2h(x) ((void *)((unsigned long)(target_ulong)(x) + GUEST_BASE))
1.1.1.11  root      201: 
                    202: #if HOST_LONG_BITS <= TARGET_VIRT_ADDR_SPACE_BITS
                    203: #define h2g_valid(x) 1
                    204: #else
                    205: #define h2g_valid(x) ({ \
                    206:     unsigned long __guest = (unsigned long)(x) - GUEST_BASE; \
1.1.1.15! root      207:     (__guest < (1ul << TARGET_VIRT_ADDR_SPACE_BITS)) && \
        !           208:     (!RESERVED_VA || (__guest < RESERVED_VA)); \
1.1.1.11  root      209: })
                    210: #endif
                    211: 
1.1.1.7   root      212: #define h2g(x) ({ \
                    213:     unsigned long __ret = (unsigned long)(x) - GUEST_BASE; \
                    214:     /* Check if given address fits target address space */ \
1.1.1.11  root      215:     assert(h2g_valid(x)); \
1.1.1.7   root      216:     (abi_ulong)__ret; \
                    217: })
1.1.1.3   root      218: 
                    219: #define saddr(x) g2h(x)
                    220: #define laddr(x) g2h(x)
                    221: 
                    222: #else /* !CONFIG_USER_ONLY */
1.1       root      223: /* NOTE: we use double casts if pointers and target_ulong have
                    224:    different sizes */
1.1.1.15! root      225: #define saddr(x) (uint8_t *)(intptr_t)(x)
        !           226: #define laddr(x) (uint8_t *)(intptr_t)(x)
1.1.1.3   root      227: #endif
                    228: 
                    229: #define ldub_raw(p) ldub_p(laddr((p)))
                    230: #define ldsb_raw(p) ldsb_p(laddr((p)))
                    231: #define lduw_raw(p) lduw_p(laddr((p)))
                    232: #define ldsw_raw(p) ldsw_p(laddr((p)))
                    233: #define ldl_raw(p) ldl_p(laddr((p)))
                    234: #define ldq_raw(p) ldq_p(laddr((p)))
                    235: #define ldfl_raw(p) ldfl_p(laddr((p)))
                    236: #define ldfq_raw(p) ldfq_p(laddr((p)))
                    237: #define stb_raw(p, v) stb_p(saddr((p)), v)
                    238: #define stw_raw(p, v) stw_p(saddr((p)), v)
                    239: #define stl_raw(p, v) stl_p(saddr((p)), v)
                    240: #define stq_raw(p, v) stq_p(saddr((p)), v)
                    241: #define stfl_raw(p, v) stfl_p(saddr((p)), v)
                    242: #define stfq_raw(p, v) stfq_p(saddr((p)), v)
1.1       root      243: 
                    244: 
1.1.1.6   root      245: #if defined(CONFIG_USER_ONLY)
1.1       root      246: 
                    247: /* if user mode, no other memory access functions */
                    248: #define ldub(p) ldub_raw(p)
                    249: #define ldsb(p) ldsb_raw(p)
                    250: #define lduw(p) lduw_raw(p)
                    251: #define ldsw(p) ldsw_raw(p)
                    252: #define ldl(p) ldl_raw(p)
                    253: #define ldq(p) ldq_raw(p)
                    254: #define ldfl(p) ldfl_raw(p)
                    255: #define ldfq(p) ldfq_raw(p)
                    256: #define stb(p, v) stb_raw(p, v)
                    257: #define stw(p, v) stw_raw(p, v)
                    258: #define stl(p, v) stl_raw(p, v)
                    259: #define stq(p, v) stq_raw(p, v)
                    260: #define stfl(p, v) stfl_raw(p, v)
                    261: #define stfq(p, v) stfq_raw(p, v)
                    262: 
1.1.1.15! root      263: #ifndef CONFIG_TCG_PASS_AREG0
1.1       root      264: #define ldub_code(p) ldub_raw(p)
                    265: #define ldsb_code(p) ldsb_raw(p)
                    266: #define lduw_code(p) lduw_raw(p)
                    267: #define ldsw_code(p) ldsw_raw(p)
                    268: #define ldl_code(p) ldl_raw(p)
1.1.1.6   root      269: #define ldq_code(p) ldq_raw(p)
1.1.1.15! root      270: #else
        !           271: #define cpu_ldub_code(env1, p) ldub_raw(p)
        !           272: #define cpu_ldsb_code(env1, p) ldsb_raw(p)
        !           273: #define cpu_lduw_code(env1, p) lduw_raw(p)
        !           274: #define cpu_ldsw_code(env1, p) ldsw_raw(p)
        !           275: #define cpu_ldl_code(env1, p) ldl_raw(p)
        !           276: #define cpu_ldq_code(env1, p) ldq_raw(p)
        !           277: #endif
1.1       root      278: 
                    279: #define ldub_kernel(p) ldub_raw(p)
                    280: #define ldsb_kernel(p) ldsb_raw(p)
                    281: #define lduw_kernel(p) lduw_raw(p)
                    282: #define ldsw_kernel(p) ldsw_raw(p)
                    283: #define ldl_kernel(p) ldl_raw(p)
1.1.1.6   root      284: #define ldq_kernel(p) ldq_raw(p)
1.1       root      285: #define ldfl_kernel(p) ldfl_raw(p)
                    286: #define ldfq_kernel(p) ldfq_raw(p)
                    287: #define stb_kernel(p, v) stb_raw(p, v)
                    288: #define stw_kernel(p, v) stw_raw(p, v)
                    289: #define stl_kernel(p, v) stl_raw(p, v)
                    290: #define stq_kernel(p, v) stq_raw(p, v)
                    291: #define stfl_kernel(p, v) stfl_raw(p, v)
                    292: #define stfq_kernel(p, vt) stfq_raw(p, v)
                    293: 
                    294: #endif /* defined(CONFIG_USER_ONLY) */
                    295: 
                    296: /* page related stuff */
                    297: 
                    298: #define TARGET_PAGE_SIZE (1 << TARGET_PAGE_BITS)
                    299: #define TARGET_PAGE_MASK ~(TARGET_PAGE_SIZE - 1)
                    300: #define TARGET_PAGE_ALIGN(addr) (((addr) + TARGET_PAGE_SIZE - 1) & TARGET_PAGE_MASK)
                    301: 
1.1.1.15! root      302: /* ??? These should be the larger of uintptr_t and target_ulong.  */
        !           303: extern uintptr_t qemu_real_host_page_size;
        !           304: extern uintptr_t qemu_host_page_size;
        !           305: extern uintptr_t qemu_host_page_mask;
1.1       root      306: 
                    307: #define HOST_PAGE_ALIGN(addr) (((addr) + qemu_host_page_size - 1) & qemu_host_page_mask)
                    308: 
                    309: /* same as PROT_xxx */
                    310: #define PAGE_READ      0x0001
                    311: #define PAGE_WRITE     0x0002
                    312: #define PAGE_EXEC      0x0004
                    313: #define PAGE_BITS      (PAGE_READ | PAGE_WRITE | PAGE_EXEC)
                    314: #define PAGE_VALID     0x0008
                    315: /* original state of the write flag (used when tracking self-modifying
                    316:    code */
1.1.1.6   root      317: #define PAGE_WRITE_ORG 0x0010
1.1.1.11  root      318: #if defined(CONFIG_BSD) && defined(CONFIG_USER_ONLY)
                    319: /* FIXME: Code that sets/uses this is broken and needs to go away.  */
1.1.1.6   root      320: #define PAGE_RESERVED  0x0020
1.1.1.11  root      321: #endif
1.1       root      322: 
1.1.1.11  root      323: #if defined(CONFIG_USER_ONLY)
1.1       root      324: void page_dump(FILE *f);
1.1.1.11  root      325: 
                    326: typedef int (*walk_memory_regions_fn)(void *, abi_ulong,
                    327:                                       abi_ulong, unsigned long);
                    328: int walk_memory_regions(void *, walk_memory_regions_fn);
                    329: 
1.1.1.3   root      330: int page_get_flags(target_ulong address);
                    331: void page_set_flags(target_ulong start, target_ulong end, int flags);
1.1.1.6   root      332: int page_check_range(target_ulong start, target_ulong len, int flags);
1.1.1.11  root      333: #endif
1.1       root      334: 
1.1.1.15! root      335: CPUArchState *cpu_copy(CPUArchState *env);
        !           336: CPUArchState *qemu_get_cpu(int cpu);
1.1       root      337: 
1.1.1.12  root      338: #define CPU_DUMP_CODE 0x00010000
                    339: 
1.1.1.15! root      340: void cpu_dump_state(CPUArchState *env, FILE *f, fprintf_function cpu_fprintf,
1.1       root      341:                     int flags);
1.1.1.15! root      342: void cpu_dump_statistics(CPUArchState *env, FILE *f, fprintf_function cpu_fprintf,
1.1.1.12  root      343:                          int flags);
1.1.1.6   root      344: 
1.1.1.15! root      345: void QEMU_NORETURN cpu_abort(CPUArchState *env, const char *fmt, ...)
1.1.1.12  root      346:     GCC_FMT_ATTR(2, 3);
1.1.1.15! root      347: extern CPUArchState *first_cpu;
        !           348: DECLARE_TLS(CPUArchState *,cpu_single_env);
        !           349: #define cpu_single_env tls_var(cpu_single_env)
1.1       root      350: 
1.1.1.13  root      351: /* Flags for use in ENV->INTERRUPT_PENDING.
                    352: 
                    353:    The numbers assigned here are non-sequential in order to preserve
                    354:    binary compatibility with the vmstate dump.  Bit 0 (0x0001) was
                    355:    previously used for CPU_INTERRUPT_EXIT, and is cleared when loading
                    356:    the vmstate dump.  */
                    357: 
                    358: /* External hardware interrupt pending.  This is typically used for
                    359:    interrupts from devices.  */
                    360: #define CPU_INTERRUPT_HARD        0x0002
                    361: 
                    362: /* Exit the current TB.  This is typically used when some system-level device
                    363:    makes some change to the memory mapping.  E.g. the a20 line change.  */
                    364: #define CPU_INTERRUPT_EXITTB      0x0004
                    365: 
                    366: /* Halt the CPU.  */
                    367: #define CPU_INTERRUPT_HALT        0x0020
                    368: 
                    369: /* Debug event pending.  */
                    370: #define CPU_INTERRUPT_DEBUG       0x0080
                    371: 
                    372: /* Several target-specific external hardware interrupts.  Each target/cpu.h
                    373:    should define proper names based on these defines.  */
                    374: #define CPU_INTERRUPT_TGT_EXT_0   0x0008
                    375: #define CPU_INTERRUPT_TGT_EXT_1   0x0010
                    376: #define CPU_INTERRUPT_TGT_EXT_2   0x0040
                    377: #define CPU_INTERRUPT_TGT_EXT_3   0x0200
                    378: #define CPU_INTERRUPT_TGT_EXT_4   0x1000
                    379: 
                    380: /* Several target-specific internal interrupts.  These differ from the
1.1.1.15! root      381:    preceding target-specific interrupts in that they are intended to
1.1.1.13  root      382:    originate from within the cpu itself, typically in response to some
                    383:    instruction being executed.  These, therefore, are not masked while
                    384:    single-stepping within the debugger.  */
                    385: #define CPU_INTERRUPT_TGT_INT_0   0x0100
                    386: #define CPU_INTERRUPT_TGT_INT_1   0x0400
                    387: #define CPU_INTERRUPT_TGT_INT_2   0x0800
1.1.1.15! root      388: #define CPU_INTERRUPT_TGT_INT_3   0x2000
1.1.1.13  root      389: 
1.1.1.15! root      390: /* First unused bit: 0x4000.  */
1.1.1.13  root      391: 
                    392: /* The set of all bits that should be masked when single-stepping.  */
                    393: #define CPU_INTERRUPT_SSTEP_MASK \
                    394:     (CPU_INTERRUPT_HARD          \
                    395:      | CPU_INTERRUPT_TGT_EXT_0   \
                    396:      | CPU_INTERRUPT_TGT_EXT_1   \
                    397:      | CPU_INTERRUPT_TGT_EXT_2   \
                    398:      | CPU_INTERRUPT_TGT_EXT_3   \
                    399:      | CPU_INTERRUPT_TGT_EXT_4)
                    400: 
                    401: #ifndef CONFIG_USER_ONLY
1.1.1.15! root      402: typedef void (*CPUInterruptHandler)(CPUArchState *, int);
1.1.1.13  root      403: 
                    404: extern CPUInterruptHandler cpu_interrupt_handler;
                    405: 
1.1.1.15! root      406: static inline void cpu_interrupt(CPUArchState *s, int mask)
1.1.1.13  root      407: {
                    408:     cpu_interrupt_handler(s, mask);
                    409: }
                    410: #else /* USER_ONLY */
1.1.1.15! root      411: void cpu_interrupt(CPUArchState *env, int mask);
1.1.1.13  root      412: #endif /* USER_ONLY */
1.1.1.2   root      413: 
1.1.1.15! root      414: void cpu_reset_interrupt(CPUArchState *env, int mask);
1.1       root      415: 
1.1.1.15! root      416: void cpu_exit(CPUArchState *s);
1.1.1.8   root      417: 
1.1.1.15! root      418: bool qemu_cpu_has_work(CPUArchState *env);
1.1.1.8   root      419: 
1.1.1.7   root      420: /* Breakpoint/watchpoint flags */
                    421: #define BP_MEM_READ           0x01
                    422: #define BP_MEM_WRITE          0x02
                    423: #define BP_MEM_ACCESS         (BP_MEM_READ | BP_MEM_WRITE)
                    424: #define BP_STOP_BEFORE_ACCESS 0x04
                    425: #define BP_WATCHPOINT_HIT     0x08
                    426: #define BP_GDB                0x10
                    427: #define BP_CPU                0x20
                    428: 
1.1.1.15! root      429: int cpu_breakpoint_insert(CPUArchState *env, target_ulong pc, int flags,
1.1.1.7   root      430:                           CPUBreakpoint **breakpoint);
1.1.1.15! root      431: int cpu_breakpoint_remove(CPUArchState *env, target_ulong pc, int flags);
        !           432: void cpu_breakpoint_remove_by_ref(CPUArchState *env, CPUBreakpoint *breakpoint);
        !           433: void cpu_breakpoint_remove_all(CPUArchState *env, int mask);
        !           434: int cpu_watchpoint_insert(CPUArchState *env, target_ulong addr, target_ulong len,
1.1.1.7   root      435:                           int flags, CPUWatchpoint **watchpoint);
1.1.1.15! root      436: int cpu_watchpoint_remove(CPUArchState *env, target_ulong addr,
1.1.1.7   root      437:                           target_ulong len, int flags);
1.1.1.15! root      438: void cpu_watchpoint_remove_by_ref(CPUArchState *env, CPUWatchpoint *watchpoint);
        !           439: void cpu_watchpoint_remove_all(CPUArchState *env, int mask);
1.1.1.7   root      440: 
                    441: #define SSTEP_ENABLE  0x1  /* Enable simulated HW single stepping */
                    442: #define SSTEP_NOIRQ   0x2  /* Do not use IRQ while single stepping */
                    443: #define SSTEP_NOTIMER 0x4  /* Do not Timers while single stepping */
                    444: 
1.1.1.15! root      445: void cpu_single_step(CPUArchState *env, int enabled);
        !           446: void cpu_state_reset(CPUArchState *s);
        !           447: int cpu_is_stopped(CPUArchState *env);
        !           448: void run_on_cpu(CPUArchState *env, void (*func)(void *data), void *data);
1.1       root      449: 
1.1.1.6   root      450: #define CPU_LOG_TB_OUT_ASM (1 << 0)
1.1       root      451: #define CPU_LOG_TB_IN_ASM  (1 << 1)
                    452: #define CPU_LOG_TB_OP      (1 << 2)
                    453: #define CPU_LOG_TB_OP_OPT  (1 << 3)
                    454: #define CPU_LOG_INT        (1 << 4)
                    455: #define CPU_LOG_EXEC       (1 << 5)
                    456: #define CPU_LOG_PCALL      (1 << 6)
                    457: #define CPU_LOG_IOPORT     (1 << 7)
                    458: #define CPU_LOG_TB_CPU     (1 << 8)
1.1.1.7   root      459: #define CPU_LOG_RESET      (1 << 9)
1.1       root      460: 
                    461: /* define log items */
                    462: typedef struct CPULogItem {
                    463:     int mask;
                    464:     const char *name;
                    465:     const char *help;
                    466: } CPULogItem;
                    467: 
1.1.1.7   root      468: extern const CPULogItem cpu_log_items[];
1.1       root      469: 
                    470: void cpu_set_log(int log_flags);
                    471: void cpu_set_log_filename(const char *filename);
                    472: int cpu_str_to_log_mask(const char *str);
                    473: 
1.1.1.11  root      474: #if !defined(CONFIG_USER_ONLY)
                    475: 
                    476: /* Return the physical page corresponding to a virtual one. Use it
                    477:    only for debugging because no protection checks are done. Return -1
                    478:    if no page found. */
1.1.1.15! root      479: target_phys_addr_t cpu_get_phys_page_debug(CPUArchState *env, target_ulong addr);
1.1.1.7   root      480: 
1.1       root      481: /* memory API */
                    482: 
                    483: extern int phys_ram_fd;
1.1.1.7   root      484: extern ram_addr_t ram_size;
1.1.1.11  root      485: 
1.1.1.13  root      486: /* RAM is pre-allocated and passed into qemu_ram_alloc_from_ptr */
                    487: #define RAM_PREALLOC_MASK   (1 << 0)
                    488: 
1.1.1.11  root      489: typedef struct RAMBlock {
1.1.1.15! root      490:     struct MemoryRegion *mr;
1.1.1.11  root      491:     uint8_t *host;
                    492:     ram_addr_t offset;
                    493:     ram_addr_t length;
1.1.1.13  root      494:     uint32_t flags;
1.1.1.11  root      495:     char idstr[256];
                    496:     QLIST_ENTRY(RAMBlock) next;
                    497: #if defined(__linux__) && !defined(TARGET_S390X)
                    498:     int fd;
                    499: #endif
                    500: } RAMBlock;
                    501: 
                    502: typedef struct RAMList {
                    503:     uint8_t *phys_dirty;
1.1.1.14  root      504:     QLIST_HEAD(, RAMBlock) blocks;
1.1.1.11  root      505: } RAMList;
                    506: extern RAMList ram_list;
                    507: 
                    508: extern const char *mem_path;
                    509: extern int mem_prealloc;
1.1       root      510: 
1.1.1.7   root      511: /* Flags stored in the low bits of the TLB virtual address.  These are
                    512:    defined so that fast path ram access is all zeros.  */
                    513: /* Zero if TLB entry is valid.  */
                    514: #define TLB_INVALID_MASK   (1 << 3)
                    515: /* Set if TLB entry references a clean RAM page.  The iotlb entry will
                    516:    contain the page physical address.  */
                    517: #define TLB_NOTDIRTY    (1 << 4)
                    518: /* Set if TLB entry is an IO callback.  */
                    519: #define TLB_MMIO        (1 << 5)
                    520: 
1.1.1.12  root      521: void dump_exec_info(FILE *f, fprintf_function cpu_fprintf);
1.1.1.11  root      522: #endif /* !CONFIG_USER_ONLY */
1.1       root      523: 
1.1.1.15! root      524: int cpu_memory_rw_debug(CPUArchState *env, target_ulong addr,
1.1.1.11  root      525:                         uint8_t *buf, int len, int is_write);
1.1.1.3   root      526: 
1.1       root      527: #endif /* CPU_ALL_H */

unix.superglobalmegacorp.com