Archipelago » qemu

#define CODE_GEN_HASH_SIZE     (1 << CODE_GEN_HASH_BITS)

typedef struct TranslationBlock {

    unsigned int flags; /* flags defining in which context the code was generated */

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

    struct TranslationBlock *hash_next; /* next matching block */

/* find a translation block in the translation cache. If not found,

   allocate a new one */

static inline TranslationBlock *tb_find_and_alloc(unsigned long pc, 

                                                  unsigned int flags)

{

    TranslationBlock **ptb, *tb;

        tb = *ptb;

        if (!tb)

            break;

            return tb;

        ptb = &tb->hash_next;

    }

    tb = &tbs[nb_tbs++];

    *ptb = tb;

    tb->pc = pc;

    tb->flags = flags;

    tb->tc_ptr = NULL;

    tb->hash_next = NULL;

    int code_gen_size, ret;

    void (*gen_func)(void);

    TranslationBlock *tb;

    unsigned int flags;

    /* first we save global registers */

            /* we compute the CPU state. We assume it will not

               change during the whole generated block. */

            flags = env->seg_cache[R_CS].seg_32bit << GEN_FLAG_CODE32_SHIFT;

            flags |= (((unsigned long)env->seg_cache[R_DS].base | 

                       (unsigned long)env->seg_cache[R_ES].base |

                       (unsigned long)env->seg_cache[R_SS].base) != 0) << 

                GEN_FLAG_ADDSEG_SHIFT;

            tc_ptr = tb->tc_ptr;

            if (!tb->tc_ptr) {

                /* if no translated code available, then translate it now */

                tc_ptr = code_gen_ptr;

                cpu_x86_gen_code(code_gen_ptr, CODE_GEN_MAX_SIZE, 

                tb->tc_ptr = tc_ptr;

                code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));

            }