git.maemo.org Git - qemu/blob - linux-user/main.c

   1 /*
   2  *  qemu user main
   3  *
   4  *  Copyright (c) 2003-2008 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 #include "qemu-common.h"
  29 /* For tb_lock */
  30 #include "exec-all.h"
  31
  32 #define DEBUG_LOGFILE "/tmp/qemu.log"
  33
  34 static const char *interp_prefix = CONFIG_QEMU_PREFIX;
  35 const char *qemu_uname_release = CONFIG_UNAME_RELEASE;
  36
  37 #if defined(__i386__) && !defined(CONFIG_STATIC)
  38 /* Force usage of an ELF interpreter even if it is an ELF shared
  39    object ! */
  40 const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2";
  41 #endif
  42
  43 /* for recent libc, we add these dummy symbols which are not declared
  44    when generating a linked object (bug in ld ?) */
  45 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(CONFIG_STATIC)
  46 asm(".globl __preinit_array_start\n"
  47     ".globl __preinit_array_end\n"
  48     ".globl __init_array_start\n"
  49     ".globl __init_array_end\n"
  50     ".globl __fini_array_start\n"
  51     ".globl __fini_array_end\n"
  52     ".section \".rodata\"\n"
  53     "__preinit_array_start:\n"
  54     "__preinit_array_end:\n"
  55     "__init_array_start:\n"
  56     "__init_array_end:\n"
  57     "__fini_array_start:\n"
  58     "__fini_array_end:\n"
  59     ".long 0\n"
  60     ".previous\n");
  61 #endif
  62
  63 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
  64    we allocate a bigger stack. Need a better solution, for example
  65    by remapping the process stack directly at the right place */
  66 unsigned long x86_stack_size = 512 * 1024;
  67
  68 void gemu_log(const char *fmt, ...)
  69 {
  70     va_list ap;
  71
  72     va_start(ap, fmt);
  73     vfprintf(stderr, fmt, ap);
  74     va_end(ap);
  75 }
  76
  77 void cpu_outb(CPUState *env, int addr, int val)
  78 {
  79     fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
  80 }
  81
  82 void cpu_outw(CPUState *env, int addr, int val)
  83 {
  84     fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
  85 }
  86
  87 void cpu_outl(CPUState *env, int addr, int val)
  88 {
  89     fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
  90 }
  91
  92 int cpu_inb(CPUState *env, int addr)
  93 {
  94     fprintf(stderr, "inb: port=0x%04x\n", addr);
  95     return 0;
  96 }
  97
  98 int cpu_inw(CPUState *env, int addr)
  99 {
 100     fprintf(stderr, "inw: port=0x%04x\n", addr);
 101     return 0;
 102 }
 103
 104 int cpu_inl(CPUState *env, int addr)
 105 {
 106     fprintf(stderr, "inl: port=0x%04x\n", addr);
 107     return 0;
 108 }
 109
 110 #if defined(TARGET_I386)
 111 int cpu_get_pic_interrupt(CPUState *env)
 112 {
 113     return -1;
 114 }
 115 #endif
 116
 117 /* timers for rdtsc */
 118
 119 #if 0
 120
 121 static uint64_t emu_time;
 122
 123 int64_t cpu_get_real_ticks(void)
 124 {
 125     return emu_time++;
 126 }
 127
 128 #endif
 129
 130 #if defined(USE_NPTL)
 131 /***********************************************************/
 132 /* Helper routines for implementing atomic operations.  */
 133
 134 /* To implement exclusive operations we force all cpus to syncronise.
 135    We don't require a full sync, only that no cpus are executing guest code.
 136    The alternative is to map target atomic ops onto host equivalents,
 137    which requires quite a lot of per host/target work.  */
 138 static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER;
 139 static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER;
 140 static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER;
 141 static int pending_cpus;
 142
 143 /* Make sure everything is in a consistent state for calling fork().  */
 144 void fork_start(void)
 145 {
 146     mmap_fork_start();
 147     pthread_mutex_lock(&tb_lock);
 148     pthread_mutex_lock(&exclusive_lock);
 149 }
 150
 151 void fork_end(int child)
 152 {
 153     if (child) {
 154         /* Child processes created by fork() only have a single thread.
 155            Discard information about the parent threads.  */
 156         first_cpu = thread_env;
 157         thread_env->next_cpu = NULL;
 158         pending_cpus = 0;
 159         pthread_mutex_init(&exclusive_lock, NULL);
 160         pthread_cond_init(&exclusive_cond, NULL);
 161         pthread_cond_init(&exclusive_resume, NULL);
 162         pthread_mutex_init(&tb_lock, NULL);
 163     } else {
 164         pthread_mutex_unlock(&exclusive_lock);
 165         pthread_mutex_unlock(&tb_lock);
 166     }
 167     mmap_fork_end(child);
 168 }
 169
 170 /* Wait for pending exclusive operations to complete.  The exclusive lock
 171    must be held.  */
 172 static inline void exclusive_idle(void)
 173 {
 174     while (pending_cpus) {
 175         pthread_cond_wait(&exclusive_resume, &exclusive_lock);
 176     }
 177 }
 178
 179 /* Start an exclusive operation.
 180    Must only be called from outside cpu_arm_exec.   */
 181 static inline void start_exclusive(void)
 182 {
 183     CPUState *other;
 184     pthread_mutex_lock(&exclusive_lock);
 185     exclusive_idle();
 186
 187     pending_cpus = 1;
 188     /* Make all other cpus stop executing.  */
 189     for (other = first_cpu; other; other = other->next_cpu) {
 190         if (other->running) {
 191             pending_cpus++;
 192             cpu_interrupt(other, CPU_INTERRUPT_EXIT);
 193         }
 194     }
 195     if (pending_cpus > 1) {
 196         pthread_cond_wait(&exclusive_cond, &exclusive_lock);
 197     }
 198 }
 199
 200 /* Finish an exclusive operation.  */
 201 static inline void end_exclusive(void)
 202 {
 203     pending_cpus = 0;
 204     pthread_cond_broadcast(&exclusive_resume);
 205     pthread_mutex_unlock(&exclusive_lock);
 206 }
 207
 208 /* Wait for exclusive ops to finish, and begin cpu execution.  */
 209 static inline void cpu_exec_start(CPUState *env)
 210 {
 211     pthread_mutex_lock(&exclusive_lock);
 212     exclusive_idle();
 213     env->running = 1;
 214     pthread_mutex_unlock(&exclusive_lock);
 215 }
 216
 217 /* Mark cpu as not executing, and release pending exclusive ops.  */
 218 static inline void cpu_exec_end(CPUState *env)
 219 {
 220     pthread_mutex_lock(&exclusive_lock);
 221     env->running = 0;
 222     if (pending_cpus > 1) {
 223         pending_cpus--;
 224         if (pending_cpus == 1) {
 225             pthread_cond_signal(&exclusive_cond);
 226         }
 227     }
 228     exclusive_idle();
 229     pthread_mutex_unlock(&exclusive_lock);
 230 }
 231 #else /* if !USE_NPTL */
 232 /* These are no-ops because we are not threadsafe.  */
 233 static inline void cpu_exec_start(CPUState *env)
 234 {
 235 }
 236
 237 static inline void cpu_exec_end(CPUState *env)
 238 {
 239 }
 240
 241 static inline void start_exclusive(void)
 242 {
 243 }
 244
 245 static inline void end_exclusive(void)
 246 {
 247 }
 248
 249 void fork_start(void)
 250 {
 251 }
 252
 253 void fork_end(int child)
 254 {
 255 }
 256 #endif
 257
 258
 259 #ifdef TARGET_I386
 260 /***********************************************************/
 261 /* CPUX86 core interface */
 262
 263 void cpu_smm_update(CPUState *env)
 264 {
 265 }
 266
 267 uint64_t cpu_get_tsc(CPUX86State *env)
 268 {
 269     return cpu_get_real_ticks();
 270 }
 271
 272 static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
 273                      int flags)
 274 {
 275     unsigned int e1, e2;
 276     uint32_t *p;
 277     e1 = (addr << 16) | (limit & 0xffff);
 278     e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
 279     e2 |= flags;
 280     p = ptr;
 281     p[0] = tswap32(e1);
 282     p[1] = tswap32(e2);
 283 }
 284
 285 #if TARGET_X86_64
 286 uint64_t idt_table[512];
 287
 288 static void set_gate64(void *ptr, unsigned int type, unsigned int dpl,
 289                        uint64_t addr, unsigned int sel)
 290 {
 291     uint32_t *p, e1, e2;
 292     e1 = (addr & 0xffff) | (sel << 16);
 293     e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
 294     p = ptr;
 295     p[0] = tswap32(e1);
 296     p[1] = tswap32(e2);
 297     p[2] = tswap32(addr >> 32);
 298     p[3] = 0;
 299 }
 300 /* only dpl matters as we do only user space emulation */
 301 static void set_idt(int n, unsigned int dpl)
 302 {
 303     set_gate64(idt_table + n * 2, 0, dpl, 0, 0);
 304 }
 305 #else
 306 uint64_t idt_table[256];
 307
 308 static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
 309                      uint32_t addr, unsigned int sel)
 310 {
 311     uint32_t *p, e1, e2;
 312     e1 = (addr & 0xffff) | (sel << 16);
 313     e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
 314     p = ptr;
 315     p[0] = tswap32(e1);
 316     p[1] = tswap32(e2);
 317 }
 318
 319 /* only dpl matters as we do only user space emulation */
 320 static void set_idt(int n, unsigned int dpl)
 321 {
 322     set_gate(idt_table + n, 0, dpl, 0, 0);
 323 }
 324 #endif
 325
 326 void cpu_loop(CPUX86State *env)
 327 {
 328     int trapnr;
 329     abi_ulong pc;
 330     target_siginfo_t info;
 331
 332     for(;;) {
 333         trapnr = cpu_x86_exec(env);
 334         switch(trapnr) {
 335         case 0x80:
 336             /* linux syscall from int $0x80 */
 337             env->regs[R_EAX] = do_syscall(env,
 338                                           env->regs[R_EAX],
 339                                           env->regs[R_EBX],
 340                                           env->regs[R_ECX],
 341                                           env->regs[R_EDX],
 342                                           env->regs[R_ESI],
 343                                           env->regs[R_EDI],
 344                                           env->regs[R_EBP]);
 345             break;
 346 #ifndef TARGET_ABI32
 347         case EXCP_SYSCALL:
 348             /* linux syscall from syscall intruction */
 349             env->regs[R_EAX] = do_syscall(env,
 350                                           env->regs[R_EAX],
 351                                           env->regs[R_EDI],
 352                                           env->regs[R_ESI],
 353                                           env->regs[R_EDX],
 354                                           env->regs[10],
 355                                           env->regs[8],
 356                                           env->regs[9]);
 357             env->eip = env->exception_next_eip;
 358             break;
 359 #endif
 360         case EXCP0B_NOSEG:
 361         case EXCP0C_STACK:
 362             info.si_signo = SIGBUS;
 363             info.si_errno = 0;
 364             info.si_code = TARGET_SI_KERNEL;
 365             info._sifields._sigfault._addr = 0;
 366             queue_signal(env, info.si_signo, &info);
 367             break;
 368         case EXCP0D_GPF:
 369             /* XXX: potential problem if ABI32 */
 370 #ifndef TARGET_X86_64
 371             if (env->eflags & VM_MASK) {
 372                 handle_vm86_fault(env);
 373             } else
 374 #endif
 375             {
 376                 info.si_signo = SIGSEGV;
 377                 info.si_errno = 0;
 378                 info.si_code = TARGET_SI_KERNEL;
 379                 info._sifields._sigfault._addr = 0;
 380                 queue_signal(env, info.si_signo, &info);
 381             }
 382             break;
 383         case EXCP0E_PAGE:
 384             info.si_signo = SIGSEGV;
 385             info.si_errno = 0;
 386             if (!(env->error_code & 1))
 387                 info.si_code = TARGET_SEGV_MAPERR;
 388             else
 389                 info.si_code = TARGET_SEGV_ACCERR;
 390             info._sifields._sigfault._addr = env->cr[2];
 391             queue_signal(env, info.si_signo, &info);
 392             break;
 393         case EXCP00_DIVZ:
 394 #ifndef TARGET_X86_64
 395             if (env->eflags & VM_MASK) {
 396                 handle_vm86_trap(env, trapnr);
 397             } else
 398 #endif
 399             {
 400                 /* division by zero */
 401                 info.si_signo = SIGFPE;
 402                 info.si_errno = 0;
 403                 info.si_code = TARGET_FPE_INTDIV;
 404                 info._sifields._sigfault._addr = env->eip;
 405                 queue_signal(env, info.si_signo, &info);
 406             }
 407             break;
 408         case EXCP01_SSTP:
 409         case EXCP03_INT3:
 410 #ifndef TARGET_X86_64
 411             if (env->eflags & VM_MASK) {
 412                 handle_vm86_trap(env, trapnr);
 413             } else
 414 #endif
 415             {
 416                 info.si_signo = SIGTRAP;
 417                 info.si_errno = 0;
 418                 if (trapnr == EXCP01_SSTP) {
 419                     info.si_code = TARGET_TRAP_BRKPT;
 420                     info._sifields._sigfault._addr = env->eip;
 421                 } else {
 422                     info.si_code = TARGET_SI_KERNEL;
 423                     info._sifields._sigfault._addr = 0;
 424                 }
 425                 queue_signal(env, info.si_signo, &info);
 426             }
 427             break;
 428         case EXCP04_INTO:
 429         case EXCP05_BOUND:
 430 #ifndef TARGET_X86_64
 431             if (env->eflags & VM_MASK) {
 432                 handle_vm86_trap(env, trapnr);
 433             } else
 434 #endif
 435             {
 436                 info.si_signo = SIGSEGV;
 437                 info.si_errno = 0;
 438                 info.si_code = TARGET_SI_KERNEL;
 439                 info._sifields._sigfault._addr = 0;
 440                 queue_signal(env, info.si_signo, &info);
 441             }
 442             break;
 443         case EXCP06_ILLOP:
 444             info.si_signo = SIGILL;
 445             info.si_errno = 0;
 446             info.si_code = TARGET_ILL_ILLOPN;
 447             info._sifields._sigfault._addr = env->eip;
 448             queue_signal(env, info.si_signo, &info);
 449             break;
 450         case EXCP_INTERRUPT:
 451             /* just indicate that signals should be handled asap */
 452             break;
 453         case EXCP_DEBUG:
 454             {
 455                 int sig;
 456
 457                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
 458                 if (sig)
 459                   {
 460                     info.si_signo = sig;
 461                     info.si_errno = 0;
 462                     info.si_code = TARGET_TRAP_BRKPT;
 463                     queue_signal(env, info.si_signo, &info);
 464                   }
 465             }
 466             break;
 467         default:
 468             pc = env->segs[R_CS].base + env->eip;
 469             fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
 470                     (long)pc, trapnr);
 471             abort();
 472         }
 473         process_pending_signals(env);
 474     }
 475 }
 476 #endif
 477
 478 #ifdef TARGET_ARM
 479
 480 /* XXX: find a better solution */
 481 extern void tb_invalidate_page_range(abi_ulong start, abi_ulong end);
 482
 483 static void arm_cache_flush(abi_ulong start, abi_ulong last)
 484 {
 485     abi_ulong addr, last1;
 486
 487     if (last < start)
 488         return;
 489     addr = start;
 490     for(;;) {
 491         last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1;
 492         if (last1 > last)
 493             last1 = last;
 494         tb_invalidate_page_range(addr, last1 + 1);
 495         if (last1 == last)
 496             break;
 497         addr = last1 + 1;
 498     }
 499 }
 500
 501 /* Handle a jump to the kernel code page.  */
 502 static int
 503 do_kernel_trap(CPUARMState *env)
 504 {
 505     uint32_t addr;
 506     uint32_t cpsr;
 507     uint32_t val;
 508
 509     switch (env->regs[15]) {
 510     case 0xffff0fa0: /* __kernel_memory_barrier */
 511         /* ??? No-op. Will need to do better for SMP.  */
 512         break;
 513     case 0xffff0fc0: /* __kernel_cmpxchg */
 514          /* XXX: This only works between threads, not between processes.
 515             It's probably possible to implement this with native host
 516             operations. However things like ldrex/strex are much harder so
 517             there's not much point trying.  */
 518         start_exclusive();
 519         cpsr = cpsr_read(env);
 520         addr = env->regs[2];
 521         /* FIXME: This should SEGV if the access fails.  */
 522         if (get_user_u32(val, addr))
 523             val = ~env->regs[0];
 524         if (val == env->regs[0]) {
 525             val = env->regs[1];
 526             /* FIXME: Check for segfaults.  */
 527             put_user_u32(val, addr);
 528             env->regs[0] = 0;
 529             cpsr |= CPSR_C;
 530         } else {
 531             env->regs[0] = -1;
 532             cpsr &= ~CPSR_C;
 533         }
 534         cpsr_write(env, cpsr, CPSR_C);
 535         end_exclusive();
 536         break;
 537     case 0xffff0fe0: /* __kernel_get_tls */
 538         env->regs[0] = env->cp15.c13_tls2;
 539         break;
 540     default:
 541         return 1;
 542     }
 543     /* Jump back to the caller.  */
 544     addr = env->regs[14];
 545     if (addr & 1) {
 546         env->thumb = 1;
 547         addr &= ~1;
 548     }
 549     env->regs[15] = addr;
 550
 551     return 0;
 552 }
 553
 554 void cpu_loop(CPUARMState *env)
 555 {
 556     int trapnr;
 557     unsigned int n, insn;
 558     target_siginfo_t info;
 559     uint32_t addr;
 560
 561     for(;;) {
 562         cpu_exec_start(env);
 563         trapnr = cpu_arm_exec(env);
 564         cpu_exec_end(env);
 565         switch(trapnr) {
 566         case EXCP_UDEF:
 567             {
 568                 TaskState *ts = env->opaque;
 569                 uint32_t opcode;
 570                 int rc;
 571
 572                 /* we handle the FPU emulation here, as Linux */
 573                 /* we get the opcode */
 574                 /* FIXME - what to do if get_user() fails? */
 575                 get_user_u32(opcode, env->regs[15]);
 576
 577                 rc = EmulateAll(opcode, &ts->fpa, env);
 578                 if (rc == 0) { /* illegal instruction */
 579                     info.si_signo = SIGILL;
 580                     info.si_errno = 0;
 581                     info.si_code = TARGET_ILL_ILLOPN;
 582                     info._sifields._sigfault._addr = env->regs[15];
 583                     queue_signal(env, info.si_signo, &info);
 584                 } else if (rc < 0) { /* FP exception */
 585                     int arm_fpe=0;
 586
 587                     /* translate softfloat flags to FPSR flags */
 588                     if (-rc & float_flag_invalid)
 589                       arm_fpe |= BIT_IOC;
 590                     if (-rc & float_flag_divbyzero)
 591                       arm_fpe |= BIT_DZC;
 592                     if (-rc & float_flag_overflow)
 593                       arm_fpe |= BIT_OFC;
 594                     if (-rc & float_flag_underflow)
 595                       arm_fpe |= BIT_UFC;
 596                     if (-rc & float_flag_inexact)
 597                       arm_fpe |= BIT_IXC;
 598
 599                     FPSR fpsr = ts->fpa.fpsr;
 600                     //printf("fpsr 0x%x, arm_fpe 0x%x\n",fpsr,arm_fpe);
 601
 602                     if (fpsr & (arm_fpe << 16)) { /* exception enabled? */
 603                       info.si_signo = SIGFPE;
 604                       info.si_errno = 0;
 605
 606                       /* ordered by priority, least first */
 607                       if (arm_fpe & BIT_IXC) info.si_code = TARGET_FPE_FLTRES;
 608                       if (arm_fpe & BIT_UFC) info.si_code = TARGET_FPE_FLTUND;
 609                       if (arm_fpe & BIT_OFC) info.si_code = TARGET_FPE_FLTOVF;
 610                       if (arm_fpe & BIT_DZC) info.si_code = TARGET_FPE_FLTDIV;
 611                       if (arm_fpe & BIT_IOC) info.si_code = TARGET_FPE_FLTINV;
 612
 613                       info._sifields._sigfault._addr = env->regs[15];
 614                       queue_signal(env, info.si_signo, &info);
 615                     } else {
 616                       env->regs[15] += 4;
 617                     }
 618
 619                     /* accumulate unenabled exceptions */
 620                     if ((!(fpsr & BIT_IXE)) && (arm_fpe & BIT_IXC))
 621                       fpsr |= BIT_IXC;
 622                     if ((!(fpsr & BIT_UFE)) && (arm_fpe & BIT_UFC))
 623                       fpsr |= BIT_UFC;
 624                     if ((!(fpsr & BIT_OFE)) && (arm_fpe & BIT_OFC))
 625                       fpsr |= BIT_OFC;
 626                     if ((!(fpsr & BIT_DZE)) && (arm_fpe & BIT_DZC))
 627                       fpsr |= BIT_DZC;
 628                     if ((!(fpsr & BIT_IOE)) && (arm_fpe & BIT_IOC))
 629                       fpsr |= BIT_IOC;
 630                     ts->fpa.fpsr=fpsr;
 631                 } else { /* everything OK */
 632                     /* increment PC */
 633                     env->regs[15] += 4;
 634                 }
 635             }
 636             break;
 637         case EXCP_SWI:
 638         case EXCP_BKPT:
 639             {
 640                 env->eabi = 1;
 641                 /* system call */
 642                 if (trapnr == EXCP_BKPT) {
 643                     if (env->thumb) {
 644                         /* FIXME - what to do if get_user() fails? */
 645                         get_user_u16(insn, env->regs[15]);
 646                         n = insn & 0xff;
 647                         env->regs[15] += 2;
 648                     } else {
 649                         /* FIXME - what to do if get_user() fails? */
 650                         get_user_u32(insn, env->regs[15]);
 651                         n = (insn & 0xf) | ((insn >> 4) & 0xff0);
 652                         env->regs[15] += 4;
 653                     }
 654                 } else {
 655                     if (env->thumb) {
 656                         /* FIXME - what to do if get_user() fails? */
 657                         get_user_u16(insn, env->regs[15] - 2);
 658                         n = insn & 0xff;
 659                     } else {
 660                         /* FIXME - what to do if get_user() fails? */
 661                         get_user_u32(insn, env->regs[15] - 4);
 662                         n = insn & 0xffffff;
 663                     }
 664                 }
 665
 666                 if (n == ARM_NR_cacheflush) {
 667                     arm_cache_flush(env->regs[0], env->regs[1]);
 668                 } else if (n == ARM_NR_semihosting
 669                            || n == ARM_NR_thumb_semihosting) {
 670                     env->regs[0] = do_arm_semihosting (env);
 671                 } else if (n == 0 || n >= ARM_SYSCALL_BASE
 672                            || (env->thumb && n == ARM_THUMB_SYSCALL)) {
 673                     /* linux syscall */
 674                     if (env->thumb || n == 0) {
 675                         n = env->regs[7];
 676                     } else {
 677                         n -= ARM_SYSCALL_BASE;
 678                         env->eabi = 0;
 679                     }
 680                     if ( n > ARM_NR_BASE) {
 681                         switch (n) {
 682                         case ARM_NR_cacheflush:
 683                             arm_cache_flush(env->regs[0], env->regs[1]);
 684                             break;
 685                         case ARM_NR_set_tls:
 686                             cpu_set_tls(env, env->regs[0]);
 687                             env->regs[0] = 0;
 688                             break;
 689                         default:
 690                             gemu_log("qemu: Unsupported ARM syscall: 0x%x\n",
 691                                      n);
 692                             env->regs[0] = -TARGET_ENOSYS;
 693                             break;
 694                         }
 695                     } else {
 696                         env->regs[0] = do_syscall(env,
 697                                                   n,
 698                                                   env->regs[0],
 699                                                   env->regs[1],
 700                                                   env->regs[2],
 701                                                   env->regs[3],
 702                                                   env->regs[4],
 703                                                   env->regs[5]);
 704                     }
 705                 } else {
 706                     goto error;
 707                 }
 708             }
 709             break;
 710         case EXCP_INTERRUPT:
 711             /* just indicate that signals should be handled asap */
 712             break;
 713         case EXCP_PREFETCH_ABORT:
 714             addr = env->cp15.c6_insn;
 715             goto do_segv;
 716         case EXCP_DATA_ABORT:
 717             addr = env->cp15.c6_data;
 718             goto do_segv;
 719         do_segv:
 720             {
 721                 info.si_signo = SIGSEGV;
 722                 info.si_errno = 0;
 723                 /* XXX: check env->error_code */
 724                 info.si_code = TARGET_SEGV_MAPERR;
 725                 info._sifields._sigfault._addr = addr;
 726                 queue_signal(env, info.si_signo, &info);
 727             }
 728             break;
 729         case EXCP_DEBUG:
 730             {
 731                 int sig;
 732
 733                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
 734                 if (sig)
 735                   {
 736                     info.si_signo = sig;
 737                     info.si_errno = 0;
 738                     info.si_code = TARGET_TRAP_BRKPT;
 739                     queue_signal(env, info.si_signo, &info);
 740                   }
 741             }
 742             break;
 743         case EXCP_KERNEL_TRAP:
 744             if (do_kernel_trap(env))
 745               goto error;
 746             break;
 747         default:
 748         error:
 749             fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
 750                     trapnr);
 751             cpu_dump_state(env, stderr, fprintf, 0);
 752             abort();
 753         }
 754         process_pending_signals(env);
 755     }
 756 }
 757
 758 #endif
 759
 760 #ifdef TARGET_SPARC
 761
 762 //#define DEBUG_WIN
 763
 764 /* WARNING: dealing with register windows _is_ complicated. More info
 765    can be found at http://www.sics.se/~psm/sparcstack.html */
 766 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
 767 {
 768     index = (index + cwp * 16) % (16 * env->nwindows);
 769     /* wrap handling : if cwp is on the last window, then we use the
 770        registers 'after' the end */
 771     if (index < 8 && env->cwp == env->nwindows - 1)
 772         index += 16 * env->nwindows;
 773     return index;
 774 }
 775
 776 /* save the register window 'cwp1' */
 777 static inline void save_window_offset(CPUSPARCState *env, int cwp1)
 778 {
 779     unsigned int i;
 780     abi_ulong sp_ptr;
 781
 782     sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
 783 #if defined(DEBUG_WIN)
 784     printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
 785            sp_ptr, cwp1);
 786 #endif
 787     for(i = 0; i < 16; i++) {
 788         /* FIXME - what to do if put_user() fails? */
 789         put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
 790         sp_ptr += sizeof(abi_ulong);
 791     }
 792 }
 793
 794 static void save_window(CPUSPARCState *env)
 795 {
 796 #ifndef TARGET_SPARC64
 797     unsigned int new_wim;
 798     new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) &
 799         ((1LL << env->nwindows) - 1);
 800     save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
 801     env->wim = new_wim;
 802 #else
 803     save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
 804     env->cansave++;
 805     env->canrestore--;
 806 #endif
 807 }
 808
 809 static void restore_window(CPUSPARCState *env)
 810 {
 811 #ifndef TARGET_SPARC64
 812     unsigned int new_wim;
 813 #endif
 814     unsigned int i, cwp1;
 815     abi_ulong sp_ptr;
 816
 817 #ifndef TARGET_SPARC64
 818     new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
 819         ((1LL << env->nwindows) - 1);
 820 #endif
 821
 822     /* restore the invalid window */
 823     cwp1 = cpu_cwp_inc(env, env->cwp + 1);
 824     sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
 825 #if defined(DEBUG_WIN)
 826     printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
 827            sp_ptr, cwp1);
 828 #endif
 829     for(i = 0; i < 16; i++) {
 830         /* FIXME - what to do if get_user() fails? */
 831         get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
 832         sp_ptr += sizeof(abi_ulong);
 833     }
 834 #ifdef TARGET_SPARC64
 835     env->canrestore++;
 836     if (env->cleanwin < env->nwindows - 1)
 837         env->cleanwin++;
 838     env->cansave--;
 839 #else
 840     env->wim = new_wim;
 841 #endif
 842 }
 843
 844 static void flush_windows(CPUSPARCState *env)
 845 {
 846     int offset, cwp1;
 847
 848     offset = 1;
 849     for(;;) {
 850         /* if restore would invoke restore_window(), then we can stop */
 851         cwp1 = cpu_cwp_inc(env, env->cwp + offset);
 852 #ifndef TARGET_SPARC64
 853         if (env->wim & (1 << cwp1))
 854             break;
 855 #else
 856         if (env->canrestore == 0)
 857             break;
 858         env->cansave++;
 859         env->canrestore--;
 860 #endif
 861         save_window_offset(env, cwp1);
 862         offset++;
 863     }
 864     cwp1 = cpu_cwp_inc(env, env->cwp + 1);
 865 #ifndef TARGET_SPARC64
 866     /* set wim so that restore will reload the registers */
 867     env->wim = 1 << cwp1;
 868 #endif
 869 #if defined(DEBUG_WIN)
 870     printf("flush_windows: nb=%d\n", offset - 1);
 871 #endif
 872 }
 873
 874 void cpu_loop (CPUSPARCState *env)
 875 {
 876     int trapnr, ret;
 877     target_siginfo_t info;
 878
 879     while (1) {
 880         trapnr = cpu_sparc_exec (env);
 881
 882         switch (trapnr) {
 883 #ifndef TARGET_SPARC64
 884         case 0x88:
 885         case 0x90:
 886 #else
 887         case 0x110:
 888         case 0x16d:
 889 #endif
 890             ret = do_syscall (env, env->gregs[1],
 891                               env->regwptr[0], env->regwptr[1],
 892                               env->regwptr[2], env->regwptr[3],
 893                               env->regwptr[4], env->regwptr[5]);
 894             if ((unsigned int)ret >= (unsigned int)(-515)) {
 895 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
 896                 env->xcc |= PSR_CARRY;
 897 #else
 898                 env->psr |= PSR_CARRY;
 899 #endif
 900                 ret = -ret;
 901             } else {
 902 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32)
 903                 env->xcc &= ~PSR_CARRY;
 904 #else
 905                 env->psr &= ~PSR_CARRY;
 906 #endif
 907             }
 908             env->regwptr[0] = ret;
 909             /* next instruction */
 910             env->pc = env->npc;
 911             env->npc = env->npc + 4;
 912             break;
 913         case 0x83: /* flush windows */
 914 #ifdef TARGET_ABI32
 915         case 0x103:
 916 #endif
 917             flush_windows(env);
 918             /* next instruction */
 919             env->pc = env->npc;
 920             env->npc = env->npc + 4;
 921             break;
 922 #ifndef TARGET_SPARC64
 923         case TT_WIN_OVF: /* window overflow */
 924             save_window(env);
 925             break;
 926         case TT_WIN_UNF: /* window underflow */
 927             restore_window(env);
 928             break;
 929         case TT_TFAULT:
 930         case TT_DFAULT:
 931             {
 932                 info.si_signo = SIGSEGV;
 933                 info.si_errno = 0;
 934                 /* XXX: check env->error_code */
 935                 info.si_code = TARGET_SEGV_MAPERR;
 936                 info._sifields._sigfault._addr = env->mmuregs[4];
 937                 queue_signal(env, info.si_signo, &info);
 938             }
 939             break;
 940 #else
 941         case TT_SPILL: /* window overflow */
 942             save_window(env);
 943             break;
 944         case TT_FILL: /* window underflow */
 945             restore_window(env);
 946             break;
 947         case TT_TFAULT:
 948         case TT_DFAULT:
 949             {
 950                 info.si_signo = SIGSEGV;
 951                 info.si_errno = 0;
 952                 /* XXX: check env->error_code */
 953                 info.si_code = TARGET_SEGV_MAPERR;
 954                 if (trapnr == TT_DFAULT)
 955                     info._sifields._sigfault._addr = env->dmmuregs[4];
 956                 else
 957                     info._sifields._sigfault._addr = env->tsptr->tpc;
 958                 queue_signal(env, info.si_signo, &info);
 959             }
 960             break;
 961 #ifndef TARGET_ABI32
 962         case 0x16e:
 963             flush_windows(env);
 964             sparc64_get_context(env);
 965             break;
 966         case 0x16f:
 967             flush_windows(env);
 968             sparc64_set_context(env);
 969             break;
 970 #endif
 971 #endif
 972         case EXCP_INTERRUPT:
 973             /* just indicate that signals should be handled asap */
 974             break;
 975         case EXCP_DEBUG:
 976             {
 977                 int sig;
 978
 979                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
 980                 if (sig)
 981                   {
 982                     info.si_signo = sig;
 983                     info.si_errno = 0;
 984                     info.si_code = TARGET_TRAP_BRKPT;
 985                     queue_signal(env, info.si_signo, &info);
 986                   }
 987             }
 988             break;
 989         default:
 990             printf ("Unhandled trap: 0x%x\n", trapnr);
 991             cpu_dump_state(env, stderr, fprintf, 0);
 992             exit (1);
 993         }
 994         process_pending_signals (env);
 995     }
 996 }
 997
 998 #endif
 999
