Archipelago » qemu

/*

 *  qemu user main

 *  Copyright (c) 2003 Fabrice Bellard

 *

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

    return cpu_get_real_ticks();

}

                     int flags)

{

    unsigned int e1, e2;

    p[1] = tswapl(e2);

}

                     unsigned long addr, unsigned int sel)

{

    unsigned int e1, e2;

        switch(trapnr) {

        case 0x80:

            /* linux syscall */

                                          env->regs[R_EBX],

                                          env->regs[R_ECX],

                                          env->regs[R_EDX],

            break;

        default:

            pc = env->segs[R_CS].base + env->eip;

                    (long)pc, trapnr);

            abort();

        }

    unsigned int n, insn;

    target_siginfo_t info;

    uint32_t addr;

    for(;;) {

        trapnr = cpu_arm_exec(env);

        switch(trapnr) {

                /* we handle the FPU emulation here, as Linux */

                /* we get the opcode */

                opcode = tget32(env->regs[15]);

                if (EmulateAll(opcode, &ts->fpa, env) == 0) {

                    info.si_signo = SIGILL;

                    info.si_errno = 0;

                        n -= ARM_SYSCALL_BASE;

                        env->eabi = 0;

                    }

                                              env->regs[0],

                                              env->regs[1],

                                              env->regs[2],

            break;

        default:

        error:

                    trapnr);

            cpu_dump_state(env, stderr, fprintf, 0);

            abort();

{

    unsigned int i;

    target_ulong sp_ptr;

    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];

#if defined(DEBUG_WIN)

           (int)sp_ptr, cwp1);

#endif

    for(i = 0; i < 16; i++) {

{

    unsigned int new_wim, i, cwp1;

    target_ulong sp_ptr;

    new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) &

        ((1LL << NWINDOWS) - 1);

    /* restore the invalid window */

    cwp1 = (env->cwp + 1) & (NWINDOWS - 1);

    sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];

#if defined(DEBUG_WIN)

           (int)sp_ptr, cwp1);

#endif

    for(i = 0; i < 16; i++) {

{

    int trapnr, ret;

    target_siginfo_t info;

    while (1) {

        trapnr = cpu_sparc_exec (env);

        switch (trapnr) {

#ifndef TARGET_SPARC64

        case 0x90:

#else

        case 0x16d:

#endif

            ret = do_syscall (env, env->gregs[1],

                              env->regwptr[4], env->regwptr[5]);

            if ((unsigned int)ret >= (unsigned int)(-515)) {

#ifdef TARGET_SPARC64

    /* TO FIX */

    return 0;

}

uint32_t cpu_ppc_load_tbl (CPUState *env)

{

    return cpu_ppc_get_tb(env) & 0xFFFFFFFF;

}

uint32_t cpu_ppc_load_tbu (CPUState *env)

{

    return cpu_ppc_get_tb(env) >> 32;

}

static void cpu_ppc_store_tb (CPUState *env, uint64_t value)

{

    /* TO FIX */

{

    cpu_ppc_store_tb(env, ((uint64_t)value << 32) | cpu_ppc_load_tbl(env));

}

void cpu_ppc_store_tbl (CPUState *env, uint32_t value)

{

    cpu_ppc_store_tb(env, ((uint64_t)cpu_ppc_load_tbl(env) << 32) | value);

    target_siginfo_t info;

    int trapnr;

    uint32_t ret;

    for(;;) {

        trapnr = cpu_ppc_exec(env);

        if (trapnr != EXCP_SYSCALL_USER && trapnr != EXCP_BRANCH &&

            }

            break;

        default:

                    trapnr);

            if (loglevel) {

                fprintf(logfile, "qemu: unhandled CPU exception 0x%02x - "

            break;

        default:

            //        error:

                    trapnr);

            cpu_dump_state(env, stderr, fprintf, 0);

            abort();

{

    int trapnr, ret;

    target_siginfo_t info;

    while (1) {

        trapnr = cpu_sh4_exec (env);

        switch (trapnr) {

        case 0x160:

                             0);

            env->gregs[0] = ret;

            env->pc += 2;

    unsigned int n;

    target_siginfo_t info;

    TaskState *ts = env->opaque;

    for(;;) {

        trapnr = cpu_m68k_exec(env);

        switch(trapnr) {

                ts->sim_syscalls = 0;

                n = env->dregs[0];

                env->pc += 2;

                                          env->dregs[1],

                                          env->dregs[2],

                                          env->dregs[3],

            }

            break;

        default:

                    trapnr);

            cpu_dump_state(env, stderr, fprintf, 0);

            abort();

{

    int trapnr;

    target_siginfo_t info;

    while (1) {

        trapnr = cpu_alpha_exec (env);

        switch (trapnr) {

        case EXCP_RESET:

            fprintf(stderr, "Reset requested. Exit\n");

            exit(1);

            break;

        case EXCP_HW_INTERRUPT:

            exit(1);

            break;

        case EXCP_DFAULT:

           "-d options   activate log (logfile=%s)\n"

           "-p pagesize  set the host page size to 'pagesize'\n",

           TARGET_ARCH,

           x86_stack_size,

           DEBUG_LOGFILE);

    _exit(1);

	    if (optind >= argc)

		break;

	    r = argv[optind++];

            mask = cpu_str_to_log_mask(r);

            if (!mask) {

            }

        } else if (!strcmp(r, "drop-ld-preload")) {

            drop_ld_preload = 1;

#ifdef USE_CODE_COPY

        if (!strcmp(r, "no-code-copy")) {

            code_copy_enabled = 0;

#endif

        {

            usage();

       qemu_host_page_size */

    env = cpu_init();

    global_env = env;

    wrk = environ;

    while (*(wrk++))

        environ_count++;

    for (wrk = target_environ; *wrk; wrk++) {

        free(*wrk);

    }

    free(target_environ);

    if (loglevel) {

        page_dump(logfile);

        fprintf(logfile, "start_brk   0x%08lx\n" , info->start_brk);

        fprintf(logfile, "end_code    0x%08lx\n" , info->end_code);

        fprintf(logfile, "start_code  0x%08lx\n" , info->start_code);

    ts->used = 1;

    ts->info = info;

    env->user_mode_only = 1;

#if defined(TARGET_I386)

    cpu_x86_set_cpl(env, 3);

    /* flags setup : we activate the IRQs by default as in user mode */

    env->eflags |= IF_MASK;

    /* linux register setup */

#if defined(TARGET_X86_64)

    env->regs[R_EAX] = regs->rax;

    env->gdt.base = h2g(gdt_table);

    env->gdt.limit = sizeof(gdt_table) - 1;

    write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,

             (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));

    write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,

             (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));

    cpu_x86_load_seg(env, R_CS, __USER_CS);

    cpu_x86_load_seg(env, R_DS, __USER_DS);