[mirror_qemu.git] / linux-user / main.c

/*
 *  qemu user main
 * 
 *  Copyright (c) 2003 Fabrice Bellard
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>

#include "qemu.h"

#define DEBUG_LOGFILE "/tmp/qemu.log"

static const char *interp_prefix = CONFIG_QEMU_PREFIX;

#if defined(__i386__) && !defined(CONFIG_STATIC)
/* Force usage of an ELF interpreter even if it is an ELF shared
   object ! */
const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2";
#endif

/* for recent libc, we add these dummy symbols which are not declared
   when generating a linked object (bug in ld ?) */
#if __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)
long __init_array_start[0];
long __init_array_end[0];
long __fini_array_start[0];
long __fini_array_end[0];
#endif

/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
   we allocate a bigger stack. Need a better solution, for example
   by remapping the process stack directly at the right place */
unsigned long x86_stack_size = 512 * 1024;

void gemu_log(const char *fmt, ...)
{
    va_list ap;

    va_start(ap, fmt);
    vfprintf(stderr, fmt, ap);
    va_end(ap);
}

#ifdef TARGET_I386
/***********************************************************/
/* CPUX86 core interface */

void cpu_x86_outb(CPUX86State *env, int addr, int val)
{
    fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
}

void cpu_x86_outw(CPUX86State *env, int addr, int val)
{
    fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
}

void cpu_x86_outl(CPUX86State *env, int addr, int val)
{
    fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
}

int cpu_x86_inb(CPUX86State *env, int addr)
{
    fprintf(stderr, "inb: port=0x%04x\n", addr);
    return 0;
}

int cpu_x86_inw(CPUX86State *env, int addr)
{
    fprintf(stderr, "inw: port=0x%04x\n", addr);
    return 0;
}

int cpu_x86_inl(CPUX86State *env, int addr)
{
    fprintf(stderr, "inl: port=0x%04x\n", addr);
    return 0;
}

int cpu_x86_get_pic_interrupt(CPUX86State *env)
{
    return -1;
}

static void write_dt(void *ptr, unsigned long addr, unsigned long limit, 
                     int flags)
{
    unsigned int e1, e2;
    e1 = (addr << 16) | (limit & 0xffff);
    e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
    e2 |= flags;
    stl((uint8_t *)ptr, e1);
    stl((uint8_t *)ptr + 4, e2);
}

static void set_gate(void *ptr, unsigned int type, unsigned int dpl, 
                     unsigned long addr, unsigned int sel)
{
    unsigned int e1, e2;
    e1 = (addr & 0xffff) | (sel << 16);
    e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
    stl((uint8_t *)ptr, e1);
    stl((uint8_t *)ptr + 4, e2);
}

uint64_t gdt_table[6];
uint64_t idt_table[256];

/* only dpl matters as we do only user space emulation */
static void set_idt(int n, unsigned int dpl)
{
    set_gate(idt_table + n, 0, dpl, 0, 0);
}

void cpu_loop(CPUX86State *env)
{
    int trapnr;
    uint8_t *pc;
    target_siginfo_t info;

    for(;;) {
        trapnr = cpu_x86_exec(env);
        switch(trapnr) {
        case 0x80:
            /* linux syscall */
            env->regs[R_EAX] = do_syscall(env, 
                                          env->regs[R_EAX], 
                                          env->regs[R_EBX],
                                          env->regs[R_ECX],
                                          env->regs[R_EDX],
                                          env->regs[R_ESI],
                                          env->regs[R_EDI],
                                          env->regs[R_EBP]);
            break;
        case EXCP0B_NOSEG:
        case EXCP0C_STACK:
            info.si_signo = SIGBUS;
            info.si_errno = 0;
            info.si_code = TARGET_SI_KERNEL;
            info._sifields._sigfault._addr = 0;
            queue_signal(info.si_signo, &info);
            break;
        case EXCP0D_GPF:
            if (env->eflags & VM_MASK) {
                handle_vm86_fault(env);
            } else {
                info.si_signo = SIGSEGV;
                info.si_errno = 0;
                info.si_code = TARGET_SI_KERNEL;
                info._sifields._sigfault._addr = 0;
                queue_signal(info.si_signo, &info);
            }
            break;
        case EXCP0E_PAGE:
            info.si_signo = SIGSEGV;
            info.si_errno = 0;
            if (!(env->error_code & 1))
                info.si_code = TARGET_SEGV_MAPERR;
            else
                info.si_code = TARGET_SEGV_ACCERR;
            info._sifields._sigfault._addr = env->cr[2];
            queue_signal(info.si_signo, &info);
            break;
        case EXCP00_DIVZ:
            if (env->eflags & VM_MASK) {
                handle_vm86_trap(env, trapnr);
            } else {
                /* division by zero */
                info.si_signo = SIGFPE;
                info.si_errno = 0;
                info.si_code = TARGET_FPE_INTDIV;
                info._sifields._sigfault._addr = env->eip;
                queue_signal(info.si_signo, &info);
            }
            break;
        case EXCP01_SSTP:
        case EXCP03_INT3:
            if (env->eflags & VM_MASK) {
                handle_vm86_trap(env, trapnr);
            } else {
                info.si_signo = SIGTRAP;
                info.si_errno = 0;
                if (trapnr == EXCP01_SSTP) {
                    info.si_code = TARGET_TRAP_BRKPT;
                    info._sifields._sigfault._addr = env->eip;
                } else {
                    info.si_code = TARGET_SI_KERNEL;
                    info._sifields._sigfault._addr = 0;
                }
                queue_signal(info.si_signo, &info);
            }
            break;
        case EXCP04_INTO:
        case EXCP05_BOUND:
            if (env->eflags & VM_MASK) {
                handle_vm86_trap(env, trapnr);
            } else {
                info.si_signo = SIGSEGV;
                info.si_errno = 0;
                info.si_code = TARGET_SI_KERNEL;
                info._sifields._sigfault._addr = 0;
                queue_signal(info.si_signo, &info);
            }
            break;
        case EXCP06_ILLOP:
            info.si_signo = SIGILL;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->eip;
            queue_signal(info.si_signo, &info);
            break;
        case EXCP_INTERRUPT:
            /* just indicate that signals should be handled asap */
            break;
        default:
            pc = env->segs[R_CS].base + env->eip;
            fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n", 
                    (long)pc, trapnr);
            abort();
        }
        process_pending_signals(env);
    }
}
#endif

