linux-user/ppc/cpu_loop.c

   1 /*
   2  *  qemu user cpu loop
   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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "qemu-common.h"
  22 #include "qemu.h"
  23 #include "user-internals.h"
  24 #include "cpu_loop-common.h"
  25 #include "signal-common.h"
  26
  27 static inline uint64_t cpu_ppc_get_tb(CPUPPCState *env)
  28 {
  29     return cpu_get_host_ticks();
  30 }
  31
  32 uint64_t cpu_ppc_load_tbl(CPUPPCState *env)
  33 {
  34     return cpu_ppc_get_tb(env);
  35 }
  36
  37 uint32_t cpu_ppc_load_tbu(CPUPPCState *env)
  38 {
  39     return cpu_ppc_get_tb(env) >> 32;
  40 }
  41
  42 uint64_t cpu_ppc_load_atbl(CPUPPCState *env)
  43 {
  44     return cpu_ppc_get_tb(env);
  45 }
  46
  47 uint32_t cpu_ppc_load_atbu(CPUPPCState *env)
  48 {
  49     return cpu_ppc_get_tb(env) >> 32;
  50 }
  51
  52 uint64_t cpu_ppc_load_vtb(CPUPPCState *env)
  53 {
  54     return cpu_ppc_get_tb(env);
  55 }
  56
  57 uint32_t cpu_ppc601_load_rtcu(CPUPPCState *env)
  58 __attribute__ (( alias ("cpu_ppc_load_tbu") ));
  59
  60 uint32_t cpu_ppc601_load_rtcl(CPUPPCState *env)
  61 {
  62     return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
  63 }
  64
  65 /* XXX: to be fixed */
  66 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp)
  67 {
  68     return -1;
  69 }
  70
  71 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val)
  72 {
  73     return -1;
  74 }
  75
  76 void cpu_loop(CPUPPCState *env)
  77 {
  78     CPUState *cs = env_cpu(env);
  79     target_siginfo_t info;
  80     int trapnr;
  81     target_ulong ret;
  82
  83     for(;;) {
  84         bool arch_interrupt;
  85
  86         cpu_exec_start(cs);
  87         trapnr = cpu_exec(cs);
  88         cpu_exec_end(cs);
  89         process_queued_cpu_work(cs);
  90
  91         arch_interrupt = true;
  92         switch (trapnr) {
  93         case POWERPC_EXCP_NONE:
  94             /* Just go on */
  95             break;
  96         case POWERPC_EXCP_CRITICAL: /* Critical input                        */
  97             cpu_abort(cs, "Critical interrupt while in user mode. "
  98                       "Aborting\n");
  99             break;
 100         case POWERPC_EXCP_MCHECK:   /* Machine check exception               */
 101             cpu_abort(cs, "Machine check exception while in user mode. "
 102                       "Aborting\n");
 103             break;
 104         case POWERPC_EXCP_DSI:      /* Data storage exception                */
 105             /* XXX: check this. Seems bugged */
 106             switch (env->error_code & 0xFF000000) {
 107             case 0x40000000:
 108             case 0x42000000:
 109                 info.si_signo = TARGET_SIGSEGV;
 110                 info.si_errno = 0;
 111                 info.si_code = TARGET_SEGV_MAPERR;
 112                 break;
 113             case 0x04000000:
 114                 info.si_signo = TARGET_SIGILL;
 115                 info.si_errno = 0;
 116                 info.si_code = TARGET_ILL_ILLADR;
 117                 break;
 118             case 0x08000000:
 119                 info.si_signo = TARGET_SIGSEGV;
 120                 info.si_errno = 0;
 121                 info.si_code = TARGET_SEGV_ACCERR;
 122                 break;
 123             default:
 124                 /* Let's send a regular segfault... */
 125                 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
 126                           env->error_code);
 127                 info.si_signo = TARGET_SIGSEGV;
 128                 info.si_errno = 0;
 129                 info.si_code = TARGET_SEGV_MAPERR;
 130                 break;
 131             }
 132             info._sifields._sigfault._addr = env->spr[SPR_DAR];
 133             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 134             break;
 135         case POWERPC_EXCP_ISI:      /* Instruction storage exception         */
 136             /* XXX: check this */
 137             switch (env->error_code & 0xFF000000) {
 138             case 0x40000000:
 139                 info.si_signo = TARGET_SIGSEGV;
 140             info.si_errno = 0;
 141                 info.si_code = TARGET_SEGV_MAPERR;
 142                 break;
 143             case 0x10000000:
 144             case 0x08000000:
 145                 info.si_signo = TARGET_SIGSEGV;
 146                 info.si_errno = 0;
 147                 info.si_code = TARGET_SEGV_ACCERR;
 148                 break;
 149             default:
 150                 /* Let's send a regular segfault... */
 151                 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
 152                           env->error_code);
 153                 info.si_signo = TARGET_SIGSEGV;
 154                 info.si_errno = 0;
 155                 info.si_code = TARGET_SEGV_MAPERR;
 156                 break;
 157             }
 158             info._sifields._sigfault._addr = env->nip - 4;
 159             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 160             break;
 161         case POWERPC_EXCP_EXTERNAL: /* External input                        */
 162             cpu_abort(cs, "External interrupt while in user mode. "
 163                       "Aborting\n");
 164             break;
 165         case POWERPC_EXCP_PROGRAM:  /* Program exception                     */
 166         case POWERPC_EXCP_HV_EMU:   /* HV emulation                          */
 167             /* XXX: check this */
 168             switch (env->error_code & ~0xF) {
 169             case POWERPC_EXCP_FP:
 170                 info.si_signo = TARGET_SIGFPE;
 171                 info.si_errno = 0;
 172                 switch (env->error_code & 0xF) {
 173                 case POWERPC_EXCP_FP_OX:
 174                     info.si_code = TARGET_FPE_FLTOVF;
 175                     break;
 176                 case POWERPC_EXCP_FP_UX:
 177                     info.si_code = TARGET_FPE_FLTUND;
 178                     break;
 179                 case POWERPC_EXCP_FP_ZX:
 180                 case POWERPC_EXCP_FP_VXZDZ:
 181                     info.si_code = TARGET_FPE_FLTDIV;
 182                     break;
 183                 case POWERPC_EXCP_FP_XX:
 184                     info.si_code = TARGET_FPE_FLTRES;
 185                     break;
 186                 case POWERPC_EXCP_FP_VXSOFT:
 187                     info.si_code = TARGET_FPE_FLTINV;
 188                     break;
 189                 case POWERPC_EXCP_FP_VXSNAN:
 190                 case POWERPC_EXCP_FP_VXISI:
 191                 case POWERPC_EXCP_FP_VXIDI:
 192                 case POWERPC_EXCP_FP_VXIMZ:
 193                 case POWERPC_EXCP_FP_VXVC:
 194                 case POWERPC_EXCP_FP_VXSQRT:
 195                 case POWERPC_EXCP_FP_VXCVI:
 196                     info.si_code = TARGET_FPE_FLTSUB;
 197                     break;
 198                 default:
 199                     EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
 200                               env->error_code);
 201                     break;
 202                 }
 203                 break;
 204             case POWERPC_EXCP_INVAL:
 205                 info.si_signo = TARGET_SIGILL;
 206                 info.si_errno = 0;
 207                 switch (env->error_code & 0xF) {
 208                 case POWERPC_EXCP_INVAL_INVAL:
 209                     info.si_code = TARGET_ILL_ILLOPC;
 210                     break;
 211                 case POWERPC_EXCP_INVAL_LSWX:
 212                     info.si_code = TARGET_ILL_ILLOPN;
 213                     break;
 214                 case POWERPC_EXCP_INVAL_SPR:
 215                     info.si_code = TARGET_ILL_PRVREG;
 216                     break;
 217                 case POWERPC_EXCP_INVAL_FP:
 218                     info.si_code = TARGET_ILL_COPROC;
 219                     break;
 220                 default:
 221                     EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
 222                               env->error_code & 0xF);
 223                     info.si_code = TARGET_ILL_ILLADR;
 224                     break;
 225                 }
 226                 break;
 227             case POWERPC_EXCP_PRIV:
 228                 info.si_signo = TARGET_SIGILL;
 229                 info.si_errno = 0;
 230                 switch (env->error_code & 0xF) {
 231                 case POWERPC_EXCP_PRIV_OPC:
 232                     info.si_code = TARGET_ILL_PRVOPC;
 233                     break;
 234                 case POWERPC_EXCP_PRIV_REG:
 235                     info.si_code = TARGET_ILL_PRVREG;
 236                     break;
 237                 default:
 238                     EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
 239                               env->error_code & 0xF);
 240                     info.si_code = TARGET_ILL_PRVOPC;
 241                     break;
 242                 }
 243                 break;
 244             case POWERPC_EXCP_TRAP:
 245                 cpu_abort(cs, "Tried to call a TRAP\n");
 246                 break;
 247             default:
 248                 /* Should not happen ! */
 249                 cpu_abort(cs, "Unknown program exception (%02x)\n",
 250                           env->error_code);
 251                 break;
 252             }
 253             info._sifields._sigfault._addr = env->nip;
 254             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 255             break;
 256         case POWERPC_EXCP_FPU:      /* Floating-point unavailable exception  */
 257             info.si_signo = TARGET_SIGILL;
 258             info.si_errno = 0;
 259             info.si_code = TARGET_ILL_COPROC;
 260             info._sifields._sigfault._addr = env->nip;
 261             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 262             break;
 263         case POWERPC_EXCP_SYSCALL:  /* System call exception                 */
 264         case POWERPC_EXCP_SYSCALL_VECTORED:
 265             cpu_abort(cs, "Syscall exception while in user mode. "
 266                       "Aborting\n");
 267             break;
 268         case POWERPC_EXCP_APU:      /* Auxiliary processor unavailable       */
 269             info.si_signo = TARGET_SIGILL;
 270             info.si_errno = 0;
 271             info.si_code = TARGET_ILL_COPROC;
 272             info._sifields._sigfault._addr = env->nip;
 273             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 274             break;
 275         case POWERPC_EXCP_DECR:     /* Decrementer exception                 */
 276             cpu_abort(cs, "Decrementer interrupt while in user mode. "
 277                       "Aborting\n");
 278             break;
 279         case POWERPC_EXCP_FIT:      /* Fixed-interval timer interrupt        */
 280             cpu_abort(cs, "Fix interval timer interrupt while in user mode. "
 281                       "Aborting\n");
 282             break;
 283         case POWERPC_EXCP_WDT:      /* Watchdog timer interrupt              */
 284             cpu_abort(cs, "Watchdog timer interrupt while in user mode. "
 285                       "Aborting\n");
 286             break;
 287         case POWERPC_EXCP_DTLB:     /* Data TLB error                        */
 288             cpu_abort(cs, "Data TLB exception while in user mode. "
 289                       "Aborting\n");
 290             break;
 291         case POWERPC_EXCP_ITLB:     /* Instruction TLB error                 */
 292             cpu_abort(cs, "Instruction TLB exception while in user mode. "
 293                       "Aborting\n");
 294             break;
 295         case POWERPC_EXCP_SPEU:     /* SPE/embedded floating-point unavail.  */
 296             info.si_signo = TARGET_SIGILL;
 297             info.si_errno = 0;
 298             info.si_code = TARGET_ILL_COPROC;
 299             info._sifields._sigfault._addr = env->nip;
 300             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 301             break;
 302         case POWERPC_EXCP_EFPDI:    /* Embedded floating-point data IRQ      */
 303             cpu_abort(cs, "Embedded floating-point data IRQ not handled\n");
 304             break;
 305         case POWERPC_EXCP_EFPRI:    /* Embedded floating-point round IRQ     */
 306             cpu_abort(cs, "Embedded floating-point round IRQ not handled\n");
 307             break;
 308         case POWERPC_EXCP_EPERFM:   /* Embedded performance monitor IRQ      */
 309             cpu_abort(cs, "Performance monitor exception not handled\n");
 310             break;
 311         case POWERPC_EXCP_DOORI:    /* Embedded doorbell interrupt           */
 312             cpu_abort(cs, "Doorbell interrupt while in user mode. "
 313                        "Aborting\n");
 314             break;
 315         case POWERPC_EXCP_DOORCI:   /* Embedded doorbell critical interrupt  */
 316             cpu_abort(cs, "Doorbell critical interrupt while in user mode. "
 317                       "Aborting\n");
 318             break;
 319         case POWERPC_EXCP_RESET:    /* System reset exception                */
 320             cpu_abort(cs, "Reset interrupt while in user mode. "
 321                       "Aborting\n");
 322             break;
 323         case POWERPC_EXCP_DSEG:     /* Data segment exception                */
 324             cpu_abort(cs, "Data segment exception while in user mode. "
 325                       "Aborting\n");
 326             break;
 327         case POWERPC_EXCP_ISEG:     /* Instruction segment exception         */
 328             cpu_abort(cs, "Instruction segment exception "
 329                       "while in user mode. Aborting\n");
 330             break;
 331         /* PowerPC 64 with hypervisor mode support */
 332         case POWERPC_EXCP_HDECR:    /* Hypervisor decrementer exception      */
 333             cpu_abort(cs, "Hypervisor decrementer interrupt "
 334                       "while in user mode. Aborting\n");
 335             break;
 336         case POWERPC_EXCP_TRACE:    /* Trace exception                       */
 337             /* Nothing to do:
 338              * we use this exception to emulate step-by-step execution mode.
 339              */
 340             break;
 341         /* PowerPC 64 with hypervisor mode support */
 342         case POWERPC_EXCP_HDSI:     /* Hypervisor data storage exception     */
 343             cpu_abort(cs, "Hypervisor data storage exception "
 344                       "while in user mode. Aborting\n");
 345             break;
 346         case POWERPC_EXCP_HISI:     /* Hypervisor instruction storage excp   */
 347             cpu_abort(cs, "Hypervisor instruction storage exception "
 348                       "while in user mode. Aborting\n");
 349             break;
 350         case POWERPC_EXCP_HDSEG:    /* Hypervisor data segment exception     */
 351             cpu_abort(cs, "Hypervisor data segment exception "
 352                       "while in user mode. Aborting\n");
 353             break;
 354         case POWERPC_EXCP_HISEG:    /* Hypervisor instruction segment excp   */
 355             cpu_abort(cs, "Hypervisor instruction segment exception "
 356                       "while in user mode. Aborting\n");
 357             break;
 358         case POWERPC_EXCP_VPU:      /* Vector unavailable exception          */
 359             info.si_signo = TARGET_SIGILL;
 360             info.si_errno = 0;
 361             info.si_code = TARGET_ILL_COPROC;
 362             info._sifields._sigfault._addr = env->nip;
 363             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 364             break;
 365         case POWERPC_EXCP_PIT:      /* Programmable interval timer IRQ       */
 366             cpu_abort(cs, "Programmable interval timer interrupt "
 367                       "while in user mode. Aborting\n");
 368             break;
 369         case POWERPC_EXCP_IO:       /* IO error exception                    */
 370             cpu_abort(cs, "IO error exception while in user mode. "
 371                       "Aborting\n");
 372             break;
 373         case POWERPC_EXCP_RUNM:     /* Run mode exception                    */
 374             cpu_abort(cs, "Run mode exception while in user mode. "
 375                       "Aborting\n");
 376             break;
 377         case POWERPC_EXCP_EMUL:     /* Emulation trap exception              */
 378             cpu_abort(cs, "Emulation trap exception not handled\n");
 379             break;
 380         case POWERPC_EXCP_IFTLB:    /* Instruction fetch TLB error           */
 381             cpu_abort(cs, "Instruction fetch TLB exception "
 382                       "while in user-mode. Aborting");
 383             break;
 384         case POWERPC_EXCP_DLTLB:    /* Data load TLB miss                    */
 385             cpu_abort(cs, "Data load TLB exception while in user-mode. "
 386                       "Aborting");
 387             break;
 388         case POWERPC_EXCP_DSTLB:    /* Data store TLB miss                   */
 389             cpu_abort(cs, "Data store TLB exception while in user-mode. "
 390                       "Aborting");
 391             break;
 392         case POWERPC_EXCP_FPA:      /* Floating-point assist exception       */
 393             cpu_abort(cs, "Floating-point assist exception not handled\n");
 394             break;
 395         case POWERPC_EXCP_IABR:     /* Instruction address breakpoint        */
 396             cpu_abort(cs, "Instruction address breakpoint exception "
 397                       "not handled\n");
 398             break;
 399         case POWERPC_EXCP_SMI:      /* System management interrupt           */
 400             cpu_abort(cs, "System management interrupt while in user mode. "
 401                       "Aborting\n");
 402             break;
 403         case POWERPC_EXCP_THERM:    /* Thermal interrupt                     */
 404             cpu_abort(cs, "Thermal interrupt interrupt while in user mode. "
 405                       "Aborting\n");
 406             break;
 407         case POWERPC_EXCP_PERFM:   /* Embedded performance monitor IRQ      */
 408             cpu_abort(cs, "Performance monitor exception not handled\n");
 409             break;
 410         case POWERPC_EXCP_VPUA:     /* Vector assist exception               */
 411             cpu_abort(cs, "Vector assist exception not handled\n");
 412             break;
 413         case POWERPC_EXCP_SOFTP:    /* Soft patch exception                  */
 414             cpu_abort(cs, "Soft patch exception not handled\n");
 415             break;
 416         case POWERPC_EXCP_MAINT:    /* Maintenance exception                 */
 417             cpu_abort(cs, "Maintenance exception while in user mode. "
 418                       "Aborting\n");
 419             break;
 420         case POWERPC_EXCP_SYSCALL_USER:
 421             /* system call in user-mode emulation */
 422             /* WARNING:
 423              * PPC ABI uses overflow flag in cr0 to signal an error
 424              * in syscalls.
 425              */
 426             env->crf[0] &= ~0x1;
 427             env->nip += 4;
 428             ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
 429                              env->gpr[5], env->gpr[6], env->gpr[7],
 430                              env->gpr[8], 0, 0);
 431             if (ret == -QEMU_ERESTARTSYS) {
 432                 env->nip -= 4;
 433                 break;
 434             }
 435             if (ret == (target_ulong)(-QEMU_ESIGRETURN)) {
 436                 /* Returning from a successful sigreturn syscall.
 437                    Avoid corrupting register state.  */
 438                 break;
 439             }
 440             if (ret > (target_ulong)(-515)) {
 441                 env->crf[0] |= 0x1;
 442                 ret = -ret;
 443             }
 444             env->gpr[3] = ret;
 445             break;
 446         case EXCP_DEBUG:
 447             info.si_signo = TARGET_SIGTRAP;
 448             info.si_errno = 0;
 449             info.si_code = TARGET_TRAP_BRKPT;
 450             queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
 451             break;
 452         case EXCP_INTERRUPT:
 453             /* just indicate that signals should be handled asap */
 454             break;
 455         case EXCP_ATOMIC:
 456             cpu_exec_step_atomic(cs);
 457             arch_interrupt = false;
 458             break;
 459         default:
 460             cpu_abort(cs, "Unknown exception 0x%x. Aborting\n", trapnr);
 461             break;
 462         }
 463         process_pending_signals(env);
 464
 465         /* Most of the traps imply a transition through kernel mode,
 466          * which implies an REI instruction has been executed.  Which
 467          * means that RX and LOCK_ADDR should be cleared.  But there
 468          * are a few exceptions for traps internal to QEMU.
 469          */
 470         if (arch_interrupt) {
 471             env->reserve_addr = -1;
 472         }
 473     }
 474 }
 475
 476 void target_cpu_copy_regs(CPUArchState *env, struct target_pt_regs *regs)
 477 {
 478     int i;
 479
 480 #if defined(TARGET_PPC64)
 481     int flag = (env->insns_flags2 & PPC2_BOOKE206) ? MSR_CM : MSR_SF;
 482 #if defined(TARGET_ABI32)
 483     ppc_store_msr(env, env->msr & ~((target_ulong)1 << flag));
 484 #else
 485     ppc_store_msr(env, env->msr | (target_ulong)1 << flag);
 486 #endif
 487 #endif
 488
 489     env->nip = regs->nip;
 490     for(i = 0; i < 32; i++) {
 491         env->gpr[i] = regs->gpr[i];
 492     }
 493 }