![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / linux-user|
Return to main.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / linux-user |
1.1 ! root 1: /* ! 2: * qemu user main ! 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> ! 23: #include <string.h> ! 24: #include <errno.h> ! 25: #include <unistd.h> ! 26: ! 27: #include "qemu.h" ! 28: ! 29: #define DEBUG_LOGFILE "/tmp/qemu.log" ! 30: ! 31: #ifdef __APPLE__ ! 32: #include <crt_externs.h> ! 33: # define environ (*_NSGetEnviron()) ! 34: #endif ! 35: ! 36: static const char *interp_prefix = CONFIG_QEMU_PREFIX; ! 37: ! 38: #if defined(__i386__) && !defined(CONFIG_STATIC) ! 39: /* Force usage of an ELF interpreter even if it is an ELF shared ! 40: object ! */ ! 41: const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2"; ! 42: #endif ! 43: ! 44: /* for recent libc, we add these dummy symbols which are not declared ! 45: when generating a linked object (bug in ld ?) */ ! 46: #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(CONFIG_STATIC) ! 47: long __preinit_array_start[0]; ! 48: long __preinit_array_end[0]; ! 49: long __init_array_start[0]; ! 50: long __init_array_end[0]; ! 51: long __fini_array_start[0]; ! 52: long __fini_array_end[0]; ! 53: #endif ! 54: ! 55: /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so ! 56: we allocate a bigger stack. Need a better solution, for example ! 57: by remapping the process stack directly at the right place */ ! 58: unsigned long x86_stack_size = 512 * 1024; ! 59: ! 60: void gemu_log(const char *fmt, ...) ! 61: { ! 62: va_list ap; ! 63: ! 64: va_start(ap, fmt); ! 65: vfprintf(stderr, fmt, ap); ! 66: va_end(ap); ! 67: } ! 68: ! 69: void cpu_outb(CPUState *env, int addr, int val) ! 70: { ! 71: fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val); ! 72: } ! 73: ! 74: void cpu_outw(CPUState *env, int addr, int val) ! 75: { ! 76: fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val); ! 77: } ! 78: ! 79: void cpu_outl(CPUState *env, int addr, int val) ! 80: { ! 81: fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val); ! 82: } ! 83: ! 84: int cpu_inb(CPUState *env, int addr) ! 85: { ! 86: fprintf(stderr, "inb: port=0x%04x\n", addr); ! 87: return 0; ! 88: } ! 89: ! 90: int cpu_inw(CPUState *env, int addr) ! 91: { ! 92: fprintf(stderr, "inw: port=0x%04x\n", addr); ! 93: return 0; ! 94: } ! 95: ! 96: int cpu_inl(CPUState *env, int addr) ! 97: { ! 98: fprintf(stderr, "inl: port=0x%04x\n", addr); ! 99: return 0; ! 100: } ! 101: ! 102: int cpu_get_pic_interrupt(CPUState *env) ! 103: { ! 104: return -1; ! 105: } ! 106: ! 107: /* timers for rdtsc */ ! 108: ! 109: #if defined(__i386__) ! 110: ! 111: int64_t cpu_get_real_ticks(void) ! 112: { ! 113: int64_t val; ! 114: asm volatile ("rdtsc" : "=A" (val)); ! 115: return val; ! 116: } ! 117: ! 118: #elif defined(__x86_64__) ! 119: ! 120: int64_t cpu_get_real_ticks(void) ! 121: { ! 122: uint32_t low,high; ! 123: int64_t val; ! 124: asm volatile("rdtsc" : "=a" (low), "=d" (high)); ! 125: val = high; ! 126: val <<= 32; ! 127: val |= low; ! 128: return val; ! 129: } ! 130: ! 131: #else ! 132: ! 133: static uint64_t emu_time; ! 134: ! 135: int64_t cpu_get_real_ticks(void) ! 136: { ! 137: return emu_time++; ! 138: } ! 139: ! 140: #endif ! 141: ! 142: #ifdef TARGET_I386 ! 143: /***********************************************************/ ! 144: /* CPUX86 core interface */ ! 145: ! 146: uint64_t cpu_get_tsc(CPUX86State *env) ! 147: { ! 148: return cpu_get_real_ticks(); ! 149: } ! 150: ! 151: static void write_dt(void *ptr, unsigned long addr, unsigned long limit, ! 152: int flags) ! 153: { ! 154: unsigned int e1, e2; ! 155: e1 = (addr << 16) | (limit & 0xffff); ! 156: e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); ! 157: e2 |= flags; ! 158: stl((uint8_t *)ptr, e1); ! 159: stl((uint8_t *)ptr + 4, e2); ! 160: } ! 161: ! 162: static void set_gate(void *ptr, unsigned int type, unsigned int dpl, ! 163: unsigned long addr, unsigned int sel) ! 164: { ! 165: unsigned int e1, e2; ! 166: e1 = (addr & 0xffff) | (sel << 16); ! 167: e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); ! 168: stl((uint8_t *)ptr, e1); ! 169: stl((uint8_t *)ptr + 4, e2); ! 170: } ! 171: ! 172: uint64_t gdt_table[6]; ! 173: uint64_t idt_table[256]; ! 174: ! 175: /* only dpl matters as we do only user space emulation */ ! 176: static void set_idt(int n, unsigned int dpl) ! 177: { ! 178: set_gate(idt_table + n, 0, dpl, 0, 0); ! 179: } ! 180: ! 181: void cpu_loop(CPUX86State *env) ! 182: { ! 183: int trapnr; ! 184: target_ulong pc; ! 185: target_siginfo_t info; ! 186: ! 187: for(;;) { ! 188: trapnr = cpu_x86_exec(env); ! 189: switch(trapnr) { ! 190: case 0x80: ! 191: /* linux syscall */ ! 192: env->regs[R_EAX] = do_syscall(env, ! 193: env->regs[R_EAX], ! 194: env->regs[R_EBX], ! 195: env->regs[R_ECX], ! 196: env->regs[R_EDX], ! 197: env->regs[R_ESI], ! 198: env->regs[R_EDI], ! 199: env->regs[R_EBP]); ! 200: break; ! 201: case EXCP0B_NOSEG: ! 202: case EXCP0C_STACK: ! 203: info.si_signo = SIGBUS; ! 204: info.si_errno = 0; ! 205: info.si_code = TARGET_SI_KERNEL; ! 206: info._sifields._sigfault._addr = 0; ! 207: queue_signal(info.si_signo, &info); ! 208: break; ! 209: case EXCP0D_GPF: ! 210: if (env->eflags & VM_MASK) { ! 211: handle_vm86_fault(env); ! 212: } else { ! 213: info.si_signo = SIGSEGV; ! 214: info.si_errno = 0; ! 215: info.si_code = TARGET_SI_KERNEL; ! 216: info._sifields._sigfault._addr = 0; ! 217: queue_signal(info.si_signo, &info); ! 218: } ! 219: break; ! 220: case EXCP0E_PAGE: ! 221: info.si_signo = SIGSEGV; ! 222: info.si_errno = 0; ! 223: if (!(env->error_code & 1)) ! 224: info.si_code = TARGET_SEGV_MAPERR; ! 225: else ! 226: info.si_code = TARGET_SEGV_ACCERR; ! 227: info._sifields._sigfault._addr = env->cr[2]; ! 228: queue_signal(info.si_signo, &info); ! 229: break; ! 230: case EXCP00_DIVZ: ! 231: if (env->eflags & VM_MASK) { ! 232: handle_vm86_trap(env, trapnr); ! 233: } else { ! 234: /* division by zero */ ! 235: info.si_signo = SIGFPE; ! 236: info.si_errno = 0; ! 237: info.si_code = TARGET_FPE_INTDIV; ! 238: info._sifields._sigfault._addr = env->eip; ! 239: queue_signal(info.si_signo, &info); ! 240: } ! 241: break; ! 242: case EXCP01_SSTP: ! 243: case EXCP03_INT3: ! 244: if (env->eflags & VM_MASK) { ! 245: handle_vm86_trap(env, trapnr); ! 246: } else { ! 247: info.si_signo = SIGTRAP; ! 248: info.si_errno = 0; ! 249: if (trapnr == EXCP01_SSTP) { ! 250: info.si_code = TARGET_TRAP_BRKPT; ! 251: info._sifields._sigfault._addr = env->eip; ! 252: } else { ! 253: info.si_code = TARGET_SI_KERNEL; ! 254: info._sifields._sigfault._addr = 0; ! 255: } ! 256: queue_signal(info.si_signo, &info); ! 257: } ! 258: break; ! 259: case EXCP04_INTO: ! 260: case EXCP05_BOUND: ! 261: if (env->eflags & VM_MASK) { ! 262: handle_vm86_trap(env, trapnr); ! 263: } else { ! 264: info.si_signo = SIGSEGV; ! 265: info.si_errno = 0; ! 266: info.si_code = TARGET_SI_KERNEL; ! 267: info._sifields._sigfault._addr = 0; ! 268: queue_signal(info.si_signo, &info); ! 269: } ! 270: break; ! 271: case EXCP06_ILLOP: ! 272: info.si_signo = SIGILL; ! 273: info.si_errno = 0; ! 274: info.si_code = TARGET_ILL_ILLOPN; ! 275: info._sifields._sigfault._addr = env->eip; ! 276: queue_signal(info.si_signo, &info); ! 277: break; ! 278: case EXCP_INTERRUPT: ! 279: /* just indicate that signals should be handled asap */ ! 280: break; ! 281: case EXCP_DEBUG: ! 282: { ! 283: int sig; ! 284: ! 285: sig = gdb_handlesig (env, TARGET_SIGTRAP); ! 286: if (sig) ! 287: { ! 288: info.si_signo = sig; ! 289: info.si_errno = 0; ! 290: info.si_code = TARGET_TRAP_BRKPT; ! 291: queue_signal(info.si_signo, &info); ! 292: } ! 293: } ! 294: break; ! 295: default: ! 296: pc = env->segs[R_CS].base + env->eip; ! 297: fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n", ! 298: (long)pc, trapnr); ! 299: abort(); ! 300: } ! 301: process_pending_signals(env); ! 302: } ! 303: } ! 304: #endif ! 305: ! 306: #ifdef TARGET_ARM ! 307: ! 308: /* XXX: find a better solution */ ! 309: extern void tb_invalidate_page_range(target_ulong start, target_ulong end); ! 310: ! 311: static void arm_cache_flush(target_ulong start, target_ulong last) ! 312: { ! 313: target_ulong addr, last1; ! 314: ! 315: if (last < start) ! 316: return; ! 317: addr = start; ! 318: for(;;) { ! 319: last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1; ! 320: if (last1 > last) ! 321: last1 = last; ! 322: tb_invalidate_page_range(addr, last1 + 1); ! 323: if (last1 == last) ! 324: break; ! 325: addr = last1 + 1; ! 326: } ! 327: } ! 328: ! 329: void cpu_loop(CPUARMState *env) ! 330: { ! 331: int trapnr; ! 332: unsigned int n, insn; ! 333: target_siginfo_t info; ! 334: ! 335: for(;;) { ! 336: trapnr = cpu_arm_exec(env); ! 337: switch(trapnr) { ! 338: case EXCP_UDEF: ! 339: { ! 340: TaskState *ts = env->opaque; ! 341: uint32_t opcode; ! 342: ! 343: /* we handle the FPU emulation here, as Linux */ ! 344: /* we get the opcode */ ! 345: opcode = ldl_raw((uint8_t *)env->regs[15]); ! 346: ! 347: if (EmulateAll(opcode, &ts->fpa, env->regs) == 0) { ! 348: info.si_signo = SIGILL; ! 349: info.si_errno = 0; ! 350: info.si_code = TARGET_ILL_ILLOPN; ! 351: info._sifields._sigfault._addr = env->regs[15]; ! 352: queue_signal(info.si_signo, &info); ! 353: } else { ! 354: /* increment PC */ ! 355: env->regs[15] += 4; ! 356: } ! 357: } ! 358: break; ! 359: case EXCP_SWI: ! 360: { ! 361: /* system call */ ! 362: if (env->thumb) { ! 363: insn = lduw((void *)(env->regs[15] - 2)); ! 364: n = insn & 0xff; ! 365: } else { ! 366: insn = ldl((void *)(env->regs[15] - 4)); ! 367: n = insn & 0xffffff; ! 368: } ! 369: ! 370: if (n == ARM_NR_cacheflush) { ! 371: arm_cache_flush(env->regs[0], env->regs[1]); ! 372: } else if (n == ARM_NR_semihosting ! 373: || n == ARM_NR_thumb_semihosting) { ! 374: env->regs[0] = do_arm_semihosting (env); ! 375: } else if (n >= ARM_SYSCALL_BASE ! 376: || (env->thumb && n == ARM_THUMB_SYSCALL)) { ! 377: /* linux syscall */ ! 378: if (env->thumb) { ! 379: n = env->regs[7]; ! 380: } else { ! 381: n -= ARM_SYSCALL_BASE; ! 382: } ! 383: env->regs[0] = do_syscall(env, ! 384: n, ! 385: env->regs[0], ! 386: env->regs[1], ! 387: env->regs[2], ! 388: env->regs[3], ! 389: env->regs[4], ! 390: env->regs[5]); ! 391: } else { ! 392: goto error; ! 393: } ! 394: } ! 395: break; ! 396: case EXCP_INTERRUPT: ! 397: /* just indicate that signals should be handled asap */ ! 398: break; ! 399: case EXCP_PREFETCH_ABORT: ! 400: case EXCP_DATA_ABORT: ! 401: { ! 402: info.si_signo = SIGSEGV; ! 403: info.si_errno = 0; ! 404: /* XXX: check env->error_code */ ! 405: info.si_code = TARGET_SEGV_MAPERR; ! 406: info._sifields._sigfault._addr = env->cp15_6; ! 407: queue_signal(info.si_signo, &info); ! 408: } ! 409: break; ! 410: case EXCP_DEBUG: ! 411: { ! 412: int sig; ! 413: ! 414: sig = gdb_handlesig (env, TARGET_SIGTRAP); ! 415: if (sig) ! 416: { ! 417: info.si_signo = sig; ! 418: info.si_errno = 0; ! 419: info.si_code = TARGET_TRAP_BRKPT; ! 420: queue_signal(info.si_signo, &info); ! 421: } ! 422: } ! 423: break; ! 424: default: ! 425: error: ! 426: fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", ! 427: trapnr); ! 428: cpu_dump_state(env, stderr, fprintf, 0); ! 429: abort(); ! 430: } ! 431: process_pending_signals(env); ! 432: } ! 433: } ! 434: ! 435: #endif ! 436: ! 437: #ifdef TARGET_SPARC ! 438: ! 439: //#define DEBUG_WIN ! 440: ! 441: /* WARNING: dealing with register windows _is_ complicated. More info ! 442: can be found at http://www.sics.se/~psm/sparcstack.html */ ! 443: static inline int get_reg_index(CPUSPARCState *env, int cwp, int index) ! 444: { ! 445: index = (index + cwp * 16) & (16 * NWINDOWS - 1); ! 446: /* wrap handling : if cwp is on the last window, then we use the ! 447: registers 'after' the end */ ! 448: if (index < 8 && env->cwp == (NWINDOWS - 1)) ! 449: index += (16 * NWINDOWS); ! 450: return index; ! 451: } ! 452: ! 453: /* save the register window 'cwp1' */ ! 454: static inline void save_window_offset(CPUSPARCState *env, int cwp1) ! 455: { ! 456: unsigned int i; ! 457: uint32_t *sp_ptr; ! 458: ! 459: sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]); ! 460: #if defined(DEBUG_WIN) ! 461: printf("win_overflow: sp_ptr=0x%x save_cwp=%d\n", ! 462: (int)sp_ptr, cwp1); ! 463: #endif ! 464: for(i = 0; i < 16; i++) { ! 465: put_user(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); ! 466: sp_ptr++; ! 467: } ! 468: } ! 469: ! 470: static void save_window(CPUSPARCState *env) ! 471: { ! 472: unsigned int new_wim; ! 473: new_wim = ((env->wim >> 1) | (env->wim << (NWINDOWS - 1))) & ! 474: ((1LL << NWINDOWS) - 1); ! 475: save_window_offset(env, (env->cwp - 2) & (NWINDOWS - 1)); ! 476: env->wim = new_wim; ! 477: } ! 478: ! 479: static void restore_window(CPUSPARCState *env) ! 480: { ! 481: unsigned int new_wim, i, cwp1; ! 482: uint32_t *sp_ptr, reg; ! 483: ! 484: new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) & ! 485: ((1LL << NWINDOWS) - 1); ! 486: ! 487: /* restore the invalid window */ ! 488: cwp1 = (env->cwp + 1) & (NWINDOWS - 1); ! 489: sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]); ! 490: #if defined(DEBUG_WIN) ! 491: printf("win_underflow: sp_ptr=0x%x load_cwp=%d\n", ! 492: (int)sp_ptr, cwp1); ! 493: #endif ! 494: for(i = 0; i < 16; i++) { ! 495: get_user(reg, sp_ptr); ! 496: env->regbase[get_reg_index(env, cwp1, 8 + i)] = reg; ! 497: sp_ptr++; ! 498: } ! 499: env->wim = new_wim; ! 500: } ! 501: ! 502: static void flush_windows(CPUSPARCState *env) ! 503: { ! 504: int offset, cwp1; ! 505: ! 506: offset = 1; ! 507: for(;;) { ! 508: /* if restore would invoke restore_window(), then we can stop */ ! 509: cwp1 = (env->cwp + offset) & (NWINDOWS - 1); ! 510: if (env->wim & (1 << cwp1)) ! 511: break; ! 512: save_window_offset(env, cwp1); ! 513: offset++; ! 514: } ! 515: /* set wim so that restore will reload the registers */ ! 516: cwp1 = (env->cwp + 1) & (NWINDOWS - 1); ! 517: env->wim = 1 << cwp1; ! 518: #if defined(DEBUG_WIN) ! 519: printf("flush_windows: nb=%d\n", offset - 1); ! 520: #endif ! 521: } ! 522: ! 523: void cpu_loop (CPUSPARCState *env) ! 524: { ! 525: int trapnr, ret; ! 526: target_siginfo_t info; ! 527: ! 528: while (1) { ! 529: trapnr = cpu_sparc_exec (env); ! 530: ! 531: switch (trapnr) { ! 532: case 0x88: ! 533: case 0x90: ! 534: ret = do_syscall (env, env->gregs[1], ! 535: env->regwptr[0], env->regwptr[1], ! 536: env->regwptr[2], env->regwptr[3], ! 537: env->regwptr[4], env->regwptr[5]); ! 538: if ((unsigned int)ret >= (unsigned int)(-515)) { ! 539: env->psr |= PSR_CARRY; ! 540: ret = -ret; ! 541: } else { ! 542: env->psr &= ~PSR_CARRY; ! 543: } ! 544: env->regwptr[0] = ret; ! 545: /* next instruction */ ! 546: env->pc = env->npc; ! 547: env->npc = env->npc + 4; ! 548: break; ! 549: case 0x83: /* flush windows */ ! 550: flush_windows(env); ! 551: /* next instruction */ ! 552: env->pc = env->npc; ! 553: env->npc = env->npc + 4; ! 554: break; ! 555: #ifndef TARGET_SPARC64 ! 556: case TT_WIN_OVF: /* window overflow */ ! 557: save_window(env); ! 558: break; ! 559: case TT_WIN_UNF: /* window underflow */ ! 560: restore_window(env); ! 561: break; ! 562: case TT_TFAULT: ! 563: case TT_DFAULT: ! 564: { ! 565: info.si_signo = SIGSEGV; ! 566: info.si_errno = 0; ! 567: /* XXX: check env->error_code */ ! 568: info.si_code = TARGET_SEGV_MAPERR; ! 569: info._sifields._sigfault._addr = env->mmuregs[4]; ! 570: queue_signal(info.si_signo, &info); ! 571: } ! 572: break; ! 573: #else ! 574: // XXX ! 575: #endif ! 576: case 0x100: // XXX, why do we get these? ! 577: break; ! 578: case EXCP_DEBUG: ! 579: { ! 580: int sig; ! 581: ! 582: sig = gdb_handlesig (env, TARGET_SIGTRAP); ! 583: if (sig) ! 584: { ! 585: info.si_signo = sig; ! 586: info.si_errno = 0; ! 587: info.si_code = TARGET_TRAP_BRKPT; ! 588: queue_signal(info.si_signo, &info); ! 589: } ! 590: } ! 591: break; ! 592: default: ! 593: printf ("Unhandled trap: 0x%x\n", trapnr); ! 594: cpu_dump_state(env, stderr, fprintf, 0); ! 595: exit (1); ! 596: } ! 597: process_pending_signals (env); ! 598: } ! 599: } ! 600: ! 601: #endif ! 602: ! 603: #ifdef TARGET_PPC ! 604: ! 605: static inline uint64_t cpu_ppc_get_tb (CPUState *env) ! 606: { ! 607: /* TO FIX */ ! 608: return 0; ! 609: } ! 610: ! 611: uint32_t cpu_ppc_load_tbl (CPUState *env) ! 612: { ! 613: return cpu_ppc_get_tb(env) & 0xFFFFFFFF; ! 614: } ! 615: ! 616: uint32_t cpu_ppc_load_tbu (CPUState *env) ! 617: { ! 618: return cpu_ppc_get_tb(env) >> 32; ! 619: } ! 620: ! 621: static void cpu_ppc_store_tb (CPUState *env, uint64_t value) ! 622: { ! 623: /* TO FIX */ ! 624: } ! 625: ! 626: void cpu_ppc_store_tbu (CPUState *env, uint32_t value) ! 627: { ! 628: cpu_ppc_store_tb(env, ((uint64_t)value << 32) | cpu_ppc_load_tbl(env)); ! 629: } ! 630: ! 631: void cpu_ppc_store_tbl (CPUState *env, uint32_t value) ! 632: { ! 633: cpu_ppc_store_tb(env, ((uint64_t)cpu_ppc_load_tbl(env) << 32) | value); ! 634: } ! 635: ! 636: uint32_t cpu_ppc_load_decr (CPUState *env) ! 637: { ! 638: /* TO FIX */ ! 639: return -1; ! 640: } ! 641: ! 642: void cpu_ppc_store_decr (CPUState *env, uint32_t value) ! 643: { ! 644: /* TO FIX */ ! 645: } ! 646: ! 647: void cpu_loop(CPUPPCState *env) ! 648: { ! 649: target_siginfo_t info; ! 650: int trapnr; ! 651: uint32_t ret; ! 652: ! 653: for(;;) { ! 654: trapnr = cpu_ppc_exec(env); ! 655: if (trapnr != EXCP_SYSCALL_USER && trapnr != EXCP_BRANCH && ! 656: trapnr != EXCP_TRACE) { ! 657: if (loglevel > 0) { ! 658: cpu_dump_state(env, logfile, fprintf, 0); ! 659: } ! 660: } ! 661: switch(trapnr) { ! 662: case EXCP_NONE: ! 663: break; ! 664: case EXCP_SYSCALL_USER: ! 665: /* system call */ ! 666: /* WARNING: ! 667: * PPC ABI uses overflow flag in cr0 to signal an error ! 668: * in syscalls. ! 669: */ ! 670: #if 0 ! 671: printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0], ! 672: env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]); ! 673: #endif ! 674: env->crf[0] &= ~0x1; ! 675: ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4], ! 676: env->gpr[5], env->gpr[6], env->gpr[7], ! 677: env->gpr[8]); ! 678: if (ret > (uint32_t)(-515)) { ! 679: env->crf[0] |= 0x1; ! 680: ret = -ret; ! 681: } ! 682: env->gpr[3] = ret; ! 683: #if 0 ! 684: printf("syscall returned 0x%08x (%d)\n", ret, ret); ! 685: #endif ! 686: break; ! 687: case EXCP_RESET: ! 688: /* Should not happen ! */ ! 689: fprintf(stderr, "RESET asked... Stop emulation\n"); ! 690: if (loglevel) ! 691: fprintf(logfile, "RESET asked... Stop emulation\n"); ! 692: abort(); ! 693: case EXCP_MACHINE_CHECK: ! 694: fprintf(stderr, "Machine check exeption... Stop emulation\n"); ! 695: if (loglevel) ! 696: fprintf(logfile, "RESET asked... Stop emulation\n"); ! 697: info.si_signo = TARGET_SIGBUS; ! 698: info.si_errno = 0; ! 699: info.si_code = TARGET_BUS_OBJERR; ! 700: info._sifields._sigfault._addr = env->nip - 4; ! 701: queue_signal(info.si_signo, &info); ! 702: case EXCP_DSI: ! 703: fprintf(stderr, "Invalid data memory access: 0x%08x\n", ! 704: env->spr[SPR_DAR]); ! 705: if (loglevel) { ! 706: fprintf(logfile, "Invalid data memory access: 0x%08x\n", ! 707: env->spr[SPR_DAR]); ! 708: } ! 709: switch (env->error_code & 0xFF000000) { ! 710: case 0x40000000: ! 711: info.si_signo = TARGET_SIGSEGV; ! 712: info.si_errno = 0; ! 713: info.si_code = TARGET_SEGV_MAPERR; ! 714: break; ! 715: case 0x04000000: ! 716: info.si_signo = TARGET_SIGILL; ! 717: info.si_errno = 0; ! 718: info.si_code = TARGET_ILL_ILLADR; ! 719: break; ! 720: case 0x08000000: ! 721: info.si_signo = TARGET_SIGSEGV; ! 722: info.si_errno = 0; ! 723: info.si_code = TARGET_SEGV_ACCERR; ! 724: break; ! 725: default: ! 726: /* Let's send a regular segfault... */ ! 727: fprintf(stderr, "Invalid segfault errno (%02x)\n", ! 728: env->error_code); ! 729: if (loglevel) { ! 730: fprintf(logfile, "Invalid segfault errno (%02x)\n", ! 731: env->error_code); ! 732: } ! 733: info.si_signo = TARGET_SIGSEGV; ! 734: info.si_errno = 0; ! 735: info.si_code = TARGET_SEGV_MAPERR; ! 736: break; ! 737: } ! 738: info._sifields._sigfault._addr = env->nip; ! 739: queue_signal(info.si_signo, &info); ! 740: break; ! 741: case EXCP_ISI: ! 742: fprintf(stderr, "Invalid instruction fetch\n"); ! 743: if (loglevel) ! 744: fprintf(logfile, "Invalid instruction fetch\n"); ! 745: switch (env->error_code & 0xFF000000) { ! 746: case 0x40000000: ! 747: info.si_signo = TARGET_SIGSEGV; ! 748: info.si_errno = 0; ! 749: info.si_code = TARGET_SEGV_MAPERR; ! 750: break; ! 751: case 0x10000000: ! 752: case 0x08000000: ! 753: info.si_signo = TARGET_SIGSEGV; ! 754: info.si_errno = 0; ! 755: info.si_code = TARGET_SEGV_ACCERR; ! 756: break; ! 757: default: ! 758: /* Let's send a regular segfault... */ ! 759: fprintf(stderr, "Invalid segfault errno (%02x)\n", ! 760: env->error_code); ! 761: if (loglevel) { ! 762: fprintf(logfile, "Invalid segfault errno (%02x)\n", ! 763: env->error_code); ! 764: } ! 765: info.si_signo = TARGET_SIGSEGV; ! 766: info.si_errno = 0; ! 767: info.si_code = TARGET_SEGV_MAPERR; ! 768: break; ! 769: } ! 770: info._sifields._sigfault._addr = env->nip - 4; ! 771: queue_signal(info.si_signo, &info); ! 772: break; ! 773: case EXCP_EXTERNAL: ! 774: /* Should not happen ! */ ! 775: fprintf(stderr, "External interruption... Stop emulation\n"); ! 776: if (loglevel) ! 777: fprintf(logfile, "External interruption... Stop emulation\n"); ! 778: abort(); ! 779: case EXCP_ALIGN: ! 780: fprintf(stderr, "Invalid unaligned memory access\n"); ! 781: if (loglevel) ! 782: fprintf(logfile, "Invalid unaligned memory access\n"); ! 783: info.si_signo = TARGET_SIGBUS; ! 784: info.si_errno = 0; ! 785: info.si_code = TARGET_BUS_ADRALN; ! 786: info._sifields._sigfault._addr = env->nip - 4; ! 787: queue_signal(info.si_signo, &info); ! 788: break; ! 789: case EXCP_PROGRAM: ! 790: switch (env->error_code & ~0xF) { ! 791: case EXCP_FP: ! 792: fprintf(stderr, "Program exception\n"); ! 793: if (loglevel) ! 794: fprintf(logfile, "Program exception\n"); ! 795: /* Set FX */ ! 796: env->fpscr[7] |= 0x8; ! 797: /* Finally, update FEX */ ! 798: if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) & ! 799: ((env->fpscr[1] << 1) | (env->fpscr[0] >> 3))) ! 800: env->fpscr[7] |= 0x4; ! 801: info.si_signo = TARGET_SIGFPE; ! 802: info.si_errno = 0; ! 803: switch (env->error_code & 0xF) { ! 804: case EXCP_FP_OX: ! 805: info.si_code = TARGET_FPE_FLTOVF; ! 806: break; ! 807: case EXCP_FP_UX: ! 808: info.si_code = TARGET_FPE_FLTUND; ! 809: break; ! 810: case EXCP_FP_ZX: ! 811: case EXCP_FP_VXZDZ: ! 812: info.si_code = TARGET_FPE_FLTDIV; ! 813: break; ! 814: case EXCP_FP_XX: ! 815: info.si_code = TARGET_FPE_FLTRES; ! 816: break; ! 817: case EXCP_FP_VXSOFT: ! 818: info.si_code = TARGET_FPE_FLTINV; ! 819: break; ! 820: case EXCP_FP_VXNAN: ! 821: case EXCP_FP_VXISI: ! 822: case EXCP_FP_VXIDI: ! 823: case EXCP_FP_VXIMZ: ! 824: case EXCP_FP_VXVC: ! 825: case EXCP_FP_VXSQRT: ! 826: case EXCP_FP_VXCVI: ! 827: info.si_code = TARGET_FPE_FLTSUB; ! 828: break; ! 829: default: ! 830: fprintf(stderr, "Unknown floating point exception " ! 831: "(%02x)\n", env->error_code); ! 832: if (loglevel) { ! 833: fprintf(logfile, "Unknown floating point exception " ! 834: "(%02x)\n", env->error_code & 0xF); ! 835: } ! 836: } ! 837: break; ! 838: case EXCP_INVAL: ! 839: fprintf(stderr, "Invalid instruction\n"); ! 840: if (loglevel) ! 841: fprintf(logfile, "Invalid instruction\n"); ! 842: info.si_signo = TARGET_SIGILL; ! 843: info.si_errno = 0; ! 844: switch (env->error_code & 0xF) { ! 845: case EXCP_INVAL_INVAL: ! 846: info.si_code = TARGET_ILL_ILLOPC; ! 847: break; ! 848: case EXCP_INVAL_LSWX: ! 849: info.si_code = TARGET_ILL_ILLOPN; ! 850: break; ! 851: case EXCP_INVAL_SPR: ! 852: info.si_code = TARGET_ILL_PRVREG; ! 853: break; ! 854: case EXCP_INVAL_FP: ! 855: info.si_code = TARGET_ILL_COPROC; ! 856: break; ! 857: default: ! 858: fprintf(stderr, "Unknown invalid operation (%02x)\n", ! 859: env->error_code & 0xF); ! 860: if (loglevel) { ! 861: fprintf(logfile, "Unknown invalid operation (%02x)\n", ! 862: env->error_code & 0xF); ! 863: } ! 864: info.si_code = TARGET_ILL_ILLADR; ! 865: break; ! 866: } ! 867: break; ! 868: case EXCP_PRIV: ! 869: fprintf(stderr, "Privilege violation\n"); ! 870: if (loglevel) ! 871: fprintf(logfile, "Privilege violation\n"); ! 872: info.si_signo = TARGET_SIGILL; ! 873: info.si_errno = 0; ! 874: switch (env->error_code & 0xF) { ! 875: case EXCP_PRIV_OPC: ! 876: info.si_code = TARGET_ILL_PRVOPC; ! 877: break; ! 878: case EXCP_PRIV_REG: ! 879: info.si_code = TARGET_ILL_PRVREG; ! 880: break; ! 881: default: ! 882: fprintf(stderr, "Unknown privilege violation (%02x)\n", ! 883: env->error_code & 0xF); ! 884: info.si_code = TARGET_ILL_PRVOPC; ! 885: break; ! 886: } ! 887: break; ! 888: case EXCP_TRAP: ! 889: fprintf(stderr, "Tried to call a TRAP\n"); ! 890: if (loglevel) ! 891: fprintf(logfile, "Tried to call a TRAP\n"); ! 892: abort(); ! 893: default: ! 894: /* Should not happen ! */ ! 895: fprintf(stderr, "Unknown program exception (%02x)\n", ! 896: env->error_code); ! 897: if (loglevel) { ! 898: fprintf(logfile, "Unknwon program exception (%02x)\n", ! 899: env->error_code); ! 900: } ! 901: abort(); ! 902: } ! 903: info._sifields._sigfault._addr = env->nip - 4; ! 904: queue_signal(info.si_signo, &info); ! 905: break; ! 906: case EXCP_NO_FP: ! 907: fprintf(stderr, "No floating point allowed\n"); ! 908: if (loglevel) ! 909: fprintf(logfile, "No floating point allowed\n"); ! 910: info.si_signo = TARGET_SIGILL; ! 911: info.si_errno = 0; ! 912: info.si_code = TARGET_ILL_COPROC; ! 913: info._sifields._sigfault._addr = env->nip - 4; ! 914: queue_signal(info.si_signo, &info); ! 915: break; ! 916: case EXCP_DECR: ! 917: /* Should not happen ! */ ! 918: fprintf(stderr, "Decrementer exception\n"); ! 919: if (loglevel) ! 920: fprintf(logfile, "Decrementer exception\n"); ! 921: abort(); ! 922: case EXCP_TRACE: ! 923: /* Do nothing: we use this to trace execution */ ! 924: break; ! 925: case EXCP_FP_ASSIST: ! 926: /* Should not happen ! */ ! 927: fprintf(stderr, "Floating point assist exception\n"); ! 928: if (loglevel) ! 929: fprintf(logfile, "Floating point assist exception\n"); ! 930: abort(); ! 931: case EXCP_MTMSR: ! 932: /* We reloaded the msr, just go on */ ! 933: if (msr_pr == 0) { ! 934: fprintf(stderr, "Tried to go into supervisor mode !\n"); ! 935: if (loglevel) ! 936: fprintf(logfile, "Tried to go into supervisor mode !\n"); ! 937: abort(); ! 938: } ! 939: break; ! 940: case EXCP_BRANCH: ! 941: /* We stopped because of a jump... */ ! 942: break; ! 943: case EXCP_INTERRUPT: ! 944: /* Don't know why this should ever happen... */ ! 945: break; ! 946: case EXCP_DEBUG: ! 947: { ! 948: int sig; ! 949: ! 950: sig = gdb_handlesig (env, TARGET_SIGTRAP); ! 951: if (sig) ! 952: { ! 953: info.si_signo = sig; ! 954: info.si_errno = 0; ! 955: info.si_code = TARGET_TRAP_BRKPT; ! 956: queue_signal(info.si_signo, &info); ! 957: } ! 958: } ! 959: break; ! 960: default: ! 961: fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", ! 962: trapnr); ! 963: if (loglevel) { ! 964: fprintf(logfile, "qemu: unhandled CPU exception 0x%02x - " ! 965: "0x%02x - aborting\n", trapnr, env->error_code); ! 966: } ! 967: abort(); ! 968: } ! 969: process_pending_signals(env); ! 970: } ! 971: } ! 972: #endif ! 973: ! 974: void usage(void) ! 975: { ! 976: printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2005 Fabrice Bellard\n" ! 977: "usage: qemu-" TARGET_ARCH " [-h] [-g] [-d opts] [-L path] [-s size] program [arguments...]\n" ! 978: "Linux CPU emulator (compiled for %s emulation)\n" ! 979: "\n" ! 980: "-h print this help\n" ! 981: "-g wait gdb connection to port %d\n" ! 982: "-L path set the elf interpreter prefix (default=%s)\n" ! 983: "-s size set the stack size in bytes (default=%ld)\n" ! 984: "\n" ! 985: "debug options:\n" ! 986: #ifdef USE_CODE_COPY ! 987: "-no-code-copy disable code copy acceleration\n" ! 988: #endif ! 989: "-d options activate log (logfile=%s)\n" ! 990: "-p pagesize set the host page size to 'pagesize'\n", ! 991: TARGET_ARCH, ! 992: DEFAULT_GDBSTUB_PORT, ! 993: interp_prefix, ! 994: x86_stack_size, ! 995: DEBUG_LOGFILE); ! 996: _exit(1); ! 997: } ! 998: ! 999: /* XXX: currently only used for async signals (see signal.c) */ ! 1000: CPUState *global_env; ! 1001: /* used only if single thread */ ! 1002: CPUState *cpu_single_env = NULL; ! 1003: ! 1004: /* used to free thread contexts */ ! 1005: TaskState *first_task_state; ! 1006: ! 1007: int main(int argc, char **argv) ! 1008: { ! 1009: const char *filename; ! 1010: struct target_pt_regs regs1, *regs = ®s1; ! 1011: struct image_info info1, *info = &info1; ! 1012: TaskState ts1, *ts = &ts1; ! 1013: CPUState *env; ! 1014: int optind; ! 1015: const char *r; ! 1016: int use_gdbstub = 0; ! 1017: ! 1018: if (argc <= 1) ! 1019: usage(); ! 1020: ! 1021: /* init debug */ ! 1022: cpu_set_log_filename(DEBUG_LOGFILE); ! 1023: ! 1024: optind = 1; ! 1025: for(;;) { ! 1026: if (optind >= argc) ! 1027: break; ! 1028: r = argv[optind]; ! 1029: if (r[0] != '-') ! 1030: break; ! 1031: optind++; ! 1032: r++; ! 1033: if (!strcmp(r, "-")) { ! 1034: break; ! 1035: } else if (!strcmp(r, "d")) { ! 1036: int mask; ! 1037: CPULogItem *item; ! 1038: ! 1039: if (optind >= argc) ! 1040: break; ! 1041: ! 1042: r = argv[optind++]; ! 1043: mask = cpu_str_to_log_mask(r); ! 1044: if (!mask) { ! 1045: printf("Log items (comma separated):\n"); ! 1046: for(item = cpu_log_items; item->mask != 0; item++) { ! 1047: printf("%-10s %s\n", item->name, item->help); ! 1048: } ! 1049: exit(1); ! 1050: } ! 1051: cpu_set_log(mask); ! 1052: } else if (!strcmp(r, "s")) { ! 1053: r = argv[optind++]; ! 1054: x86_stack_size = strtol(r, (char **)&r, 0); ! 1055: if (x86_stack_size <= 0) ! 1056: usage(); ! 1057: if (*r == 'M') ! 1058: x86_stack_size *= 1024 * 1024; ! 1059: else if (*r == 'k' || *r == 'K') ! 1060: x86_stack_size *= 1024; ! 1061: } else if (!strcmp(r, "L")) { ! 1062: interp_prefix = argv[optind++]; ! 1063: } else if (!strcmp(r, "p")) { ! 1064: qemu_host_page_size = atoi(argv[optind++]); ! 1065: if (qemu_host_page_size == 0 || ! 1066: (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) { ! 1067: fprintf(stderr, "page size must be a power of two\n"); ! 1068: exit(1); ! 1069: } ! 1070: } else if (!strcmp(r, "g")) { ! 1071: use_gdbstub = 1; ! 1072: } else ! 1073: #ifdef USE_CODE_COPY ! 1074: if (!strcmp(r, "no-code-copy")) { ! 1075: code_copy_enabled = 0; ! 1076: } else ! 1077: #endif ! 1078: { ! 1079: usage(); ! 1080: } ! 1081: } ! 1082: if (optind >= argc) ! 1083: usage(); ! 1084: filename = argv[optind]; ! 1085: ! 1086: /* Zero out regs */ ! 1087: memset(regs, 0, sizeof(struct target_pt_regs)); ! 1088: ! 1089: /* Zero out image_info */ ! 1090: memset(info, 0, sizeof(struct image_info)); ! 1091: ! 1092: /* Scan interp_prefix dir for replacement files. */ ! 1093: init_paths(interp_prefix); ! 1094: ! 1095: /* NOTE: we need to init the CPU at this stage to get ! 1096: qemu_host_page_size */ ! 1097: env = cpu_init(); ! 1098: ! 1099: if (elf_exec(filename, argv+optind, environ, regs, info) != 0) { ! 1100: printf("Error loading %s\n", filename); ! 1101: _exit(1); ! 1102: } ! 1103: ! 1104: if (loglevel) { ! 1105: page_dump(logfile); ! 1106: ! 1107: fprintf(logfile, "start_brk 0x%08lx\n" , info->start_brk); ! 1108: fprintf(logfile, "end_code 0x%08lx\n" , info->end_code); ! 1109: fprintf(logfile, "start_code 0x%08lx\n" , info->start_code); ! 1110: fprintf(logfile, "end_data 0x%08lx\n" , info->end_data); ! 1111: fprintf(logfile, "start_stack 0x%08lx\n" , info->start_stack); ! 1112: fprintf(logfile, "brk 0x%08lx\n" , info->brk); ! 1113: fprintf(logfile, "entry 0x%08lx\n" , info->entry); ! 1114: } ! 1115: ! 1116: target_set_brk((char *)info->brk); ! 1117: syscall_init(); ! 1118: signal_init(); ! 1119: ! 1120: global_env = env; ! 1121: ! 1122: /* build Task State */ ! 1123: memset(ts, 0, sizeof(TaskState)); ! 1124: env->opaque = ts; ! 1125: ts->used = 1; ! 1126: env->user_mode_only = 1; ! 1127: ! 1128: #if defined(TARGET_I386) ! 1129: cpu_x86_set_cpl(env, 3); ! 1130: ! 1131: env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK; ! 1132: env->hflags |= HF_PE_MASK; ! 1133: if (env->cpuid_features & CPUID_SSE) { ! 1134: env->cr[4] |= CR4_OSFXSR_MASK; ! 1135: env->hflags |= HF_OSFXSR_MASK; ! 1136: } ! 1137: ! 1138: /* flags setup : we activate the IRQs by default as in user mode */ ! 1139: env->eflags |= IF_MASK; ! 1140: ! 1141: /* linux register setup */ ! 1142: env->regs[R_EAX] = regs->eax; ! 1143: env->regs[R_EBX] = regs->ebx; ! 1144: env->regs[R_ECX] = regs->ecx; ! 1145: env->regs[R_EDX] = regs->edx; ! 1146: env->regs[R_ESI] = regs->esi; ! 1147: env->regs[R_EDI] = regs->edi; ! 1148: env->regs[R_EBP] = regs->ebp; ! 1149: env->regs[R_ESP] = regs->esp; ! 1150: env->eip = regs->eip; ! 1151: ! 1152: /* linux interrupt setup */ ! 1153: env->idt.base = (long)idt_table; ! 1154: env->idt.limit = sizeof(idt_table) - 1; ! 1155: set_idt(0, 0); ! 1156: set_idt(1, 0); ! 1157: set_idt(2, 0); ! 1158: set_idt(3, 3); ! 1159: set_idt(4, 3); ! 1160: set_idt(5, 3); ! 1161: set_idt(6, 0); ! 1162: set_idt(7, 0); ! 1163: set_idt(8, 0); ! 1164: set_idt(9, 0); ! 1165: set_idt(10, 0); ! 1166: set_idt(11, 0); ! 1167: set_idt(12, 0); ! 1168: set_idt(13, 0); ! 1169: set_idt(14, 0); ! 1170: set_idt(15, 0); ! 1171: set_idt(16, 0); ! 1172: set_idt(17, 0); ! 1173: set_idt(18, 0); ! 1174: set_idt(19, 0); ! 1175: set_idt(0x80, 3); ! 1176: ! 1177: /* linux segment setup */ ! 1178: env->gdt.base = (long)gdt_table; ! 1179: env->gdt.limit = sizeof(gdt_table) - 1; ! 1180: write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, ! 1181: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | ! 1182: (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT)); ! 1183: write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff, ! 1184: DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | ! 1185: (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT)); ! 1186: cpu_x86_load_seg(env, R_CS, __USER_CS); ! 1187: cpu_x86_load_seg(env, R_DS, __USER_DS); ! 1188: cpu_x86_load_seg(env, R_ES, __USER_DS); ! 1189: cpu_x86_load_seg(env, R_SS, __USER_DS); ! 1190: cpu_x86_load_seg(env, R_FS, __USER_DS); ! 1191: cpu_x86_load_seg(env, R_GS, __USER_DS); ! 1192: ! 1193: #elif defined(TARGET_ARM) ! 1194: { ! 1195: int i; ! 1196: for(i = 0; i < 16; i++) { ! 1197: env->regs[i] = regs->uregs[i]; ! 1198: } ! 1199: env->cpsr = regs->uregs[16]; ! 1200: ts->stack_base = info->start_stack; ! 1201: ts->heap_base = info->brk; ! 1202: /* This will be filled in on the first SYS_HEAPINFO call. */ ! 1203: ts->heap_limit = 0; ! 1204: } ! 1205: #elif defined(TARGET_SPARC) ! 1206: { ! 1207: int i; ! 1208: env->pc = regs->pc; ! 1209: env->npc = regs->npc; ! 1210: env->y = regs->y; ! 1211: for(i = 0; i < 8; i++) ! 1212: env->gregs[i] = regs->u_regs[i]; ! 1213: for(i = 0; i < 8; i++) ! 1214: env->regwptr[i] = regs->u_regs[i + 8]; ! 1215: } ! 1216: #elif defined(TARGET_PPC) ! 1217: { ! 1218: ppc_def_t *def; ! 1219: int i; ! 1220: ! 1221: /* Choose and initialise CPU */ ! 1222: /* XXX: CPU model (or PVR) should be provided on command line */ ! 1223: // ppc_find_by_name("750gx", &def); ! 1224: // ppc_find_by_name("750fx", &def); ! 1225: // ppc_find_by_name("750p", &def); ! 1226: ppc_find_by_name("750", &def); ! 1227: // ppc_find_by_name("G3", &def); ! 1228: // ppc_find_by_name("604r", &def); ! 1229: // ppc_find_by_name("604e", &def); ! 1230: // ppc_find_by_name("604", &def); ! 1231: if (def == NULL) { ! 1232: cpu_abort(cpu_single_env, ! 1233: "Unable to find PowerPC CPU definition\n"); ! 1234: } ! 1235: cpu_ppc_register(cpu_single_env, def); ! 1236: ! 1237: for (i = 0; i < 32; i++) { ! 1238: if (i != 12 && i != 6 && i != 13) ! 1239: env->msr[i] = (regs->msr >> i) & 1; ! 1240: } ! 1241: env->nip = regs->nip; ! 1242: for(i = 0; i < 32; i++) { ! 1243: env->gpr[i] = regs->gpr[i]; ! 1244: } ! 1245: } ! 1246: #else ! 1247: #error unsupported target CPU ! 1248: #endif ! 1249: ! 1250: if (use_gdbstub) { ! 1251: gdbserver_start (DEFAULT_GDBSTUB_PORT); ! 1252: gdb_handlesig(env, 0); ! 1253: } ! 1254: cpu_loop(env); ! 1255: /* never exits */ ! 1256: return 0; ! 1257: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.