#ifdef TARGET_ARM

void cpu_loop(CPUARMState *env)
{
    int trapnr;
    unsigned int n, insn;
    target_siginfo_t info;
    
    for(;;) {
        trapnr = cpu_arm_exec(env);
        switch(trapnr) {
        case EXCP_UDEF:
            info.si_signo = SIGILL;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->regs[15];
            queue_signal(info.si_signo, &info);
            break;
        case EXCP_SWI:
            {
                /* system call */
                insn = ldl((void *)(env->regs[15] - 4));
                n = insn & 0xffffff;
                if (n >= ARM_SYSCALL_BASE) {
                    /* linux syscall */
                    n -= ARM_SYSCALL_BASE;
                    env->regs[0] = do_syscall(env, 
                                              n, 
                                              env->regs[0],
                                              env->regs[1],
                                              env->regs[2],
                                              env->regs[3],
                                              env->regs[4],
                                              0);
                } else {
                    goto error;
                }
            }
            break;
        case EXCP_INTERRUPT:
            /* just indicate that signals should be handled asap */
            break;
        default:
        error:
            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 
                    trapnr);
            cpu_arm_dump_state(env, stderr, 0);
            abort();
        }
        process_pending_signals(env);
    }
}

#endif

#ifdef TARGET_SPARC

void cpu_loop (CPUSPARCState *env)
{
	int trapnr;

	while (1) {
		trapnr = cpu_sparc_exec (env);

		switch (trapnr) {
		  case 0x8: case 0x10:
			env->regwptr[0] = do_syscall (env, env->gregs[1],
				env->regwptr[0], env->regwptr[1], env->regwptr[2],
				env->regwptr[3], env->regwptr[4], env->regwptr[13]);
			if (env->regwptr[0] >= 0xffffffe0)
				env->psr |= PSR_CARRY;
			break;
		  default:
			printf ("Invalid trap: %d\n", trapnr);
			exit (1);
		}
		process_pending_signals (env);
	}
}

#endif

#ifdef TARGET_PPC

void cpu_loop(CPUPPCState *env)
{
    int trapnr;
    target_siginfo_t info;
    
    for(;;) {
        trapnr = cpu_ppc_exec(env);
        switch(trapnr) {
        case EXCP_NONE:
        case EXCP_INTERRUPT:
        case EXCP_MTMSR: /* mtmsr instruction:               */
        case EXCP_BRANCH: /* branch instruction               */
            /* Single step mode */
            break;
#if 0
        case EXCP_RESET: /* System reset                     */
            fprintf(stderr, "RESET asked... Stop emulation\n");
            cpu_ppc_dump_state(env, stderr, 0);
            abort();
#endif
        case EXCP_MACHINE_CHECK: /* Machine check exception          */
            fprintf(stderr, "Machine check exeption... "
                    "See you in kernel code !\n");
            cpu_ppc_dump_state(env, stderr, 0);
            abort();
        case EXCP_DSI:  /* Impossible memory access         */
            fprintf(stderr, "Invalid memory access\n");
            info.si_signo = SIGSEGV;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->nip;
            queue_signal(info.si_signo, &info);
            break;
        case EXCP_ISI: /* Impossible instruction fetch     */
            fprintf(stderr, "Invalid instruction fetch\n");
            info.si_signo = SIGBUS;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->nip;
            queue_signal(info.si_signo, &info);
            break;
        case EXCP_EXTERNAL: /* External interruption            */
            fprintf(stderr, "External access exeption\n");
            cpu_ppc_dump_state(env, stderr, 0);
            abort();
        case EXCP_ALIGN: /* Alignment exception              */
            fprintf(stderr, "Alignment exception\n");
            cpu_ppc_dump_state(env, stderr, 0);
            abort();
        case EXCP_PROGRAM: /* Program exception                */
            fprintf(stderr, "Program exception\n");
            cpu_ppc_dump_state(env, stderr, 0);
            abort();
            break;
        /* Trap */
        case EXCP_TRAP: /* Trap                             */
        case EXCP_TRACE: /* Trace exception (optional)       */
            info.si_signo = SIGTRAP;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->nip;
            queue_signal(info.si_signo, &info);
            break;
        /* Invalid instruction */
        case EXCP_INVAL:
            info.si_signo = SIGILL;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->nip;
            queue_signal(info.si_signo, &info);
            break;
        /* Privileged instruction */
        case EXCP_PRIV: /* Privileged instruction           */
            info.si_signo = SIGILL;
            info.si_errno = 0;
            info.si_code = TARGET_ILL_ILLOPN;
            info._sifields._sigfault._addr = env->nip;
            queue_signal(info.si_signo, &info);
            break;
        case EXCP_NO_FP: /* No floating point                */
        case EXCP_DECR: /* Decrementer exception            */
        case EXCP_RESA: /* Implementation specific          */
        case EXCP_RESB: /* Implementation specific          */
        case EXCP_FP_ASSIST: /* Floating-point assist (optional) */
            fprintf(stderr, "Misc expt...\n");
            cpu_ppc_dump_state(env, stderr, 0);
            abort();

        case EXCP_SYSCALL:
        {
            uint32_t ret;
            /* system call */
            /* WARNING:
             * PPC ABI uses overflow flag in cr0 to signal an error
             * in syscalls.
             */
            env->crf[0] &= ~0x1;
            ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
                             env->gpr[5], env->gpr[6], env->gpr[7],
                             env->gpr[8]);
            if (ret > (uint32_t)(-515)) {
                env->crf[0] |= 0x1;
                ret = -ret;
            }
            env->gpr[3] = ret;
            break;
        }
        default:
//        error:
            fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", 
                    trapnr);
            cpu_ppc_dump_state(env, stderr, 0);
            abort();
        }
        process_pending_signals(env);
    }
}
#endif

