Archipelago » qemu

#define SMC_BITMAP_USE_THRESHOLD 10

static TranslationBlock *tbs;

TranslationBlock *tb_phys_hash[CODE_GEN_PHYS_HASH_SIZE];

static int nb_tbs;

/* any access to the tbs or the page table must use this lock */

spinlock_t tb_lock = SPIN_LOCK_UNLOCKED;

typedef struct PageDesc {

    /* list of TBs intersecting this ram page */

    TranslationBlock *first_tb;

    if (tb_size > MAX_CODE_GEN_BUFFER_SIZE) {

        tb_size = MAX_CODE_GEN_BUFFER_SIZE;

    }

    return tb_size;

}

static inline void *alloc_code_gen_buffer(void)

{

    return static_code_gen_buffer;

}

#elif defined(USE_MMAP)

       Leave the choice of exact location with the kernel.  */

    flags |= MAP_32BIT;

    /* Cannot expect to map more than 800MB in low memory.  */

    }

# elif defined(__sparc__)

    start = 0x40000000ul;

    start = 0x90000000ul;

# endif

               PROT_WRITE | PROT_READ | PROT_EXEC, flags, -1, 0);

    return buf == MAP_FAILED ? NULL : buf;

}

#else

static inline void *alloc_code_gen_buffer(void)

{

    if (buf) {

    }

    return buf;

}

static inline void code_gen_alloc(size_t tb_size)

{

        fprintf(stderr, "Could not allocate dynamic translator buffer\n");

        exit(1);

    }

    /* Steal room for the prologue at the end of the buffer.  This ensures

       (via the MAX_CODE_GEN_BUFFER_SIZE limits above) that direct branches

       from TB's to the prologue are going to be in range.  It also means

       that we don't need to mark (additional) portions of the data segment

       as executable.  */

        (TCG_MAX_OP_SIZE * OPC_BUF_SIZE);

}

/* Must be called before using the QEMU cpus. 'tb_size' is the size

{

    cpu_gen_init();

    code_gen_alloc(tb_size);

    page_init();

#if !defined(CONFIG_USER_ONLY) || !defined(CONFIG_USE_GUEST_BASE)

    /* There's no guest base to take into account, so go ahead and

bool tcg_enabled(void)

{

}

/* Allocate a new translation block. Flush the translation buffer if

{

    TranslationBlock *tb;

        return NULL;

    }

    tb = &tbs[nb_tbs++];

       Ignore the hard cases and just back up if this TB happens to

       be the last one generated.  */

    if (nb_tbs > 0 && tb == &tbs[nb_tbs - 1]) {

        nb_tbs--;

    }

}

#if defined(DEBUG_FLUSH)

    printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld\n",

           nb_tbs, nb_tbs > 0 ?

#endif

        cpu_abort(env1, "Internal error: code buffer overflow\n");

    }

    nb_tbs = 0;

    memset(tb_phys_hash, 0, CODE_GEN_PHYS_HASH_SIZE * sizeof(void *));

    page_flush_tb();

    /* XXX: flush processor icache at this point if cache flush is

       expensive */

    tb_flush_count++;

        /* Don't forget to invalidate previous TB info.  */

        tb_invalidated_flag = 1;

    }

    tb->tc_ptr = tc_ptr;

    tb->cs_base = cs_base;

    tb->flags = flags;

    tb->cflags = cflags;

    cpu_gen_code(env, tb, &code_gen_size);

    /* check next page if needed */

    virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;

{

    /* This can be called during code generation, code_gen_buffer_max_size

       is used instead of code_gen_ptr for upper boundary checking */

}

#endif

    if (nb_tbs <= 0) {

        return NULL;

    }

        return NULL;

    }

    /* binary search (cf Knuth) */

    /* XXX: avoid using doubles ? */

    cpu_fprintf(f, "Translation buffer state:\n");

    cpu_fprintf(f, "gen code size       %td/%zd\n",

    cpu_fprintf(f, "TB count            %d/%d\n",

    cpu_fprintf(f, "TB avg target size  %d max=%d bytes\n",

                nb_tbs ? target_code_size / nb_tbs : 0,

                max_target_code_size);

    cpu_fprintf(f, "TB avg host size    %td bytes (expansion ratio: %0.1f)\n",

    cpu_fprintf(f, "cross page TB count %d (%d%%)\n",

            cross_page,

            nb_tbs ? (cross_page * 100) / nb_tbs : 0);