cpu_abort(env, "Data TLB exception while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */            cpu_abort(env, "Instruction TLB exception while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_DEBUG:    /* Debug interrupt                       */            gdb_handlesig (env, SIGTRAP);            break;        case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */            EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");            info.si_signo = SIGILL;            info.si_errno = 0;            info.si_code = ILL_COPROC;            info.si_addr = (void*)(env->nip - 4);            queue_signal(info.si_signo, &info);            break;        case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */            cpu_abort(env, "Embedded floating-point data IRQ not handled\n");            break;        case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */            cpu_abort(env, "Embedded floating-point round IRQ not handled\n");            break;        case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */            cpu_abort(env, "Performance monitor exception not handled\n");            break;        case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */            cpu_abort(env, "Doorbell interrupt while in user mode. "                       "Aborting\n");            break;        case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */            cpu_abort(env, "Doorbell critical interrupt while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_RESET:    /* System reset exception                */            cpu_abort(env, "Reset interrupt while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_DSEG:     /* Data segment exception                */            cpu_abort(env, "Data segment exception while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */            cpu_abort(env, "Instruction segment exception "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */            cpu_abort(env, "Hypervisor decrementer interrupt "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_TRACE:    /* Trace exception                       */            /* Nothing to do:             * we use this exception to emulate step-by-step execution mode.             */            break;        case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */            cpu_abort(env, "Hypervisor data storage exception "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */            cpu_abort(env, "Hypervisor instruction storage exception "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */            cpu_abort(env, "Hypervisor data segment exception "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */            cpu_abort(env, "Hypervisor instruction segment exception "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */            EXCP_DUMP(env, "No Altivec instructions allowed\n");            info.si_signo = SIGILL;            info.si_errno = 0;            info.si_code = ILL_COPROC;            info.si_addr = (void*)(env->nip - 4);            queue_signal(info.si_signo, &info);            break;        case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */            cpu_abort(env, "Programable interval timer interrupt "                      "while in user mode. Aborting\n");            break;        case POWERPC_EXCP_IO:       /* IO error exception                    */            cpu_abort(env, "IO error exception while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_RUNM:     /* Run mode exception                    */            cpu_abort(env, "Run mode exception while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */            cpu_abort(env, "Emulation trap exception not handled\n");            break;        case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */            cpu_abort(env, "Instruction fetch TLB exception "                      "while in user-mode. Aborting");            break;        case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */            cpu_abort(env, "Data load TLB exception while in user-mode. "                      "Aborting");            break;        case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */            cpu_abort(env, "Data store TLB exception while in user-mode. "                      "Aborting");            break;        case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */            cpu_abort(env, "Floating-point assist exception not handled\n");            break;        case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */            cpu_abort(env, "Instruction address breakpoint exception "                      "not handled\n");            break;        case POWERPC_EXCP_SMI:      /* System management interrupt           */            cpu_abort(env, "System management interrupt while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */            cpu_abort(env, "Thermal interrupt interrupt while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_PERFM:    /* Embedded performance monitor IRQ      */            cpu_abort(env, "Performance monitor exception not handled\n");            break;        case POWERPC_EXCP_VPUA:     /* Vector assist exception               */            cpu_abort(env, "Vector assist exception not handled\n");            break;        case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */            cpu_abort(env, "Soft patch exception not handled\n");            break;        case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */            cpu_abort(env, "Maintenance exception while in user mode. "                      "Aborting\n");            break;        case POWERPC_EXCP_STOP:     /* stop translation                      */            /* We did invalidate the instruction cache. Go on */            break;        case POWERPC_EXCP_BRANCH:   /* branch instruction:                   */            /* We just stopped because of a branch. Go on */            break;        case POWERPC_EXCP_SYSCALL_USER:            /* system call in user-mode emulation */            /* system call */            if(((int)env->gpr[0]) <= SYS_MAXSYSCALL && ((int)env->gpr[0])>0)                ret = do_unix_syscall(env, env->gpr[0]/*, env->gpr[3], env->gpr[4],                                      env->gpr[5], env->gpr[6], env->gpr[7],                                      env->gpr[8], env->gpr[9], env->gpr[10]*/);            else if(((int)env->gpr[0])<0)                ret = do_mach_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],                                      env->gpr[5], env->gpr[6], env->gpr[7],                                      env->gpr[8], env->gpr[9], env->gpr[10]);            else                ret = do_thread_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],                                        env->gpr[5], env->gpr[6], env->gpr[7],                                        env->gpr[8], env->gpr[9], env->gpr[10]);            /* Unix syscall error signaling */            if(((int)env->gpr[0]) <= SYS_MAXSYSCALL && ((int)env->gpr[0])>0)            {                if( (int)ret < 0 )                    env->nip += 0;                else                    env->nip += 4;            }            /* Return value */            env->gpr[3] = ret;            break;        case EXCP_INTERRUPT:            /* just indicate that signals should be handled asap */            break;        default:            cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr);            break;        }        process_pending_signals(env);    }}#endif#ifdef TARGET_I386/***********************************************************//* CPUX86 core interface */uint64_t cpu_get_tsc(CPUX86State *env){    return cpu_get_real_ticks();}voidwrite_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);}#define GDT_TABLE_SIZE 14#define LDT_TABLE_SIZE 15#define IDT_TABLE_SIZE 256#define TSS_SIZE 104uint64_t gdt_table[GDT_TABLE_SIZE];uint64_t ldt_table[LDT_TABLE_SIZE];uint64_t idt_table[IDT_TABLE_SIZE];uint32_t tss[TSS_SIZE];/* 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);}/* ABI convention: after a syscall if there was an error the CF flag is set */static inline void set_error(CPUX86State *env, int ret){    if(ret<0)        env->eflags = env->eflags | 0x1;    else        env->eflags &= ~0x1;    env->regs[R_EAX] = ret;}void cpu_loop(CPUX86State *env){    int trapnr;    int ret;    uint8_t *pc;    target_siginfo_t info;    for(;;) {        trapnr = cpu_x86_exec(env);        uint32_t *params = (uint32_t *)env->regs[R_ESP];        switch(trapnr) {        case 0x79: /* Our commpage hack back door exit is here */            do_commpage(env,  env->eip,   *(params + 1), *(params + 2),                                          *(params + 3), *(params + 4),                                          *(params + 5), *(params + 6),                                          *(params + 7), *(params + 8));            break;        case 0x81: /* mach syscall */        {            ret = do_mach_syscall(env,  env->regs[R_EAX],                                          *(params + 1), *(params + 2),                                          *(params + 3), *(params + 4),                                          *(params + 5), *(params + 6),                                          *(params + 7), *(params + 8));            set_error(env, ret);            break;        }        case 0x90: /* unix backdoor */        {            /* after sysenter, stack is in R_ECX, new eip in R_EDX (sysexit will flip them back)*/            int saved_stack = env->regs[R_ESP];            env->regs[R_ESP] = env->regs[R_ECX];            ret = do_unix_syscall(env, env->regs[R_EAX]);            env->regs[R_ECX] = env->regs[R_ESP];            env->regs[R_ESP] = saved_stack;            set_error(env, ret);            break;        }        case 0x80: /* unix syscall */        {            ret = do_unix_syscall(env, env->regs[R_EAX]/*,                                          *(params + 1), *(params + 2),                                          *(params + 3), *(params + 4),                                          *(params + 5), *(params + 6),                                          *(params + 7), *(params + 8)*/);            set_error(env, ret);            break;        }        case 0x82: /* thread syscall */        {            ret = do_thread_syscall(env,  env->regs[R_EAX],                                          *(params + 1), *(params + 2),                                          *(params + 3), *(params + 4),                                          *(params + 5), *(params + 6),                                          *(params + 7), *(params + 8));            set_error(env, ret);            break;        }        case EXCP0B_NOSEG:        case EXCP0C_STACK:            info.si_signo = SIGBUS;            info.si_errno = 0;            info.si_code = BUS_NOOP;            info.si_addr = 0;            gdb_handlesig (env, SIGBUS);            queue_signal(info.si_signo, &info);            break;        case EXCP0D_GPF:            info.si_signo = SIGSEGV;            info.si_errno = 0;            info.si_code = SEGV_NOOP;            info.si_addr = 0;            gdb_handlesig (env, SIGSEGV);            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 = SEGV_MAPERR;            else                info.si_code = SEGV_ACCERR;            info.si_addr = (void*)env->cr[2];            gdb_handlesig (env, SIGSEGV);            queue_signal(info.si_signo, &info);            break;        case EXCP00_DIVZ:            /* division by zero */            info.si_signo = SIGFPE;            info.si_errno = 0;            info.si_code = FPE_INTDIV;            info.si_addr = (void*)env->eip;            gdb_handlesig (env, SIGFPE);            queue_signal(info.si_signo, &info);            break;        case EXCP01_SSTP:        case EXCP03_INT3:            info.si_signo = SIGTRAP;            info.si_errno = 0;            info.si_code = TRAP_BRKPT;            info.si_addr = (void*)env->eip;            gdb_handlesig (env, SIGTRAP);            queue_signal(info.si_signo, &info);            break;        case EXCP04_INTO:        case EXCP05_BOUND:            info.si_signo = SIGSEGV;