void usage(void)
{
    printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003 Fabrice Bellard\n"
           "usage: qemu-" TARGET_ARCH " [-h] [-d] [-L path] [-s size] program [arguments...]\n"
           "Linux CPU emulator (compiled for %s emulation)\n"
           "\n"
           "-h           print this help\n"
           "-L path      set the elf interpreter prefix (default=%s)\n"
           "-s size      set the stack size in bytes (default=%ld)\n"
           "\n"
           "debug options:\n"
           "-d           activate log (logfile=%s)\n"
           "-p pagesize  set the host page size to 'pagesize'\n",
           TARGET_ARCH,
           interp_prefix, 
           x86_stack_size,
           DEBUG_LOGFILE);
    _exit(1);
}

/* XXX: currently only used for async signals (see signal.c) */
CPUState *global_env;
/* used only if single thread */
CPUState *cpu_single_env = NULL;

/* used to free thread contexts */
TaskState *first_task_state;

int main(int argc, char **argv)
{
    const char *filename;
    struct target_pt_regs regs1, *regs = &regs1;
    struct image_info info1, *info = &info1;
    TaskState ts1, *ts = &ts1;
    CPUState *env;
    int optind;
    const char *r;
    
    if (argc <= 1)
        usage();

    /* init debug */
    cpu_set_log_filename(DEBUG_LOGFILE);

    optind = 1;
    for(;;) {
        if (optind >= argc)
            break;
        r = argv[optind];
        if (r[0] != '-')
            break;
        optind++;
        r++;
        if (!strcmp(r, "-")) {
            break;
        } else if (!strcmp(r, "d")) {
            cpu_set_log(CPU_LOG_ALL);
        } else if (!strcmp(r, "s")) {
            r = argv[optind++];
            x86_stack_size = strtol(r, (char **)&r, 0);
            if (x86_stack_size <= 0)
                usage();
            if (*r == 'M')
                x86_stack_size *= 1024 * 1024;
            else if (*r == 'k' || *r == 'K')
                x86_stack_size *= 1024;
        } else if (!strcmp(r, "L")) {
            interp_prefix = argv[optind++];
        } else if (!strcmp(r, "p")) {
            host_page_size = atoi(argv[optind++]);
            if (host_page_size == 0 ||
                (host_page_size & (host_page_size - 1)) != 0) {
                fprintf(stderr, "page size must be a power of two\n");
                exit(1);
            }
        } else {
            usage();
        }
    }
    if (optind >= argc)
        usage();
    filename = argv[optind];

    /* Zero out regs */
    memset(regs, 0, sizeof(struct target_pt_regs));

    /* Zero out image_info */
    memset(info, 0, sizeof(struct image_info));

    /* Scan interp_prefix dir for replacement files. */
    init_paths(interp_prefix);

    /* NOTE: we need to init the CPU at this stage to get the
       host_page_size */
    env = cpu_init();
    
    if (elf_exec(filename, argv+optind, environ, regs, info) != 0) {
	printf("Error loading %s\n", filename);
	_exit(1);
    }
    
    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);
        fprintf(logfile, "end_data    0x%08lx\n" , info->end_data);
        fprintf(logfile, "start_stack 0x%08lx\n" , info->start_stack);
        fprintf(logfile, "brk         0x%08lx\n" , info->brk);
        fprintf(logfile, "entry       0x%08lx\n" , info->entry);
    }

    target_set_brk((char *)info->brk);
    syscall_init();
    signal_init();

    global_env = env;

    /* build Task State */
    memset(ts, 0, sizeof(TaskState));
    env->opaque = ts;
    ts->used = 1;
    env->user_mode_only = 1;
    