1000 #ifdef TARGET_PPC
1001 static inline uint64_t cpu_ppc_get_tb (CPUState *env)
1002 {
1003     /* TO FIX */
1004     return 0;
1005 }
1006
1007 uint32_t cpu_ppc_load_tbl (CPUState *env)
1008 {
1009     return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
1010 }
1011
1012 uint32_t cpu_ppc_load_tbu (CPUState *env)
1013 {
1014     return cpu_ppc_get_tb(env) >> 32;
1015 }
1016
1017 uint32_t cpu_ppc_load_atbl (CPUState *env)
1018 {
1019     return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
1020 }
1021
1022 uint32_t cpu_ppc_load_atbu (CPUState *env)
1023 {
1024     return cpu_ppc_get_tb(env) >> 32;
1025 }
1026
1027 uint32_t cpu_ppc601_load_rtcu (CPUState *env)
1028 __attribute__ (( alias ("cpu_ppc_load_tbu") ));
1029
1030 uint32_t cpu_ppc601_load_rtcl (CPUState *env)
1031 {
1032     return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
1033 }
1034
1035 /* XXX: to be fixed */
1036 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, target_ulong *valp)
1037 {
1038     return -1;
1039 }
1040
1041 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, target_ulong val)
1042 {
1043     return -1;
1044 }
1045
1046 #define EXCP_DUMP(env, fmt, args...)                                         \
1047 do {                                                                          \
1048     fprintf(stderr, fmt , ##args);                                            \
1049     cpu_dump_state(env, stderr, fprintf, 0);                                  \
1050     if (loglevel != 0) {                                                      \
1051         fprintf(logfile, fmt , ##args);                                       \
1052         cpu_dump_state(env, logfile, fprintf, 0);                             \
1053     }                                                                         \
1054 } while (0)
1055
1056 void cpu_loop(CPUPPCState *env)
1057 {
1058     target_siginfo_t info;
1059     int trapnr;
1060     uint32_t ret;
1061
1062     for(;;) {
1063         trapnr = cpu_ppc_exec(env);
1064         switch(trapnr) {
1065         case POWERPC_EXCP_NONE:
1066             /* Just go on */
1067             break;
1068         case POWERPC_EXCP_CRITICAL: /* Critical input                        */
1069             cpu_abort(env, "Critical interrupt while in user mode. "
1070                       "Aborting\n");
1071             break;
1072         case POWERPC_EXCP_MCHECK:   /* Machine check exception               */
1073             cpu_abort(env, "Machine check exception while in user mode. "
1074                       "Aborting\n");
1075             break;
1076         case POWERPC_EXCP_DSI:      /* Data storage exception                */
1077             EXCP_DUMP(env, "Invalid data memory access: 0x" ADDRX "\n",
1078                       env->spr[SPR_DAR]);
1079             /* XXX: check this. Seems bugged */
1080             switch (env->error_code & 0xFF000000) {
1081             case 0x40000000:
1082                 info.si_signo = TARGET_SIGSEGV;
1083                 info.si_errno = 0;
1084                 info.si_code = TARGET_SEGV_MAPERR;
1085                 break;
1086             case 0x04000000:
1087                 info.si_signo = TARGET_SIGILL;
1088                 info.si_errno = 0;
1089                 info.si_code = TARGET_ILL_ILLADR;
1090                 break;
1091             case 0x08000000:
1092                 info.si_signo = TARGET_SIGSEGV;
1093                 info.si_errno = 0;
1094                 info.si_code = TARGET_SEGV_ACCERR;
1095                 break;
1096             default:
1097                 /* Let's send a regular segfault... */
1098                 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
1099                           env->error_code);
1100                 info.si_signo = TARGET_SIGSEGV;
1101                 info.si_errno = 0;
1102                 info.si_code = TARGET_SEGV_MAPERR;
1103                 break;
1104             }
1105             info._sifields._sigfault._addr = env->nip;
1106             queue_signal(env, info.si_signo, &info);
1107             break;
1108         case POWERPC_EXCP_ISI:      /* Instruction storage exception         */
1109             EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" ADDRX "\n",
1110                       env->spr[SPR_SRR0]);
1111             /* XXX: check this */
1112             switch (env->error_code & 0xFF000000) {
1113             case 0x40000000:
1114                 info.si_signo = TARGET_SIGSEGV;
1115             info.si_errno = 0;
1116                 info.si_code = TARGET_SEGV_MAPERR;
1117                 break;
1118             case 0x10000000:
1119             case 0x08000000:
1120                 info.si_signo = TARGET_SIGSEGV;
1121                 info.si_errno = 0;
1122                 info.si_code = TARGET_SEGV_ACCERR;
1123                 break;
1124             default:
1125                 /* Let's send a regular segfault... */
1126                 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
1127                           env->error_code);
1128                 info.si_signo = TARGET_SIGSEGV;
1129                 info.si_errno = 0;
1130                 info.si_code = TARGET_SEGV_MAPERR;
1131                 break;
1132             }
1133             info._sifields._sigfault._addr = env->nip - 4;
1134             queue_signal(env, info.si_signo, &info);
1135             break;
1136         case POWERPC_EXCP_EXTERNAL: /* External input                        */
1137             cpu_abort(env, "External interrupt while in user mode. "
1138                       "Aborting\n");
1139             break;
1140         case POWERPC_EXCP_ALIGN:    /* Alignment exception                   */
1141             EXCP_DUMP(env, "Unaligned memory access\n");
1142             /* XXX: check this */
1143             info.si_signo = TARGET_SIGBUS;
1144             info.si_errno = 0;
1145             info.si_code = TARGET_BUS_ADRALN;
1146             info._sifields._sigfault._addr = env->nip - 4;
1147             queue_signal(env, info.si_signo, &info);
1148             break;
1149         case POWERPC_EXCP_PROGRAM:  /* Program exception                     */
1150             /* XXX: check this */
1151             switch (env->error_code & ~0xF) {
1152             case POWERPC_EXCP_FP:
1153                 EXCP_DUMP(env, "Floating point program exception\n");
1154                 info.si_signo = TARGET_SIGFPE;
1155                 info.si_errno = 0;
1156                 switch (env->error_code & 0xF) {
1157                 case POWERPC_EXCP_FP_OX:
1158                     info.si_code = TARGET_FPE_FLTOVF;
1159                     break;
1160                 case POWERPC_EXCP_FP_UX:
1161                     info.si_code = TARGET_FPE_FLTUND;
1162                     break;
1163                 case POWERPC_EXCP_FP_ZX:
1164                 case POWERPC_EXCP_FP_VXZDZ:
1165                     info.si_code = TARGET_FPE_FLTDIV;
1166                     break;
1167                 case POWERPC_EXCP_FP_XX:
1168                     info.si_code = TARGET_FPE_FLTRES;
1169                     break;
1170                 case POWERPC_EXCP_FP_VXSOFT:
1171                     info.si_code = TARGET_FPE_FLTINV;
1172                     break;
1173                 case POWERPC_EXCP_FP_VXSNAN:
1174                 case POWERPC_EXCP_FP_VXISI:
1175                 case POWERPC_EXCP_FP_VXIDI:
1176                 case POWERPC_EXCP_FP_VXIMZ:
1177                 case POWERPC_EXCP_FP_VXVC:
1178                 case POWERPC_EXCP_FP_VXSQRT:
1179                 case POWERPC_EXCP_FP_VXCVI:
1180                     info.si_code = TARGET_FPE_FLTSUB;
1181                     break;
1182                 default:
1183                     EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
1184                               env->error_code);
1185                     break;
1186                 }
1187                 break;
1188             case POWERPC_EXCP_INVAL:
1189                 EXCP_DUMP(env, "Invalid instruction\n");
1190                 info.si_signo = TARGET_SIGILL;
1191                 info.si_errno = 0;
1192                 switch (env->error_code & 0xF) {
1193                 case POWERPC_EXCP_INVAL_INVAL:
1194                     info.si_code = TARGET_ILL_ILLOPC;
1195                     break;
1196                 case POWERPC_EXCP_INVAL_LSWX:
1197                     info.si_code = TARGET_ILL_ILLOPN;
1198                     break;
1199                 case POWERPC_EXCP_INVAL_SPR:
1200                     info.si_code = TARGET_ILL_PRVREG;
1201                     break;
1202                 case POWERPC_EXCP_INVAL_FP:
1203                     info.si_code = TARGET_ILL_COPROC;
1204                     break;
1205                 default:
1206                     EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
1207                               env->error_code & 0xF);
1208                     info.si_code = TARGET_ILL_ILLADR;
1209                     break;
1210                 }
1211                 break;
1212             case POWERPC_EXCP_PRIV:
1213                 EXCP_DUMP(env, "Privilege violation\n");
1214                 info.si_signo = TARGET_SIGILL;
1215                 info.si_errno = 0;
1216                 switch (env->error_code & 0xF) {
1217                 case POWERPC_EXCP_PRIV_OPC:
1218                     info.si_code = TARGET_ILL_PRVOPC;
1219                     break;
1220                 case POWERPC_EXCP_PRIV_REG:
1221                     info.si_code = TARGET_ILL_PRVREG;
1222                     break;
1223                 default:
1224                     EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
1225                               env->error_code & 0xF);
1226                     info.si_code = TARGET_ILL_PRVOPC;
1227                     break;
1228                 }
1229                 break;
1230             case POWERPC_EXCP_TRAP:
1231                 cpu_abort(env, "Tried to call a TRAP\n");
1232                 break;
1233             default:
1234                 /* Should not happen ! */
1235                 cpu_abort(env, "Unknown program exception (%02x)\n",
1236                           env->error_code);
1237                 break;
1238             }
1239             info._sifields._sigfault._addr = env->nip - 4;
1240             queue_signal(env, info.si_signo, &info);
1241             break;
1242         case POWERPC_EXCP_FPU:      /* Floating-point unavailable exception  */
1243             EXCP_DUMP(env, "No floating point allowed\n");
1244             info.si_signo = TARGET_SIGILL;
1245             info.si_errno = 0;
1246             info.si_code = TARGET_ILL_COPROC;
1247             info._sifields._sigfault._addr = env->nip - 4;
1248             queue_signal(env, info.si_signo, &info);
1249             break;
1250         case POWERPC_EXCP_SYSCALL:  /* System call exception                 */
1251             cpu_abort(env, "Syscall exception while in user mode. "
1252                       "Aborting\n");
1253             break;
1254         case POWERPC_EXCP_APU:      /* Auxiliary processor unavailable       */
1255             EXCP_DUMP(env, "No APU instruction allowed\n");
1256             info.si_signo = TARGET_SIGILL;
1257             info.si_errno = 0;
1258             info.si_code = TARGET_ILL_COPROC;
1259             info._sifields._sigfault._addr = env->nip - 4;
1260             queue_signal(env, info.si_signo, &info);
1261             break;
1262         case POWERPC_EXCP_DECR:     /* Decrementer exception                 */
1263             cpu_abort(env, "Decrementer interrupt while in user mode. "
1264                       "Aborting\n");
1265             break;
1266         case POWERPC_EXCP_FIT:      /* Fixed-interval timer interrupt        */
1267             cpu_abort(env, "Fix interval timer interrupt while in user mode. "
1268                       "Aborting\n");
1269             break;
1270         case POWERPC_EXCP_WDT:      /* Watchdog timer interrupt              */
1271             cpu_abort(env, "Watchdog timer interrupt while in user mode. "
1272                       "Aborting\n");
1273             break;
1274         case POWERPC_EXCP_DTLB:     /* Data TLB error                        */
1275             cpu_abort(env, "Data TLB exception while in user mode. "
1276                       "Aborting\n");
1277             break;
1278         case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */
1279             cpu_abort(env, "Instruction TLB exception while in user mode. "
1280                       "Aborting\n");
1281             break;
1282         case POWERPC_EXCP_DEBUG:    /* Debug interrupt                       */
1283             /* XXX: check this */
1284             {
1285                 int sig;
1286
1287                 sig = gdb_handlesig(env, TARGET_SIGTRAP);
1288                 if (sig) {
1289                     info.si_signo = sig;
1290                     info.si_errno = 0;
1291                     info.si_code = TARGET_TRAP_BRKPT;
1292                     queue_signal(env, info.si_signo, &info);
1293                   }
1294             }
1295             break;
1296         case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */
1297             EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");
1298             info.si_signo = TARGET_SIGILL;
1299             info.si_errno = 0;
1300             info.si_code = TARGET_ILL_COPROC;
1301             info._sifields._sigfault._addr = env->nip - 4;
1302             queue_signal(env, info.si_signo, &info);
1303             break;
1304         case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */
1305             cpu_abort(env, "Embedded floating-point data IRQ not handled\n");
1306             break;
1307         case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */
1308             cpu_abort(env, "Embedded floating-point round IRQ not handled\n");
1309             break;
1310         case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */
1311             cpu_abort(env, "Performance monitor exception not handled\n");
1312             break;
1313         case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */
1314             cpu_abort(env, "Doorbell interrupt while in user mode. "
1315                        "Aborting\n");
1316             break;
1317         case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */
1318             cpu_abort(env, "Doorbell critical interrupt while in user mode. "
1319                       "Aborting\n");
1320             break;
1321         case POWERPC_EXCP_RESET:    /* System reset exception                */
1322             cpu_abort(env, "Reset interrupt while in user mode. "
1323                       "Aborting\n");
1324             break;
1325         case POWERPC_EXCP_DSEG:     /* Data segment exception                */
1326             cpu_abort(env, "Data segment exception while in user mode. "
1327                       "Aborting\n");
1328             break;
1329         case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */
1330             cpu_abort(env, "Instruction segment exception "
1331                       "while in user mode. Aborting\n");
1332             break;
1333         /* PowerPC 64 with hypervisor mode support */
1334         case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */
1335             cpu_abort(env, "Hypervisor decrementer interrupt "
1336                       "while in user mode. Aborting\n");
1337             break;
1338         case POWERPC_EXCP_TRACE:    /* Trace exception                       */
1339             /* Nothing to do:
1340              * we use this exception to emulate step-by-step execution mode.
1341              */
1342             break;
1343         /* PowerPC 64 with hypervisor mode support */
1344         case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */
1345             cpu_abort(env, "Hypervisor data storage exception "
1346                       "while in user mode. Aborting\n");
1347             break;
1348         case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */
1349             cpu_abort(env, "Hypervisor instruction storage exception "
1350                       "while in user mode. Aborting\n");
1351             break;
1352         case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */
1353             cpu_abort(env, "Hypervisor data segment exception "
1354                       "while in user mode. Aborting\n");
1355             break;
1356         case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */
1357             cpu_abort(env, "Hypervisor instruction segment exception "
1358                       "while in user mode. Aborting\n");
1359             break;
1360         case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */
1361             EXCP_DUMP(env, "No Altivec instructions allowed\n");
1362             info.si_signo = TARGET_SIGILL;
1363             info.si_errno = 0;
1364             info.si_code = TARGET_ILL_COPROC;
1365             info._sifields._sigfault._addr = env->nip - 4;
1366             queue_signal(env, info.si_signo, &info);
1367             break;
1368         case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */
1369             cpu_abort(env, "Programable interval timer interrupt "
1370                       "while in user mode. Aborting\n");
1371             break;
1372         case POWERPC_EXCP_IO:       /* IO error exception                    */
1373             cpu_abort(env, "IO error exception while in user mode. "
1374                       "Aborting\n");
1375             break;
1376         case POWERPC_EXCP_RUNM:     /* Run mode exception                    */
1377             cpu_abort(env, "Run mode exception while in user mode. "
1378                       "Aborting\n");
1379             break;
1380         case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */
1381             cpu_abort(env, "Emulation trap exception not handled\n");
1382             break;
1383         case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */
1384             cpu_abort(env, "Instruction fetch TLB exception "
1385                       "while in user-mode. Aborting");
1386             break;
1387         case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */
1388             cpu_abort(env, "Data load TLB exception while in user-mode. "
1389                       "Aborting");
1390             break;
1391         case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */
1392             cpu_abort(env, "Data store TLB exception while in user-mode. "
1393                       "Aborting");
1394             break;
1395         case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */
1396             cpu_abort(env, "Floating-point assist exception not handled\n");
1397             break;
1398         case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */
1399             cpu_abort(env, "Instruction address breakpoint exception "
1400                       "not handled\n");
1401             break;
1402         case POWERPC_EXCP_SMI:      /* System management interrupt           */
1403             cpu_abort(env, "System management interrupt while in user mode. "
1404                       "Aborting\n");
1405             break;
1406         case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */
1407             cpu_abort(env, "Thermal interrupt interrupt while in user mode. "
1408                       "Aborting\n");
1409             break;
1410         case POWERPC_EXCP_PERFM:   /* Embedded performance monitor IRQ      */
1411             cpu_abort(env, "Performance monitor exception not handled\n");
1412             break;
1413         case POWERPC_EXCP_VPUA:     /* Vector assist exception               */
1414             cpu_abort(env, "Vector assist exception not handled\n");
1415             break;
1416         case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */
1417             cpu_abort(env, "Soft patch exception not handled\n");
1418             break;
1419         case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */
1420             cpu_abort(env, "Maintenance exception while in user mode. "
1421                       "Aborting\n");
1422             break;
1423         case POWERPC_EXCP_STOP:     /* stop translation                      */
1424             /* We did invalidate the instruction cache. Go on */
1425             break;
1426         case POWERPC_EXCP_BRANCH:   /* branch instruction:                   */
1427             /* We just stopped because of a branch. Go on */
1428             break;
1429         case POWERPC_EXCP_SYSCALL_USER:
1430             /* system call in user-mode emulation */
1431             /* WARNING:
1432              * PPC ABI uses overflow flag in cr0 to signal an error
1433              * in syscalls.
1434              */
1435 #if 0
1436             printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0],
1437                    env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]);
1438 #endif
1439             env->crf[0] &= ~0x1;
1440             ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
1441                              env->gpr[5], env->gpr[6], env->gpr[7],
1442                              env->gpr[8]);
1443             if (ret > (uint32_t)(-515)) {
1444                 env->crf[0] |= 0x1;
1445                 ret = -ret;
1446             }
1447             env->gpr[3] = ret;
1448 #if 0
1449             printf("syscall returned 0x%08x (%d)\n", ret, ret);
1450 #endif
1451             break;
1452         case EXCP_INTERRUPT:
1453             /* just indicate that signals should be handled asap */
1454             break;
1455         default:
1456             cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr);
1457             break;
1458         }
1459         process_pending_signals(env);
1460     }
1461 }
1462 #endif
1463
1464 #ifdef TARGET_MIPS
1465
1466 #define MIPS_SYS(name, args) args,
1467
1468 static const uint8_t mips_syscall_args[] = {
1469         MIPS_SYS(sys_syscall    , 0)    /* 4000 */
1470         MIPS_SYS(sys_exit       , 1)
1471         MIPS_SYS(sys_fork       , 0)
1472         MIPS_SYS(sys_read       , 3)
1473         MIPS_SYS(sys_write      , 3)
1474         MIPS_SYS(sys_open       , 3)    /* 4005 */
1475         MIPS_SYS(sys_close      , 1)
1476         MIPS_SYS(sys_waitpid    , 3)
1477         MIPS_SYS(sys_creat      , 2)
1478         MIPS_SYS(sys_link       , 2)
1479         MIPS_SYS(sys_unlink     , 1)    /* 4010 */
1480         MIPS_SYS(sys_execve     , 0)
1481         MIPS_SYS(sys_chdir      , 1)
1482         MIPS_SYS(sys_time       , 1)
1483         MIPS_SYS(sys_mknod      , 3)
1484         MIPS_SYS(sys_chmod      , 2)    /* 4015 */
1485         MIPS_SYS(sys_lchown     , 3)
1486         MIPS_SYS(sys_ni_syscall , 0)
1487         MIPS_SYS(sys_ni_syscall , 0)    /* was sys_stat */
1488         MIPS_SYS(sys_lseek      , 3)
1489         MIPS_SYS(sys_getpid     , 0)    /* 4020 */
1490         MIPS_SYS(sys_mount      , 5)
1491         MIPS_SYS(sys_oldumount  , 1)
1492         MIPS_SYS(sys_setuid     , 1)
1493         MIPS_SYS(sys_getuid     , 0)
1494         MIPS_SYS(sys_stime      , 1)    /* 4025 */
1495         MIPS_SYS(sys_ptrace     , 4)
1496         MIPS_SYS(sys_alarm      , 1)
1497         MIPS_SYS(sys_ni_syscall , 0)    /* was sys_fstat */
1498         MIPS_SYS(sys_pause      , 0)
1499         MIPS_SYS(sys_utime      , 2)    /* 4030 */
1500         MIPS_SYS(sys_ni_syscall , 0)
1501         MIPS_SYS(sys_ni_syscall , 0)
1502         MIPS_SYS(sys_access     , 2)
1503         MIPS_SYS(sys_nice       , 1)
1504         MIPS_SYS(sys_ni_syscall , 0)    /* 4035 */
1505         MIPS_SYS(sys_sync       , 0)
1506         MIPS_SYS(sys_kill       , 2)
1507         MIPS_SYS(sys_rename     , 2)
1508         MIPS_SYS(sys_mkdir      , 2)
1509         MIPS_SYS(sys_rmdir      , 1)    /* 4040 */
1510         MIPS_SYS(sys_dup                , 1)
1511         MIPS_SYS(sys_pipe       , 0)
1512         MIPS_SYS(sys_times      , 1)
1513         MIPS_SYS(sys_ni_syscall , 0)
1514         MIPS_SYS(sys_brk                , 1)    /* 4045 */
1515         MIPS_SYS(sys_setgid     , 1)
1516         MIPS_SYS(sys_getgid     , 0)
1517         MIPS_SYS(sys_ni_syscall , 0)    /* was signal(2) */
1518         MIPS_SYS(sys_geteuid    , 0)
1519         MIPS_SYS(sys_getegid    , 0)    /* 4050 */
1520         MIPS_SYS(sys_acct       , 0)
1521         MIPS_SYS(sys_umount     , 2)
1522         MIPS_SYS(sys_ni_syscall , 0)
1523         MIPS_SYS(sys_ioctl      , 3)
1524         MIPS_SYS(sys_fcntl      , 3)    /* 4055 */
1525         MIPS_SYS(sys_ni_syscall , 2)
1526         MIPS_SYS(sys_setpgid    , 2)
1527         MIPS_SYS(sys_ni_syscall , 0)
1528         MIPS_SYS(sys_olduname   , 1)
1529         MIPS_SYS(sys_umask      , 1)    /* 4060 */
1530         MIPS_SYS(sys_chroot     , 1)
1531         MIPS_SYS(sys_ustat      , 2)
1532         MIPS_SYS(sys_dup2       , 2)
1533         MIPS_SYS(sys_getppid    , 0)
1534         MIPS_SYS(sys_getpgrp    , 0)    /* 4065 */
1535         MIPS_SYS(sys_setsid     , 0)
1536         MIPS_SYS(sys_sigaction  , 3)
1537         MIPS_SYS(sys_sgetmask   , 0)
1538         MIPS_SYS(sys_ssetmask   , 1)
1539         MIPS_SYS(sys_setreuid   , 2)    /* 4070 */
1540         MIPS_SYS(sys_setregid   , 2)
1541         MIPS_SYS(sys_sigsuspend , 0)
1542         MIPS_SYS(sys_sigpending , 1)
1543         MIPS_SYS(sys_sethostname        , 2)
1544         MIPS_SYS(sys_setrlimit  , 2)    /* 4075 */
1545         MIPS_SYS(sys_getrlimit  , 2)
1546         MIPS_SYS(sys_getrusage  , 2)
1547         MIPS_SYS(sys_gettimeofday, 2)
1548         MIPS_SYS(sys_settimeofday, 2)
1549         MIPS_SYS(sys_getgroups  , 2)    /* 4080 */
1550         MIPS_SYS(sys_setgroups  , 2)
1551         MIPS_SYS(sys_ni_syscall , 0)    /* old_select */
1552         MIPS_SYS(sys_symlink    , 2)
1553         MIPS_SYS(sys_ni_syscall , 0)    /* was sys_lstat */
1554         MIPS_SYS(sys_readlink   , 3)    /* 4085 */
1555         MIPS_SYS(sys_uselib     , 1)
1556         MIPS_SYS(sys_swapon     , 2)
1557         MIPS_SYS(sys_reboot     , 3)
1558         MIPS_SYS(old_readdir    , 3)
1559         MIPS_SYS(old_mmap       , 6)    /* 4090 */
1560         MIPS_SYS(sys_munmap     , 2)
1561         MIPS_SYS(sys_truncate   , 2)
1562         MIPS_SYS(sys_ftruncate  , 2)
1563         MIPS_SYS(sys_fchmod     , 2)
1564         MIPS_SYS(sys_fchown     , 3)    /* 4095 */
1565         MIPS_SYS(sys_getpriority        , 2)
1566         MIPS_SYS(sys_setpriority        , 3)
1567         MIPS_SYS(sys_ni_syscall , 0)
1568         MIPS_SYS(sys_statfs     , 2)
1569         MIPS_SYS(sys_fstatfs    , 2)    /* 4100 */
1570         MIPS_SYS(sys_ni_syscall , 0)    /* was ioperm(2) */
1571         MIPS_SYS(sys_socketcall , 2)
1572         MIPS_SYS(sys_syslog     , 3)
1573         MIPS_SYS(sys_setitimer  , 3)
1574         MIPS_SYS(sys_getitimer  , 2)    /* 4105 */
1575         MIPS_SYS(sys_newstat    , 2)
1576         MIPS_SYS(sys_newlstat   , 2)
1577         MIPS_SYS(sys_newfstat   , 2)
1578         MIPS_SYS(sys_uname      , 1)
1579         MIPS_SYS(sys_ni_syscall , 0)    /* 4110 was iopl(2) */
1580         MIPS_SYS(sys_vhangup    , 0)
1581         MIPS_SYS(sys_ni_syscall , 0)    /* was sys_idle() */
1582         MIPS_SYS(sys_ni_syscall , 0)    /* was sys_vm86 */
1583         MIPS_SYS(sys_wait4      , 4)
1584         MIPS_SYS(sys_swapoff    , 1)    /* 4115 */
1585         MIPS_SYS(sys_sysinfo    , 1)
1586         MIPS_SYS(sys_ipc                , 6)
1587         MIPS_SYS(sys_fsync      , 1)
1588         MIPS_SYS(sys_sigreturn  , 0)
1589         MIPS_SYS(sys_clone      , 0)    /* 4120 */
1590         MIPS_SYS(sys_setdomainname, 2)
1591         MIPS_SYS(sys_newuname   , 1)
1592         MIPS_SYS(sys_ni_syscall , 0)    /* sys_modify_ldt */
1593         MIPS_SYS(sys_adjtimex   , 1)
1594         MIPS_SYS(sys_mprotect   , 3)    /* 4125 */
1595         MIPS_SYS(sys_sigprocmask        , 3)
1596         MIPS_SYS(sys_ni_syscall , 0)    /* was create_module */
1597         MIPS_SYS(sys_init_module        , 5)
1598         MIPS_SYS(sys_delete_module, 1)
1599         MIPS_SYS(sys_ni_syscall , 0)    /* 4130 was get_kernel_syms */
1600         MIPS_SYS(sys_quotactl   , 0)
1601         MIPS_SYS(sys_getpgid    , 1)
1602         MIPS_SYS(sys_fchdir     , 1)
1603         MIPS_SYS(sys_bdflush    , 2)
1604         MIPS_SYS(sys_sysfs      , 3)    /* 4135 */
1605         MIPS_SYS(sys_personality        , 1)
1606         MIPS_SYS(sys_ni_syscall , 0)    /* for afs_syscall */
1607         MIPS_SYS(sys_setfsuid   , 1)
1608         MIPS_SYS(sys_setfsgid   , 1)
1609         MIPS_SYS(sys_llseek     , 5)    /* 4140 */
1610         MIPS_SYS(sys_getdents   , 3)
1611         MIPS_SYS(sys_select     , 5)
1612         MIPS_SYS(sys_flock      , 2)
1613         MIPS_SYS(sys_msync      , 3)
1614         MIPS_SYS(sys_readv      , 3)    /* 4145 */
1615         MIPS_SYS(sys_writev     , 3)
1616         MIPS_SYS(sys_cacheflush , 3)
1617         MIPS_SYS(sys_cachectl   , 3)
1618         MIPS_SYS(sys_sysmips    , 4)
1619         MIPS_SYS(sys_ni_syscall , 0)    /* 4150 */
1620         MIPS_SYS(sys_getsid     , 1)
1621         MIPS_SYS(sys_fdatasync  , 0)
1622         MIPS_SYS(sys_sysctl     , 1)
1623         MIPS_SYS(sys_mlock      , 2)
1624         MIPS_SYS(sys_munlock    , 2)    /* 4155 */
1625         MIPS_SYS(sys_mlockall   , 1)
1626         MIPS_SYS(sys_munlockall , 0)
1627         MIPS_SYS(sys_sched_setparam, 2)
1628         MIPS_SYS(sys_sched_getparam, 2)
1629         MIPS_SYS(sys_sched_setscheduler, 3)     /* 4160 */
1630         MIPS_SYS(sys_sched_getscheduler, 1)
1631         MIPS_SYS(sys_sched_yield        , 0)
1632         MIPS_SYS(sys_sched_get_priority_max, 1)
1633         MIPS_SYS(sys_sched_get_priority_min, 1)
1634         MIPS_SYS(sys_sched_rr_get_interval, 2)  /* 4165 */
1635         MIPS_SYS(sys_nanosleep, 2)
1636         MIPS_SYS(sys_mremap     , 4)
1637         MIPS_SYS(sys_accept     , 3)
1638         MIPS_SYS(sys_bind       , 3)
1639         MIPS_SYS(sys_connect    , 3)    /* 4170 */
1640         MIPS_SYS(sys_getpeername        , 3)
1641         MIPS_SYS(sys_getsockname        , 3)
1642         MIPS_SYS(sys_getsockopt , 5)
1643         MIPS_SYS(sys_listen     , 2)
1644         MIPS_SYS(sys_recv       , 4)    /* 4175 */
1645         MIPS_SYS(sys_recvfrom   , 6)
1646         MIPS_SYS(sys_recvmsg    , 3)
1647         MIPS_SYS(sys_send       , 4)
1648         MIPS_SYS(sys_sendmsg    , 3)
1649         MIPS_SYS(sys_sendto     , 6)    /* 4180 */
1650         MIPS_SYS(sys_setsockopt , 5)
1651         MIPS_SYS(sys_shutdown   , 2)
1652         MIPS_SYS(sys_socket     , 3)
1653         MIPS_SYS(sys_socketpair , 4)
1654         MIPS_SYS(sys_setresuid  , 3)    /* 4185 */
1655         MIPS_SYS(sys_getresuid  , 3)
1656         MIPS_SYS(sys_ni_syscall , 0)    /* was sys_query_module */
1657         MIPS_SYS(sys_poll       , 3)
1658         MIPS_SYS(sys_nfsservctl , 3)
1659         MIPS_SYS(sys_setresgid  , 3)    /* 4190 */
1660         MIPS_SYS(sys_getresgid  , 3)
1661         MIPS_SYS(sys_prctl      , 5)
1662         MIPS_SYS(sys_rt_sigreturn, 0)
1663         MIPS_SYS(sys_rt_sigaction, 4)
1664         MIPS_SYS(sys_rt_sigprocmask, 4) /* 4195 */
1665         MIPS_SYS(sys_rt_sigpending, 2)
1666         MIPS_SYS(sys_rt_sigtimedwait, 4)
1667         MIPS_SYS(sys_rt_sigqueueinfo, 3)
1668         MIPS_SYS(sys_rt_sigsuspend, 0)
1669         MIPS_SYS(sys_pread64    , 6)    /* 4200 */
1670         MIPS_SYS(sys_pwrite64   , 6)
1671         MIPS_SYS(sys_chown      , 3)
1672         MIPS_SYS(sys_getcwd     , 2)
1673         MIPS_SYS(sys_capget     , 2)
1674         MIPS_SYS(sys_capset     , 2)    /* 4205 */
1675         MIPS_SYS(sys_sigaltstack        , 0)
1676         MIPS_SYS(sys_sendfile   , 4)
1677         MIPS_SYS(sys_ni_syscall , 0)
1678         MIPS_SYS(sys_ni_syscall , 0)
1679         MIPS_SYS(sys_mmap2      , 6)    /* 4210 */
1680         MIPS_SYS(sys_truncate64 , 4)
1681         MIPS_SYS(sys_ftruncate64        , 4)
1682         MIPS_SYS(sys_stat64     , 2)
1683         MIPS_SYS(sys_lstat64    , 2)
1684         MIPS_SYS(sys_fstat64    , 2)    /* 4215 */
1685         MIPS_SYS(sys_pivot_root , 2)
1686         MIPS_SYS(sys_mincore    , 3)
1687         MIPS_SYS(sys_madvise    , 3)
1688         MIPS_SYS(sys_getdents64 , 3)
1689         MIPS_SYS(sys_fcntl64    , 3)    /* 4220 */
1690         MIPS_SYS(sys_ni_syscall , 0)
1691         MIPS_SYS(sys_gettid     , 0)
1692         MIPS_SYS(sys_readahead  , 5)
1693         MIPS_SYS(sys_setxattr   , 5)
1694         MIPS_SYS(sys_lsetxattr  , 5)    /* 4225 */
1695         MIPS_SYS(sys_fsetxattr  , 5)
1696         MIPS_SYS(sys_getxattr   , 4)
1697         MIPS_SYS(sys_lgetxattr  , 4)
1698         MIPS_SYS(sys_fgetxattr  , 4)
1699         MIPS_SYS(sys_listxattr  , 3)    /* 4230 */
1700         MIPS_SYS(sys_llistxattr , 3)
1701         MIPS_SYS(sys_flistxattr , 3)
1702         MIPS_SYS(sys_removexattr        , 2)
1703         MIPS_SYS(sys_lremovexattr, 2)
1704         MIPS_SYS(sys_fremovexattr, 2)   /* 4235 */
1705         MIPS_SYS(sys_tkill      , 2)
1706         MIPS_SYS(sys_sendfile64 , 5)
1707         MIPS_SYS(sys_futex      , 2)
1708         MIPS_SYS(sys_sched_setaffinity, 3)
1709         MIPS_SYS(sys_sched_getaffinity, 3)      /* 4240 */
1710         MIPS_SYS(sys_io_setup   , 2)
1711         MIPS_SYS(sys_io_destroy , 1)
1712         MIPS_SYS(sys_io_getevents, 5)
1713         MIPS_SYS(sys_io_submit  , 3)
1714         MIPS_SYS(sys_io_cancel  , 3)    /* 4245 */
1715         MIPS_SYS(sys_exit_group , 1)
1716         MIPS_SYS(sys_lookup_dcookie, 3)
1717         MIPS_SYS(sys_epoll_create, 1)
1718         MIPS_SYS(sys_epoll_ctl  , 4)
1719         MIPS_SYS(sys_epoll_wait , 3)    /* 4250 */
1720         MIPS_SYS(sys_remap_file_pages, 5)
1721         MIPS_SYS(sys_set_tid_address, 1)
1722         MIPS_SYS(sys_restart_syscall, 0)
1723         MIPS_SYS(sys_fadvise64_64, 7)
1724         MIPS_SYS(sys_statfs64   , 3)    /* 4255 */
1725         MIPS_SYS(sys_fstatfs64  , 2)
1726         MIPS_SYS(sys_timer_create, 3)
1727         MIPS_SYS(sys_timer_settime, 4)
1728         MIPS_SYS(sys_timer_gettime, 2)
1729         MIPS_SYS(sys_timer_getoverrun, 1)       /* 4260 */
1730         MIPS_SYS(sys_timer_delete, 1)
1731         MIPS_SYS(sys_clock_settime, 2)
1732         MIPS_SYS(sys_clock_gettime, 2)
1733         MIPS_SYS(sys_clock_getres, 2)
1734         MIPS_SYS(sys_clock_nanosleep, 4)        /* 4265 */
1735         MIPS_SYS(sys_tgkill     , 3)
1736         MIPS_SYS(sys_utimes     , 2)
1737         MIPS_SYS(sys_mbind      , 4)
1738         MIPS_SYS(sys_ni_syscall , 0)    /* sys_get_mempolicy */
1739         MIPS_SYS(sys_ni_syscall , 0)    /* 4270 sys_set_mempolicy */
1740         MIPS_SYS(sys_mq_open    , 4)
1741         MIPS_SYS(sys_mq_unlink  , 1)
1742         MIPS_SYS(sys_mq_timedsend, 5)
1743         MIPS_SYS(sys_mq_timedreceive, 5)
1744         MIPS_SYS(sys_mq_notify  , 2)    /* 4275 */
1745         MIPS_SYS(sys_mq_getsetattr, 3)
1746         MIPS_SYS(sys_ni_syscall , 0)    /* sys_vserver */
1747         MIPS_SYS(sys_waitid     , 4)
1748         MIPS_SYS(sys_ni_syscall , 0)    /* available, was setaltroot */
1749         MIPS_SYS(sys_add_key    , 5)
1750         MIPS_SYS(sys_request_key, 4)
1751         MIPS_SYS(sys_keyctl     , 5)
1752         MIPS_SYS(sys_set_thread_area, 1)
1753         MIPS_SYS(sys_inotify_init, 0)
1754         MIPS_SYS(sys_inotify_add_watch, 3) /* 4285 */
1755         MIPS_SYS(sys_inotify_rm_watch, 2)
1756         MIPS_SYS(sys_migrate_pages, 4)
1757         MIPS_SYS(sys_openat, 4)
1758         MIPS_SYS(sys_mkdirat, 3)
1759         MIPS_SYS(sys_mknodat, 4)        /* 4290 */
1760         MIPS_SYS(sys_fchownat, 5)
1761         MIPS_SYS(sys_futimesat, 3)
1762         MIPS_SYS(sys_fstatat64, 4)
1763         MIPS_SYS(sys_unlinkat, 3)
1764         MIPS_SYS(sys_renameat, 4)       /* 4295 */
1765         MIPS_SYS(sys_linkat, 5)
1766         MIPS_SYS(sys_symlinkat, 3)
1767         MIPS_SYS(sys_readlinkat, 4)
1768         MIPS_SYS(sys_fchmodat, 3)
1769         MIPS_SYS(sys_faccessat, 3)      /* 4300 */
1770         MIPS_SYS(sys_pselect6, 6)
1771         MIPS_SYS(sys_ppoll, 5)
1772         MIPS_SYS(sys_unshare, 1)
1773         MIPS_SYS(sys_splice, 4)
1774         MIPS_SYS(sys_sync_file_range, 7) /* 4305 */
1775         MIPS_SYS(sys_tee, 4)
1776         MIPS_SYS(sys_vmsplice, 4)
1777         MIPS_SYS(sys_move_pages, 6)
1778         MIPS_SYS(sys_set_robust_list, 2)
1779         MIPS_SYS(sys_get_robust_list, 3) /* 4310 */
1780         MIPS_SYS(sys_kexec_load, 4)
1781         MIPS_SYS(sys_getcpu, 3)
1782         MIPS_SYS(sys_epoll_pwait, 6)
1783         MIPS_SYS(sys_ioprio_set, 3)
1784         MIPS_SYS(sys_ioprio_get, 2)
1785 };
1786
1787 #undef MIPS_SYS
1788
1789 void cpu_loop(CPUMIPSState *env)
1790 {
1791     target_siginfo_t info;
1792     int trapnr, ret;
1793     unsigned int syscall_num;
1794
1795     for(;;) {
1796         trapnr = cpu_mips_exec(env);
1797         switch(trapnr) {
1798         case EXCP_SYSCALL:
1799             syscall_num = env->active_tc.gpr[2] - 4000;
1800             env->active_tc.PC += 4;
1801             if (syscall_num >= sizeof(mips_syscall_args)) {
1802                 ret = -ENOSYS;
1803             } else {
1804                 int nb_args;
1805                 abi_ulong sp_reg;
1806                 abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0;
1807
1808                 nb_args = mips_syscall_args[syscall_num];
1809                 sp_reg = env->active_tc.gpr[29];
1810                 switch (nb_args) {
1811                 /* these arguments are taken from the stack */
1812                 /* FIXME - what to do if get_user() fails? */
1813                 case 8: get_user_ual(arg8, sp_reg + 28);
1814                 case 7: get_user_ual(arg7, sp_reg + 24);
1815                 case 6: get_user_ual(arg6, sp_reg + 20);
1816                 case 5: get_user_ual(arg5, sp_reg + 16);
1817                 default:
1818                     break;
1819                 }
1820                 ret = do_syscall(env, env->active_tc.gpr[2],
1821                                  env->active_tc.gpr[4],
1822                                  env->active_tc.gpr[5],
1823                                  env->active_tc.gpr[6],
1824                                  env->active_tc.gpr[7],
1825                                  arg5, arg6/*, arg7, arg8*/);
1826             }
1827             if ((unsigned int)ret >= (unsigned int)(-1133)) {
1828                 env->active_tc.gpr[7] = 1; /* error flag */
1829                 ret = -ret;
1830             } else {
1831                 env->active_tc.gpr[7] = 0; /* error flag */
1832             }
1833             env->active_tc.gpr[2] = ret;
1834             break;
1835         case EXCP_TLBL:
1836         case EXCP_TLBS:
1837         case EXCP_CpU:
1838         case EXCP_RI:
1839             info.si_signo = TARGET_SIGILL;
1840             info.si_errno = 0;
1841             info.si_code = 0;
1842             queue_signal(env, info.si_signo, &info);
1843             break;
1844         case EXCP_INTERRUPT:
1845             /* just indicate that signals should be handled asap */
1846             break;
1847         case EXCP_DEBUG:
1848             {
1849                 int sig;
1850
1851                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
1852                 if (sig)
1853                   {
1854                     info.si_signo = sig;
1855                     info.si_errno = 0;
1856                     info.si_code = TARGET_TRAP_BRKPT;
1857                     queue_signal(env, info.si_signo, &info);
1858                   }
1859             }
1860             break;
1861         default:
1862             //        error:
1863             fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
1864                     trapnr);
1865             cpu_dump_state(env, stderr, fprintf, 0);
1866             abort();
1867         }
1868         process_pending_signals(env);
1869     }
1870 }
1871 #endif
1872
1873 #ifdef TARGET_SH4
1874 void cpu_loop (CPUState *env)
1875 {
1876     int trapnr, ret;
1877     target_siginfo_t info;
1878
1879     while (1) {
1880         trapnr = cpu_sh4_exec (env);
1881
1882         switch (trapnr) {
1883         case 0x160:
1884             ret = do_syscall(env,
1885                              env->gregs[3],
1886                              env->gregs[4],
1887                              env->gregs[5],
1888                              env->gregs[6],
1889                              env->gregs[7],
1890                              env->gregs[0],
1891                              env->gregs[1]);
1892             env->gregs[0] = ret;
1893             env->pc += 2;
1894             break;
1895         case EXCP_INTERRUPT:
1896             /* just indicate that signals should be handled asap */
1897             break;
1898         case EXCP_DEBUG:
1899             {
1900                 int sig;
1901
1902                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
1903                 if (sig)
1904                   {
1905                     info.si_signo = sig;
1906                     info.si_errno = 0;
1907                     info.si_code = TARGET_TRAP_BRKPT;
1908                     queue_signal(env, info.si_signo, &info);
1909                   }
1910             }
1911             break;
1912         case 0xa0:
1913         case 0xc0:
1914             info.si_signo = SIGSEGV;
1915             info.si_errno = 0;
1916             info.si_code = TARGET_SEGV_MAPERR;
1917             info._sifields._sigfault._addr = env->tea;
1918             queue_signal(env, info.si_signo, &info);
1919             break;
1920
1921         default:
1922             printf ("Unhandled trap: 0x%x\n", trapnr);
1923             cpu_dump_state(env, stderr, fprintf, 0);
1924             exit (1);
1925         }
1926         process_pending_signals (env);
1927     }
1928 }
1929 #endif
1930
1931 #ifdef TARGET_CRIS
1932 void cpu_loop (CPUState *env)
1933 {
1934     int trapnr, ret;
1935     target_siginfo_t info;
1936
1937     while (1) {
1938         trapnr = cpu_cris_exec (env);
1939         switch (trapnr) {
1940         case 0xaa:
1941             {
1942                 info.si_signo = SIGSEGV;
1943                 info.si_errno = 0;
1944                 /* XXX: check env->error_code */
1945                 info.si_code = TARGET_SEGV_MAPERR;
1946                 info._sifields._sigfault._addr = env->pregs[PR_EDA];
1947                 queue_signal(env, info.si_signo, &info);
1948             }
1949             break;
1950         case EXCP_INTERRUPT:
1951           /* just indicate that signals should be handled asap */
1952           break;
1953         case EXCP_BREAK:
1954             ret = do_syscall(env,
1955                              env->regs[9],
1956                              env->regs[10],
1957                              env->regs[11],
1958                              env->regs[12],
1959                              env->regs[13],
1960                              env->pregs[7],
1961                              env->pregs[11]);
1962             env->regs[10] = ret;
1963             env->pc += 2;
1964             break;
1965         case EXCP_DEBUG:
1966             {
1967                 int sig;
1968
1969                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
1970                 if (sig)
1971                   {
1972                     info.si_signo = sig;
1973                     info.si_errno = 0;
1974                     info.si_code = TARGET_TRAP_BRKPT;
1975                     queue_signal(env, info.si_signo, &info);
1976                   }
1977             }
1978             break;
1979         default:
1980             printf ("Unhandled trap: 0x%x\n", trapnr);
1981             cpu_dump_state(env, stderr, fprintf, 0);
1982             exit (1);
1983         }
1984         process_pending_signals (env);
1985     }
1986 }
1987 #endif
1988
1989 #ifdef TARGET_M68K
1990
1991 void cpu_loop(CPUM68KState *env)
1992 {
1993     int trapnr;
1994     unsigned int n;
1995     target_siginfo_t info;
1996     TaskState *ts = env->opaque;
1997
1998     for(;;) {
1999         trapnr = cpu_m68k_exec(env);
2000         switch(trapnr) {
2001         case EXCP_ILLEGAL:
2002             {
2003                 if (ts->sim_syscalls) {
2004                     uint16_t nr;
2005                     nr = lduw(env->pc + 2);
2006                     env->pc += 4;
2007                     do_m68k_simcall(env, nr);
2008                 } else {
2009                     goto do_sigill;
2010                 }
2011             }
2012             break;
2013         case EXCP_HALT_INSN:
2014             /* Semihosing syscall.  */
2015             env->pc += 4;
2016             do_m68k_semihosting(env, env->dregs[0]);
2017             break;
2018         case EXCP_LINEA:
2019         case EXCP_LINEF:
2020         case EXCP_UNSUPPORTED:
2021         do_sigill:
2022             info.si_signo = SIGILL;
2023             info.si_errno = 0;
2024             info.si_code = TARGET_ILL_ILLOPN;
2025             info._sifields._sigfault._addr = env->pc;
2026             queue_signal(env, info.si_signo, &info);
2027             break;
2028         case EXCP_TRAP0:
2029             {
2030                 ts->sim_syscalls = 0;
2031                 n = env->dregs[0];
2032                 env->pc += 2;
2033                 env->dregs[0] = do_syscall(env,
2034                                           n,
2035                                           env->dregs[1],
2036                                           env->dregs[2],
2037                                           env->dregs[3],
2038                                           env->dregs[4],
2039                                           env->dregs[5],
2040                                           env->aregs[0]);
2041             }
2042             break;
2043         case EXCP_INTERRUPT:
2044             /* just indicate that signals should be handled asap */
2045             break;
2046         case EXCP_ACCESS:
2047             {
2048                 info.si_signo = SIGSEGV;
2049                 info.si_errno = 0;
2050                 /* XXX: check env->error_code */
2051                 info.si_code = TARGET_SEGV_MAPERR;
2052                 info._sifields._sigfault._addr = env->mmu.ar;
2053                 queue_signal(env, info.si_signo, &info);
2054             }
2055             break;
2056         case EXCP_DEBUG:
2057             {
2058                 int sig;
2059
2060                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2061                 if (sig)
2062                   {
2063                     info.si_signo = sig;
2064                     info.si_errno = 0;
2065                     info.si_code = TARGET_TRAP_BRKPT;
2066                     queue_signal(env, info.si_signo, &info);
2067                   }
2068             }
2069             break;
2070         default:
2071             fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
2072                     trapnr);
2073             cpu_dump_state(env, stderr, fprintf, 0);
2074             abort();
2075         }
2076         process_pending_signals(env);
2077     }
2078 }
2079 #endif /* TARGET_M68K */
2080
2081 #ifdef TARGET_ALPHA
2082 void cpu_loop (CPUState *env)
2083 {
2084     int trapnr;
2085     target_siginfo_t info;
2086
2087     while (1) {
2088         trapnr = cpu_alpha_exec (env);
2089
2090         switch (trapnr) {
2091         case EXCP_RESET:
2092             fprintf(stderr, "Reset requested. Exit\n");
2093             exit(1);
2094             break;
2095         case EXCP_MCHK:
2096             fprintf(stderr, "Machine check exception. Exit\n");
2097             exit(1);
2098             break;
2099         case EXCP_ARITH:
2100             fprintf(stderr, "Arithmetic trap.\n");
2101             exit(1);
2102             break;
2103         case EXCP_HW_INTERRUPT:
2104             fprintf(stderr, "External interrupt. Exit\n");
2105             exit(1);
2106             break;
2107         case EXCP_DFAULT:
2108             fprintf(stderr, "MMU data fault\n");
2109             exit(1);
2110             break;
2111         case EXCP_DTB_MISS_PAL:
2112             fprintf(stderr, "MMU data TLB miss in PALcode\n");
2113             exit(1);
2114             break;
2115         case EXCP_ITB_MISS:
2116             fprintf(stderr, "MMU instruction TLB miss\n");
2117             exit(1);
2118             break;
2119         case EXCP_ITB_ACV:
2120             fprintf(stderr, "MMU instruction access violation\n");
2121             exit(1);
2122             break;
2123         case EXCP_DTB_MISS_NATIVE:
2124             fprintf(stderr, "MMU data TLB miss\n");
2125             exit(1);
2126             break;
2127         case EXCP_UNALIGN:
2128             fprintf(stderr, "Unaligned access\n");
2129             exit(1);
2130             break;
2131         case EXCP_OPCDEC:
2132             fprintf(stderr, "Invalid instruction\n");
2133             exit(1);
2134             break;
2135         case EXCP_FEN:
2136             fprintf(stderr, "Floating-point not allowed\n");
2137             exit(1);
2138             break;
2139         case EXCP_CALL_PAL ... (EXCP_CALL_PALP - 1):
2140             fprintf(stderr, "Call to PALcode\n");
2141             call_pal(env, (trapnr >> 6) | 0x80);
2142             break;
2143         case EXCP_CALL_PALP ... (EXCP_CALL_PALE - 1):
2144             fprintf(stderr, "Privileged call to PALcode\n");
2145             exit(1);
2146             break;
2147         case EXCP_DEBUG:
2148             {
2149                 int sig;
2150
2151                 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2152                 if (sig)
2153                   {
2154                     info.si_signo = sig;
2155                     info.si_errno = 0;
2156                     info.si_code = TARGET_TRAP_BRKPT;
2157                     queue_signal(env, info.si_signo, &info);
2158                   }
2159             }
2160             break;
2161         default:
2162             printf ("Unhandled trap: 0x%x\n", trapnr);
2163             cpu_dump_state(env, stderr, fprintf, 0);
2164             exit (1);
2165         }
2166         process_pending_signals (env);
2167     }
2168 }
2169 #endif /* TARGET_ALPHA */
2170
2171 static void usage(void)
2172 {
2173     printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
2174            "usage: qemu-" TARGET_ARCH " [options] program [arguments...]\n"
2175            "Linux CPU emulator (compiled for %s emulation)\n"
2176            "\n"
2177            "Standard options:\n"
2178            "-h                print this help\n"
2179            "-g port           wait gdb connection to port\n"
2180            "-L path           set the elf interpreter prefix (default=%s)\n"
2181            "-s size           set the stack size in bytes (default=%ld)\n"
2182            "-cpu model        select CPU (-cpu ? for list)\n"
2183            "-drop-ld-preload  drop LD_PRELOAD for target process\n"
2184            "\n"
2185            "Debug options:\n"
2186            "-d options   activate log (logfile=%s)\n"
2187            "-p pagesize  set the host page size to 'pagesize'\n"
2188            "-strace      log system calls\n"
2189            "\n"
2190            "Environment variables:\n"
2191            "QEMU_STRACE       Print system calls and arguments similar to the\n"
2192            "                  'strace' program.  Enable by setting to any value.\n"
2193            ,
2194            TARGET_ARCH,
2195            interp_prefix,
2196            x86_stack_size,
2197            DEBUG_LOGFILE);
2198     _exit(1);
2199 }
2200
2201 THREAD CPUState *thread_env;
2202
2203 /* Assumes contents are already zeroed.  */
2204 void init_task_state(TaskState *ts)
2205 {
2206     int i;
2207
2208     ts->used = 1;
2209     ts->first_free = ts->sigqueue_table;
2210     for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) {
2211         ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1];
2212     }
2213     ts->sigqueue_table[i].next = NULL;
2214 }
2215
2216 int main(int argc, char **argv)
2217 {
2218     const char *filename;
2219     const char *cpu_model;
2220     struct target_pt_regs regs1, *regs = &regs1;
2221     struct image_info info1, *info = &info1;
2222     TaskState ts1, *ts = &ts1;
2223     CPUState *env;
2224     int optind;
2225     const char *r;
2226     int gdbstub_port = 0;
2227     int drop_ld_preload = 0, environ_count = 0;
2228     char **target_environ, **wrk, **dst;
2229
2230     if (argc <= 1)
2231         usage();
2232
2233     /* init debug */
2234     cpu_set_log_filename(DEBUG_LOGFILE);
2235
2236     cpu_model = NULL;
2237     optind = 1;
2238     for(;;) {
2239         if (optind >= argc)
2240             break;
2241         r = argv[optind];
2242         if (r[0] != '-')
2243             break;
2244         optind++;
2245         r++;
2246         if (!strcmp(r, "-")) {
2247             break;
2248         } else if (!strcmp(r, "d")) {
2249             int mask;
2250             CPULogItem *item;
2251
2252             if (optind >= argc)
2253                 break;
2254
2255             r = argv[optind++];
2256             mask = cpu_str_to_log_mask(r);
2257             if (!mask) {
2258                 printf("Log items (comma separated):\n");
2259                 for(item = cpu_log_items; item->mask != 0; item++) {
2260                     printf("%-10s %s\n", item->name, item->help);
2261                 }
2262                 exit(1);
2263             }
2264             cpu_set_log(mask);
2265         } else if (!strcmp(r, "s")) {
2266             r = argv[optind++];
2267             x86_stack_size = strtol(r, (char **)&r, 0);
2268             if (x86_stack_size <= 0)
2269                 usage();
2270             if (*r == 'M')
2271                 x86_stack_size *= 1024 * 1024;
2272             else if (*r == 'k' || *r == 'K')
2273                 x86_stack_size *= 1024;
2274         } else if (!strcmp(r, "L")) {
2275             interp_prefix = argv[optind++];
2276         } else if (!strcmp(r, "p")) {
2277             qemu_host_page_size = atoi(argv[optind++]);
2278             if (qemu_host_page_size == 0 ||
2279                 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
2280                 fprintf(stderr, "page size must be a power of two\n");
2281                 exit(1);
2282             }
2283         } else if (!strcmp(r, "g")) {
2284             gdbstub_port = atoi(argv[optind++]);
2285         } else if (!strcmp(r, "r")) {
2286             qemu_uname_release = argv[optind++];
2287         } else if (!strcmp(r, "cpu")) {
2288             cpu_model = argv[optind++];
2289             if (strcmp(cpu_model, "?") == 0) {
2290 /* XXX: implement xxx_cpu_list for targets that still miss it */
2291 #if defined(cpu_list)
2292                     cpu_list(stdout, &fprintf);
2293 #endif
2294                 _exit(1);
2295             }
2296         } else if (!strcmp(r, "drop-ld-preload")) {
2297             drop_ld_preload = 1;
2298         } else if (!strcmp(r, "strace")) {
2299             do_strace = 1;
2300         } else
2301         {
2302             usage();
2303         }
2304     }
2305     if (optind >= argc)
2306         usage();
2307     filename = argv[optind];
2308
2309     /* Zero out regs */
2310     memset(regs, 0, sizeof(struct target_pt_regs));
2311
2312     /* Zero out image_info */
2313     memset(info, 0, sizeof(struct image_info));
2314
2315     /* Scan interp_prefix dir for replacement files. */
2316     init_paths(interp_prefix);
2317
2318     if (cpu_model == NULL) {
2319 #if defined(TARGET_I386)
2320 #ifdef TARGET_X86_64
2321         cpu_model = "qemu64";
2322 #else
2323         cpu_model = "qemu32";
2324 #endif
2325 #elif defined(TARGET_ARM)
2326         cpu_model = "arm926";
2327 #elif defined(TARGET_M68K)
2328         cpu_model = "any";
2329 #elif defined(TARGET_SPARC)
2330 #ifdef TARGET_SPARC64
2331         cpu_model = "TI UltraSparc II";
2332 #else
2333         cpu_model = "Fujitsu MB86904";
2334 #endif
2335 #elif defined(TARGET_MIPS)
2336 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
2337         cpu_model = "20Kc";
2338 #else
2339         cpu_model = "24Kf";
2340 #endif
2341 #elif defined(TARGET_PPC)
2342 #ifdef TARGET_PPC64
2343         cpu_model = "970";
2344 #else
2345         cpu_model = "750";
2346 #endif
2347 #else
2348         cpu_model = "any";
2349 #endif
2350     }
2351     cpu_exec_init_all(0);
2352     /* NOTE: we need to init the CPU at this stage to get
2353        qemu_host_page_size */
2354     env = cpu_init(cpu_model);
2355     if (!env) {
2356         fprintf(stderr, "Unable to find CPU definition\n");
2357         exit(1);
2358     }
2359     thread_env = env;
2360
2361     if (getenv("QEMU_STRACE")) {
2362         do_strace = 1;
2363     }
2364
2365     wrk = environ;
2366     while (*(wrk++))
2367         environ_count++;
2368
2369     target_environ = malloc((environ_count + 1) * sizeof(char *));
2370     if (!target_environ)
2371         abort();
2372     for (wrk = environ, dst = target_environ; *wrk; wrk++) {
2373         if (drop_ld_preload && !strncmp(*wrk, "LD_PRELOAD=", 11))
2374             continue;
2375         *(dst++) = strdup(*wrk);
2376     }
2377     *dst = NULL; /* NULL terminate target_environ */
2378
2379     if (loader_exec(filename, argv+optind, target_environ, regs, info) != 0) {
2380         printf("Error loading %s\n", filename);
2381         _exit(1);
2382     }
2383
2384     for (wrk = target_environ; *wrk; wrk++) {
2385         free(*wrk);
2386     }
2387
2388     free(target_environ);
2389
2390     if (loglevel) {
2391         page_dump(logfile);
2392
2393         fprintf(logfile, "start_brk   0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
2394         fprintf(logfile, "end_code    0x" TARGET_ABI_FMT_lx "\n", info->end_code);
2395         fprintf(logfile, "start_code  0x" TARGET_ABI_FMT_lx "\n",
2396                 info->start_code);
2397         fprintf(logfile, "start_data  0x" TARGET_ABI_FMT_lx "\n",
2398                 info->start_data);
2399         fprintf(logfile, "end_data    0x" TARGET_ABI_FMT_lx "\n", info->end_data);
2400         fprintf(logfile, "start_stack 0x" TARGET_ABI_FMT_lx "\n",
2401                 info->start_stack);
2402         fprintf(logfile, "brk         0x" TARGET_ABI_FMT_lx "\n", info->brk);
2403         fprintf(logfile, "entry       0x" TARGET_ABI_FMT_lx "\n", info->entry);
2404     }
2405
2406     target_set_brk(info->brk);
2407     syscall_init();
2408     signal_init();
2409
2410     /* build Task State */
2411     memset(ts, 0, sizeof(TaskState));
2412     init_task_state(ts);
2413     ts->info = info;
2414     env->opaque = ts;
2415     env->user_mode_only = 1;
2416
2417 #if defined(TARGET_I386)
2418     cpu_x86_set_cpl(env, 3);
2419
2420     env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
2421     env->hflags |= HF_PE_MASK;
2422     if (env->cpuid_features & CPUID_SSE) {
2423         env->cr[4] |= CR4_OSFXSR_MASK;
2424         env->hflags |= HF_OSFXSR_MASK;
2425     }
2426 #ifndef TARGET_ABI32
2427     /* enable 64 bit mode if possible */
2428     if (!(env->cpuid_ext2_features & CPUID_EXT2_LM)) {
2429         fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n");
2430         exit(1);
2431     }
2432     env->cr[4] |= CR4_PAE_MASK;
2433     env->efer |= MSR_EFER_LMA | MSR_EFER_LME;
2434     env->hflags |= HF_LMA_MASK;
2435 #endif
2436
2437     /* flags setup : we activate the IRQs by default as in user mode */
2438     env->eflags |= IF_MASK;
2439
2440     /* linux register setup */
2441 #ifndef TARGET_ABI32
2442     env->regs[R_EAX] = regs->rax;
2443     env->regs[R_EBX] = regs->rbx;
2444     env->regs[R_ECX] = regs->rcx;
2445     env->regs[R_EDX] = regs->rdx;
2446     env->regs[R_ESI] = regs->rsi;
2447     env->regs[R_EDI] = regs->rdi;
2448     env->regs[R_EBP] = regs->rbp;
2449     env->regs[R_ESP] = regs->rsp;
2450     env->eip = regs->rip;
2451 #else
2452     env->regs[R_EAX] = regs->eax;
2453     env->regs[R_EBX] = regs->ebx;
2454     env->regs[R_ECX] = regs->ecx;
2455     env->regs[R_EDX] = regs->edx;
2456     env->regs[R_ESI] = regs->esi;
2457     env->regs[R_EDI] = regs->edi;
2458     env->regs[R_EBP] = regs->ebp;
2459     env->regs[R_ESP] = regs->esp;
2460     env->eip = regs->eip;
2461 #endif
2462
2463     /* linux interrupt setup */
2464     env->idt.base = h2g(idt_table);
2465     env->idt.limit = sizeof(idt_table) - 1;
2466     set_idt(0, 0);
2467     set_idt(1, 0);
2468     set_idt(2, 0);
2469     set_idt(3, 3);
2470     set_idt(4, 3);
2471     set_idt(5, 0);
2472     set_idt(6, 0);
2473     set_idt(7, 0);
2474     set_idt(8, 0);
2475     set_idt(9, 0);
2476     set_idt(10, 0);
2477     set_idt(11, 0);
2478     set_idt(12, 0);
2479     set_idt(13, 0);
2480     set_idt(14, 0);
2481     set_idt(15, 0);
2482     set_idt(16, 0);
2483     set_idt(17, 0);
2484     set_idt(18, 0);
2485     set_idt(19, 0);
2486     set_idt(0x80, 3);
2487
2488     /* linux segment setup */
2489     {
2490         uint64_t *gdt_table;
2491         gdt_table = qemu_mallocz(sizeof(uint64_t) * TARGET_GDT_ENTRIES);
2492         env->gdt.base = h2g((unsigned long)gdt_table);
2493         env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1;
2494 #ifdef TARGET_ABI32
2495         write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
2496                  DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
2497                  (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
2498 #else
2499         /* 64 bit code segment */
2500         write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
2501                  DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
2502                  DESC_L_MASK |
2503                  (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
2504 #endif
2505         write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
2506                  DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
2507                  (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
2508     }
2509     cpu_x86_load_seg(env, R_CS, __USER_CS);
2510     cpu_x86_load_seg(env, R_SS, __USER_DS);
2511 #ifdef TARGET_ABI32
2512     cpu_x86_load_seg(env, R_DS, __USER_DS);
2513     cpu_x86_load_seg(env, R_ES, __USER_DS);
2514     cpu_x86_load_seg(env, R_FS, __USER_DS);
2515     cpu_x86_load_seg(env, R_GS, __USER_DS);
2516     /* This hack makes Wine work... */
2517     env->segs[R_FS].selector = 0;
2518 #else
2519     cpu_x86_load_seg(env, R_DS, 0);
2520     cpu_x86_load_seg(env, R_ES, 0);
2521     cpu_x86_load_seg(env, R_FS, 0);
2522     cpu_x86_load_seg(env, R_GS, 0);
2523 #endif
2524 #elif defined(TARGET_ARM)
2525     {
2526         int i;
2527         cpsr_write(env, regs->uregs[16], 0xffffffff);
2528         for(i = 0; i < 16; i++) {
2529             env->regs[i] = regs->uregs[i];
2530         }
2531     }
2532 #elif defined(TARGET_SPARC)
2533     {
2534         int i;
2535         env->pc = regs->pc;
2536         env->npc = regs->npc;
2537         env->y = regs->y;
2538         for(i = 0; i < 8; i++)
2539             env->gregs[i] = regs->u_regs[i];
2540         for(i = 0; i < 8; i++)
2541             env->regwptr[i] = regs->u_regs[i + 8];
2542     }
2543 #elif defined(TARGET_PPC)
2544     {
2545         int i;
2546
2547 #if defined(TARGET_PPC64)
2548 #if defined(TARGET_ABI32)
2549         env->msr &= ~((target_ulong)1 << MSR_SF);
2550 #else
2551         env->msr |= (target_ulong)1 << MSR_SF;
2552 #endif
2553 #endif
2554         env->nip = regs->nip;
2555         for(i = 0; i < 32; i++) {
2556             env->gpr[i] = regs->gpr[i];
2557         }
2558     }
2559 #elif defined(TARGET_M68K)
2560     {
2561         env->pc = regs->pc;
2562         env->dregs[0] = regs->d0;
2563         env->dregs[1] = regs->d1;
2564         env->dregs[2] = regs->d2;
2565         env->dregs[3] = regs->d3;
2566         env->dregs[4] = regs->d4;
2567         env->dregs[5] = regs->d5;
2568         env->dregs[6] = regs->d6;
2569         env->dregs[7] = regs->d7;
2570         env->aregs[0] = regs->a0;
2571         env->aregs[1] = regs->a1;
2572         env->aregs[2] = regs->a2;
2573         env->aregs[3] = regs->a3;
2574         env->aregs[4] = regs->a4;
2575         env->aregs[5] = regs->a5;
2576         env->aregs[6] = regs->a6;
2577         env->aregs[7] = regs->usp;
2578         env->sr = regs->sr;
2579         ts->sim_syscalls = 1;
2580     }
2581 #elif defined(TARGET_MIPS)
2582     {
2583         int i;
2584
2585         for(i = 0; i < 32; i++) {
2586             env->active_tc.gpr[i] = regs->regs[i];
2587         }
2588         env->active_tc.PC = regs->cp0_epc;
2589     }
2590 #elif defined(TARGET_SH4)
2591     {
2592         int i;
2593
2594         for(i = 0; i < 16; i++) {
2595             env->gregs[i] = regs->regs[i];
2596         }
2597         env->pc = regs->pc;
2598     }
2599 #elif defined(TARGET_ALPHA)
2600     {
2601         int i;
2602
2603         for(i = 0; i < 28; i++) {
2604             env->ir[i] = ((abi_ulong *)regs)[i];
2605         }
2606         env->ipr[IPR_USP] = regs->usp;
2607         env->ir[30] = regs->usp;
2608         env->pc = regs->pc;
2609         env->unique = regs->unique;
2610     }
2611 #elif defined(TARGET_CRIS)
2612     {
2613             env->regs[0] = regs->r0;
2614             env->regs[1] = regs->r1;
2615             env->regs[2] = regs->r2;
2616             env->regs[3] = regs->r3;
2617             env->regs[4] = regs->r4;
2618             env->regs[5] = regs->r5;
2619             env->regs[6] = regs->r6;
2620             env->regs[7] = regs->r7;
2621             env->regs[8] = regs->r8;
2622             env->regs[9] = regs->r9;
2623             env->regs[10] = regs->r10;
2624             env->regs[11] = regs->r11;
2625             env->regs[12] = regs->r12;
2626             env->regs[13] = regs->r13;
2627             env->regs[14] = info->start_stack;
2628             env->regs[15] = regs->acr;
2629             env->pc = regs->erp;
2630     }
2631 #else
2632 #error unsupported target CPU
2633 #endif
2634
2635 #if defined(TARGET_ARM) || defined(TARGET_M68K)
2636     ts->stack_base = info->start_stack;
2637     ts->heap_base = info->brk;
2638     /* This will be filled in on the first SYS_HEAPINFO call.  */
2639     ts->heap_limit = 0;
2640 #endif
2641
2642     if (gdbstub_port) {
2643         gdbserver_start (gdbstub_port);
2644         gdb_handlesig(env, 0);
2645     }
2646     cpu_loop(env);
2647     /* never exits */
2648     return 0;
2649 }