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

   1 /*
   2  *  qemu user main
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *  Copyright (c) 2006 Pierre d'Herbemont
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20  *  MA 02110-1301, USA.
  21  */
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28
  29 #include <sys/syscall.h>
  30 #include <sys/mman.h>
  31
  32 #include "qemu.h"
  33
  34 #define DEBUG_LOGFILE "/tmp/qemu.log"
  35
  36 #ifdef __APPLE__
  37 #include <crt_externs.h>
  38 # define environ  (*_NSGetEnviron())
  39 #endif
  40
  41 #include <mach/mach_init.h>
  42 #include <mach/vm_map.h>
  43
  44 int singlestep;
  45
  46 const char *interp_prefix = "";
  47
  48 asm(".zerofill __STD_PROG_ZONE, __STD_PROG_ZONE, __std_prog_zone, 0x0dfff000");
  49
  50 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
  51    we allocate a bigger stack. Need a better solution, for example
  52    by remapping the process stack directly at the right place */
  53 unsigned long stack_size = 512 * 1024;
  54
  55 void qerror(const char *fmt, ...)
  56 {
  57     va_list ap;
  58
  59     va_start(ap, fmt);
  60     vfprintf(stderr, fmt, ap);
  61     va_end(ap);
  62     fprintf(stderr, "\n");
  63     exit(1);
  64 }
  65
  66 void gemu_log(const char *fmt, ...)
  67 {
  68     va_list ap;
  69
  70     va_start(ap, fmt);
  71     vfprintf(stderr, fmt, ap);
  72     va_end(ap);
  73 }
  74
  75 void cpu_outb(CPUState *env, int addr, int val)
  76 {
  77     fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
  78 }
  79
  80 void cpu_outw(CPUState *env, int addr, int val)
  81 {
  82     fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
  83 }
  84
  85 void cpu_outl(CPUState *env, int addr, int val)
  86 {
  87     fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
  88 }
  89
  90 int cpu_inb(CPUState *env, int addr)
  91 {
  92     fprintf(stderr, "inb: port=0x%04x\n", addr);
  93     return 0;
  94 }
  95
  96 int cpu_inw(CPUState *env, int addr)
  97 {
  98     fprintf(stderr, "inw: port=0x%04x\n", addr);
  99     return 0;
 100 }
 101
 102 int cpu_inl(CPUState *env, int addr)
 103 {
 104     fprintf(stderr, "inl: port=0x%04x\n", addr);
 105     return 0;
 106 }
 107
 108 int cpu_get_pic_interrupt(CPUState *env)
 109 {
 110     return -1;
 111 }
 112 #ifdef TARGET_PPC
 113
 114 static inline uint64_t cpu_ppc_get_tb (CPUState *env)
 115 {
 116     /* TO FIX */
 117     return 0;
 118 }
 119
 120 uint32_t cpu_ppc_load_tbl (CPUState *env)
 121 {
 122     return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
 123 }
 124
 125 uint32_t cpu_ppc_load_tbu (CPUState *env)
 126 {
 127     return cpu_ppc_get_tb(env) >> 32;
 128 }
 129
 130 uint32_t cpu_ppc_load_atbl (CPUState *env)
 131 {
 132     return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
 133 }
 134
 135 uint32_t cpu_ppc_load_atbu (CPUState *env)
 136 {
 137     return cpu_ppc_get_tb(env) >> 32;
 138 }
 139
 140 uint32_t cpu_ppc601_load_rtcu (CPUState *env)
 141 {
 142     cpu_ppc_load_tbu(env);
 143 }
 144
 145 uint32_t cpu_ppc601_load_rtcl (CPUState *env)
 146 {
 147     return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
 148 }
 149
 150 /* XXX: to be fixed */
 151 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, target_ulong *valp)
 152 {
 153     return -1;
 154 }
 155
 156 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, target_ulong val)
 157 {
 158     return -1;
 159 }
 160
 161 #define EXCP_DUMP(env, fmt, ...)                                        \
 162 do {                                                                    \
 163     fprintf(stderr, fmt , ## __VA_ARGS__);                              \
 164     cpu_dump_state(env, stderr, fprintf, 0);                            \
 165     qemu_log(fmt, ## __VA_ARGS__);                                      \
 166     log_cpu_state(env, 0);                                              \
 167 } while (0)
 168
 169 void cpu_loop(CPUPPCState *env)
 170 {
 171     int trapnr;
 172     uint32_t ret;
 173     target_siginfo_t info;
 174
 175     for(;;) {
 176         trapnr = cpu_ppc_exec(env);
 177         switch(trapnr) {
 178         case POWERPC_EXCP_NONE:
 179             /* Just go on */
 180             break;
 181         case POWERPC_EXCP_CRITICAL: /* Critical input                        */
 182             cpu_abort(env, "Critical interrupt while in user mode. "
 183                       "Aborting\n");
 184             break;
 185         case POWERPC_EXCP_MCHECK:   /* Machine check exception               */
 186             cpu_abort(env, "Machine check exception while in user mode. "
 187                       "Aborting\n");
 188             break;
 189         case POWERPC_EXCP_DSI:      /* Data storage exception                */
 190 #ifndef DAR
 191 /* To deal with multiple qemu header version as host for the darwin-user code */
 192 # define DAR SPR_DAR
 193 #endif
 194             EXCP_DUMP(env, "Invalid data memory access: 0x" ADDRX "\n",
 195                       env->spr[SPR_DAR]);
 196             /* Handle this via the gdb */
 197             gdb_handlesig (env, SIGSEGV);
 198
 199             info.si_addr = (void*)env->nip;
 200             queue_signal(info.si_signo, &info);
 201             break;
 202         case POWERPC_EXCP_ISI:      /* Instruction storage exception         */
 203             EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" ADDRX "\n",
 204                       env->spr[SPR_DAR]);
 205             /* Handle this via the gdb */
 206             gdb_handlesig (env, SIGSEGV);
 207
 208             info.si_addr = (void*)(env->nip - 4);
 209             queue_signal(info.si_signo, &info);
 210             break;
 211         case POWERPC_EXCP_EXTERNAL: /* External input                        */
 212             cpu_abort(env, "External interrupt while in user mode. "
 213                       "Aborting\n");
 214             break;
 215         case POWERPC_EXCP_ALIGN:    /* Alignment exception                   */
 216             EXCP_DUMP(env, "Unaligned memory access\n");
 217             info.si_errno = 0;
 218             info.si_code = BUS_ADRALN;
 219             info.si_addr = (void*)(env->nip - 4);
 220             queue_signal(info.si_signo, &info);
 221             break;
 222         case POWERPC_EXCP_PROGRAM:  /* Program exception                     */
 223             /* XXX: check this */
 224             switch (env->error_code & ~0xF) {
 225             case POWERPC_EXCP_FP:
 226                 EXCP_DUMP(env, "Floating point program exception\n");
 227                 /* Set FX */
 228                 info.si_signo = SIGFPE;
 229                 info.si_errno = 0;
 230                 switch (env->error_code & 0xF) {
 231                 case POWERPC_EXCP_FP_OX:
 232                     info.si_code = FPE_FLTOVF;
 233                     break;
 234                 case POWERPC_EXCP_FP_UX:
 235                     info.si_code = FPE_FLTUND;
 236                     break;
 237                 case POWERPC_EXCP_FP_ZX:
 238                 case POWERPC_EXCP_FP_VXZDZ:
 239                     info.si_code = FPE_FLTDIV;
 240                     break;
 241                 case POWERPC_EXCP_FP_XX:
 242                     info.si_code = FPE_FLTRES;
 243                     break;
 244                 case POWERPC_EXCP_FP_VXSOFT:
 245                     info.si_code = FPE_FLTINV;
 246                     break;
 247                 case POWERPC_EXCP_FP_VXSNAN:
 248                 case POWERPC_EXCP_FP_VXISI:
 249                 case POWERPC_EXCP_FP_VXIDI:
 250                 case POWERPC_EXCP_FP_VXIMZ:
 251                 case POWERPC_EXCP_FP_VXVC:
 252                 case POWERPC_EXCP_FP_VXSQRT:
 253                 case POWERPC_EXCP_FP_VXCVI:
 254                     info.si_code = FPE_FLTSUB;
 255                     break;
 256                 default:
 257                     EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
 258                               env->error_code);
 259                     break;
 260                 }
 261                 break;
 262             case POWERPC_EXCP_INVAL:
 263                 EXCP_DUMP(env, "Invalid instruction\n");
 264                 info.si_signo = SIGILL;
 265                 info.si_errno = 0;
 266                 switch (env->error_code & 0xF) {
 267                 case POWERPC_EXCP_INVAL_INVAL:
 268                     info.si_code = ILL_ILLOPC;
 269                     break;
 270                 case POWERPC_EXCP_INVAL_LSWX:
 271                     info.si_code = ILL_ILLOPN;
 272                     break;
 273                 case POWERPC_EXCP_INVAL_SPR:
 274                     info.si_code = ILL_PRVREG;
 275                     break;
 276                 case POWERPC_EXCP_INVAL_FP:
 277                     info.si_code = ILL_COPROC;
 278                     break;
 279                 default:
 280                     EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
 281                               env->error_code & 0xF);
 282                     info.si_code = ILL_ILLADR;
 283                     break;
 284                 }
 285                 /* Handle this via the gdb */
 286                 gdb_handlesig (env, SIGSEGV);
 287                 break;
 288             case POWERPC_EXCP_PRIV:
 289                 EXCP_DUMP(env, "Privilege violation\n");
 290                 info.si_signo = SIGILL;
 291                 info.si_errno = 0;
 292                 switch (env->error_code & 0xF) {
 293                 case POWERPC_EXCP_PRIV_OPC:
 294                     info.si_code = ILL_PRVOPC;
 295                     break;
 296                 case POWERPC_EXCP_PRIV_REG:
 297                     info.si_code = ILL_PRVREG;
 298                     break;
 299                 default:
 300                     EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
 301                               env->error_code & 0xF);
 302                     info.si_code = ILL_PRVOPC;
 303                     break;
 304                 }
 305                 break;
 306             case POWERPC_EXCP_TRAP:
 307                 cpu_abort(env, "Tried to call a TRAP\n");
 308                 break;
 309             default:
 310                 /* Should not happen ! */
 311                 cpu_abort(env, "Unknown program exception (%02x)\n",
 312                           env->error_code);
 313                 break;
 314             }
 315             info.si_addr = (void*)(env->nip - 4);
 316             queue_signal(info.si_signo, &info);
 317             break;
 318         case POWERPC_EXCP_FPU:      /* Floating-point unavailable exception  */
 319             EXCP_DUMP(env, "No floating point allowed\n");
 320             info.si_signo = SIGILL;
 321             info.si_errno = 0;
 322             info.si_code = ILL_COPROC;
 323             info.si_addr = (void*)(env->nip - 4);
 324             queue_signal(info.si_signo, &info);
 325             break;
 326         case POWERPC_EXCP_SYSCALL:  /* System call exception                 */
 327             cpu_abort(env, "Syscall exception while in user mode. "
 328                       "Aborting\n");
 329             break;
 330         case POWERPC_EXCP_APU:      /* Auxiliary processor unavailable       */
 331             EXCP_DUMP(env, "No APU instruction allowed\n");
 332             info.si_signo = SIGILL;
 333             info.si_errno = 0;
 334             info.si_code = ILL_COPROC;
 335             info.si_addr = (void*)(env->nip - 4);
 336             queue_signal(info.si_signo, &info);
 337             break;
 338         case POWERPC_EXCP_DECR:     /* Decrementer exception                 */
 339             cpu_abort(env, "Decrementer interrupt while in user mode. "
 340                       "Aborting\n");
 341             break;
 342         case POWERPC_EXCP_FIT:      /* Fixed-interval timer interrupt        */
 343             cpu_abort(env, "Fix interval timer interrupt while in user mode. "
 344                       "Aborting\n");
 345             break;
 346         case POWERPC_EXCP_WDT:      /* Watchdog timer interrupt              */
 347             cpu_abort(env, "Watchdog timer interrupt while in user mode. "
 348                       "Aborting\n");
 349             break;
 350         case POWERPC_EXCP_DTLB:     /* Data TLB error                        */
 351             cpu_abort(env, "Data TLB exception while in user mode. "
 352                       "Aborting\n");
 353             break;
 354         case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */
 355             cpu_abort(env, "Instruction TLB exception while in user mode. "
 356                       "Aborting\n");
 357             break;
 358         case POWERPC_EXCP_DEBUG:    /* Debug interrupt                       */
 359             gdb_handlesig (env, SIGTRAP);
 360             break;
 361         case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */
 362             EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");
 363             info.si_signo = SIGILL;
 364             info.si_errno = 0;
 365             info.si_code = ILL_COPROC;
 366             info.si_addr = (void*)(env->nip - 4);
 367             queue_signal(info.si_signo, &info);
 368             break;
 369         case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */
 370             cpu_abort(env, "Embedded floating-point data IRQ not handled\n");
 371             break;
 372         case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */
 373             cpu_abort(env, "Embedded floating-point round IRQ not handled\n");
 374             break;
 375         case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */
 376             cpu_abort(env, "Performance monitor exception not handled\n");
 377             break;
 378         case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */
 379             cpu_abort(env, "Doorbell interrupt while in user mode. "
 380                        "Aborting\n");
 381             break;
 382         case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */
 383             cpu_abort(env, "Doorbell critical interrupt while in user mode. "
 384                       "Aborting\n");
 385             break;
 386         case POWERPC_EXCP_RESET:    /* System reset exception                */
 387             cpu_abort(env, "Reset interrupt while in user mode. "
 388                       "Aborting\n");
 389             break;
 390         case POWERPC_EXCP_DSEG:     /* Data segment exception                */
 391             cpu_abort(env, "Data segment exception while in user mode. "
 392                       "Aborting\n");
 393             break;
 394         case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */
 395             cpu_abort(env, "Instruction segment exception "
 396                       "while in user mode. Aborting\n");
 397             break;
 398         case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */
 399             cpu_abort(env, "Hypervisor decrementer interrupt "
 400                       "while in user mode. Aborting\n");
 401             break;
 402         case POWERPC_EXCP_TRACE:    /* Trace exception                       */
 403             /* Nothing to do:
 404              * we use this exception to emulate step-by-step execution mode.
 405              */
 406             break;
 407         case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */
 408             cpu_abort(env, "Hypervisor data storage exception "
 409                       "while in user mode. Aborting\n");
 410             break;
 411         case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */
 412             cpu_abort(env, "Hypervisor instruction storage exception "
 413                       "while in user mode. Aborting\n");
 414             break;
 415         case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */
 416             cpu_abort(env, "Hypervisor data segment exception "
 417                       "while in user mode. Aborting\n");
 418             break;
 419         case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */
 420             cpu_abort(env, "Hypervisor instruction segment exception "
 421                       "while in user mode. Aborting\n");
 422             break;
 423         case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */
 424             EXCP_DUMP(env, "No Altivec instructions allowed\n");
 425             info.si_signo = SIGILL;
 426             info.si_errno = 0;
 427             info.si_code = ILL_COPROC;
 428             info.si_addr = (void*)(env->nip - 4);
 429             queue_signal(info.si_signo, &info);
 430             break;
 431         case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */
 432             cpu_abort(env, "Programable interval timer interrupt "
 433                       "while in user mode. Aborting\n");
 434             break;
 435         case POWERPC_EXCP_IO:       /* IO error exception                    */
 436             cpu_abort(env, "IO error exception while in user mode. "
 437                       "Aborting\n");
 438             break;
 439         case POWERPC_EXCP_RUNM:     /* Run mode exception                    */
 440             cpu_abort(env, "Run mode exception while in user mode. "
 441                       "Aborting\n");
 442             break;
 443         case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */
 444             cpu_abort(env, "Emulation trap exception not handled\n");
 445             break;
 446         case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */
 447             cpu_abort(env, "Instruction fetch TLB exception "
 448                       "while in user-mode. Aborting");
 449             break;
 450         case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */
 451             cpu_abort(env, "Data load TLB exception while in user-mode. "
 452                       "Aborting");
 453             break;
 454         case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */
 455             cpu_abort(env, "Data store TLB exception while in user-mode. "
 456                       "Aborting");
 457             break;
 458         case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */
 459             cpu_abort(env, "Floating-point assist exception not handled\n");
 460             break;
 461         case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */
 462             cpu_abort(env, "Instruction address breakpoint exception "
 463                       "not handled\n");
 464             break;
 465         case POWERPC_EXCP_SMI:      /* System management interrupt           */
 466             cpu_abort(env, "System management interrupt while in user mode. "
 467                       "Aborting\n");
 468             break;
 469         case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */
 470             cpu_abort(env, "Thermal interrupt interrupt while in user mode. "
 471                       "Aborting\n");
 472             break;
 473         case POWERPC_EXCP_PERFM:    /* Embedded performance monitor IRQ      */
 474             cpu_abort(env, "Performance monitor exception not handled\n");
 475             break;
 476         case POWERPC_EXCP_VPUA:     /* Vector assist exception               */
 477             cpu_abort(env, "Vector assist exception not handled\n");
 478             break;
 479         case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */
 480             cpu_abort(env, "Soft patch exception not handled\n");
 481             break;
 482         case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */
 483             cpu_abort(env, "Maintenance exception while in user mode. "
 484                       "Aborting\n");
 485             break;
 486         case POWERPC_EXCP_STOP:     /* stop translation                      */
 487             /* We did invalidate the instruction cache. Go on */
 488             break;
 489         case POWERPC_EXCP_BRANCH:   /* branch instruction:                   */
 490             /* We just stopped because of a branch. Go on */
 491             break;
 492         case POWERPC_EXCP_SYSCALL_USER:
 493             /* system call in user-mode emulation */
 494             /* system call */
 495             if(((int)env->gpr[0]) <= SYS_MAXSYSCALL && ((int)env->gpr[0])>0)
 496                 ret = do_unix_syscall(env, env->gpr[0]/*, env->gpr[3], env->gpr[4],
 497                                       env->gpr[5], env->gpr[6], env->gpr[7],
 498                                       env->gpr[8], env->gpr[9], env->gpr[10]*/);
 499             else if(((int)env->gpr[0])<0)
 500                 ret = do_mach_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
 501                                       env->gpr[5], env->gpr[6], env->gpr[7],
 502                                       env->gpr[8], env->gpr[9], env->gpr[10]);
 503             else
 504                 ret = do_thread_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
 505                                         env->gpr[5], env->gpr[6], env->gpr[7],
 506                                         env->gpr[8], env->gpr[9], env->gpr[10]);
 507
 508             /* Unix syscall error signaling */
 509             if(((int)env->gpr[0]) <= SYS_MAXSYSCALL && ((int)env->gpr[0])>0)
 510             {
 511                 if( (int)ret < 0 )
 512                     env->nip += 0;
 513                 else
 514                     env->nip += 4;
 515             }
 516
 517             /* Return value */
 518             env->gpr[3] = ret;
 519             break;
 520         case EXCP_INTERRUPT:
 521             /* just indicate that signals should be handled asap */
 522             break;
 523         default:
 524             cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr);
 525             break;
 526         }
 527         process_pending_signals(env);
 528     }
 529 }
 530 #endif
 531
 532
 533 #ifdef TARGET_I386
 534
 535 /***********************************************************/
 536 /* CPUX86 core interface */
 537
 538 uint64_t cpu_get_tsc(CPUX86State *env)
 539 {
 540     return cpu_get_real_ticks();
 541 }
 542
 543 void
 544 write_dt(void *ptr, unsigned long addr, unsigned long limit,
 545                      int flags)
 546 {
 547     unsigned int e1, e2;
 548     e1 = (addr << 16) | (limit & 0xffff);
 549     e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
 550     e2 |= flags;
 551     stl((uint8_t *)ptr, e1);
 552     stl((uint8_t *)ptr + 4, e2);
 553 }
 554
 555 static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
 556                      unsigned long addr, unsigned int sel)
 557 {
 558     unsigned int e1, e2;
 559     e1 = (addr & 0xffff) | (sel << 16);
 560     e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
 561     stl((uint8_t *)ptr, e1);
 562     stl((uint8_t *)ptr + 4, e2);
 563 }
 564
 565 #define GDT_TABLE_SIZE 14
 566 #define LDT_TABLE_SIZE 15
 567 #define IDT_TABLE_SIZE 256
 568 #define TSS_SIZE 104
 569 uint64_t gdt_table[GDT_TABLE_SIZE];
 570 uint64_t ldt_table[LDT_TABLE_SIZE];
 571 uint64_t idt_table[IDT_TABLE_SIZE];
 572 uint32_t tss[TSS_SIZE];
 573
 574 /* only dpl matters as we do only user space emulation */
 575 static void set_idt(int n, unsigned int dpl)
 576 {
 577     set_gate(idt_table + n, 0, dpl, 0, 0);
 578 }
 579
 580 /* ABI convention: after a syscall if there was an error the CF flag is set */
 581 static inline void set_error(CPUX86State *env, int ret)
 582 {
 583     if(ret<0)
 584         env->eflags = env->eflags | 0x1;
 585     else
 586         env->eflags &= ~0x1;
 587     env->regs[R_EAX] = ret;
 588 }
 589
 590 void cpu_loop(CPUX86State *env)
 591 {
 592     int trapnr;
 593     int ret;
 594     uint8_t *pc;
 595     target_siginfo_t info;
 596
 597     for(;;) {
 598         trapnr = cpu_x86_exec(env);
 599         uint32_t *params = (uint32_t *)env->regs[R_ESP];
 600         switch(trapnr) {
 601         case 0x79: /* Our commpage hack back door exit is here */
 602             do_commpage(env,  env->eip,   *(params + 1), *(params + 2),
 603                                           *(params + 3), *(params + 4),
 604                                           *(params + 5), *(params + 6),
 605                                           *(params + 7), *(params + 8));
 606             break;
 607         case 0x81: /* mach syscall */
 608         {
 609             ret = do_mach_syscall(env,  env->regs[R_EAX],
 610                                           *(params + 1), *(params + 2),
 611                                           *(params + 3), *(params + 4),
 612                                           *(params + 5), *(params + 6),
 613                                           *(params + 7), *(params + 8));
 614             set_error(env, ret);
 615             break;
 616         }
 617         case 0x90: /* unix backdoor */
 618         {
 619             /* after sysenter, stack is in R_ECX, new eip in R_EDX (sysexit will flip them back)*/
 620             int saved_stack = env->regs[R_ESP];
 621             env->regs[R_ESP] = env->regs[R_ECX];
 622
 623             ret = do_unix_syscall(env, env->regs[R_EAX]);
 624
 625             env->regs[R_ECX] = env->regs[R_ESP];
 626             env->regs[R_ESP] = saved_stack;
 627
 628             set_error(env, ret);
 629             break;
 630         }
 631         case 0x80: /* unix syscall */
 632         {
 633             ret = do_unix_syscall(env, env->regs[R_EAX]/*,
 634                                           *(params + 1), *(params + 2),
 635                                           *(params + 3), *(params + 4),
 636                                           *(params + 5), *(params + 6),
 637                                           *(params + 7), *(params + 8)*/);
 638             set_error(env, ret);
 639             break;
 640         }
 641         case 0x82: /* thread syscall */
 642         {
 643             ret = do_thread_syscall(env,  env->regs[R_EAX],
 644                                           *(params + 1), *(params + 2),
 645                                           *(params + 3), *(params + 4),
 646                                           *(params + 5), *(params + 6),
 647                                           *(params + 7), *(params + 8));
 648             set_error(env, ret);
 649             break;
 650         }
 651         case EXCP0B_NOSEG:
 652         case EXCP0C_STACK:
 653             info.si_signo = SIGBUS;
 654             info.si_errno = 0;
 655             info.si_code = BUS_NOOP;
 656             info.si_addr = 0;
 657             gdb_handlesig (env, SIGBUS);
 658             queue_signal(info.si_signo, &info);
 659             break;
 660         case EXCP0D_GPF:
 661             info.si_signo = SIGSEGV;
 662             info.si_errno = 0;
 663             info.si_code = SEGV_NOOP;
 664             info.si_addr = 0;
 665             gdb_handlesig (env, SIGSEGV);
 666             queue_signal(info.si_signo, &info);
 667             break;
 668         case EXCP0E_PAGE:
 669             info.si_signo = SIGSEGV;
 670             info.si_errno = 0;
 671             if (!(env->error_code & 1))
 672                 info.si_code = SEGV_MAPERR;
 673             else
 674                 info.si_code = SEGV_ACCERR;
 675             info.si_addr = (void*)env->cr[2];
 676             gdb_handlesig (env, SIGSEGV);
 677             queue_signal(info.si_signo, &info);
 678             break;
 679         case EXCP00_DIVZ:
 680             /* division by zero */
 681             info.si_signo = SIGFPE;
 682             info.si_errno = 0;
 683             info.si_code = FPE_INTDIV;
 684             info.si_addr = (void*)env->eip;
 685             gdb_handlesig (env, SIGFPE);
 686             queue_signal(info.si_signo, &info);
 687             break;
 688         case EXCP01_SSTP:
 689         case EXCP03_INT3:
 690             info.si_signo = SIGTRAP;
 691             info.si_errno = 0;
 692             info.si_code = TRAP_BRKPT;
 693             info.si_addr = (void*)env->eip;
 694             gdb_handlesig (env, SIGTRAP);
 695             queue_signal(info.si_signo, &info);
 696             break;
 697         case EXCP04_INTO:
 698         case EXCP05_BOUND:
 699             info.si_signo = SIGSEGV;
 700             info.si_errno = 0;
 701             info.si_code = SEGV_NOOP;
 702             info.si_addr = 0;
 703             gdb_handlesig (env, SIGSEGV);
 704             queue_signal(info.si_signo, &info);
 705             break;
 706         case EXCP06_ILLOP:
 707             info.si_signo = SIGILL;
 708             info.si_errno = 0;
 709             info.si_code = ILL_ILLOPN;
 710             info.si_addr = (void*)env->eip;
 711             gdb_handlesig (env, SIGILL);
 712             queue_signal(info.si_signo, &info);
 713             break;
 714         case EXCP_INTERRUPT:
 715             /* just indicate that signals should be handled asap */
 716             break;
 717         case EXCP_DEBUG:
 718             {
 719                 int sig;
 720
 721                 sig = gdb_handlesig (env, SIGTRAP);
 722                 if (sig)
 723                   {
 724                     info.si_signo = sig;
 725                     info.si_errno = 0;
 726                     info.si_code = TRAP_BRKPT;
 727                     queue_signal(info.si_signo, &info);
 728                   }
 729             }
 730             break;
 731         default:
 732             pc = (void*)(env->segs[R_CS].base + env->eip);
 733             fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
 734                     (long)pc, trapnr);
 735             abort();
 736         }
 737         process_pending_signals(env);
 738     }
 739 }
 740 #endif
 741
 742 void usage(void)
 743 {
 744     printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n"
 745            "usage: qemu-" TARGET_ARCH " [-h] [-d opts] [-L path] [-s size] program [arguments...]\n"
 746            "Darwin CPU emulator (compiled for %s emulation)\n"
 747            "\n"
 748            "-h           print this help\n"
 749            "-L path      set the %s library path (default='%s')\n"
 750            "-s size      set the stack size in bytes (default=%ld)\n"
 751            "\n"
 752            "debug options:\n"
 753            "-d options   activate log (logfile='%s')\n"
 754            "-g wait for gdb on port 1234\n"
 755            "-p pagesize  set the host page size to 'pagesize'\n",
 756            "-singlestep  always run in singlestep mode\n"
 757            TARGET_ARCH,
 758            TARGET_ARCH,
 759            interp_prefix,
 760            stack_size,
 761            DEBUG_LOGFILE);
 762     exit(1);
 763 }
 764
 765 /* XXX: currently only used for async signals (see signal.c) */
 766 CPUState *global_env;
 767 /* used only if single thread */
 768 CPUState *cpu_single_env = NULL;
 769
 770 /* used to free thread contexts */
 771 TaskState *first_task_state;
 772
 773 int main(int argc, char **argv)
 774 {
 775     const char *filename;
 776     struct target_pt_regs regs1, *regs = &regs1;
 777     TaskState ts1, *ts = &ts1;
 778     CPUState *env;
 779     int optind;
 780     short use_gdbstub = 0;
 781     const char *r;
 782     const char *cpu_model;
 783
 784     if (argc <= 1)
 785         usage();
 786
 787     /* init debug */
 788     cpu_set_log_filename(DEBUG_LOGFILE);
 789
 790     optind = 1;
 791     for(;;) {
 792         if (optind >= argc)
 793             break;
 794         r = argv[optind];
 795         if (r[0] != '-')
 796             break;
 797         optind++;
 798         r++;
 799         if (!strcmp(r, "-")) {
 800             break;
 801         } else if (!strcmp(r, "d")) {
 802             int mask;
 803             CPULogItem *item;
 804
 805         if (optind >= argc)
 806         break;
 807
 808         r = argv[optind++];
 809             mask = cpu_str_to_log_mask(r);
 810             if (!mask) {
 811                 printf("Log items (comma separated):\n");
 812                 for(item = cpu_log_items; item->mask != 0; item++) {
 813                     printf("%-10s %s\n", item->name, item->help);
 814                 }
 815                 exit(1);
 816             }
 817             cpu_set_log(mask);
 818         } else if (!strcmp(r, "s")) {
 819             r = argv[optind++];
 820             stack_size = strtol(r, (char **)&r, 0);
 821             if (stack_size <= 0)
 822                 usage();
 823             if (*r == 'M')
 824                 stack_size *= 1024 * 1024;
 825             else if (*r == 'k' || *r == 'K')
 826                 stack_size *= 1024;
 827         } else if (!strcmp(r, "L")) {
 828             interp_prefix = argv[optind++];
 829         } else if (!strcmp(r, "p")) {
 830             qemu_host_page_size = atoi(argv[optind++]);
 831             if (qemu_host_page_size == 0 ||
 832                 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
 833                 fprintf(stderr, "page size must be a power of two\n");
 834                 exit(1);
 835             }
 836         } else
 837         if (!strcmp(r, "g")) {
 838             use_gdbstub = 1;
 839         } else if (!strcmp(r, "cpu")) {
 840             cpu_model = argv[optind++];
 841             if (strcmp(cpu_model, "?") == 0) {
 842 /* XXX: implement xxx_cpu_list for targets that still miss it */
 843 #if defined(cpu_list)
 844                     cpu_list(stdout, &fprintf);
 845 #endif
 846                 exit(1);
 847             }
 848         } else if (!strcmp(r, "singlestep")) {
 849             singlestep = 1;
 850         } else
 851         {
 852             usage();
 853         }
 854     }
 855     if (optind >= argc)
 856         usage();
 857     filename = argv[optind];
 858
 859     /* Zero out regs */
 860     memset(regs, 0, sizeof(struct target_pt_regs));
 861
 862     if (cpu_model == NULL) {
 863 #if defined(TARGET_I386)
 864 #ifdef TARGET_X86_64
 865         cpu_model = "qemu64";
 866 #else
 867         cpu_model = "qemu32";
 868 #endif
 869 #elif defined(TARGET_PPC)
 870 #ifdef TARGET_PPC64
 871         cpu_model = "970";
 872 #else
 873         cpu_model = "750";
 874 #endif
 875 #else
 876 #error unsupported CPU
 877 #endif
 878     }
 879
 880     cpu_exec_init_all(0);
 881     /* NOTE: we need to init the CPU at this stage to get
 882        qemu_host_page_size */
 883     env = cpu_init(cpu_model);
 884
 885     printf("Starting %s with qemu\n----------------\n", filename);
 886
 887     commpage_init();
 888
 889     if (mach_exec(filename, argv+optind, environ, regs) != 0) {
 890     printf("Error loading %s\n", filename);
 891     _exit(1);
 892     }
 893
 894     syscall_init();
 895     signal_init();
 896     global_env = env;
 897
 898     /* build Task State */
 899     memset(ts, 0, sizeof(TaskState));
 900     env->opaque = ts;
 901     ts->used = 1;
 902
 903 #if defined(TARGET_I386)
 904     cpu_x86_set_cpl(env, 3);
 905
 906     env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
 907     env->hflags |= HF_PE_MASK;
 908
 909     if (env->cpuid_features & CPUID_SSE) {
 910         env->cr[4] |= CR4_OSFXSR_MASK;
 911         env->hflags |= HF_OSFXSR_MASK;
 912     }
 913
 914     /* flags setup : we activate the IRQs by default as in user mode */
 915     env->eflags |= IF_MASK;
 916
 917     /* darwin register setup */
 918     env->regs[R_EAX] = regs->eax;
 919     env->regs[R_EBX] = regs->ebx;
 920     env->regs[R_ECX] = regs->ecx;
 921     env->regs[R_EDX] = regs->edx;
 922     env->regs[R_ESI] = regs->esi;
 923     env->regs[R_EDI] = regs->edi;
 924     env->regs[R_EBP] = regs->ebp;
 925     env->regs[R_ESP] = regs->esp;
 926     env->eip = regs->eip;
 927
 928     /* Darwin LDT setup */
 929     /* 2 - User code segment
 930        3 - User data segment
 931        4 - User cthread */
 932     bzero(ldt_table, LDT_TABLE_SIZE * sizeof(ldt_table[0]));
 933     env->ldt.base = (uint32_t) ldt_table;
 934     env->ldt.limit = sizeof(ldt_table) - 1;
 935
 936     write_dt(ldt_table + 2, 0, 0xfffff,
 937              DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
 938              (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
 939     write_dt(ldt_table + 3, 0, 0xfffff,
 940              DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
 941              (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
 942     write_dt(ldt_table + 4, 0, 0xfffff,
 943              DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
 944              (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
 945
 946     /* Darwin GDT setup.
 947      * has changed a lot between old Darwin/x86 (pre-Mac Intel) and Mac OS X/x86,
 948        now everything is done via  int 0x81(mach) int 0x82 (thread) and sysenter/sysexit(unix) */
 949     bzero(gdt_table, sizeof(gdt_table));
 950     env->gdt.base = (uint32_t)gdt_table;
 951     env->gdt.limit = sizeof(gdt_table) - 1;
 952
 953     /* Set up a back door to handle sysenter syscalls (unix) */
 954     char * syscallbackdoor = malloc(64);
 955     page_set_flags((int)syscallbackdoor, (int)syscallbackdoor + 64, PROT_EXEC | PROT_READ | PAGE_VALID);
 956
 957     int i = 0;
 958     syscallbackdoor[i++] = 0xcd;
 959     syscallbackdoor[i++] = 0x90; /* int 0x90 */
 960     syscallbackdoor[i++] = 0x0F;
 961     syscallbackdoor[i++] = 0x35; /* sysexit */
 962
 963     /* Darwin sysenter/sysexit setup */
 964     env->sysenter_cs = 0x1; //XXX
 965     env->sysenter_eip = (int)syscallbackdoor;
 966     env->sysenter_esp = (int)malloc(64);
 967
 968     /* Darwin TSS setup
 969        This must match up with GDT[4] */
 970     env->tr.base = (uint32_t) tss;
 971     env->tr.limit = sizeof(tss) - 1;
 972     env->tr.flags = DESC_P_MASK | (0x9 << DESC_TYPE_SHIFT);
 973     stw(tss + 2, 0x10);  // ss0 = 0x10 = GDT[2] = Kernel Data Segment
 974
 975     /* Darwin interrupt setup */
 976     bzero(idt_table, sizeof(idt_table));
 977     env->idt.base = (uint32_t) idt_table;
 978     env->idt.limit = sizeof(idt_table) - 1;
 979     set_idt(0, 0);
 980     set_idt(1, 0);
 981     set_idt(2, 0);
 982     set_idt(3, 3);
 983     set_idt(4, 3);
 984     set_idt(5, 3);
 985     set_idt(6, 0);
 986     set_idt(7, 0);
 987     set_idt(8, 0);
 988     set_idt(9, 0);
 989     set_idt(10, 0);
 990     set_idt(11, 0);
 991     set_idt(12, 0);
 992     set_idt(13, 0);
 993     set_idt(14, 0);
 994     set_idt(15, 0);
 995     set_idt(16, 0);
 996     set_idt(17, 0);
 997     set_idt(18, 0);
 998     set_idt(19, 0);
 999     /* Syscalls are done via
1000         int 0x80 (unix) (rarely used)
1001         int 0x81 (mach)
1002         int 0x82 (thread)
1003         int 0x83 (diag) (not handled here)
1004         sysenter/sysexit (unix) -> we redirect that to int 0x90 */
1005     set_idt(0x79, 3); /* Commpage hack, here is our backdoor interrupt */
1006     set_idt(0x80, 3); /* Unix Syscall */
1007     set_idt(0x81, 3); /* Mach Syscalls */
1008     set_idt(0x82, 3); /* thread Syscalls */
1009
1010     set_idt(0x90, 3); /* qemu-darwin-user's Unix syscalls backdoor */
1011
1012
1013     cpu_x86_load_seg(env, R_CS, __USER_CS);
1014     cpu_x86_load_seg(env, R_DS, __USER_DS);
1015     cpu_x86_load_seg(env, R_ES, __USER_DS);
1016     cpu_x86_load_seg(env, R_SS, __USER_DS);
1017     cpu_x86_load_seg(env, R_FS, __USER_DS);
1018     cpu_x86_load_seg(env, R_GS, __USER_DS);
1019
1020 #elif defined(TARGET_PPC)
1021     {
1022         int i;
1023
1024 #if defined(TARGET_PPC64)
1025 #if defined(TARGET_ABI32)
1026         env->msr &= ~((target_ulong)1 << MSR_SF);
1027 #else
1028         env->msr |= (target_ulong)1 << MSR_SF;
1029 #endif
1030 #endif
1031         env->nip = regs->nip;
1032         for(i = 0; i < 32; i++) {
1033             env->gpr[i] = regs->gpr[i];
1034         }
1035     }
1036 #else
1037 #error unsupported target CPU
1038 #endif
1039
1040     if (use_gdbstub) {
1041         printf("Waiting for gdb Connection on port 1234...\n");
1042         gdbserver_start (1234);
1043         gdb_handlesig(env, 0);
1044     }
1045
1046     cpu_loop(env);
1047     /* never exits */
1048     return 0;
1049 }