#if defined(TARGET_I386)
    cpu_x86_set_cpl(env, 3);

    env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;

    /* linux register setup */
    env->regs[R_EAX] = regs->eax;
    env->regs[R_EBX] = regs->ebx;
    env->regs[R_ECX] = regs->ecx;
    env->regs[R_EDX] = regs->edx;
    env->regs[R_ESI] = regs->esi;
    env->regs[R_EDI] = regs->edi;
    env->regs[R_EBP] = regs->ebp;
    env->regs[R_ESP] = regs->esp;
    env->eip = regs->eip;

    /* linux interrupt setup */
    env->idt.base = (void *)idt_table;
    env->idt.limit = sizeof(idt_table) - 1;
    set_idt(0, 0);
    set_idt(1, 0);
    set_idt(2, 0);
    set_idt(3, 3);
    set_idt(4, 3);
    set_idt(5, 3);
    set_idt(6, 0);
    set_idt(7, 0);
    set_idt(8, 0);
    set_idt(9, 0);
    set_idt(10, 0);
    set_idt(11, 0);
    set_idt(12, 0);
    set_idt(13, 0);
    set_idt(14, 0);
    set_idt(15, 0);
    set_idt(16, 0);
    set_idt(17, 0);
    set_idt(18, 0);
    set_idt(19, 0);
    set_idt(0x80, 3);

    /* linux segment setup */
    env->gdt.base = (void *)gdt_table;
    env->gdt.limit = sizeof(gdt_table) - 1;
    write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
             DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 
             (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
    write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
             DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 
             (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);
    cpu_x86_load_seg(env, R_ES, __USER_DS);
    cpu_x86_load_seg(env, R_SS, __USER_DS);
    cpu_x86_load_seg(env, R_FS, __USER_DS);
    cpu_x86_load_seg(env, R_GS, __USER_DS);

#elif defined(TARGET_ARM)
    {
        int i;
        for(i = 0; i < 16; i++) {
            env->regs[i] = regs->uregs[i];
        }
        env->cpsr = regs->uregs[16];
    }
#elif defined(TARGET_SPARC)
	env->pc = regs->u_regs[0];
	env->regwptr[6] = regs->u_regs[1]-0x40;
#elif defined(TARGET_PPC)
    {
        int i;
        for (i = 0; i < 32; i++)
            env->msr[i] = (regs->msr >> i) & 1;
        env->nip = regs->nip;
        for(i = 0; i < 32; i++) {
            env->gpr[i] = regs->gpr[i];
        }
    }
#else
#error unsupported target CPU
#endif

    cpu_loop(env);
    /* never exits */
    return 0;
}
Commit	Line	Data
31e31b8a	1	/*
93ac68bc	2	* qemu user main
31e31b8a FB	3	*
	4	* Copyright (c) 2003 Fabrice Bellard
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program 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
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	19	*/
	20	#include <stdlib.h>
	21	#include <stdio.h>
	22	#include <stdarg.h>
04369ff2	23	#include <string.h>
31e31b8a	24	#include <errno.h>
0ecfa993	25	#include <unistd.h>
31e31b8a	26
3ef693a0	27	#include "qemu.h"
31e31b8a	28
3ef693a0	29	#define DEBUG_LOGFILE "/tmp/qemu.log"
586314f2	30
74cd30b8	31	static const char *interp_prefix = CONFIG_QEMU_PREFIX;
586314f2	32
3a4739d6	33	#if defined(__i386__) && !defined(CONFIG_STATIC)
f801f97e FB	34	/* Force usage of an ELF interpreter even if it is an ELF shared
	35	object ! */
	36	const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2";
4304763b	37	#endif
74cd30b8	38
93ac68bc	39	/* for recent libc, we add these dummy symbols which are not declared
74cd30b8 FB	40	when generating a linked object (bug in ld ?) */
	41	#if __GLIBC__ > 2 \|\| (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)
	42	long __init_array_start[0];
	43	long __init_array_end[0];
	44	long __fini_array_start[0];
	45	long __fini_array_end[0];
	46	#endif
	47
9de5e440 FB	48	/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
	49	we allocate a bigger stack. Need a better solution, for example
	50	by remapping the process stack directly at the right place */
	51	unsigned long x86_stack_size = 512 * 1024;
31e31b8a FB	52
	53	void gemu_log(const char *fmt, ...)
	54	{
	55	va_list ap;
	56
	57	va_start(ap, fmt);
	58	vfprintf(stderr, fmt, ap);
	59	va_end(ap);
	60	}
	61
b346ff46	62	#ifdef TARGET_I386
31e31b8a	63	/***********************************************************/
0ecfa993	64	/* CPUX86 core interface */
367e86e8	65
b689bc57	66	void cpu_x86_outb(CPUX86State *env, int addr, int val)
367e86e8 FB	67	{
	68	fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
	69	}
	70
b689bc57	71	void cpu_x86_outw(CPUX86State *env, int addr, int val)
367e86e8 FB	72	{
	73	fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
	74	}
	75
b689bc57	76	void cpu_x86_outl(CPUX86State *env, int addr, int val)
367e86e8 FB	77	{
	78	fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
	79	}
	80
b689bc57	81	int cpu_x86_inb(CPUX86State *env, int addr)
367e86e8 FB	82	{
	83	fprintf(stderr, "inb: port=0x%04x\n", addr);
	84	return 0;
	85	}
	86
b689bc57	87	int cpu_x86_inw(CPUX86State *env, int addr)
367e86e8 FB	88	{
	89	fprintf(stderr, "inw: port=0x%04x\n", addr);
	90	return 0;
	91	}
	92
b689bc57	93	int cpu_x86_inl(CPUX86State *env, int addr)
367e86e8 FB	94	{
	95	fprintf(stderr, "inl: port=0x%04x\n", addr);
	96	return 0;
	97	}
	98
92ccca6a FB	99	int cpu_x86_get_pic_interrupt(CPUX86State *env)
	100	{
	101	return -1;
	102	}
	103
f4beb510 FB	104	static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
f4beb510 FB	105	int flags)
6dbad63e	106	{
f4beb510	107	unsigned int e1, e2;
6dbad63e FB	108	e1 = (addr << 16) \| (limit & 0xffff);
6dbad63e FB	109	e2 = ((addr >> 16) & 0xff) \| (addr & 0xff000000) \| (limit & 0x000f0000);
f4beb510 FB	110	e2 \|= flags;
	111	stl((uint8_t *)ptr, e1);
	112	stl((uint8_t *)ptr + 4, e2);
	113	}
	114
	115	static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
	116	unsigned long addr, unsigned int sel)
	117	{
	118	unsigned int e1, e2;
	119	e1 = (addr & 0xffff) \| (sel << 16);
	120	e2 = (addr & 0xffff0000) \| 0x8000 \| (dpl << 13) \| (type << 8);
6dbad63e FB	121	stl((uint8_t *)ptr, e1);
	122	stl((uint8_t *)ptr + 4, e2);
	123	}
	124
	125	uint64_t gdt_table[6];
