X-Git-Url: http://vcs.maemo.org/git/?a=blobdiff_plain;f=linux-user%2Fmain.c;h=0c5e6b5b431de2f7151e13ffa88cb77694545eab;hb=c35734b2a6f9b028edacd5813ff271728ce2a9e3;hp=56accfbb5277a6a3933c2f789cc89a4e3fc681dd;hpb=06c949e62a098f97bd68a7382eb1953898a11e09;p=qemu diff --git a/linux-user/main.c b/linux-user/main.c index 56accfb..0c5e6b5 100644 --- a/linux-user/main.c +++ b/linux-user/main.c @@ -34,6 +34,7 @@ #endif static const char *interp_prefix = CONFIG_QEMU_PREFIX; +const char *qemu_uname_release = CONFIG_UNAME_RELEASE; #if defined(__i386__) && !defined(CONFIG_STATIC) /* Force usage of an ELF interpreter even if it is an ELF shared @@ -106,29 +107,7 @@ int cpu_get_pic_interrupt(CPUState *env) /* timers for rdtsc */ -#if defined(__i386__) - -int64_t cpu_get_real_ticks(void) -{ - int64_t val; - asm volatile ("rdtsc" : "=A" (val)); - return val; -} - -#elif defined(__x86_64__) - -int64_t cpu_get_real_ticks(void) -{ - uint32_t low,high; - int64_t val; - asm volatile("rdtsc" : "=a" (low), "=d" (high)); - val = high; - val <<= 32; - val |= low; - return val; -} - -#else +#if 0 static uint64_t emu_time; @@ -143,6 +122,10 @@ int64_t cpu_get_real_ticks(void) /***********************************************************/ /* CPUX86 core interface */ +void cpu_smm_update(CPUState *env) +{ +} + uint64_t cpu_get_tsc(CPUX86State *env) { return cpu_get_real_ticks(); @@ -152,21 +135,25 @@ static void write_dt(void *ptr, unsigned long addr, unsigned long limit, int flags) { unsigned int e1, e2; + uint32_t *p; 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); + p = ptr; + p[0] = tswapl(e1); + p[1] = tswapl(e2); } static void set_gate(void *ptr, unsigned int type, unsigned int dpl, unsigned long addr, unsigned int sel) { unsigned int e1, e2; + uint32_t *p; e1 = (addr & 0xffff) | (sel << 16); e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); - stl((uint8_t *)ptr, e1); - stl((uint8_t *)ptr + 4, e2); + p = ptr; + p[0] = tswapl(e1); + p[1] = tswapl(e2); } uint64_t gdt_table[6]; @@ -343,9 +330,9 @@ void cpu_loop(CPUARMState *env) /* we handle the FPU emulation here, as Linux */ /* we get the opcode */ - opcode = ldl_raw((uint8_t *)env->regs[15]); + opcode = tget32(env->regs[15]); - if (EmulateAll(opcode, &ts->fpa, env->regs) == 0) { + if (EmulateAll(opcode, &ts->fpa, env) == 0) { info.si_signo = SIGILL; info.si_errno = 0; info.si_code = TARGET_ILL_ILLOPN; @@ -360,23 +347,24 @@ void cpu_loop(CPUARMState *env) case EXCP_SWI: case EXCP_BKPT: { + env->eabi = 1; /* system call */ if (trapnr == EXCP_BKPT) { if (env->thumb) { - insn = lduw((void *)(env->regs[15])); + insn = tget16(env->regs[15]); n = insn & 0xff; env->regs[15] += 2; } else { - insn = ldl((void *)(env->regs[15])); + insn = tget32(env->regs[15]); n = (insn & 0xf) | ((insn >> 4) & 0xff0); env->regs[15] += 4; } } else { if (env->thumb) { - insn = lduw((void *)(env->regs[15] - 2)); + insn = tget16(env->regs[15] - 2); n = insn & 0xff; } else { - insn = ldl((void *)(env->regs[15] - 4)); + insn = tget32(env->regs[15] - 4); n = insn & 0xffffff; } } @@ -386,13 +374,14 @@ void cpu_loop(CPUARMState *env) } else if (n == ARM_NR_semihosting || n == ARM_NR_thumb_semihosting) { env->regs[0] = do_arm_semihosting (env); - } else if (n >= ARM_SYSCALL_BASE + } else if (n == 0 || n >= ARM_SYSCALL_BASE || (env->thumb && n == ARM_THUMB_SYSCALL)) { /* linux syscall */ - if (env->thumb) { + if (env->thumb || n == 0) { n = env->regs[7]; } else { n -= ARM_SYSCALL_BASE; + env->eabi = 0; } env->regs[0] = do_syscall(env, n, @@ -473,49 +462,60 @@ static inline int get_reg_index(CPUSPARCState *env, int cwp, int index) static inline void save_window_offset(CPUSPARCState *env, int cwp1) { unsigned int i; - uint32_t *sp_ptr; + target_ulong sp_ptr; - sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]); + sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; #if defined(DEBUG_WIN) printf("win_overflow: sp_ptr=0x%x save_cwp=%d\n", (int)sp_ptr, cwp1); #endif for(i = 0; i < 16; i++) { - put_user(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); - sp_ptr++; + tputl(sp_ptr, env->regbase[get_reg_index(env, cwp1, 8 + i)]); + sp_ptr += sizeof(target_ulong); } } static void save_window(CPUSPARCState *env) { +#ifndef TARGET_SPARC64 unsigned int new_wim; new_wim = ((env->wim >> 1) | (env->wim << (NWINDOWS - 1))) & ((1LL << NWINDOWS) - 1); save_window_offset(env, (env->cwp - 2) & (NWINDOWS - 1)); env->wim = new_wim; +#else + save_window_offset(env, (env->cwp - 2) & (NWINDOWS - 1)); + env->cansave++; + env->canrestore--; +#endif } static void restore_window(CPUSPARCState *env) { unsigned int new_wim, i, cwp1; - uint32_t *sp_ptr, reg; + 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 = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]); + sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; #if defined(DEBUG_WIN) printf("win_underflow: sp_ptr=0x%x load_cwp=%d\n", (int)sp_ptr, cwp1); #endif for(i = 0; i < 16; i++) { - get_user(reg, sp_ptr); - env->regbase[get_reg_index(env, cwp1, 8 + i)] = reg; - sp_ptr++; + env->regbase[get_reg_index(env, cwp1, 8 + i)] = tgetl(sp_ptr); + sp_ptr += sizeof(target_ulong); } env->wim = new_wim; +#ifdef TARGET_SPARC64 + env->canrestore++; + if (env->cleanwin < NWINDOWS - 1) + env->cleanwin++; + env->cansave--; +#endif } static void flush_windows(CPUSPARCState *env) @@ -548,17 +548,29 @@ void cpu_loop (CPUSPARCState *env) trapnr = cpu_sparc_exec (env); switch (trapnr) { +#ifndef TARGET_SPARC64 case 0x88: case 0x90: +#else + case 0x16d: +#endif ret = do_syscall (env, env->gregs[1], env->regwptr[0], env->regwptr[1], env->regwptr[2], env->regwptr[3], env->regwptr[4], env->regwptr[5]); if ((unsigned int)ret >= (unsigned int)(-515)) { +#ifdef TARGET_SPARC64 + env->xcc |= PSR_CARRY; +#else env->psr |= PSR_CARRY; +#endif ret = -ret; } else { +#ifdef TARGET_SPARC64 + env->xcc &= ~PSR_CARRY; +#else env->psr &= ~PSR_CARRY; +#endif } env->regwptr[0] = ret; /* next instruction */ @@ -590,10 +602,17 @@ void cpu_loop (CPUSPARCState *env) } break; #else + case TT_SPILL: /* window overflow */ + save_window(env); + break; + case TT_FILL: /* window underflow */ + restore_window(env); + break; // XXX #endif - case 0x100: // XXX, why do we get these? - break; + case EXCP_INTERRUPT: + /* just indicate that signals should be handled asap */ + break; case EXCP_DEBUG: { int sig; @@ -651,18 +670,23 @@ void cpu_ppc_store_tbl (CPUState *env, uint32_t value) { cpu_ppc_store_tb(env, ((uint64_t)cpu_ppc_load_tbl(env) << 32) | value); } - -uint32_t cpu_ppc_load_decr (CPUState *env) + +void cpu_ppc601_store_rtcu (CPUState *env, uint32_t value) +__attribute__ (( alias ("cpu_ppc_store_tbu") )); + +uint32_t cpu_ppc601_load_rtcu (CPUState *env) +__attribute__ (( alias ("cpu_ppc_load_tbu") )); + +void cpu_ppc601_store_rtcl (CPUState *env, uint32_t value) { - /* TO FIX */ - return -1; + cpu_ppc_store_tbl(env, value & 0x3FFFFF80); } - -void cpu_ppc_store_decr (CPUState *env, uint32_t value) + +uint32_t cpu_ppc601_load_rtcl (CPUState *env) { - /* TO FIX */ + return cpu_ppc_load_tbl(env) & 0x3FFFFF80; } - + void cpu_loop(CPUPPCState *env) { target_siginfo_t info; @@ -1278,6 +1302,7 @@ static const uint8_t mips_syscall_args[] = { MIPS_SYS(sys_add_key , 5) MIPS_SYS(sys_request_key , 4) MIPS_SYS(sys_keyctl , 5) + MIPS_SYS(sys_set_thread_area, 1) }; #undef MIPS_SYS @@ -1295,6 +1320,7 @@ void cpu_loop(CPUMIPSState *env) case EXCP_SYSCALL: { syscall_num = env->gpr[2] - 4000; + env->PC += 4; if (syscall_num >= sizeof(mips_syscall_args)) { ret = -ENOSYS; } else { @@ -1302,15 +1328,9 @@ void cpu_loop(CPUMIPSState *env) if (nb_args >= 5) { sp_reg = env->gpr[29]; /* these arguments are taken from the stack */ - if (get_user(arg5, (target_ulong *)(sp_reg + 16))) { - ret = -EFAULT; - goto fail; - } + arg5 = tgetl(sp_reg + 16); if (nb_args >= 6) { - if (get_user(arg6, (target_ulong *)(sp_reg + 20))) { - ret = -EFAULT; - goto fail; - } + arg6 = tgetl(sp_reg + 20); } else { arg6 = 0; } @@ -1327,8 +1347,6 @@ void cpu_loop(CPUMIPSState *env) arg5, arg6); } - fail: - env->PC += 4; if ((unsigned int)ret >= (unsigned int)(-1133)) { env->gpr[7] = 1; /* error flag */ ret = -ret; @@ -1340,41 +1358,30 @@ void cpu_loop(CPUMIPSState *env) } } break; + case EXCP_TLBL: + case EXCP_TLBS: case EXCP_CpU: case EXCP_RI: + info.si_signo = TARGET_SIGILL; + info.si_errno = 0; + info.si_code = 0; + queue_signal(info.si_signo, &info); + break; + case EXCP_INTERRUPT: + /* just indicate that signals should be handled asap */ + break; + case EXCP_DEBUG: { - uint32_t insn, op; - - if (get_user(insn, (uint32_t *)env->PC) < 0) - goto sigill; - op = insn >> 26; - // printf("insn=%08x op=%02x\n", insn, op); - /* XXX: totally dummy FP ops just to be able to launch - a few executables */ - switch(op) { - case 0x31: /* LWC1 */ - env->PC += 4; - break; - case 0x39: /* SWC1 */ - env->PC += 4; - break; - case 0x11: - switch((insn >> 21) & 0x1f) { - case 0x02: /* CFC1 */ - env->PC += 4; - break; - default: - goto sigill; - } - break; - default: - sigill: - info.si_signo = TARGET_SIGILL; + int sig; + + sig = gdb_handlesig (env, TARGET_SIGTRAP); + if (sig) + { + info.si_signo = sig; info.si_errno = 0; - info.si_code = 0; + info.si_code = TARGET_TRAP_BRKPT; queue_signal(info.si_signo, &info); - break; - } + } } break; default: @@ -1389,16 +1396,155 @@ void cpu_loop(CPUMIPSState *env) } #endif +#ifdef TARGET_SH4 +void cpu_loop (CPUState *env) +{ + int trapnr, ret; + target_siginfo_t info; + + while (1) { + trapnr = cpu_sh4_exec (env); + + switch (trapnr) { + case 0x160: + ret = do_syscall(env, + env->gregs[3], + env->gregs[4], + env->gregs[5], + env->gregs[6], + env->gregs[7], + env->gregs[0], + 0); + env->gregs[0] = ret; + env->pc += 2; + break; + case EXCP_DEBUG: + { + int sig; + + sig = gdb_handlesig (env, TARGET_SIGTRAP); + if (sig) + { + info.si_signo = sig; + info.si_errno = 0; + info.si_code = TARGET_TRAP_BRKPT; + queue_signal(info.si_signo, &info); + } + } + break; + default: + printf ("Unhandled trap: 0x%x\n", trapnr); + cpu_dump_state(env, stderr, fprintf, 0); + exit (1); + } + process_pending_signals (env); + } +} +#endif + +#ifdef TARGET_M68K + +void cpu_loop(CPUM68KState *env) +{ + int trapnr; + unsigned int n; + target_siginfo_t info; + TaskState *ts = env->opaque; + + for(;;) { + trapnr = cpu_m68k_exec(env); + switch(trapnr) { + case EXCP_ILLEGAL: + { + if (ts->sim_syscalls) { + uint16_t nr; + nr = lduw(env->pc + 2); + env->pc += 4; + do_m68k_simcall(env, nr); + } else { + goto do_sigill; + } + } + break; + case EXCP_HALTED: + /* Semihosing syscall. */ + env->pc += 2; + do_m68k_semihosting(env, env->dregs[0]); + break; + case EXCP_LINEA: + case EXCP_LINEF: + case EXCP_UNSUPPORTED: + do_sigill: + info.si_signo = SIGILL; + info.si_errno = 0; + info.si_code = TARGET_ILL_ILLOPN; + info._sifields._sigfault._addr = env->pc; + queue_signal(info.si_signo, &info); + break; + case EXCP_TRAP0: + { + ts->sim_syscalls = 0; + n = env->dregs[0]; + env->pc += 2; + env->dregs[0] = do_syscall(env, + n, + env->dregs[1], + env->dregs[2], + env->dregs[3], + env->dregs[4], + env->dregs[5], + env->dregs[6]); + } + break; + case EXCP_INTERRUPT: + /* just indicate that signals should be handled asap */ + break; + case EXCP_ACCESS: + { + info.si_signo = SIGSEGV; + info.si_errno = 0; + /* XXX: check env->error_code */ + info.si_code = TARGET_SEGV_MAPERR; + info._sifields._sigfault._addr = env->mmu.ar; + queue_signal(info.si_signo, &info); + } + break; + case EXCP_DEBUG: + { + int sig; + + sig = gdb_handlesig (env, TARGET_SIGTRAP); + if (sig) + { + info.si_signo = sig; + info.si_errno = 0; + info.si_code = TARGET_TRAP_BRKPT; + queue_signal(info.si_signo, &info); + } + } + break; + default: + fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", + trapnr); + cpu_dump_state(env, stderr, fprintf, 0); + abort(); + } + process_pending_signals(env); + } +} +#endif /* TARGET_M68K */ + void usage(void) { - printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2005 Fabrice Bellard\n" - "usage: qemu-" TARGET_ARCH " [-h] [-g] [-d opts] [-L path] [-s size] program [arguments...]\n" + printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2007 Fabrice Bellard\n" + "usage: qemu-" TARGET_ARCH " [-h] [-g] [-d opts] [-L path] [-s size] [-cpu model] program [arguments...]\n" "Linux CPU emulator (compiled for %s emulation)\n" "\n" "-h print this help\n" "-g port wait gdb connection to port\n" "-L path set the elf interpreter prefix (default=%s)\n" "-s size set the stack size in bytes (default=%ld)\n" + "-cpu model select CPU (-cpu ? for list)\n" "\n" "debug options:\n" #ifdef USE_CODE_COPY @@ -1422,6 +1568,7 @@ TaskState *first_task_state; int main(int argc, char **argv) { const char *filename; + const char *cpu_model; struct target_pt_regs regs1, *regs = ®s1; struct image_info info1, *info = &info1; TaskState ts1, *ts = &ts1; @@ -1436,6 +1583,7 @@ int main(int argc, char **argv) /* init debug */ cpu_set_log_filename(DEBUG_LOGFILE); + cpu_model = NULL; optind = 1; for(;;) { if (optind >= argc) @@ -1484,6 +1632,20 @@ int main(int argc, char **argv) } } else if (!strcmp(r, "g")) { gdbstub_port = atoi(argv[optind++]); + } else if (!strcmp(r, "r")) { + qemu_uname_release = argv[optind++]; + } else if (!strcmp(r, "cpu")) { + cpu_model = argv[optind++]; + if (strcmp(cpu_model, "?") == 0) { +#if defined(TARGET_PPC) + ppc_cpu_list(stdout, &fprintf); +#elif defined(TARGET_ARM) + arm_cpu_list(); +#elif defined(TARGET_MIPS) + mips_cpu_list(stdout, &fprintf); +#endif + _exit(1); + } } else #ifdef USE_CODE_COPY if (!strcmp(r, "no-code-copy")) { @@ -1512,7 +1674,7 @@ int main(int argc, char **argv) env = cpu_init(); global_env = env; - if (elf_exec(filename, argv+optind, environ, regs, info) != 0) { + if (loader_exec(filename, argv+optind, environ, regs, info) != 0) { printf("Error loading %s\n", filename); _exit(1); } @@ -1523,13 +1685,14 @@ int main(int argc, char **argv) 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, "start_data 0x%08lx\n" , info->start_data); 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); + target_set_brk(info->brk); syscall_init(); signal_init(); @@ -1537,6 +1700,7 @@ int main(int argc, char **argv) memset(ts, 0, sizeof(TaskState)); env->opaque = ts; ts->used = 1; + ts->info = info; env->user_mode_only = 1; #if defined(TARGET_I386) @@ -1564,7 +1728,7 @@ int main(int argc, char **argv) env->eip = regs->eip; /* linux interrupt setup */ - env->idt.base = (long)idt_table; + env->idt.base = h2g(idt_table); env->idt.limit = sizeof(idt_table) - 1; set_idt(0, 0); set_idt(1, 0); @@ -1589,7 +1753,7 @@ int main(int argc, char **argv) set_idt(0x80, 3); /* linux segment setup */ - env->gdt.base = (long)gdt_table; + env->gdt.base = h2g(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 | @@ -1607,6 +1771,9 @@ int main(int argc, char **argv) #elif defined(TARGET_ARM) { int i; + if (cpu_model == NULL) + cpu_model = "arm926"; + cpu_arm_set_model(env, cpu_model); cpsr_write(env, regs->uregs[16], 0xffffffff); for(i = 0; i < 16; i++) { env->regs[i] = regs->uregs[i]; @@ -1633,15 +1800,9 @@ int main(int argc, char **argv) int i; /* Choose and initialise CPU */ - /* XXX: CPU model (or PVR) should be provided on command line */ - // ppc_find_by_name("750gx", &def); - // ppc_find_by_name("750fx", &def); - // ppc_find_by_name("750p", &def); - ppc_find_by_name("750", &def); - // ppc_find_by_name("G3", &def); - // ppc_find_by_name("604r", &def); - // ppc_find_by_name("604e", &def); - // ppc_find_by_name("604", &def); + if (cpu_model == NULL) + cpu_model = "750"; + ppc_find_by_name(cpu_model, &def); if (def == NULL) { cpu_abort(env, "Unable to find PowerPC CPU definition\n"); @@ -1657,14 +1818,64 @@ int main(int argc, char **argv) env->gpr[i] = regs->gpr[i]; } } +#elif defined(TARGET_M68K) + { + m68k_def_t *def; + def = m68k_find_by_name("cfv4e"); + if (def == NULL) { + cpu_abort(cpu_single_env, + "Unable to find m68k CPU definition\n"); + } + cpu_m68k_register(cpu_single_env, def); + env->pc = regs->pc; + env->dregs[0] = regs->d0; + env->dregs[1] = regs->d1; + env->dregs[2] = regs->d2; + env->dregs[3] = regs->d3; + env->dregs[4] = regs->d4; + env->dregs[5] = regs->d5; + env->dregs[6] = regs->d6; + env->dregs[7] = regs->d7; + env->aregs[0] = regs->a0; + env->aregs[1] = regs->a1; + env->aregs[2] = regs->a2; + env->aregs[3] = regs->a3; + env->aregs[4] = regs->a4; + env->aregs[5] = regs->a5; + env->aregs[6] = regs->a6; + env->aregs[7] = regs->usp; + env->sr = regs->sr; + ts->sim_syscalls = 1; + } #elif defined(TARGET_MIPS) { + mips_def_t *def; int i; + /* Choose and initialise CPU */ + if (cpu_model == NULL) + cpu_model = "24Kf"; + mips_find_by_name(cpu_model, &def); + if (def == NULL) + cpu_abort(env, "Unable to find MIPS CPU definition\n"); + cpu_mips_register(env, def); + for(i = 0; i < 32; i++) { env->gpr[i] = regs->regs[i]; } env->PC = regs->cp0_epc; + if (env->CP0_Config1 & (1 << CP0C1_FP)) { + env->CP0_Status |= (1 << CP0St_CU1); + } + } +#elif defined(TARGET_SH4) + { + int i; + + for(i = 0; i < 16; i++) { + env->gregs[i] = regs->regs[i]; + } + env->pc = regs->pc; } #else #error unsupported target CPU