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 } 494