f4beb510 FB	126	uint64_t idt_table[256];
	127
	128	/* only dpl matters as we do only user space emulation */
	129	static void set_idt(int n, unsigned int dpl)
	130	{
	131	set_gate(idt_table + n, 0, dpl, 0, 0);
	132	}
31e31b8a	133
89e957e7	134	void cpu_loop(CPUX86State *env)
1b6b029e	135	{
bc8a22cc	136	int trapnr;
9de5e440 FB	137	uint8_t *pc;
9de5e440 FB	138	target_siginfo_t info;
851e67a1	139
1b6b029e	140	for(;;) {
bc8a22cc	141	trapnr = cpu_x86_exec(env);
bc8a22cc	142	switch(trapnr) {
f4beb510 FB	143	case 0x80:
	144	/* linux syscall */
	145	env->regs[R_EAX] = do_syscall(env,
	146	env->regs[R_EAX],
	147	env->regs[R_EBX],
	148	env->regs[R_ECX],
	149	env->regs[R_EDX],
	150	env->regs[R_ESI],
	151	env->regs[R_EDI],
	152	env->regs[R_EBP]);
	153	break;
	154	case EXCP0B_NOSEG:
	155	case EXCP0C_STACK:
	156	info.si_signo = SIGBUS;
	157	info.si_errno = 0;
	158	info.si_code = TARGET_SI_KERNEL;
	159	info._sifields._sigfault._addr = 0;
	160	queue_signal(info.si_signo, &info);
	161	break;
1b6b029e	162	case EXCP0D_GPF:
851e67a1	163	if (env->eflags & VM_MASK) {
89e957e7	164	handle_vm86_fault(env);
1b6b029e	165	} else {
f4beb510 FB	166	info.si_signo = SIGSEGV;
	167	info.si_errno = 0;
	168	info.si_code = TARGET_SI_KERNEL;
	169	info._sifields._sigfault._addr = 0;
	170	queue_signal(info.si_signo, &info);
1b6b029e FB	171	}
1b6b029e FB	172	break;
b689bc57 FB	173	case EXCP0E_PAGE:
	174	info.si_signo = SIGSEGV;
	175	info.si_errno = 0;
	176	if (!(env->error_code & 1))
	177	info.si_code = TARGET_SEGV_MAPERR;
	178	else
	179	info.si_code = TARGET_SEGV_ACCERR;
970a87a6	180	info._sifields._sigfault._addr = env->cr[2];
b689bc57 FB	181	queue_signal(info.si_signo, &info);
b689bc57 FB	182	break;
9de5e440	183	case EXCP00_DIVZ:
bc8a22cc	184	if (env->eflags & VM_MASK) {
447db213	185	handle_vm86_trap(env, trapnr);
bc8a22cc FB	186	} else {
	187	/* division by zero */
	188	info.si_signo = SIGFPE;
	189	info.si_errno = 0;
	190	info.si_code = TARGET_FPE_INTDIV;
	191	info._sifields._sigfault._addr = env->eip;
	192	queue_signal(info.si_signo, &info);
	193	}
9de5e440	194	break;
447db213 FB	195	case EXCP01_SSTP:
	196	case EXCP03_INT3:
	197	if (env->eflags & VM_MASK) {
	198	handle_vm86_trap(env, trapnr);
	199	} else {
	200	info.si_signo = SIGTRAP;
	201	info.si_errno = 0;
	202	if (trapnr == EXCP01_SSTP) {
	203	info.si_code = TARGET_TRAP_BRKPT;
	204	info._sifields._sigfault._addr = env->eip;
	205	} else {
	206	info.si_code = TARGET_SI_KERNEL;
	207	info._sifields._sigfault._addr = 0;
	208	}
	209	queue_signal(info.si_signo, &info);
	210	}
	211	break;
9de5e440 FB	212	case EXCP04_INTO:
9de5e440 FB	213	case EXCP05_BOUND:
bc8a22cc	214	if (env->eflags & VM_MASK) {
447db213	215	handle_vm86_trap(env, trapnr);
bc8a22cc FB	216	} else {
	217	info.si_signo = SIGSEGV;
	218	info.si_errno = 0;
b689bc57	219	info.si_code = TARGET_SI_KERNEL;
bc8a22cc FB	220	info._sifields._sigfault._addr = 0;
	221	queue_signal(info.si_signo, &info);
	222	}
9de5e440 FB	223	break;
	224	case EXCP06_ILLOP:
	225	info.si_signo = SIGILL;
	226	info.si_errno = 0;
	227	info.si_code = TARGET_ILL_ILLOPN;
	228	info._sifields._sigfault._addr = env->eip;
	229	queue_signal(info.si_signo, &info);
	230	break;
	231	case EXCP_INTERRUPT:
	232	/* just indicate that signals should be handled asap */
	233	break;
1b6b029e	234	default:
970a87a6	235	pc = env->segs[R_CS].base + env->eip;
bc8a22cc FB	236	fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
bc8a22cc FB	237	(long)pc, trapnr);
1b6b029e FB	238	abort();
1b6b029e FB	239	}
66fb9763	240	process_pending_signals(env);
1b6b029e FB	241	}
1b6b029e FB	242	}
b346ff46 FB	243	#endif
	244
	245	#ifdef TARGET_ARM
	246
