Archipelago » qemu

/*

 * internal execution defines for qemu

 *  Copyright (c) 2003 Fabrice Bellard

 *

 * This library is free software; you can redistribute it and/or

typedef void (GenOpFunc1)(long);

typedef void (GenOpFunc2)(long, long);

typedef void (GenOpFunc3)(long, long, long);

#if defined(TARGET_I386)

void optimize_flags_init(void);

void dump_ops(const uint16_t *opc_buf, const uint32_t *opparam_buf);

int cpu_gen_code(CPUState *env, struct TranslationBlock *tb,

                 int max_code_size, int *gen_code_size_ptr);

                      CPUState *env, unsigned long searched_pc,

                      void *puc);

int cpu_gen_code_copy(CPUState *env, struct TranslationBlock *tb,

                      int max_code_size, int *gen_code_size_ptr);

                           CPUState *env, unsigned long searched_pc,

                           void *puc);

void cpu_resume_from_signal(CPUState *env1, void *puc);

void cpu_exec_init(CPUState *env);

int page_unprotect(target_ulong address, unsigned long pc, void *puc);

                                   int is_cpu_write_access);

void tb_invalidate_page_range(target_ulong start, target_ulong end);

void tlb_flush_page(CPUState *env, target_ulong addr);

void tlb_flush(CPUState *env, int flush_global);

                      int is_user, int is_softmmu);

                               int is_user, int is_softmmu)

{

    if (prot & PAGE_READ)

#define CODE_GEN_MAX_BLOCKS    (CODE_GEN_BUFFER_SIZE / CODE_GEN_AVG_BLOCK_SIZE)

#define USE_DIRECT_JUMP

#endif

#if defined(__i386__) && !defined(_WIN32)

    uint8_t *tc_ptr;    /* pointer to the translated code */

    /* next matching tb for physical address. */

    /* first and second physical page containing code. The lower bit

       of the pointer tells the index in page_next[] */

    /* the following data are used to directly call another TB from

       the code of this one. */

       the two least significant bits of the pointers to tell what is

       the next pointer: 0 = jmp_next[0], 1 = jmp_next[1], 2 =

       jmp_first */

    struct TranslationBlock *jmp_first;

} TranslationBlock;

TranslationBlock *tb_alloc(target_ulong pc);

void tb_flush(CPUState *env);

                  target_ulong phys_pc, target_ulong phys_page2);

extern TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];

}

#endif

                                     int n, unsigned long addr)

{

    unsigned long offset;

#else

/* set the jump target */

                                     int n, unsigned long addr)

{

    tb->tb_next[n] = addr;

#endif

                               TranslationBlock *tb_next)

{

    /* NOTE: this test is only needed for thread safety */

    if (!tb->jmp_next[n]) {

        /* patch the native jump address */

        tb_set_jmp_target(tb, n, (unsigned long)tb_next->tc_ptr);

        /* add in TB jmp circular list */

        tb->jmp_next[n] = tb_next->jmp_first;

        tb_next->jmp_first = (TranslationBlock *)((long)(tb) | (n));

static inline int testandset (int *p)

{

    long int readval = 0;

    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"

                          : "+m" (*p), "+a" (readval)

                          : "r" (1)

static inline int testandset (int *p)

{

    long int readval = 0;

    __asm__ __volatile__ ("lock; cmpxchgl %2, %0"

                          : "+m" (*p), "+a" (readval)

                          : "r" (1)

    __asm__ __volatile__ ("0: cs    %0,%1,0(%2)\n"

			  "   jl    0b"

			  : "=&d" (ret)

			  : "cc", "memory" );

    return ret;

}

    __asm__ __volatile__("swp %0, %1, [%2]"

                         : "=r"(ret)

                         : "0"(1), "r"(spinlock));

    return ret;

}

#elif defined(__mc68000)

#if !defined(CONFIG_USER_ONLY)

              void *retaddr);

#define ACCESS_TYPE 3

#else

#error unimplemented CPU

#endif

                         (addr & TARGET_PAGE_MASK), 0)) {

        ldub_code(addr);

    }

static inline int kqemu_is_ok(CPUState *env)

{

    return(env->kqemu_enabled &&

           !(env->hflags & HF_INHIBIT_IRQ_MASK) &&

           (env->eflags & IF_MASK) &&

           !(env->eflags & VM_MASK) &&

            ((env->hflags & HF_CPL_MASK) == 3 &&

             (env->eflags & IOPL_MASK) != IOPL_MASK)));

}