b346ff46 FB	247	void cpu_loop(CPUARMState *env)
	248	{
	249	int trapnr;
	250	unsigned int n, insn;
	251	target_siginfo_t info;
	252
	253	for(;;) {
	254	trapnr = cpu_arm_exec(env);
	255	switch(trapnr) {
	256	case EXCP_UDEF:
	257	info.si_signo = SIGILL;
	258	info.si_errno = 0;
	259	info.si_code = TARGET_ILL_ILLOPN;
	260	info._sifields._sigfault._addr = env->regs[15];
	261	queue_signal(info.si_signo, &info);
	262	break;
	263	case EXCP_SWI:
	264	{
	265	/* system call */
	266	insn = ldl((void *)(env->regs[15] - 4));
	267	n = insn & 0xffffff;
	268	if (n >= ARM_SYSCALL_BASE) {
	269	/* linux syscall */
	270	n -= ARM_SYSCALL_BASE;
	271	env->regs[0] = do_syscall(env,
	272	n,
	273	env->regs[0],
	274	env->regs[1],
	275	env->regs[2],
	276	env->regs[3],
	277	env->regs[4],
	278	0);
	279	} else {
	280	goto error;
	281	}
	282	}
	283	break;
43fff238 FB	284	case EXCP_INTERRUPT:
	285	/* just indicate that signals should be handled asap */
	286	break;
b346ff46 FB	287	default:
	288	error:
	289	fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
	290	trapnr);
	291	cpu_arm_dump_state(env, stderr, 0);
	292	abort();
	293	}
	294	process_pending_signals(env);
	295	}
	296	}
	297
	298	#endif
1b6b029e	299
93ac68bc FB	300	#ifdef TARGET_SPARC
	301
	302	void cpu_loop (CPUSPARCState *env)
	303	{
	304	int trapnr;
	305
	306	while (1) {
	307	trapnr = cpu_sparc_exec (env);
	308
	309	switch (trapnr) {
	310	case 0x8: case 0x10:
	311	env->regwptr[0] = do_syscall (env, env->gregs[1],
	312	env->regwptr[0], env->regwptr[1], env->regwptr[2],
	313	env->regwptr[3], env->regwptr[4], env->regwptr[13]);
	314	if (env->regwptr[0] >= 0xffffffe0)
	315	env->psr \|= PSR_CARRY;
	316	break;
	317	default:
	318	printf ("Invalid trap: %d\n", trapnr);
	319	exit (1);
	320	}
	321	process_pending_signals (env);
	322	}
	323	}
	324
	325	#endif
	326
67867308 FB	327	#ifdef TARGET_PPC
	328
	329	void cpu_loop(CPUPPCState *env)
	330	{
	331	int trapnr;
	332	target_siginfo_t info;
	333
	334	for(;;) {
	335	trapnr = cpu_ppc_exec(env);
	336	switch(trapnr) {
	337	case EXCP_NONE:
	338	case EXCP_INTERRUPT:
	339	case EXCP_MTMSR: /* mtmsr instruction: */
	340	case EXCP_BRANCH: /* branch instruction */
	341	/* Single step mode */
	342	break;
	343	#if 0
	344	case EXCP_RESET: /* System reset */
	345	fprintf(stderr, "RESET asked... Stop emulation\n");
	346	cpu_ppc_dump_state(env, stderr, 0);
	347	abort();
	348	#endif
	349	case EXCP_MACHINE_CHECK: /* Machine check exception */
	350	fprintf(stderr, "Machine check exeption... "
	351	"See you in kernel code !\n");
	352	cpu_ppc_dump_state(env, stderr, 0);
	353	abort();
	354	case EXCP_DSI: /* Impossible memory access */
	355	fprintf(stderr, "Invalid memory access\n");
	356	info.si_signo = SIGSEGV;
	357	info.si_errno = 0;
	358	info.si_code = TARGET_ILL_ILLOPN;
	359	info._sifields._sigfault._addr = env->nip;
	360	queue_signal(info.si_signo, &info);
	361	break;
	362	case EXCP_ISI: /* Impossible instruction fetch */
	363	fprintf(stderr, "Invalid instruction fetch\n");
	364	info.si_signo = SIGBUS;
	365	info.si_errno = 0;
	366	info.si_code = TARGET_ILL_ILLOPN;
	367	info._sifields._sigfault._addr = env->nip;
	368	queue_signal(info.si_signo, &info);
	369	break;
	370	case EXCP_EXTERNAL: /* External interruption */
	371	fprintf(stderr, "External access exeption\n");
	372	cpu_ppc_dump_state(env, stderr, 0);
	373	abort();
	374	case EXCP_ALIGN: /* Alignment exception */
	375	fprintf(stderr, "Alignment exception\n");
	376	cpu_ppc_dump_state(env, stderr, 0);
	377	abort();
	378	case EXCP_PROGRAM: /* Program exception */
	379	fprintf(stderr, "Program exception\n");
	380	cpu_ppc_dump_state(env, stderr, 0);
	381	abort();
	382	break;
	383	/* Trap */
	384	case EXCP_TRAP: /* Trap */
	385	case EXCP_TRACE: /* Trace exception (optional) */
	386	info.si_signo = SIGTRAP;
	387	info.si_errno = 0;
	388	info.si_code = TARGET_ILL_ILLOPN;
	389	info._sifields._sigfault._addr = env->nip;
	390	queue_signal(info.si_signo, &info);
391	break;
392	/* Invalid instruction */
393	case EXCP_INVAL:
394	info.si_signo = SIGILL;
395	info.si_errno = 0;
396	info.si_code = TARGET_ILL_ILLOPN;
397	info._sifields._sigfault._addr = env->nip;
398	queue_signal(info.si_signo, &info);
399	break;
400	/* Privileged instruction */
401	case EXCP_PRIV: /* Privileged instruction */
402	info.si_signo = SIGILL;
403	info.si_errno = 0;
404	info.si_code = TARGET_ILL_ILLOPN;
405	info._sifields._sigfault._addr = env->nip;
406	queue_signal(info.si_signo, &info);
407	break;
408	case EXCP_NO_FP: /* No floating point */
409	case EXCP_DECR: /* Decrementer exception */
410	case EXCP_RESA: /* Implementation specific */
411	case EXCP_RESB: /* Implementation specific */
412	case EXCP_FP_ASSIST: /* Floating-point assist (optional) */
413	fprintf(stderr, "Misc expt...\n");
414	cpu_ppc_dump_state(env, stderr, 0);
415	abort();
416
417	case EXCP_SYSCALL:
418	{
419	uint32_t ret;
420	/* system call */
421	/* WARNING:
422	* PPC ABI uses overflow flag in cr0 to signal an error
423	* in syscalls.
424	*/
425	env->crf[0] &= ~0x1;
426	ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
427	env->gpr[5], env->gpr[6], env->gpr[7],
428	env->gpr[8]);
429	if (ret > (uint32_t)(-515)) {
430	env->crf[0] \|= 0x1;
431	ret = -ret;
432	}
433	env->gpr[3] = ret;
434	break;
435	}
436	default:
437	// error:
438	fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
439	trapnr);
440	cpu_ppc_dump_state(env, stderr, 0);
441	abort();
442	}
443	process_pending_signals(env);
444	}
445	}
446	#endif
447
31e31b8a FB	448	void usage(void)
31e31b8a FB	449	{
93ac68bc FB	450	printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003 Fabrice Bellard\n"
93ac68bc FB	451	"usage: qemu-" TARGET_ARCH " [-h] [-d] [-L path] [-s size] program [arguments...]\n"
b346ff46	452	"Linux CPU emulator (compiled for %s emulation)\n"
d691f669	453	"\n"
54936004	454	"-h print this help\n"
b346ff46 FB	455	"-L path set the elf interpreter prefix (default=%s)\n"
b346ff46 FB	456	"-s size set the stack size in bytes (default=%ld)\n"
54936004 FB	457	"\n"
	458	"debug options:\n"
	459	"-d activate log (logfile=%s)\n"
	460	"-p pagesize set the host page size to 'pagesize'\n",
b346ff46	461	TARGET_ARCH,
d691f669	462	interp_prefix,
54936004 FB	463	x86_stack_size,
54936004 FB	464	DEBUG_LOGFILE);
74cd30b8	465	_exit(1);
31e31b8a FB	466	}
31e31b8a FB	467
9de5e440	468	/* XXX: currently only used for async signals (see signal.c) */
b346ff46	469	CPUState *global_env;
59faf6d6 FB	470	/* used only if single thread */
	471	CPUState *cpu_single_env = NULL;
	472
851e67a1 FB	473	/* used to free thread contexts */
851e67a1 FB	474	TaskState *first_task_state;
9de5e440	475
31e31b8a FB	476	int main(int argc, char **argv)
	477	{
	478	const char *filename;
01ffc75b	479	struct target_pt_regs regs1, *regs = &regs1;
31e31b8a	480	struct image_info info1, *info = &info1;
851e67a1	481	TaskState ts1, *ts = &ts1;
b346ff46	482	CPUState *env;
586314f2	483	int optind;
d691f669 FB	484	const char *r;
d691f669 FB	485
31e31b8a FB	486	if (argc <= 1)
31e31b8a FB	487	usage();
f801f97e	488
cc38b844 FB	489	/* init debug */
	490	cpu_set_log_filename(DEBUG_LOGFILE);
	491
586314f2	492	optind = 1;
d691f669 FB	493	for(;;) {
	494	if (optind >= argc)
	495	break;
	496	r = argv[optind];
	497	if (r[0] != '-')
	498	break;
586314f2	499	optind++;
d691f669 FB	500	r++;
	501	if (!strcmp(r, "-")) {
	502	break;
	503	} else if (!strcmp(r, "d")) {
cc38b844	504	cpu_set_log(CPU_LOG_ALL);
d691f669 FB	505	} else if (!strcmp(r, "s")) {
	506	r = argv[optind++];
	507	x86_stack_size = strtol(r, (char **)&r, 0);
	508	if (x86_stack_size <= 0)
	509	usage();
	510	if (*r == 'M')
	511	x86_stack_size = 1024 1024;
	512	else if (r == 'k' \|\| r == 'K')
	513	x86_stack_size *= 1024;
	514	} else if (!strcmp(r, "L")) {
	515	interp_prefix = argv[optind++];
54936004 FB	516	} else if (!strcmp(r, "p")) {
	517	host_page_size = atoi(argv[optind++]);
	518	if (host_page_size == 0 \|\|
	519	(host_page_size & (host_page_size - 1)) != 0) {
	520	fprintf(stderr, "page size must be a power of two\n");
	521	exit(1);
	522	}
d691f669 FB	523	} else {
	524	usage();
	525	}
586314f2	526	}
d691f669 FB	527	if (optind >= argc)
d691f669 FB	528	usage();
586314f2 FB	529	filename = argv[optind];
586314f2 FB	530
31e31b8a	531	/* Zero out regs */
01ffc75b	532	memset(regs, 0, sizeof(struct target_pt_regs));
31e31b8a FB	533
	534	/* Zero out image_info */
	535	memset(info, 0, sizeof(struct image_info));
	536
74cd30b8 FB	537	/* Scan interp_prefix dir for replacement files. */
	538	init_paths(interp_prefix);
	539
54936004 FB	540	/* NOTE: we need to init the CPU at this stage to get the
54936004 FB	541	host_page_size */
b346ff46	542	env = cpu_init();
92ccca6a	543
74cd30b8	544	if (elf_exec(filename, argv+optind, environ, regs, info) != 0) {
31e31b8a	545	printf("Error loading %s\n", filename);
74cd30b8	546	_exit(1);
31e31b8a FB	547	}
31e31b8a FB	548
4b74fe1f	549	if (loglevel) {
54936004 FB	550	page_dump(logfile);
54936004 FB	551
4b74fe1f FB	552	fprintf(logfile, "start_brk 0x%08lx\n" , info->start_brk);
	553	fprintf(logfile, "end_code 0x%08lx\n" , info->end_code);
	554	fprintf(logfile, "start_code 0x%08lx\n" , info->start_code);
	555	fprintf(logfile, "end_data 0x%08lx\n" , info->end_data);
	556	fprintf(logfile, "start_stack 0x%08lx\n" , info->start_stack);
	557	fprintf(logfile, "brk 0x%08lx\n" , info->brk);
b346ff46	558	fprintf(logfile, "entry 0x%08lx\n" , info->entry);
4b74fe1f	559	}
31e31b8a FB	560
	561	target_set_brk((char *)info->brk);
	562	syscall_init();
66fb9763	563	signal_init();
31e31b8a	564
9de5e440	565	global_env = env;
0ecfa993	566
851e67a1 FB	567	/* build Task State */
	568	memset(ts, 0, sizeof(TaskState));
	569	env->opaque = ts;
	570	ts->used = 1;
59faf6d6	571	env->user_mode_only = 1;
851e67a1	572
b346ff46	573	#if defined(TARGET_I386)
2e255c6b FB	574	cpu_x86_set_cpl(env, 3);
2e255c6b FB	575
3802ce26 FB	576	env->cr[0] = CR0_PG_MASK \| CR0_WP_MASK \| CR0_PE_MASK;
3802ce26 FB	577
6dbad63e	578	/* linux register setup */
0ecfa993 FB	579	env->regs[R_EAX] = regs->eax;
	580	env->regs[R_EBX] = regs->ebx;
	581	env->regs[R_ECX] = regs->ecx;
	582	env->regs[R_EDX] = regs->edx;
	583	env->regs[R_ESI] = regs->esi;
	584	env->regs[R_EDI] = regs->edi;
	585	env->regs[R_EBP] = regs->ebp;
	586	env->regs[R_ESP] = regs->esp;
dab2ed99	587	env->eip = regs->eip;
31e31b8a	588
f4beb510 FB	589	/* linux interrupt setup */
	590	env->idt.base = (void *)idt_table;
	591	env->idt.limit = sizeof(idt_table) - 1;
	592	set_idt(0, 0);
	593	set_idt(1, 0);
	594	set_idt(2, 0);
	595	set_idt(3, 3);
	596	set_idt(4, 3);
	597	set_idt(5, 3);
	598	set_idt(6, 0);
	599	set_idt(7, 0);
	600	set_idt(8, 0);
	601	set_idt(9, 0);
	602	set_idt(10, 0);
	603	set_idt(11, 0);
	604	set_idt(12, 0);
	605	set_idt(13, 0);
	606	set_idt(14, 0);
	607	set_idt(15, 0);
	608	set_idt(16, 0);
	609	set_idt(17, 0);
	610	set_idt(18, 0);
	611	set_idt(19, 0);
	612	set_idt(0x80, 3);
	613
6dbad63e FB	614	/* linux segment setup */
	615	env->gdt.base = (void *)gdt_table;
	616	env->gdt.limit = sizeof(gdt_table) - 1;
f4beb510 FB	617	write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
	618	DESC_G_MASK \| DESC_B_MASK \| DESC_P_MASK \| DESC_S_MASK \|
	619	(3 << DESC_DPL_SHIFT) \| (0xa << DESC_TYPE_SHIFT));
	620	write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
	621	DESC_G_MASK \| DESC_B_MASK \| DESC_P_MASK \| DESC_S_MASK \|
	622	(3 << DESC_DPL_SHIFT) \| (0x2 << DESC_TYPE_SHIFT));
6dbad63e FB	623	cpu_x86_load_seg(env, R_CS, __USER_CS);
	624	cpu_x86_load_seg(env, R_DS, __USER_DS);
	625	cpu_x86_load_seg(env, R_ES, __USER_DS);
	626	cpu_x86_load_seg(env, R_SS, __USER_DS);
	627	cpu_x86_load_seg(env, R_FS, __USER_DS);
	628	cpu_x86_load_seg(env, R_GS, __USER_DS);
92ccca6a	629
b346ff46 FB	630	#elif defined(TARGET_ARM)
	631	{
	632	int i;
	633	for(i = 0; i < 16; i++) {
	634	env->regs[i] = regs->uregs[i];
	635	}
	636	env->cpsr = regs->uregs[16];
	637	}
93ac68bc FB	638	#elif defined(TARGET_SPARC)
	639	env->pc = regs->u_regs[0];
	640	env->regwptr[6] = regs->u_regs[1]-0x40;
67867308 FB	641	#elif defined(TARGET_PPC)
	642	{
	643	int i;
	644	for (i = 0; i < 32; i++)
	645	env->msr[i] = (regs->msr >> i) & 1;
	646	env->nip = regs->nip;
	647	for(i = 0; i < 32; i++) {
	648	env->gpr[i] = regs->gpr[i];
	649	}
	650	}
b346ff46 FB	651	#else
	652	#error unsupported target CPU
	653	#endif
31e31b8a	654
1b6b029e FB	655	cpu_loop(env);
1b6b029e FB	656	/* never exits */
31e31b8a FB	657	return 0;
31e31b8a FB	658	}