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, see <http://www.gnu.org/licenses/>. 18 */ 19 #include "qemu/osdep.h" 20 #include "qemu-version.h" 21 #include <sys/syscall.h> 22 #include <sys/resource.h> 23 24 #include "qapi/error.h" 25 #include "qemu.h" 26 #include "qemu/path.h" 27 #include "qemu/cutils.h" 28 #include "qemu/help_option.h" 29 #include "cpu.h" 30 #include "exec/exec-all.h" 31 #include "tcg.h" 32 #include "qemu/timer.h" 33 #include "qemu/envlist.h" 34 #include "elf.h" 35 #include "exec/log.h" 36 37 char *exec_path; 38 39 int singlestep; 40 static const char *filename; 41 static const char *argv0; 42 static int gdbstub_port; 43 static envlist_t *envlist; 44 static const char *cpu_model; 45 unsigned long mmap_min_addr; 46 unsigned long guest_base; 47 int have_guest_base; 48 49 #define EXCP_DUMP(env, fmt, ...) \ 50 do { \ 51 CPUState *cs = ENV_GET_CPU(env); \ 52 fprintf(stderr, fmt , ## __VA_ARGS__); \ 53 cpu_dump_state(cs, stderr, fprintf, 0); \ 54 if (qemu_log_separate()) { \ 55 qemu_log(fmt, ## __VA_ARGS__); \ 56 log_cpu_state(cs, 0); \ 57 } \ 58 } while (0) 59 60 #if (TARGET_LONG_BITS == 32) && (HOST_LONG_BITS == 64) 61 /* 62 * When running 32-on-64 we should make sure we can fit all of the possible 63 * guest address space into a contiguous chunk of virtual host memory. 64 * 65 * This way we will never overlap with our own libraries or binaries or stack 66 * or anything else that QEMU maps. 67 */ 68 # ifdef TARGET_MIPS 69 /* MIPS only supports 31 bits of virtual address space for user space */ 70 unsigned long reserved_va = 0x77000000; 71 # else 72 unsigned long reserved_va = 0xf7000000; 73 # endif 74 #else 75 unsigned long reserved_va; 76 #endif 77 78 static void usage(int exitcode); 79 80 static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX; 81 const char *qemu_uname_release; 82 83 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so 84 we allocate a bigger stack. Need a better solution, for example 85 by remapping the process stack directly at the right place */ 86 unsigned long guest_stack_size = 8 * 1024 * 1024UL; 87 88 void gemu_log(const char *fmt, ...) 89 { 90 va_list ap; 91 92 va_start(ap, fmt); 93 vfprintf(stderr, fmt, ap); 94 va_end(ap); 95 } 96 97 #if defined(TARGET_I386) 98 int cpu_get_pic_interrupt(CPUX86State *env) 99 { 100 return -1; 101 } 102 #endif 103 104 /***********************************************************/ 105 /* Helper routines for implementing atomic operations. */ 106 107 /* To implement exclusive operations we force all cpus to syncronise. 108 We don't require a full sync, only that no cpus are executing guest code. 109 The alternative is to map target atomic ops onto host equivalents, 110 which requires quite a lot of per host/target work. */ 111 static pthread_mutex_t cpu_list_mutex = PTHREAD_MUTEX_INITIALIZER; 112 static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER; 113 static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER; 114 static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER; 115 static int pending_cpus; 116 117 /* Make sure everything is in a consistent state for calling fork(). */ 118 void fork_start(void) 119 { 120 qemu_mutex_lock(&tcg_ctx.tb_ctx.tb_lock); 121 pthread_mutex_lock(&exclusive_lock); 122 mmap_fork_start(); 123 } 124 125 void fork_end(int child) 126 { 127 mmap_fork_end(child); 128 if (child) { 129 CPUState *cpu, *next_cpu; 130 /* Child processes created by fork() only have a single thread. 131 Discard information about the parent threads. */ 132 CPU_FOREACH_SAFE(cpu, next_cpu) { 133 if (cpu != thread_cpu) { 134 QTAILQ_REMOVE(&cpus, cpu, node); 135 } 136 } 137 pending_cpus = 0; 138 pthread_mutex_init(&exclusive_lock, NULL); 139 pthread_mutex_init(&cpu_list_mutex, NULL); 140 pthread_cond_init(&exclusive_cond, NULL); 141 pthread_cond_init(&exclusive_resume, NULL); 142 qemu_mutex_init(&tcg_ctx.tb_ctx.tb_lock); 143 gdbserver_fork(thread_cpu); 144 } else { 145 pthread_mutex_unlock(&exclusive_lock); 146 qemu_mutex_unlock(&tcg_ctx.tb_ctx.tb_lock); 147 } 148 } 149 150 /* Wait for pending exclusive operations to complete. The exclusive lock 151 must be held. */ 152 static inline void exclusive_idle(void) 153 { 154 while (pending_cpus) { 155 pthread_cond_wait(&exclusive_resume, &exclusive_lock); 156 } 157 } 158 159 /* Start an exclusive operation. 160 Must only be called from outside cpu_exec. */ 161 static inline void start_exclusive(void) 162 { 163 CPUState *other_cpu; 164 165 pthread_mutex_lock(&exclusive_lock); 166 exclusive_idle(); 167 168 pending_cpus = 1; 169 /* Make all other cpus stop executing. */ 170 CPU_FOREACH(other_cpu) { 171 if (other_cpu->running) { 172 pending_cpus++; 173 cpu_exit(other_cpu); 174 } 175 } 176 if (pending_cpus > 1) { 177 pthread_cond_wait(&exclusive_cond, &exclusive_lock); 178 } 179 } 180 181 /* Finish an exclusive operation. */ 182 static inline void __attribute__((unused)) end_exclusive(void) 183 { 184 pending_cpus = 0; 185 pthread_cond_broadcast(&exclusive_resume); 186 pthread_mutex_unlock(&exclusive_lock); 187 } 188 189 /* Wait for exclusive ops to finish, and begin cpu execution. */ 190 static inline void cpu_exec_start(CPUState *cpu) 191 { 192 pthread_mutex_lock(&exclusive_lock); 193 exclusive_idle(); 194 cpu->running = true; 195 pthread_mutex_unlock(&exclusive_lock); 196 } 197 198 /* Mark cpu as not executing, and release pending exclusive ops. */ 199 static inline void cpu_exec_end(CPUState *cpu) 200 { 201 pthread_mutex_lock(&exclusive_lock); 202 cpu->running = false; 203 if (pending_cpus > 1) { 204 pending_cpus--; 205 if (pending_cpus == 1) { 206 pthread_cond_signal(&exclusive_cond); 207 } 208 } 209 exclusive_idle(); 210 pthread_mutex_unlock(&exclusive_lock); 211 } 212 213 void cpu_list_lock(void) 214 { 215 pthread_mutex_lock(&cpu_list_mutex); 216 } 217 218 void cpu_list_unlock(void) 219 { 220 pthread_mutex_unlock(&cpu_list_mutex); 221 } 222 223 224 #ifdef TARGET_I386 225 /***********************************************************/ 226 /* CPUX86 core interface */ 227 228 uint64_t cpu_get_tsc(CPUX86State *env) 229 { 230 return cpu_get_host_ticks(); 231 } 232 233 static void write_dt(void *ptr, unsigned long addr, unsigned long limit, 234 int flags) 235 { 236 unsigned int e1, e2; 237 uint32_t *p; 238 e1 = (addr << 16) | (limit & 0xffff); 239 e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000); 240 e2 |= flags; 241 p = ptr; 242 p[0] = tswap32(e1); 243 p[1] = tswap32(e2); 244 } 245 246 static uint64_t *idt_table; 247 #ifdef TARGET_X86_64 248 static void set_gate64(void *ptr, unsigned int type, unsigned int dpl, 249 uint64_t addr, unsigned int sel) 250 { 251 uint32_t *p, e1, e2; 252 e1 = (addr & 0xffff) | (sel << 16); 253 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); 254 p = ptr; 255 p[0] = tswap32(e1); 256 p[1] = tswap32(e2); 257 p[2] = tswap32(addr >> 32); 258 p[3] = 0; 259 } 260 /* only dpl matters as we do only user space emulation */ 261 static void set_idt(int n, unsigned int dpl) 262 { 263 set_gate64(idt_table + n * 2, 0, dpl, 0, 0); 264 } 265 #else 266 static void set_gate(void *ptr, unsigned int type, unsigned int dpl, 267 uint32_t addr, unsigned int sel) 268 { 269 uint32_t *p, e1, e2; 270 e1 = (addr & 0xffff) | (sel << 16); 271 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8); 272 p = ptr; 273 p[0] = tswap32(e1); 274 p[1] = tswap32(e2); 275 } 276 277 /* only dpl matters as we do only user space emulation */ 278 static void set_idt(int n, unsigned int dpl) 279 { 280 set_gate(idt_table + n, 0, dpl, 0, 0); 281 } 282 #endif 283 284 void cpu_loop(CPUX86State *env) 285 { 286 CPUState *cs = CPU(x86_env_get_cpu(env)); 287 int trapnr; 288 abi_ulong pc; 289 abi_ulong ret; 290 target_siginfo_t info; 291 292 for(;;) { 293 cpu_exec_start(cs); 294 trapnr = cpu_exec(cs); 295 cpu_exec_end(cs); 296 switch(trapnr) { 297 case 0x80: 298 /* linux syscall from int $0x80 */ 299 ret = do_syscall(env, 300 env->regs[R_EAX], 301 env->regs[R_EBX], 302 env->regs[R_ECX], 303 env->regs[R_EDX], 304 env->regs[R_ESI], 305 env->regs[R_EDI], 306 env->regs[R_EBP], 307 0, 0); 308 if (ret == -TARGET_ERESTARTSYS) { 309 env->eip -= 2; 310 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 311 env->regs[R_EAX] = ret; 312 } 313 break; 314 #ifndef TARGET_ABI32 315 case EXCP_SYSCALL: 316 /* linux syscall from syscall instruction */ 317 ret = do_syscall(env, 318 env->regs[R_EAX], 319 env->regs[R_EDI], 320 env->regs[R_ESI], 321 env->regs[R_EDX], 322 env->regs[10], 323 env->regs[8], 324 env->regs[9], 325 0, 0); 326 if (ret == -TARGET_ERESTARTSYS) { 327 env->eip -= 2; 328 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 329 env->regs[R_EAX] = ret; 330 } 331 break; 332 #endif 333 case EXCP0B_NOSEG: 334 case EXCP0C_STACK: 335 info.si_signo = TARGET_SIGBUS; 336 info.si_errno = 0; 337 info.si_code = TARGET_SI_KERNEL; 338 info._sifields._sigfault._addr = 0; 339 queue_signal(env, info.si_signo, &info); 340 break; 341 case EXCP0D_GPF: 342 /* XXX: potential problem if ABI32 */ 343 #ifndef TARGET_X86_64 344 if (env->eflags & VM_MASK) { 345 handle_vm86_fault(env); 346 } else 347 #endif 348 { 349 info.si_signo = TARGET_SIGSEGV; 350 info.si_errno = 0; 351 info.si_code = TARGET_SI_KERNEL; 352 info._sifields._sigfault._addr = 0; 353 queue_signal(env, info.si_signo, &info); 354 } 355 break; 356 case EXCP0E_PAGE: 357 info.si_signo = TARGET_SIGSEGV; 358 info.si_errno = 0; 359 if (!(env->error_code & 1)) 360 info.si_code = TARGET_SEGV_MAPERR; 361 else 362 info.si_code = TARGET_SEGV_ACCERR; 363 info._sifields._sigfault._addr = env->cr[2]; 364 queue_signal(env, info.si_signo, &info); 365 break; 366 case EXCP00_DIVZ: 367 #ifndef TARGET_X86_64 368 if (env->eflags & VM_MASK) { 369 handle_vm86_trap(env, trapnr); 370 } else 371 #endif 372 { 373 /* division by zero */ 374 info.si_signo = TARGET_SIGFPE; 375 info.si_errno = 0; 376 info.si_code = TARGET_FPE_INTDIV; 377 info._sifields._sigfault._addr = env->eip; 378 queue_signal(env, info.si_signo, &info); 379 } 380 break; 381 case EXCP01_DB: 382 case EXCP03_INT3: 383 #ifndef TARGET_X86_64 384 if (env->eflags & VM_MASK) { 385 handle_vm86_trap(env, trapnr); 386 } else 387 #endif 388 { 389 info.si_signo = TARGET_SIGTRAP; 390 info.si_errno = 0; 391 if (trapnr == EXCP01_DB) { 392 info.si_code = TARGET_TRAP_BRKPT; 393 info._sifields._sigfault._addr = env->eip; 394 } else { 395 info.si_code = TARGET_SI_KERNEL; 396 info._sifields._sigfault._addr = 0; 397 } 398 queue_signal(env, info.si_signo, &info); 399 } 400 break; 401 case EXCP04_INTO: 402 case EXCP05_BOUND: 403 #ifndef TARGET_X86_64 404 if (env->eflags & VM_MASK) { 405 handle_vm86_trap(env, trapnr); 406 } else 407 #endif 408 { 409 info.si_signo = TARGET_SIGSEGV; 410 info.si_errno = 0; 411 info.si_code = TARGET_SI_KERNEL; 412 info._sifields._sigfault._addr = 0; 413 queue_signal(env, info.si_signo, &info); 414 } 415 break; 416 case EXCP06_ILLOP: 417 info.si_signo = TARGET_SIGILL; 418 info.si_errno = 0; 419 info.si_code = TARGET_ILL_ILLOPN; 420 info._sifields._sigfault._addr = env->eip; 421 queue_signal(env, info.si_signo, &info); 422 break; 423 case EXCP_INTERRUPT: 424 /* just indicate that signals should be handled asap */ 425 break; 426 case EXCP_DEBUG: 427 { 428 int sig; 429 430 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 431 if (sig) 432 { 433 info.si_signo = sig; 434 info.si_errno = 0; 435 info.si_code = TARGET_TRAP_BRKPT; 436 queue_signal(env, info.si_signo, &info); 437 } 438 } 439 break; 440 default: 441 pc = env->segs[R_CS].base + env->eip; 442 EXCP_DUMP(env, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n", 443 (long)pc, trapnr); 444 abort(); 445 } 446 process_pending_signals(env); 447 } 448 } 449 #endif 450 451 #ifdef TARGET_ARM 452 453 #define get_user_code_u32(x, gaddr, env) \ 454 ({ abi_long __r = get_user_u32((x), (gaddr)); \ 455 if (!__r && bswap_code(arm_sctlr_b(env))) { \ 456 (x) = bswap32(x); \ 457 } \ 458 __r; \ 459 }) 460 461 #define get_user_code_u16(x, gaddr, env) \ 462 ({ abi_long __r = get_user_u16((x), (gaddr)); \ 463 if (!__r && bswap_code(arm_sctlr_b(env))) { \ 464 (x) = bswap16(x); \ 465 } \ 466 __r; \ 467 }) 468 469 #define get_user_data_u32(x, gaddr, env) \ 470 ({ abi_long __r = get_user_u32((x), (gaddr)); \ 471 if (!__r && arm_cpu_bswap_data(env)) { \ 472 (x) = bswap32(x); \ 473 } \ 474 __r; \ 475 }) 476 477 #define get_user_data_u16(x, gaddr, env) \ 478 ({ abi_long __r = get_user_u16((x), (gaddr)); \ 479 if (!__r && arm_cpu_bswap_data(env)) { \ 480 (x) = bswap16(x); \ 481 } \ 482 __r; \ 483 }) 484 485 #define put_user_data_u32(x, gaddr, env) \ 486 ({ typeof(x) __x = (x); \ 487 if (arm_cpu_bswap_data(env)) { \ 488 __x = bswap32(__x); \ 489 } \ 490 put_user_u32(__x, (gaddr)); \ 491 }) 492 493 #define put_user_data_u16(x, gaddr, env) \ 494 ({ typeof(x) __x = (x); \ 495 if (arm_cpu_bswap_data(env)) { \ 496 __x = bswap16(__x); \ 497 } \ 498 put_user_u16(__x, (gaddr)); \ 499 }) 500 501 #ifdef TARGET_ABI32 502 /* Commpage handling -- there is no commpage for AArch64 */ 503 504 /* 505 * See the Linux kernel's Documentation/arm/kernel_user_helpers.txt 506 * Input: 507 * r0 = pointer to oldval 508 * r1 = pointer to newval 509 * r2 = pointer to target value 510 * 511 * Output: 512 * r0 = 0 if *ptr was changed, non-0 if no exchange happened 513 * C set if *ptr was changed, clear if no exchange happened 514 * 515 * Note segv's in kernel helpers are a bit tricky, we can set the 516 * data address sensibly but the PC address is just the entry point. 517 */ 518 static void arm_kernel_cmpxchg64_helper(CPUARMState *env) 519 { 520 uint64_t oldval, newval, val; 521 uint32_t addr, cpsr; 522 target_siginfo_t info; 523 524 /* Based on the 32 bit code in do_kernel_trap */ 525 526 /* XXX: This only works between threads, not between processes. 527 It's probably possible to implement this with native host 528 operations. However things like ldrex/strex are much harder so 529 there's not much point trying. */ 530 start_exclusive(); 531 cpsr = cpsr_read(env); 532 addr = env->regs[2]; 533 534 if (get_user_u64(oldval, env->regs[0])) { 535 env->exception.vaddress = env->regs[0]; 536 goto segv; 537 }; 538 539 if (get_user_u64(newval, env->regs[1])) { 540 env->exception.vaddress = env->regs[1]; 541 goto segv; 542 }; 543 544 if (get_user_u64(val, addr)) { 545 env->exception.vaddress = addr; 546 goto segv; 547 } 548 549 if (val == oldval) { 550 val = newval; 551 552 if (put_user_u64(val, addr)) { 553 env->exception.vaddress = addr; 554 goto segv; 555 }; 556 557 env->regs[0] = 0; 558 cpsr |= CPSR_C; 559 } else { 560 env->regs[0] = -1; 561 cpsr &= ~CPSR_C; 562 } 563 cpsr_write(env, cpsr, CPSR_C, CPSRWriteByInstr); 564 end_exclusive(); 565 return; 566 567 segv: 568 end_exclusive(); 569 /* We get the PC of the entry address - which is as good as anything, 570 on a real kernel what you get depends on which mode it uses. */ 571 info.si_signo = TARGET_SIGSEGV; 572 info.si_errno = 0; 573 /* XXX: check env->error_code */ 574 info.si_code = TARGET_SEGV_MAPERR; 575 info._sifields._sigfault._addr = env->exception.vaddress; 576 queue_signal(env, info.si_signo, &info); 577 } 578 579 /* Handle a jump to the kernel code page. */ 580 static int 581 do_kernel_trap(CPUARMState *env) 582 { 583 uint32_t addr; 584 uint32_t cpsr; 585 uint32_t val; 586 587 switch (env->regs[15]) { 588 case 0xffff0fa0: /* __kernel_memory_barrier */ 589 /* ??? No-op. Will need to do better for SMP. */ 590 break; 591 case 0xffff0fc0: /* __kernel_cmpxchg */ 592 /* XXX: This only works between threads, not between processes. 593 It's probably possible to implement this with native host 594 operations. However things like ldrex/strex are much harder so 595 there's not much point trying. */ 596 start_exclusive(); 597 cpsr = cpsr_read(env); 598 addr = env->regs[2]; 599 /* FIXME: This should SEGV if the access fails. */ 600 if (get_user_u32(val, addr)) 601 val = ~env->regs[0]; 602 if (val == env->regs[0]) { 603 val = env->regs[1]; 604 /* FIXME: Check for segfaults. */ 605 put_user_u32(val, addr); 606 env->regs[0] = 0; 607 cpsr |= CPSR_C; 608 } else { 609 env->regs[0] = -1; 610 cpsr &= ~CPSR_C; 611 } 612 cpsr_write(env, cpsr, CPSR_C, CPSRWriteByInstr); 613 end_exclusive(); 614 break; 615 case 0xffff0fe0: /* __kernel_get_tls */ 616 env->regs[0] = cpu_get_tls(env); 617 break; 618 case 0xffff0f60: /* __kernel_cmpxchg64 */ 619 arm_kernel_cmpxchg64_helper(env); 620 break; 621 622 default: 623 return 1; 624 } 625 /* Jump back to the caller. */ 626 addr = env->regs[14]; 627 if (addr & 1) { 628 env->thumb = 1; 629 addr &= ~1; 630 } 631 env->regs[15] = addr; 632 633 return 0; 634 } 635 636 /* Store exclusive handling for AArch32 */ 637 static int do_strex(CPUARMState *env) 638 { 639 uint64_t val; 640 int size; 641 int rc = 1; 642 int segv = 0; 643 uint32_t addr; 644 start_exclusive(); 645 if (env->exclusive_addr != env->exclusive_test) { 646 goto fail; 647 } 648 /* We know we're always AArch32 so the address is in uint32_t range 649 * unless it was the -1 exclusive-monitor-lost value (which won't 650 * match exclusive_test above). 651 */ 652 assert(extract64(env->exclusive_addr, 32, 32) == 0); 653 addr = env->exclusive_addr; 654 size = env->exclusive_info & 0xf; 655 switch (size) { 656 case 0: 657 segv = get_user_u8(val, addr); 658 break; 659 case 1: 660 segv = get_user_data_u16(val, addr, env); 661 break; 662 case 2: 663 case 3: 664 segv = get_user_data_u32(val, addr, env); 665 break; 666 default: 667 abort(); 668 } 669 if (segv) { 670 env->exception.vaddress = addr; 671 goto done; 672 } 673 if (size == 3) { 674 uint32_t valhi; 675 segv = get_user_data_u32(valhi, addr + 4, env); 676 if (segv) { 677 env->exception.vaddress = addr + 4; 678 goto done; 679 } 680 if (arm_cpu_bswap_data(env)) { 681 val = deposit64((uint64_t)valhi, 32, 32, val); 682 } else { 683 val = deposit64(val, 32, 32, valhi); 684 } 685 } 686 if (val != env->exclusive_val) { 687 goto fail; 688 } 689 690 val = env->regs[(env->exclusive_info >> 8) & 0xf]; 691 switch (size) { 692 case 0: 693 segv = put_user_u8(val, addr); 694 break; 695 case 1: 696 segv = put_user_data_u16(val, addr, env); 697 break; 698 case 2: 699 case 3: 700 segv = put_user_data_u32(val, addr, env); 701 break; 702 } 703 if (segv) { 704 env->exception.vaddress = addr; 705 goto done; 706 } 707 if (size == 3) { 708 val = env->regs[(env->exclusive_info >> 12) & 0xf]; 709 segv = put_user_data_u32(val, addr + 4, env); 710 if (segv) { 711 env->exception.vaddress = addr + 4; 712 goto done; 713 } 714 } 715 rc = 0; 716 fail: 717 env->regs[15] += 4; 718 env->regs[(env->exclusive_info >> 4) & 0xf] = rc; 719 done: 720 end_exclusive(); 721 return segv; 722 } 723 724 void cpu_loop(CPUARMState *env) 725 { 726 CPUState *cs = CPU(arm_env_get_cpu(env)); 727 int trapnr; 728 unsigned int n, insn; 729 target_siginfo_t info; 730 uint32_t addr; 731 abi_ulong ret; 732 733 for(;;) { 734 cpu_exec_start(cs); 735 trapnr = cpu_exec(cs); 736 cpu_exec_end(cs); 737 switch(trapnr) { 738 case EXCP_UDEF: 739 { 740 TaskState *ts = cs->opaque; 741 uint32_t opcode; 742 int rc; 743 744 /* we handle the FPU emulation here, as Linux */ 745 /* we get the opcode */ 746 /* FIXME - what to do if get_user() fails? */ 747 get_user_code_u32(opcode, env->regs[15], env); 748 749 rc = EmulateAll(opcode, &ts->fpa, env); 750 if (rc == 0) { /* illegal instruction */ 751 info.si_signo = TARGET_SIGILL; 752 info.si_errno = 0; 753 info.si_code = TARGET_ILL_ILLOPN; 754 info._sifields._sigfault._addr = env->regs[15]; 755 queue_signal(env, info.si_signo, &info); 756 } else if (rc < 0) { /* FP exception */ 757 int arm_fpe=0; 758 759 /* translate softfloat flags to FPSR flags */ 760 if (-rc & float_flag_invalid) 761 arm_fpe |= BIT_IOC; 762 if (-rc & float_flag_divbyzero) 763 arm_fpe |= BIT_DZC; 764 if (-rc & float_flag_overflow) 765 arm_fpe |= BIT_OFC; 766 if (-rc & float_flag_underflow) 767 arm_fpe |= BIT_UFC; 768 if (-rc & float_flag_inexact) 769 arm_fpe |= BIT_IXC; 770 771 FPSR fpsr = ts->fpa.fpsr; 772 //printf("fpsr 0x%x, arm_fpe 0x%x\n",fpsr,arm_fpe); 773 774 if (fpsr & (arm_fpe << 16)) { /* exception enabled? */ 775 info.si_signo = TARGET_SIGFPE; 776 info.si_errno = 0; 777 778 /* ordered by priority, least first */ 779 if (arm_fpe & BIT_IXC) info.si_code = TARGET_FPE_FLTRES; 780 if (arm_fpe & BIT_UFC) info.si_code = TARGET_FPE_FLTUND; 781 if (arm_fpe & BIT_OFC) info.si_code = TARGET_FPE_FLTOVF; 782 if (arm_fpe & BIT_DZC) info.si_code = TARGET_FPE_FLTDIV; 783 if (arm_fpe & BIT_IOC) info.si_code = TARGET_FPE_FLTINV; 784 785 info._sifields._sigfault._addr = env->regs[15]; 786 queue_signal(env, info.si_signo, &info); 787 } else { 788 env->regs[15] += 4; 789 } 790 791 /* accumulate unenabled exceptions */ 792 if ((!(fpsr & BIT_IXE)) && (arm_fpe & BIT_IXC)) 793 fpsr |= BIT_IXC; 794 if ((!(fpsr & BIT_UFE)) && (arm_fpe & BIT_UFC)) 795 fpsr |= BIT_UFC; 796 if ((!(fpsr & BIT_OFE)) && (arm_fpe & BIT_OFC)) 797 fpsr |= BIT_OFC; 798 if ((!(fpsr & BIT_DZE)) && (arm_fpe & BIT_DZC)) 799 fpsr |= BIT_DZC; 800 if ((!(fpsr & BIT_IOE)) && (arm_fpe & BIT_IOC)) 801 fpsr |= BIT_IOC; 802 ts->fpa.fpsr=fpsr; 803 } else { /* everything OK */ 804 /* increment PC */ 805 env->regs[15] += 4; 806 } 807 } 808 break; 809 case EXCP_SWI: 810 case EXCP_BKPT: 811 { 812 env->eabi = 1; 813 /* system call */ 814 if (trapnr == EXCP_BKPT) { 815 if (env->thumb) { 816 /* FIXME - what to do if get_user() fails? */ 817 get_user_code_u16(insn, env->regs[15], env); 818 n = insn & 0xff; 819 env->regs[15] += 2; 820 } else { 821 /* FIXME - what to do if get_user() fails? */ 822 get_user_code_u32(insn, env->regs[15], env); 823 n = (insn & 0xf) | ((insn >> 4) & 0xff0); 824 env->regs[15] += 4; 825 } 826 } else { 827 if (env->thumb) { 828 /* FIXME - what to do if get_user() fails? */ 829 get_user_code_u16(insn, env->regs[15] - 2, env); 830 n = insn & 0xff; 831 } else { 832 /* FIXME - what to do if get_user() fails? */ 833 get_user_code_u32(insn, env->regs[15] - 4, env); 834 n = insn & 0xffffff; 835 } 836 } 837 838 if (n == ARM_NR_cacheflush) { 839 /* nop */ 840 } else if (n == ARM_NR_semihosting 841 || n == ARM_NR_thumb_semihosting) { 842 env->regs[0] = do_arm_semihosting (env); 843 } else if (n == 0 || n >= ARM_SYSCALL_BASE || env->thumb) { 844 /* linux syscall */ 845 if (env->thumb || n == 0) { 846 n = env->regs[7]; 847 } else { 848 n -= ARM_SYSCALL_BASE; 849 env->eabi = 0; 850 } 851 if ( n > ARM_NR_BASE) { 852 switch (n) { 853 case ARM_NR_cacheflush: 854 /* nop */ 855 break; 856 case ARM_NR_set_tls: 857 cpu_set_tls(env, env->regs[0]); 858 env->regs[0] = 0; 859 break; 860 case ARM_NR_breakpoint: 861 env->regs[15] -= env->thumb ? 2 : 4; 862 goto excp_debug; 863 default: 864 gemu_log("qemu: Unsupported ARM syscall: 0x%x\n", 865 n); 866 env->regs[0] = -TARGET_ENOSYS; 867 break; 868 } 869 } else { 870 ret = do_syscall(env, 871 n, 872 env->regs[0], 873 env->regs[1], 874 env->regs[2], 875 env->regs[3], 876 env->regs[4], 877 env->regs[5], 878 0, 0); 879 if (ret == -TARGET_ERESTARTSYS) { 880 env->regs[15] -= env->thumb ? 2 : 4; 881 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 882 env->regs[0] = ret; 883 } 884 } 885 } else { 886 goto error; 887 } 888 } 889 break; 890 case EXCP_INTERRUPT: 891 /* just indicate that signals should be handled asap */ 892 break; 893 case EXCP_STREX: 894 if (!do_strex(env)) { 895 break; 896 } 897 /* fall through for segv */ 898 case EXCP_PREFETCH_ABORT: 899 case EXCP_DATA_ABORT: 900 addr = env->exception.vaddress; 901 { 902 info.si_signo = TARGET_SIGSEGV; 903 info.si_errno = 0; 904 /* XXX: check env->error_code */ 905 info.si_code = TARGET_SEGV_MAPERR; 906 info._sifields._sigfault._addr = addr; 907 queue_signal(env, info.si_signo, &info); 908 } 909 break; 910 case EXCP_DEBUG: 911 excp_debug: 912 { 913 int sig; 914 915 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 916 if (sig) 917 { 918 info.si_signo = sig; 919 info.si_errno = 0; 920 info.si_code = TARGET_TRAP_BRKPT; 921 queue_signal(env, info.si_signo, &info); 922 } 923 } 924 break; 925 case EXCP_KERNEL_TRAP: 926 if (do_kernel_trap(env)) 927 goto error; 928 break; 929 case EXCP_YIELD: 930 /* nothing to do here for user-mode, just resume guest code */ 931 break; 932 default: 933 error: 934 EXCP_DUMP(env, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr); 935 abort(); 936 } 937 process_pending_signals(env); 938 } 939 } 940 941 #else 942 943 /* 944 * Handle AArch64 store-release exclusive 945 * 946 * rs = gets the status result of store exclusive 947 * rt = is the register that is stored 948 * rt2 = is the second register store (in STP) 949 * 950 */ 951 static int do_strex_a64(CPUARMState *env) 952 { 953 uint64_t val; 954 int size; 955 bool is_pair; 956 int rc = 1; 957 int segv = 0; 958 uint64_t addr; 959 int rs, rt, rt2; 960 961 start_exclusive(); 962 /* size | is_pair << 2 | (rs << 4) | (rt << 9) | (rt2 << 14)); */ 963 size = extract32(env->exclusive_info, 0, 2); 964 is_pair = extract32(env->exclusive_info, 2, 1); 965 rs = extract32(env->exclusive_info, 4, 5); 966 rt = extract32(env->exclusive_info, 9, 5); 967 rt2 = extract32(env->exclusive_info, 14, 5); 968 969 addr = env->exclusive_addr; 970 971 if (addr != env->exclusive_test) { 972 goto finish; 973 } 974 975 switch (size) { 976 case 0: 977 segv = get_user_u8(val, addr); 978 break; 979 case 1: 980 segv = get_user_u16(val, addr); 981 break; 982 case 2: 983 segv = get_user_u32(val, addr); 984 break; 985 case 3: 986 segv = get_user_u64(val, addr); 987 break; 988 default: 989 abort(); 990 } 991 if (segv) { 992 env->exception.vaddress = addr; 993 goto error; 994 } 995 if (val != env->exclusive_val) { 996 goto finish; 997 } 998 if (is_pair) { 999 if (size == 2) { 1000 segv = get_user_u32(val, addr + 4); 1001 } else { 1002 segv = get_user_u64(val, addr + 8); 1003 } 1004 if (segv) { 1005 env->exception.vaddress = addr + (size == 2 ? 4 : 8); 1006 goto error; 1007 } 1008 if (val != env->exclusive_high) { 1009 goto finish; 1010 } 1011 } 1012 /* handle the zero register */ 1013 val = rt == 31 ? 0 : env->xregs[rt]; 1014 switch (size) { 1015 case 0: 1016 segv = put_user_u8(val, addr); 1017 break; 1018 case 1: 1019 segv = put_user_u16(val, addr); 1020 break; 1021 case 2: 1022 segv = put_user_u32(val, addr); 1023 break; 1024 case 3: 1025 segv = put_user_u64(val, addr); 1026 break; 1027 } 1028 if (segv) { 1029 goto error; 1030 } 1031 if (is_pair) { 1032 /* handle the zero register */ 1033 val = rt2 == 31 ? 0 : env->xregs[rt2]; 1034 if (size == 2) { 1035 segv = put_user_u32(val, addr + 4); 1036 } else { 1037 segv = put_user_u64(val, addr + 8); 1038 } 1039 if (segv) { 1040 env->exception.vaddress = addr + (size == 2 ? 4 : 8); 1041 goto error; 1042 } 1043 } 1044 rc = 0; 1045 finish: 1046 env->pc += 4; 1047 /* rs == 31 encodes a write to the ZR, thus throwing away 1048 * the status return. This is rather silly but valid. 1049 */ 1050 if (rs < 31) { 1051 env->xregs[rs] = rc; 1052 } 1053 error: 1054 /* instruction faulted, PC does not advance */ 1055 /* either way a strex releases any exclusive lock we have */ 1056 env->exclusive_addr = -1; 1057 end_exclusive(); 1058 return segv; 1059 } 1060 1061 /* AArch64 main loop */ 1062 void cpu_loop(CPUARMState *env) 1063 { 1064 CPUState *cs = CPU(arm_env_get_cpu(env)); 1065 int trapnr, sig; 1066 abi_long ret; 1067 target_siginfo_t info; 1068 1069 for (;;) { 1070 cpu_exec_start(cs); 1071 trapnr = cpu_exec(cs); 1072 cpu_exec_end(cs); 1073 1074 switch (trapnr) { 1075 case EXCP_SWI: 1076 ret = do_syscall(env, 1077 env->xregs[8], 1078 env->xregs[0], 1079 env->xregs[1], 1080 env->xregs[2], 1081 env->xregs[3], 1082 env->xregs[4], 1083 env->xregs[5], 1084 0, 0); 1085 if (ret == -TARGET_ERESTARTSYS) { 1086 env->pc -= 4; 1087 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 1088 env->xregs[0] = ret; 1089 } 1090 break; 1091 case EXCP_INTERRUPT: 1092 /* just indicate that signals should be handled asap */ 1093 break; 1094 case EXCP_UDEF: 1095 info.si_signo = TARGET_SIGILL; 1096 info.si_errno = 0; 1097 info.si_code = TARGET_ILL_ILLOPN; 1098 info._sifields._sigfault._addr = env->pc; 1099 queue_signal(env, info.si_signo, &info); 1100 break; 1101 case EXCP_STREX: 1102 if (!do_strex_a64(env)) { 1103 break; 1104 } 1105 /* fall through for segv */ 1106 case EXCP_PREFETCH_ABORT: 1107 case EXCP_DATA_ABORT: 1108 info.si_signo = TARGET_SIGSEGV; 1109 info.si_errno = 0; 1110 /* XXX: check env->error_code */ 1111 info.si_code = TARGET_SEGV_MAPERR; 1112 info._sifields._sigfault._addr = env->exception.vaddress; 1113 queue_signal(env, info.si_signo, &info); 1114 break; 1115 case EXCP_DEBUG: 1116 case EXCP_BKPT: 1117 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 1118 if (sig) { 1119 info.si_signo = sig; 1120 info.si_errno = 0; 1121 info.si_code = TARGET_TRAP_BRKPT; 1122 queue_signal(env, info.si_signo, &info); 1123 } 1124 break; 1125 case EXCP_SEMIHOST: 1126 env->xregs[0] = do_arm_semihosting(env); 1127 break; 1128 case EXCP_YIELD: 1129 /* nothing to do here for user-mode, just resume guest code */ 1130 break; 1131 default: 1132 EXCP_DUMP(env, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr); 1133 abort(); 1134 } 1135 process_pending_signals(env); 1136 /* Exception return on AArch64 always clears the exclusive monitor, 1137 * so any return to running guest code implies this. 1138 * A strex (successful or otherwise) also clears the monitor, so 1139 * we don't need to specialcase EXCP_STREX. 1140 */ 1141 env->exclusive_addr = -1; 1142 } 1143 } 1144 #endif /* ndef TARGET_ABI32 */ 1145 1146 #endif 1147 1148 #ifdef TARGET_UNICORE32 1149 1150 void cpu_loop(CPUUniCore32State *env) 1151 { 1152 CPUState *cs = CPU(uc32_env_get_cpu(env)); 1153 int trapnr; 1154 unsigned int n, insn; 1155 target_siginfo_t info; 1156 1157 for (;;) { 1158 cpu_exec_start(cs); 1159 trapnr = cpu_exec(cs); 1160 cpu_exec_end(cs); 1161 switch (trapnr) { 1162 case UC32_EXCP_PRIV: 1163 { 1164 /* system call */ 1165 get_user_u32(insn, env->regs[31] - 4); 1166 n = insn & 0xffffff; 1167 1168 if (n >= UC32_SYSCALL_BASE) { 1169 /* linux syscall */ 1170 n -= UC32_SYSCALL_BASE; 1171 if (n == UC32_SYSCALL_NR_set_tls) { 1172 cpu_set_tls(env, env->regs[0]); 1173 env->regs[0] = 0; 1174 } else { 1175 abi_long ret = do_syscall(env, 1176 n, 1177 env->regs[0], 1178 env->regs[1], 1179 env->regs[2], 1180 env->regs[3], 1181 env->regs[4], 1182 env->regs[5], 1183 0, 0); 1184 if (ret == -TARGET_ERESTARTSYS) { 1185 env->regs[31] -= 4; 1186 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 1187 env->regs[0] = ret; 1188 } 1189 } 1190 } else { 1191 goto error; 1192 } 1193 } 1194 break; 1195 case UC32_EXCP_DTRAP: 1196 case UC32_EXCP_ITRAP: 1197 info.si_signo = TARGET_SIGSEGV; 1198 info.si_errno = 0; 1199 /* XXX: check env->error_code */ 1200 info.si_code = TARGET_SEGV_MAPERR; 1201 info._sifields._sigfault._addr = env->cp0.c4_faultaddr; 1202 queue_signal(env, info.si_signo, &info); 1203 break; 1204 case EXCP_INTERRUPT: 1205 /* just indicate that signals should be handled asap */ 1206 break; 1207 case EXCP_DEBUG: 1208 { 1209 int sig; 1210 1211 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 1212 if (sig) { 1213 info.si_signo = sig; 1214 info.si_errno = 0; 1215 info.si_code = TARGET_TRAP_BRKPT; 1216 queue_signal(env, info.si_signo, &info); 1217 } 1218 } 1219 break; 1220 default: 1221 goto error; 1222 } 1223 process_pending_signals(env); 1224 } 1225 1226 error: 1227 EXCP_DUMP(env, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr); 1228 abort(); 1229 } 1230 #endif 1231 1232 #ifdef TARGET_SPARC 1233 #define SPARC64_STACK_BIAS 2047 1234 1235 //#define DEBUG_WIN 1236 1237 /* WARNING: dealing with register windows _is_ complicated. More info 1238 can be found at http://www.sics.se/~psm/sparcstack.html */ 1239 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index) 1240 { 1241 index = (index + cwp * 16) % (16 * env->nwindows); 1242 /* wrap handling : if cwp is on the last window, then we use the 1243 registers 'after' the end */ 1244 if (index < 8 && env->cwp == env->nwindows - 1) 1245 index += 16 * env->nwindows; 1246 return index; 1247 } 1248 1249 /* save the register window 'cwp1' */ 1250 static inline void save_window_offset(CPUSPARCState *env, int cwp1) 1251 { 1252 unsigned int i; 1253 abi_ulong sp_ptr; 1254 1255 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 1256 #ifdef TARGET_SPARC64 1257 if (sp_ptr & 3) 1258 sp_ptr += SPARC64_STACK_BIAS; 1259 #endif 1260 #if defined(DEBUG_WIN) 1261 printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n", 1262 sp_ptr, cwp1); 1263 #endif 1264 for(i = 0; i < 16; i++) { 1265 /* FIXME - what to do if put_user() fails? */ 1266 put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 1267 sp_ptr += sizeof(abi_ulong); 1268 } 1269 } 1270 1271 static void save_window(CPUSPARCState *env) 1272 { 1273 #ifndef TARGET_SPARC64 1274 unsigned int new_wim; 1275 new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) & 1276 ((1LL << env->nwindows) - 1); 1277 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2)); 1278 env->wim = new_wim; 1279 #else 1280 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2)); 1281 env->cansave++; 1282 env->canrestore--; 1283 #endif 1284 } 1285 1286 static void restore_window(CPUSPARCState *env) 1287 { 1288 #ifndef TARGET_SPARC64 1289 unsigned int new_wim; 1290 #endif 1291 unsigned int i, cwp1; 1292 abi_ulong sp_ptr; 1293 1294 #ifndef TARGET_SPARC64 1295 new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) & 1296 ((1LL << env->nwindows) - 1); 1297 #endif 1298 1299 /* restore the invalid window */ 1300 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 1301 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)]; 1302 #ifdef TARGET_SPARC64 1303 if (sp_ptr & 3) 1304 sp_ptr += SPARC64_STACK_BIAS; 1305 #endif 1306 #if defined(DEBUG_WIN) 1307 printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n", 1308 sp_ptr, cwp1); 1309 #endif 1310 for(i = 0; i < 16; i++) { 1311 /* FIXME - what to do if get_user() fails? */ 1312 get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr); 1313 sp_ptr += sizeof(abi_ulong); 1314 } 1315 #ifdef TARGET_SPARC64 1316 env->canrestore++; 1317 if (env->cleanwin < env->nwindows - 1) 1318 env->cleanwin++; 1319 env->cansave--; 1320 #else 1321 env->wim = new_wim; 1322 #endif 1323 } 1324 1325 static void flush_windows(CPUSPARCState *env) 1326 { 1327 int offset, cwp1; 1328 1329 offset = 1; 1330 for(;;) { 1331 /* if restore would invoke restore_window(), then we can stop */ 1332 cwp1 = cpu_cwp_inc(env, env->cwp + offset); 1333 #ifndef TARGET_SPARC64 1334 if (env->wim & (1 << cwp1)) 1335 break; 1336 #else 1337 if (env->canrestore == 0) 1338 break; 1339 env->cansave++; 1340 env->canrestore--; 1341 #endif 1342 save_window_offset(env, cwp1); 1343 offset++; 1344 } 1345 cwp1 = cpu_cwp_inc(env, env->cwp + 1); 1346 #ifndef TARGET_SPARC64 1347 /* set wim so that restore will reload the registers */ 1348 env->wim = 1 << cwp1; 1349 #endif 1350 #if defined(DEBUG_WIN) 1351 printf("flush_windows: nb=%d\n", offset - 1); 1352 #endif 1353 } 1354 1355 void cpu_loop (CPUSPARCState *env) 1356 { 1357 CPUState *cs = CPU(sparc_env_get_cpu(env)); 1358 int trapnr; 1359 abi_long ret; 1360 target_siginfo_t info; 1361 1362 while (1) { 1363 cpu_exec_start(cs); 1364 trapnr = cpu_exec(cs); 1365 cpu_exec_end(cs); 1366 1367 /* Compute PSR before exposing state. */ 1368 if (env->cc_op != CC_OP_FLAGS) { 1369 cpu_get_psr(env); 1370 } 1371 1372 switch (trapnr) { 1373 #ifndef TARGET_SPARC64 1374 case 0x88: 1375 case 0x90: 1376 #else 1377 case 0x110: 1378 case 0x16d: 1379 #endif 1380 ret = do_syscall (env, env->gregs[1], 1381 env->regwptr[0], env->regwptr[1], 1382 env->regwptr[2], env->regwptr[3], 1383 env->regwptr[4], env->regwptr[5], 1384 0, 0); 1385 if (ret == -TARGET_ERESTARTSYS || ret == -TARGET_QEMU_ESIGRETURN) { 1386 break; 1387 } 1388 if ((abi_ulong)ret >= (abi_ulong)(-515)) { 1389 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 1390 env->xcc |= PSR_CARRY; 1391 #else 1392 env->psr |= PSR_CARRY; 1393 #endif 1394 ret = -ret; 1395 } else { 1396 #if defined(TARGET_SPARC64) && !defined(TARGET_ABI32) 1397 env->xcc &= ~PSR_CARRY; 1398 #else 1399 env->psr &= ~PSR_CARRY; 1400 #endif 1401 } 1402 env->regwptr[0] = ret; 1403 /* next instruction */ 1404 env->pc = env->npc; 1405 env->npc = env->npc + 4; 1406 break; 1407 case 0x83: /* flush windows */ 1408 #ifdef TARGET_ABI32 1409 case 0x103: 1410 #endif 1411 flush_windows(env); 1412 /* next instruction */ 1413 env->pc = env->npc; 1414 env->npc = env->npc + 4; 1415 break; 1416 #ifndef TARGET_SPARC64 1417 case TT_WIN_OVF: /* window overflow */ 1418 save_window(env); 1419 break; 1420 case TT_WIN_UNF: /* window underflow */ 1421 restore_window(env); 1422 break; 1423 case TT_TFAULT: 1424 case TT_DFAULT: 1425 { 1426 info.si_signo = TARGET_SIGSEGV; 1427 info.si_errno = 0; 1428 /* XXX: check env->error_code */ 1429 info.si_code = TARGET_SEGV_MAPERR; 1430 info._sifields._sigfault._addr = env->mmuregs[4]; 1431 queue_signal(env, info.si_signo, &info); 1432 } 1433 break; 1434 #else 1435 case TT_SPILL: /* window overflow */ 1436 save_window(env); 1437 break; 1438 case TT_FILL: /* window underflow */ 1439 restore_window(env); 1440 break; 1441 case TT_TFAULT: 1442 case TT_DFAULT: 1443 { 1444 info.si_signo = TARGET_SIGSEGV; 1445 info.si_errno = 0; 1446 /* XXX: check env->error_code */ 1447 info.si_code = TARGET_SEGV_MAPERR; 1448 if (trapnr == TT_DFAULT) 1449 info._sifields._sigfault._addr = env->dmmuregs[4]; 1450 else 1451 info._sifields._sigfault._addr = cpu_tsptr(env)->tpc; 1452 queue_signal(env, info.si_signo, &info); 1453 } 1454 break; 1455 #ifndef TARGET_ABI32 1456 case 0x16e: 1457 flush_windows(env); 1458 sparc64_get_context(env); 1459 break; 1460 case 0x16f: 1461 flush_windows(env); 1462 sparc64_set_context(env); 1463 break; 1464 #endif 1465 #endif 1466 case EXCP_INTERRUPT: 1467 /* just indicate that signals should be handled asap */ 1468 break; 1469 case TT_ILL_INSN: 1470 { 1471 info.si_signo = TARGET_SIGILL; 1472 info.si_errno = 0; 1473 info.si_code = TARGET_ILL_ILLOPC; 1474 info._sifields._sigfault._addr = env->pc; 1475 queue_signal(env, info.si_signo, &info); 1476 } 1477 break; 1478 case EXCP_DEBUG: 1479 { 1480 int sig; 1481 1482 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 1483 if (sig) 1484 { 1485 info.si_signo = sig; 1486 info.si_errno = 0; 1487 info.si_code = TARGET_TRAP_BRKPT; 1488 queue_signal(env, info.si_signo, &info); 1489 } 1490 } 1491 break; 1492 default: 1493 printf ("Unhandled trap: 0x%x\n", trapnr); 1494 cpu_dump_state(cs, stderr, fprintf, 0); 1495 exit(EXIT_FAILURE); 1496 } 1497 process_pending_signals (env); 1498 } 1499 } 1500 1501 #endif 1502 1503 #ifdef TARGET_PPC 1504 static inline uint64_t cpu_ppc_get_tb(CPUPPCState *env) 1505 { 1506 return cpu_get_host_ticks(); 1507 } 1508 1509 uint64_t cpu_ppc_load_tbl(CPUPPCState *env) 1510 { 1511 return cpu_ppc_get_tb(env); 1512 } 1513 1514 uint32_t cpu_ppc_load_tbu(CPUPPCState *env) 1515 { 1516 return cpu_ppc_get_tb(env) >> 32; 1517 } 1518 1519 uint64_t cpu_ppc_load_atbl(CPUPPCState *env) 1520 { 1521 return cpu_ppc_get_tb(env); 1522 } 1523 1524 uint32_t cpu_ppc_load_atbu(CPUPPCState *env) 1525 { 1526 return cpu_ppc_get_tb(env) >> 32; 1527 } 1528 1529 uint32_t cpu_ppc601_load_rtcu(CPUPPCState *env) 1530 __attribute__ (( alias ("cpu_ppc_load_tbu") )); 1531 1532 uint32_t cpu_ppc601_load_rtcl(CPUPPCState *env) 1533 { 1534 return cpu_ppc_load_tbl(env) & 0x3FFFFF80; 1535 } 1536 1537 /* XXX: to be fixed */ 1538 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp) 1539 { 1540 return -1; 1541 } 1542 1543 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val) 1544 { 1545 return -1; 1546 } 1547 1548 static int do_store_exclusive(CPUPPCState *env) 1549 { 1550 target_ulong addr; 1551 target_ulong page_addr; 1552 target_ulong val, val2 __attribute__((unused)) = 0; 1553 int flags; 1554 int segv = 0; 1555 1556 addr = env->reserve_ea; 1557 page_addr = addr & TARGET_PAGE_MASK; 1558 start_exclusive(); 1559 mmap_lock(); 1560 flags = page_get_flags(page_addr); 1561 if ((flags & PAGE_READ) == 0) { 1562 segv = 1; 1563 } else { 1564 int reg = env->reserve_info & 0x1f; 1565 int size = env->reserve_info >> 5; 1566 int stored = 0; 1567 1568 if (addr == env->reserve_addr) { 1569 switch (size) { 1570 case 1: segv = get_user_u8(val, addr); break; 1571 case 2: segv = get_user_u16(val, addr); break; 1572 case 4: segv = get_user_u32(val, addr); break; 1573 #if defined(TARGET_PPC64) 1574 case 8: segv = get_user_u64(val, addr); break; 1575 case 16: { 1576 segv = get_user_u64(val, addr); 1577 if (!segv) { 1578 segv = get_user_u64(val2, addr + 8); 1579 } 1580 break; 1581 } 1582 #endif 1583 default: abort(); 1584 } 1585 if (!segv && val == env->reserve_val) { 1586 val = env->gpr[reg]; 1587 switch (size) { 1588 case 1: segv = put_user_u8(val, addr); break; 1589 case 2: segv = put_user_u16(val, addr); break; 1590 case 4: segv = put_user_u32(val, addr); break; 1591 #if defined(TARGET_PPC64) 1592 case 8: segv = put_user_u64(val, addr); break; 1593 case 16: { 1594 if (val2 == env->reserve_val2) { 1595 if (msr_le) { 1596 val2 = val; 1597 val = env->gpr[reg+1]; 1598 } else { 1599 val2 = env->gpr[reg+1]; 1600 } 1601 segv = put_user_u64(val, addr); 1602 if (!segv) { 1603 segv = put_user_u64(val2, addr + 8); 1604 } 1605 } 1606 break; 1607 } 1608 #endif 1609 default: abort(); 1610 } 1611 if (!segv) { 1612 stored = 1; 1613 } 1614 } 1615 } 1616 env->crf[0] = (stored << 1) | xer_so; 1617 env->reserve_addr = (target_ulong)-1; 1618 } 1619 if (!segv) { 1620 env->nip += 4; 1621 } 1622 mmap_unlock(); 1623 end_exclusive(); 1624 return segv; 1625 } 1626 1627 void cpu_loop(CPUPPCState *env) 1628 { 1629 CPUState *cs = CPU(ppc_env_get_cpu(env)); 1630 target_siginfo_t info; 1631 int trapnr; 1632 target_ulong ret; 1633 1634 for(;;) { 1635 cpu_exec_start(cs); 1636 trapnr = cpu_exec(cs); 1637 cpu_exec_end(cs); 1638 switch(trapnr) { 1639 case POWERPC_EXCP_NONE: 1640 /* Just go on */ 1641 break; 1642 case POWERPC_EXCP_CRITICAL: /* Critical input */ 1643 cpu_abort(cs, "Critical interrupt while in user mode. " 1644 "Aborting\n"); 1645 break; 1646 case POWERPC_EXCP_MCHECK: /* Machine check exception */ 1647 cpu_abort(cs, "Machine check exception while in user mode. " 1648 "Aborting\n"); 1649 break; 1650 case POWERPC_EXCP_DSI: /* Data storage exception */ 1651 EXCP_DUMP(env, "Invalid data memory access: 0x" TARGET_FMT_lx "\n", 1652 env->spr[SPR_DAR]); 1653 /* XXX: check this. Seems bugged */ 1654 switch (env->error_code & 0xFF000000) { 1655 case 0x40000000: 1656 info.si_signo = TARGET_SIGSEGV; 1657 info.si_errno = 0; 1658 info.si_code = TARGET_SEGV_MAPERR; 1659 break; 1660 case 0x04000000: 1661 info.si_signo = TARGET_SIGILL; 1662 info.si_errno = 0; 1663 info.si_code = TARGET_ILL_ILLADR; 1664 break; 1665 case 0x08000000: 1666 info.si_signo = TARGET_SIGSEGV; 1667 info.si_errno = 0; 1668 info.si_code = TARGET_SEGV_ACCERR; 1669 break; 1670 default: 1671 /* Let's send a regular segfault... */ 1672 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n", 1673 env->error_code); 1674 info.si_signo = TARGET_SIGSEGV; 1675 info.si_errno = 0; 1676 info.si_code = TARGET_SEGV_MAPERR; 1677 break; 1678 } 1679 info._sifields._sigfault._addr = env->nip; 1680 queue_signal(env, info.si_signo, &info); 1681 break; 1682 case POWERPC_EXCP_ISI: /* Instruction storage exception */ 1683 EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" TARGET_FMT_lx 1684 "\n", env->spr[SPR_SRR0]); 1685 /* XXX: check this */ 1686 switch (env->error_code & 0xFF000000) { 1687 case 0x40000000: 1688 info.si_signo = TARGET_SIGSEGV; 1689 info.si_errno = 0; 1690 info.si_code = TARGET_SEGV_MAPERR; 1691 break; 1692 case 0x10000000: 1693 case 0x08000000: 1694 info.si_signo = TARGET_SIGSEGV; 1695 info.si_errno = 0; 1696 info.si_code = TARGET_SEGV_ACCERR; 1697 break; 1698 default: 1699 /* Let's send a regular segfault... */ 1700 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n", 1701 env->error_code); 1702 info.si_signo = TARGET_SIGSEGV; 1703 info.si_errno = 0; 1704 info.si_code = TARGET_SEGV_MAPERR; 1705 break; 1706 } 1707 info._sifields._sigfault._addr = env->nip - 4; 1708 queue_signal(env, info.si_signo, &info); 1709 break; 1710 case POWERPC_EXCP_EXTERNAL: /* External input */ 1711 cpu_abort(cs, "External interrupt while in user mode. " 1712 "Aborting\n"); 1713 break; 1714 case POWERPC_EXCP_ALIGN: /* Alignment exception */ 1715 EXCP_DUMP(env, "Unaligned memory access\n"); 1716 /* XXX: check this */ 1717 info.si_signo = TARGET_SIGBUS; 1718 info.si_errno = 0; 1719 info.si_code = TARGET_BUS_ADRALN; 1720 info._sifields._sigfault._addr = env->nip; 1721 queue_signal(env, info.si_signo, &info); 1722 break; 1723 case POWERPC_EXCP_PROGRAM: /* Program exception */ 1724 case POWERPC_EXCP_HV_EMU: /* HV emulation */ 1725 /* XXX: check this */ 1726 switch (env->error_code & ~0xF) { 1727 case POWERPC_EXCP_FP: 1728 EXCP_DUMP(env, "Floating point program exception\n"); 1729 info.si_signo = TARGET_SIGFPE; 1730 info.si_errno = 0; 1731 switch (env->error_code & 0xF) { 1732 case POWERPC_EXCP_FP_OX: 1733 info.si_code = TARGET_FPE_FLTOVF; 1734 break; 1735 case POWERPC_EXCP_FP_UX: 1736 info.si_code = TARGET_FPE_FLTUND; 1737 break; 1738 case POWERPC_EXCP_FP_ZX: 1739 case POWERPC_EXCP_FP_VXZDZ: 1740 info.si_code = TARGET_FPE_FLTDIV; 1741 break; 1742 case POWERPC_EXCP_FP_XX: 1743 info.si_code = TARGET_FPE_FLTRES; 1744 break; 1745 case POWERPC_EXCP_FP_VXSOFT: 1746 info.si_code = TARGET_FPE_FLTINV; 1747 break; 1748 case POWERPC_EXCP_FP_VXSNAN: 1749 case POWERPC_EXCP_FP_VXISI: 1750 case POWERPC_EXCP_FP_VXIDI: 1751 case POWERPC_EXCP_FP_VXIMZ: 1752 case POWERPC_EXCP_FP_VXVC: 1753 case POWERPC_EXCP_FP_VXSQRT: 1754 case POWERPC_EXCP_FP_VXCVI: 1755 info.si_code = TARGET_FPE_FLTSUB; 1756 break; 1757 default: 1758 EXCP_DUMP(env, "Unknown floating point exception (%02x)\n", 1759 env->error_code); 1760 break; 1761 } 1762 break; 1763 case POWERPC_EXCP_INVAL: 1764 EXCP_DUMP(env, "Invalid instruction\n"); 1765 info.si_signo = TARGET_SIGILL; 1766 info.si_errno = 0; 1767 switch (env->error_code & 0xF) { 1768 case POWERPC_EXCP_INVAL_INVAL: 1769 info.si_code = TARGET_ILL_ILLOPC; 1770 break; 1771 case POWERPC_EXCP_INVAL_LSWX: 1772 info.si_code = TARGET_ILL_ILLOPN; 1773 break; 1774 case POWERPC_EXCP_INVAL_SPR: 1775 info.si_code = TARGET_ILL_PRVREG; 1776 break; 1777 case POWERPC_EXCP_INVAL_FP: 1778 info.si_code = TARGET_ILL_COPROC; 1779 break; 1780 default: 1781 EXCP_DUMP(env, "Unknown invalid operation (%02x)\n", 1782 env->error_code & 0xF); 1783 info.si_code = TARGET_ILL_ILLADR; 1784 break; 1785 } 1786 break; 1787 case POWERPC_EXCP_PRIV: 1788 EXCP_DUMP(env, "Privilege violation\n"); 1789 info.si_signo = TARGET_SIGILL; 1790 info.si_errno = 0; 1791 switch (env->error_code & 0xF) { 1792 case POWERPC_EXCP_PRIV_OPC: 1793 info.si_code = TARGET_ILL_PRVOPC; 1794 break; 1795 case POWERPC_EXCP_PRIV_REG: 1796 info.si_code = TARGET_ILL_PRVREG; 1797 break; 1798 default: 1799 EXCP_DUMP(env, "Unknown privilege violation (%02x)\n", 1800 env->error_code & 0xF); 1801 info.si_code = TARGET_ILL_PRVOPC; 1802 break; 1803 } 1804 break; 1805 case POWERPC_EXCP_TRAP: 1806 cpu_abort(cs, "Tried to call a TRAP\n"); 1807 break; 1808 default: 1809 /* Should not happen ! */ 1810 cpu_abort(cs, "Unknown program exception (%02x)\n", 1811 env->error_code); 1812 break; 1813 } 1814 info._sifields._sigfault._addr = env->nip - 4; 1815 queue_signal(env, info.si_signo, &info); 1816 break; 1817 case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */ 1818 EXCP_DUMP(env, "No floating point allowed\n"); 1819 info.si_signo = TARGET_SIGILL; 1820 info.si_errno = 0; 1821 info.si_code = TARGET_ILL_COPROC; 1822 info._sifields._sigfault._addr = env->nip - 4; 1823 queue_signal(env, info.si_signo, &info); 1824 break; 1825 case POWERPC_EXCP_SYSCALL: /* System call exception */ 1826 cpu_abort(cs, "Syscall exception while in user mode. " 1827 "Aborting\n"); 1828 break; 1829 case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */ 1830 EXCP_DUMP(env, "No APU instruction allowed\n"); 1831 info.si_signo = TARGET_SIGILL; 1832 info.si_errno = 0; 1833 info.si_code = TARGET_ILL_COPROC; 1834 info._sifields._sigfault._addr = env->nip - 4; 1835 queue_signal(env, info.si_signo, &info); 1836 break; 1837 case POWERPC_EXCP_DECR: /* Decrementer exception */ 1838 cpu_abort(cs, "Decrementer interrupt while in user mode. " 1839 "Aborting\n"); 1840 break; 1841 case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */ 1842 cpu_abort(cs, "Fix interval timer interrupt while in user mode. " 1843 "Aborting\n"); 1844 break; 1845 case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */ 1846 cpu_abort(cs, "Watchdog timer interrupt while in user mode. " 1847 "Aborting\n"); 1848 break; 1849 case POWERPC_EXCP_DTLB: /* Data TLB error */ 1850 cpu_abort(cs, "Data TLB exception while in user mode. " 1851 "Aborting\n"); 1852 break; 1853 case POWERPC_EXCP_ITLB: /* Instruction TLB error */ 1854 cpu_abort(cs, "Instruction TLB exception while in user mode. " 1855 "Aborting\n"); 1856 break; 1857 case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavail. */ 1858 EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n"); 1859 info.si_signo = TARGET_SIGILL; 1860 info.si_errno = 0; 1861 info.si_code = TARGET_ILL_COPROC; 1862 info._sifields._sigfault._addr = env->nip - 4; 1863 queue_signal(env, info.si_signo, &info); 1864 break; 1865 case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */ 1866 cpu_abort(cs, "Embedded floating-point data IRQ not handled\n"); 1867 break; 1868 case POWERPC_EXCP_EFPRI: /* Embedded floating-point round IRQ */ 1869 cpu_abort(cs, "Embedded floating-point round IRQ not handled\n"); 1870 break; 1871 case POWERPC_EXCP_EPERFM: /* Embedded performance monitor IRQ */ 1872 cpu_abort(cs, "Performance monitor exception not handled\n"); 1873 break; 1874 case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */ 1875 cpu_abort(cs, "Doorbell interrupt while in user mode. " 1876 "Aborting\n"); 1877 break; 1878 case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */ 1879 cpu_abort(cs, "Doorbell critical interrupt while in user mode. " 1880 "Aborting\n"); 1881 break; 1882 case POWERPC_EXCP_RESET: /* System reset exception */ 1883 cpu_abort(cs, "Reset interrupt while in user mode. " 1884 "Aborting\n"); 1885 break; 1886 case POWERPC_EXCP_DSEG: /* Data segment exception */ 1887 cpu_abort(cs, "Data segment exception while in user mode. " 1888 "Aborting\n"); 1889 break; 1890 case POWERPC_EXCP_ISEG: /* Instruction segment exception */ 1891 cpu_abort(cs, "Instruction segment exception " 1892 "while in user mode. Aborting\n"); 1893 break; 1894 /* PowerPC 64 with hypervisor mode support */ 1895 case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */ 1896 cpu_abort(cs, "Hypervisor decrementer interrupt " 1897 "while in user mode. Aborting\n"); 1898 break; 1899 case POWERPC_EXCP_TRACE: /* Trace exception */ 1900 /* Nothing to do: 1901 * we use this exception to emulate step-by-step execution mode. 1902 */ 1903 break; 1904 /* PowerPC 64 with hypervisor mode support */ 1905 case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */ 1906 cpu_abort(cs, "Hypervisor data storage exception " 1907 "while in user mode. Aborting\n"); 1908 break; 1909 case POWERPC_EXCP_HISI: /* Hypervisor instruction storage excp */ 1910 cpu_abort(cs, "Hypervisor instruction storage exception " 1911 "while in user mode. Aborting\n"); 1912 break; 1913 case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */ 1914 cpu_abort(cs, "Hypervisor data segment exception " 1915 "while in user mode. Aborting\n"); 1916 break; 1917 case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment excp */ 1918 cpu_abort(cs, "Hypervisor instruction segment exception " 1919 "while in user mode. Aborting\n"); 1920 break; 1921 case POWERPC_EXCP_VPU: /* Vector unavailable exception */ 1922 EXCP_DUMP(env, "No Altivec instructions allowed\n"); 1923 info.si_signo = TARGET_SIGILL; 1924 info.si_errno = 0; 1925 info.si_code = TARGET_ILL_COPROC; 1926 info._sifields._sigfault._addr = env->nip - 4; 1927 queue_signal(env, info.si_signo, &info); 1928 break; 1929 case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */ 1930 cpu_abort(cs, "Programmable interval timer interrupt " 1931 "while in user mode. Aborting\n"); 1932 break; 1933 case POWERPC_EXCP_IO: /* IO error exception */ 1934 cpu_abort(cs, "IO error exception while in user mode. " 1935 "Aborting\n"); 1936 break; 1937 case POWERPC_EXCP_RUNM: /* Run mode exception */ 1938 cpu_abort(cs, "Run mode exception while in user mode. " 1939 "Aborting\n"); 1940 break; 1941 case POWERPC_EXCP_EMUL: /* Emulation trap exception */ 1942 cpu_abort(cs, "Emulation trap exception not handled\n"); 1943 break; 1944 case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */ 1945 cpu_abort(cs, "Instruction fetch TLB exception " 1946 "while in user-mode. Aborting"); 1947 break; 1948 case POWERPC_EXCP_DLTLB: /* Data load TLB miss */ 1949 cpu_abort(cs, "Data load TLB exception while in user-mode. " 1950 "Aborting"); 1951 break; 1952 case POWERPC_EXCP_DSTLB: /* Data store TLB miss */ 1953 cpu_abort(cs, "Data store TLB exception while in user-mode. " 1954 "Aborting"); 1955 break; 1956 case POWERPC_EXCP_FPA: /* Floating-point assist exception */ 1957 cpu_abort(cs, "Floating-point assist exception not handled\n"); 1958 break; 1959 case POWERPC_EXCP_IABR: /* Instruction address breakpoint */ 1960 cpu_abort(cs, "Instruction address breakpoint exception " 1961 "not handled\n"); 1962 break; 1963 case POWERPC_EXCP_SMI: /* System management interrupt */ 1964 cpu_abort(cs, "System management interrupt while in user mode. " 1965 "Aborting\n"); 1966 break; 1967 case POWERPC_EXCP_THERM: /* Thermal interrupt */ 1968 cpu_abort(cs, "Thermal interrupt interrupt while in user mode. " 1969 "Aborting\n"); 1970 break; 1971 case POWERPC_EXCP_PERFM: /* Embedded performance monitor IRQ */ 1972 cpu_abort(cs, "Performance monitor exception not handled\n"); 1973 break; 1974 case POWERPC_EXCP_VPUA: /* Vector assist exception */ 1975 cpu_abort(cs, "Vector assist exception not handled\n"); 1976 break; 1977 case POWERPC_EXCP_SOFTP: /* Soft patch exception */ 1978 cpu_abort(cs, "Soft patch exception not handled\n"); 1979 break; 1980 case POWERPC_EXCP_MAINT: /* Maintenance exception */ 1981 cpu_abort(cs, "Maintenance exception while in user mode. " 1982 "Aborting\n"); 1983 break; 1984 case POWERPC_EXCP_STOP: /* stop translation */ 1985 /* We did invalidate the instruction cache. Go on */ 1986 break; 1987 case POWERPC_EXCP_BRANCH: /* branch instruction: */ 1988 /* We just stopped because of a branch. Go on */ 1989 break; 1990 case POWERPC_EXCP_SYSCALL_USER: 1991 /* system call in user-mode emulation */ 1992 /* WARNING: 1993 * PPC ABI uses overflow flag in cr0 to signal an error 1994 * in syscalls. 1995 */ 1996 env->crf[0] &= ~0x1; 1997 ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4], 1998 env->gpr[5], env->gpr[6], env->gpr[7], 1999 env->gpr[8], 0, 0); 2000 if (ret == -TARGET_ERESTARTSYS) { 2001 env->nip -= 4; 2002 break; 2003 } 2004 if (ret == (target_ulong)(-TARGET_QEMU_ESIGRETURN)) { 2005 /* Returning from a successful sigreturn syscall. 2006 Avoid corrupting register state. */ 2007 break; 2008 } 2009 if (ret > (target_ulong)(-515)) { 2010 env->crf[0] |= 0x1; 2011 ret = -ret; 2012 } 2013 env->gpr[3] = ret; 2014 break; 2015 case POWERPC_EXCP_STCX: 2016 if (do_store_exclusive(env)) { 2017 info.si_signo = TARGET_SIGSEGV; 2018 info.si_errno = 0; 2019 info.si_code = TARGET_SEGV_MAPERR; 2020 info._sifields._sigfault._addr = env->nip; 2021 queue_signal(env, info.si_signo, &info); 2022 } 2023 break; 2024 case EXCP_DEBUG: 2025 { 2026 int sig; 2027 2028 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 2029 if (sig) { 2030 info.si_signo = sig; 2031 info.si_errno = 0; 2032 info.si_code = TARGET_TRAP_BRKPT; 2033 queue_signal(env, info.si_signo, &info); 2034 } 2035 } 2036 break; 2037 case EXCP_INTERRUPT: 2038 /* just indicate that signals should be handled asap */ 2039 break; 2040 default: 2041 cpu_abort(cs, "Unknown exception 0x%d. Aborting\n", trapnr); 2042 break; 2043 } 2044 process_pending_signals(env); 2045 } 2046 } 2047 #endif 2048 2049 #ifdef TARGET_MIPS 2050 2051 # ifdef TARGET_ABI_MIPSO32 2052 # define MIPS_SYS(name, args) args, 2053 static const uint8_t mips_syscall_args[] = { 2054 MIPS_SYS(sys_syscall , 8) /* 4000 */ 2055 MIPS_SYS(sys_exit , 1) 2056 MIPS_SYS(sys_fork , 0) 2057 MIPS_SYS(sys_read , 3) 2058 MIPS_SYS(sys_write , 3) 2059 MIPS_SYS(sys_open , 3) /* 4005 */ 2060 MIPS_SYS(sys_close , 1) 2061 MIPS_SYS(sys_waitpid , 3) 2062 MIPS_SYS(sys_creat , 2) 2063 MIPS_SYS(sys_link , 2) 2064 MIPS_SYS(sys_unlink , 1) /* 4010 */ 2065 MIPS_SYS(sys_execve , 0) 2066 MIPS_SYS(sys_chdir , 1) 2067 MIPS_SYS(sys_time , 1) 2068 MIPS_SYS(sys_mknod , 3) 2069 MIPS_SYS(sys_chmod , 2) /* 4015 */ 2070 MIPS_SYS(sys_lchown , 3) 2071 MIPS_SYS(sys_ni_syscall , 0) 2072 MIPS_SYS(sys_ni_syscall , 0) /* was sys_stat */ 2073 MIPS_SYS(sys_lseek , 3) 2074 MIPS_SYS(sys_getpid , 0) /* 4020 */ 2075 MIPS_SYS(sys_mount , 5) 2076 MIPS_SYS(sys_umount , 1) 2077 MIPS_SYS(sys_setuid , 1) 2078 MIPS_SYS(sys_getuid , 0) 2079 MIPS_SYS(sys_stime , 1) /* 4025 */ 2080 MIPS_SYS(sys_ptrace , 4) 2081 MIPS_SYS(sys_alarm , 1) 2082 MIPS_SYS(sys_ni_syscall , 0) /* was sys_fstat */ 2083 MIPS_SYS(sys_pause , 0) 2084 MIPS_SYS(sys_utime , 2) /* 4030 */ 2085 MIPS_SYS(sys_ni_syscall , 0) 2086 MIPS_SYS(sys_ni_syscall , 0) 2087 MIPS_SYS(sys_access , 2) 2088 MIPS_SYS(sys_nice , 1) 2089 MIPS_SYS(sys_ni_syscall , 0) /* 4035 */ 2090 MIPS_SYS(sys_sync , 0) 2091 MIPS_SYS(sys_kill , 2) 2092 MIPS_SYS(sys_rename , 2) 2093 MIPS_SYS(sys_mkdir , 2) 2094 MIPS_SYS(sys_rmdir , 1) /* 4040 */ 2095 MIPS_SYS(sys_dup , 1) 2096 MIPS_SYS(sys_pipe , 0) 2097 MIPS_SYS(sys_times , 1) 2098 MIPS_SYS(sys_ni_syscall , 0) 2099 MIPS_SYS(sys_brk , 1) /* 4045 */ 2100 MIPS_SYS(sys_setgid , 1) 2101 MIPS_SYS(sys_getgid , 0) 2102 MIPS_SYS(sys_ni_syscall , 0) /* was signal(2) */ 2103 MIPS_SYS(sys_geteuid , 0) 2104 MIPS_SYS(sys_getegid , 0) /* 4050 */ 2105 MIPS_SYS(sys_acct , 0) 2106 MIPS_SYS(sys_umount2 , 2) 2107 MIPS_SYS(sys_ni_syscall , 0) 2108 MIPS_SYS(sys_ioctl , 3) 2109 MIPS_SYS(sys_fcntl , 3) /* 4055 */ 2110 MIPS_SYS(sys_ni_syscall , 2) 2111 MIPS_SYS(sys_setpgid , 2) 2112 MIPS_SYS(sys_ni_syscall , 0) 2113 MIPS_SYS(sys_olduname , 1) 2114 MIPS_SYS(sys_umask , 1) /* 4060 */ 2115 MIPS_SYS(sys_chroot , 1) 2116 MIPS_SYS(sys_ustat , 2) 2117 MIPS_SYS(sys_dup2 , 2) 2118 MIPS_SYS(sys_getppid , 0) 2119 MIPS_SYS(sys_getpgrp , 0) /* 4065 */ 2120 MIPS_SYS(sys_setsid , 0) 2121 MIPS_SYS(sys_sigaction , 3) 2122 MIPS_SYS(sys_sgetmask , 0) 2123 MIPS_SYS(sys_ssetmask , 1) 2124 MIPS_SYS(sys_setreuid , 2) /* 4070 */ 2125 MIPS_SYS(sys_setregid , 2) 2126 MIPS_SYS(sys_sigsuspend , 0) 2127 MIPS_SYS(sys_sigpending , 1) 2128 MIPS_SYS(sys_sethostname , 2) 2129 MIPS_SYS(sys_setrlimit , 2) /* 4075 */ 2130 MIPS_SYS(sys_getrlimit , 2) 2131 MIPS_SYS(sys_getrusage , 2) 2132 MIPS_SYS(sys_gettimeofday, 2) 2133 MIPS_SYS(sys_settimeofday, 2) 2134 MIPS_SYS(sys_getgroups , 2) /* 4080 */ 2135 MIPS_SYS(sys_setgroups , 2) 2136 MIPS_SYS(sys_ni_syscall , 0) /* old_select */ 2137 MIPS_SYS(sys_symlink , 2) 2138 MIPS_SYS(sys_ni_syscall , 0) /* was sys_lstat */ 2139 MIPS_SYS(sys_readlink , 3) /* 4085 */ 2140 MIPS_SYS(sys_uselib , 1) 2141 MIPS_SYS(sys_swapon , 2) 2142 MIPS_SYS(sys_reboot , 3) 2143 MIPS_SYS(old_readdir , 3) 2144 MIPS_SYS(old_mmap , 6) /* 4090 */ 2145 MIPS_SYS(sys_munmap , 2) 2146 MIPS_SYS(sys_truncate , 2) 2147 MIPS_SYS(sys_ftruncate , 2) 2148 MIPS_SYS(sys_fchmod , 2) 2149 MIPS_SYS(sys_fchown , 3) /* 4095 */ 2150 MIPS_SYS(sys_getpriority , 2) 2151 MIPS_SYS(sys_setpriority , 3) 2152 MIPS_SYS(sys_ni_syscall , 0) 2153 MIPS_SYS(sys_statfs , 2) 2154 MIPS_SYS(sys_fstatfs , 2) /* 4100 */ 2155 MIPS_SYS(sys_ni_syscall , 0) /* was ioperm(2) */ 2156 MIPS_SYS(sys_socketcall , 2) 2157 MIPS_SYS(sys_syslog , 3) 2158 MIPS_SYS(sys_setitimer , 3) 2159 MIPS_SYS(sys_getitimer , 2) /* 4105 */ 2160 MIPS_SYS(sys_newstat , 2) 2161 MIPS_SYS(sys_newlstat , 2) 2162 MIPS_SYS(sys_newfstat , 2) 2163 MIPS_SYS(sys_uname , 1) 2164 MIPS_SYS(sys_ni_syscall , 0) /* 4110 was iopl(2) */ 2165 MIPS_SYS(sys_vhangup , 0) 2166 MIPS_SYS(sys_ni_syscall , 0) /* was sys_idle() */ 2167 MIPS_SYS(sys_ni_syscall , 0) /* was sys_vm86 */ 2168 MIPS_SYS(sys_wait4 , 4) 2169 MIPS_SYS(sys_swapoff , 1) /* 4115 */ 2170 MIPS_SYS(sys_sysinfo , 1) 2171 MIPS_SYS(sys_ipc , 6) 2172 MIPS_SYS(sys_fsync , 1) 2173 MIPS_SYS(sys_sigreturn , 0) 2174 MIPS_SYS(sys_clone , 6) /* 4120 */ 2175 MIPS_SYS(sys_setdomainname, 2) 2176 MIPS_SYS(sys_newuname , 1) 2177 MIPS_SYS(sys_ni_syscall , 0) /* sys_modify_ldt */ 2178 MIPS_SYS(sys_adjtimex , 1) 2179 MIPS_SYS(sys_mprotect , 3) /* 4125 */ 2180 MIPS_SYS(sys_sigprocmask , 3) 2181 MIPS_SYS(sys_ni_syscall , 0) /* was create_module */ 2182 MIPS_SYS(sys_init_module , 5) 2183 MIPS_SYS(sys_delete_module, 1) 2184 MIPS_SYS(sys_ni_syscall , 0) /* 4130 was get_kernel_syms */ 2185 MIPS_SYS(sys_quotactl , 0) 2186 MIPS_SYS(sys_getpgid , 1) 2187 MIPS_SYS(sys_fchdir , 1) 2188 MIPS_SYS(sys_bdflush , 2) 2189 MIPS_SYS(sys_sysfs , 3) /* 4135 */ 2190 MIPS_SYS(sys_personality , 1) 2191 MIPS_SYS(sys_ni_syscall , 0) /* for afs_syscall */ 2192 MIPS_SYS(sys_setfsuid , 1) 2193 MIPS_SYS(sys_setfsgid , 1) 2194 MIPS_SYS(sys_llseek , 5) /* 4140 */ 2195 MIPS_SYS(sys_getdents , 3) 2196 MIPS_SYS(sys_select , 5) 2197 MIPS_SYS(sys_flock , 2) 2198 MIPS_SYS(sys_msync , 3) 2199 MIPS_SYS(sys_readv , 3) /* 4145 */ 2200 MIPS_SYS(sys_writev , 3) 2201 MIPS_SYS(sys_cacheflush , 3) 2202 MIPS_SYS(sys_cachectl , 3) 2203 MIPS_SYS(sys_sysmips , 4) 2204 MIPS_SYS(sys_ni_syscall , 0) /* 4150 */ 2205 MIPS_SYS(sys_getsid , 1) 2206 MIPS_SYS(sys_fdatasync , 0) 2207 MIPS_SYS(sys_sysctl , 1) 2208 MIPS_SYS(sys_mlock , 2) 2209 MIPS_SYS(sys_munlock , 2) /* 4155 */ 2210 MIPS_SYS(sys_mlockall , 1) 2211 MIPS_SYS(sys_munlockall , 0) 2212 MIPS_SYS(sys_sched_setparam, 2) 2213 MIPS_SYS(sys_sched_getparam, 2) 2214 MIPS_SYS(sys_sched_setscheduler, 3) /* 4160 */ 2215 MIPS_SYS(sys_sched_getscheduler, 1) 2216 MIPS_SYS(sys_sched_yield , 0) 2217 MIPS_SYS(sys_sched_get_priority_max, 1) 2218 MIPS_SYS(sys_sched_get_priority_min, 1) 2219 MIPS_SYS(sys_sched_rr_get_interval, 2) /* 4165 */ 2220 MIPS_SYS(sys_nanosleep, 2) 2221 MIPS_SYS(sys_mremap , 5) 2222 MIPS_SYS(sys_accept , 3) 2223 MIPS_SYS(sys_bind , 3) 2224 MIPS_SYS(sys_connect , 3) /* 4170 */ 2225 MIPS_SYS(sys_getpeername , 3) 2226 MIPS_SYS(sys_getsockname , 3) 2227 MIPS_SYS(sys_getsockopt , 5) 2228 MIPS_SYS(sys_listen , 2) 2229 MIPS_SYS(sys_recv , 4) /* 4175 */ 2230 MIPS_SYS(sys_recvfrom , 6) 2231 MIPS_SYS(sys_recvmsg , 3) 2232 MIPS_SYS(sys_send , 4) 2233 MIPS_SYS(sys_sendmsg , 3) 2234 MIPS_SYS(sys_sendto , 6) /* 4180 */ 2235 MIPS_SYS(sys_setsockopt , 5) 2236 MIPS_SYS(sys_shutdown , 2) 2237 MIPS_SYS(sys_socket , 3) 2238 MIPS_SYS(sys_socketpair , 4) 2239 MIPS_SYS(sys_setresuid , 3) /* 4185 */ 2240 MIPS_SYS(sys_getresuid , 3) 2241 MIPS_SYS(sys_ni_syscall , 0) /* was sys_query_module */ 2242 MIPS_SYS(sys_poll , 3) 2243 MIPS_SYS(sys_nfsservctl , 3) 2244 MIPS_SYS(sys_setresgid , 3) /* 4190 */ 2245 MIPS_SYS(sys_getresgid , 3) 2246 MIPS_SYS(sys_prctl , 5) 2247 MIPS_SYS(sys_rt_sigreturn, 0) 2248 MIPS_SYS(sys_rt_sigaction, 4) 2249 MIPS_SYS(sys_rt_sigprocmask, 4) /* 4195 */ 2250 MIPS_SYS(sys_rt_sigpending, 2) 2251 MIPS_SYS(sys_rt_sigtimedwait, 4) 2252 MIPS_SYS(sys_rt_sigqueueinfo, 3) 2253 MIPS_SYS(sys_rt_sigsuspend, 0) 2254 MIPS_SYS(sys_pread64 , 6) /* 4200 */ 2255 MIPS_SYS(sys_pwrite64 , 6) 2256 MIPS_SYS(sys_chown , 3) 2257 MIPS_SYS(sys_getcwd , 2) 2258 MIPS_SYS(sys_capget , 2) 2259 MIPS_SYS(sys_capset , 2) /* 4205 */ 2260 MIPS_SYS(sys_sigaltstack , 2) 2261 MIPS_SYS(sys_sendfile , 4) 2262 MIPS_SYS(sys_ni_syscall , 0) 2263 MIPS_SYS(sys_ni_syscall , 0) 2264 MIPS_SYS(sys_mmap2 , 6) /* 4210 */ 2265 MIPS_SYS(sys_truncate64 , 4) 2266 MIPS_SYS(sys_ftruncate64 , 4) 2267 MIPS_SYS(sys_stat64 , 2) 2268 MIPS_SYS(sys_lstat64 , 2) 2269 MIPS_SYS(sys_fstat64 , 2) /* 4215 */ 2270 MIPS_SYS(sys_pivot_root , 2) 2271 MIPS_SYS(sys_mincore , 3) 2272 MIPS_SYS(sys_madvise , 3) 2273 MIPS_SYS(sys_getdents64 , 3) 2274 MIPS_SYS(sys_fcntl64 , 3) /* 4220 */ 2275 MIPS_SYS(sys_ni_syscall , 0) 2276 MIPS_SYS(sys_gettid , 0) 2277 MIPS_SYS(sys_readahead , 5) 2278 MIPS_SYS(sys_setxattr , 5) 2279 MIPS_SYS(sys_lsetxattr , 5) /* 4225 */ 2280 MIPS_SYS(sys_fsetxattr , 5) 2281 MIPS_SYS(sys_getxattr , 4) 2282 MIPS_SYS(sys_lgetxattr , 4) 2283 MIPS_SYS(sys_fgetxattr , 4) 2284 MIPS_SYS(sys_listxattr , 3) /* 4230 */ 2285 MIPS_SYS(sys_llistxattr , 3) 2286 MIPS_SYS(sys_flistxattr , 3) 2287 MIPS_SYS(sys_removexattr , 2) 2288 MIPS_SYS(sys_lremovexattr, 2) 2289 MIPS_SYS(sys_fremovexattr, 2) /* 4235 */ 2290 MIPS_SYS(sys_tkill , 2) 2291 MIPS_SYS(sys_sendfile64 , 5) 2292 MIPS_SYS(sys_futex , 6) 2293 MIPS_SYS(sys_sched_setaffinity, 3) 2294 MIPS_SYS(sys_sched_getaffinity, 3) /* 4240 */ 2295 MIPS_SYS(sys_io_setup , 2) 2296 MIPS_SYS(sys_io_destroy , 1) 2297 MIPS_SYS(sys_io_getevents, 5) 2298 MIPS_SYS(sys_io_submit , 3) 2299 MIPS_SYS(sys_io_cancel , 3) /* 4245 */ 2300 MIPS_SYS(sys_exit_group , 1) 2301 MIPS_SYS(sys_lookup_dcookie, 3) 2302 MIPS_SYS(sys_epoll_create, 1) 2303 MIPS_SYS(sys_epoll_ctl , 4) 2304 MIPS_SYS(sys_epoll_wait , 3) /* 4250 */ 2305 MIPS_SYS(sys_remap_file_pages, 5) 2306 MIPS_SYS(sys_set_tid_address, 1) 2307 MIPS_SYS(sys_restart_syscall, 0) 2308 MIPS_SYS(sys_fadvise64_64, 7) 2309 MIPS_SYS(sys_statfs64 , 3) /* 4255 */ 2310 MIPS_SYS(sys_fstatfs64 , 2) 2311 MIPS_SYS(sys_timer_create, 3) 2312 MIPS_SYS(sys_timer_settime, 4) 2313 MIPS_SYS(sys_timer_gettime, 2) 2314 MIPS_SYS(sys_timer_getoverrun, 1) /* 4260 */ 2315 MIPS_SYS(sys_timer_delete, 1) 2316 MIPS_SYS(sys_clock_settime, 2) 2317 MIPS_SYS(sys_clock_gettime, 2) 2318 MIPS_SYS(sys_clock_getres, 2) 2319 MIPS_SYS(sys_clock_nanosleep, 4) /* 4265 */ 2320 MIPS_SYS(sys_tgkill , 3) 2321 MIPS_SYS(sys_utimes , 2) 2322 MIPS_SYS(sys_mbind , 4) 2323 MIPS_SYS(sys_ni_syscall , 0) /* sys_get_mempolicy */ 2324 MIPS_SYS(sys_ni_syscall , 0) /* 4270 sys_set_mempolicy */ 2325 MIPS_SYS(sys_mq_open , 4) 2326 MIPS_SYS(sys_mq_unlink , 1) 2327 MIPS_SYS(sys_mq_timedsend, 5) 2328 MIPS_SYS(sys_mq_timedreceive, 5) 2329 MIPS_SYS(sys_mq_notify , 2) /* 4275 */ 2330 MIPS_SYS(sys_mq_getsetattr, 3) 2331 MIPS_SYS(sys_ni_syscall , 0) /* sys_vserver */ 2332 MIPS_SYS(sys_waitid , 4) 2333 MIPS_SYS(sys_ni_syscall , 0) /* available, was setaltroot */ 2334 MIPS_SYS(sys_add_key , 5) 2335 MIPS_SYS(sys_request_key, 4) 2336 MIPS_SYS(sys_keyctl , 5) 2337 MIPS_SYS(sys_set_thread_area, 1) 2338 MIPS_SYS(sys_inotify_init, 0) 2339 MIPS_SYS(sys_inotify_add_watch, 3) /* 4285 */ 2340 MIPS_SYS(sys_inotify_rm_watch, 2) 2341 MIPS_SYS(sys_migrate_pages, 4) 2342 MIPS_SYS(sys_openat, 4) 2343 MIPS_SYS(sys_mkdirat, 3) 2344 MIPS_SYS(sys_mknodat, 4) /* 4290 */ 2345 MIPS_SYS(sys_fchownat, 5) 2346 MIPS_SYS(sys_futimesat, 3) 2347 MIPS_SYS(sys_fstatat64, 4) 2348 MIPS_SYS(sys_unlinkat, 3) 2349 MIPS_SYS(sys_renameat, 4) /* 4295 */ 2350 MIPS_SYS(sys_linkat, 5) 2351 MIPS_SYS(sys_symlinkat, 3) 2352 MIPS_SYS(sys_readlinkat, 4) 2353 MIPS_SYS(sys_fchmodat, 3) 2354 MIPS_SYS(sys_faccessat, 3) /* 4300 */ 2355 MIPS_SYS(sys_pselect6, 6) 2356 MIPS_SYS(sys_ppoll, 5) 2357 MIPS_SYS(sys_unshare, 1) 2358 MIPS_SYS(sys_splice, 6) 2359 MIPS_SYS(sys_sync_file_range, 7) /* 4305 */ 2360 MIPS_SYS(sys_tee, 4) 2361 MIPS_SYS(sys_vmsplice, 4) 2362 MIPS_SYS(sys_move_pages, 6) 2363 MIPS_SYS(sys_set_robust_list, 2) 2364 MIPS_SYS(sys_get_robust_list, 3) /* 4310 */ 2365 MIPS_SYS(sys_kexec_load, 4) 2366 MIPS_SYS(sys_getcpu, 3) 2367 MIPS_SYS(sys_epoll_pwait, 6) 2368 MIPS_SYS(sys_ioprio_set, 3) 2369 MIPS_SYS(sys_ioprio_get, 2) 2370 MIPS_SYS(sys_utimensat, 4) 2371 MIPS_SYS(sys_signalfd, 3) 2372 MIPS_SYS(sys_ni_syscall, 0) /* was timerfd */ 2373 MIPS_SYS(sys_eventfd, 1) 2374 MIPS_SYS(sys_fallocate, 6) /* 4320 */ 2375 MIPS_SYS(sys_timerfd_create, 2) 2376 MIPS_SYS(sys_timerfd_gettime, 2) 2377 MIPS_SYS(sys_timerfd_settime, 4) 2378 MIPS_SYS(sys_signalfd4, 4) 2379 MIPS_SYS(sys_eventfd2, 2) /* 4325 */ 2380 MIPS_SYS(sys_epoll_create1, 1) 2381 MIPS_SYS(sys_dup3, 3) 2382 MIPS_SYS(sys_pipe2, 2) 2383 MIPS_SYS(sys_inotify_init1, 1) 2384 MIPS_SYS(sys_preadv, 6) /* 4330 */ 2385 MIPS_SYS(sys_pwritev, 6) 2386 MIPS_SYS(sys_rt_tgsigqueueinfo, 4) 2387 MIPS_SYS(sys_perf_event_open, 5) 2388 MIPS_SYS(sys_accept4, 4) 2389 MIPS_SYS(sys_recvmmsg, 5) /* 4335 */ 2390 MIPS_SYS(sys_fanotify_init, 2) 2391 MIPS_SYS(sys_fanotify_mark, 6) 2392 MIPS_SYS(sys_prlimit64, 4) 2393 MIPS_SYS(sys_name_to_handle_at, 5) 2394 MIPS_SYS(sys_open_by_handle_at, 3) /* 4340 */ 2395 MIPS_SYS(sys_clock_adjtime, 2) 2396 MIPS_SYS(sys_syncfs, 1) 2397 }; 2398 # undef MIPS_SYS 2399 # endif /* O32 */ 2400 2401 static int do_store_exclusive(CPUMIPSState *env) 2402 { 2403 target_ulong addr; 2404 target_ulong page_addr; 2405 target_ulong val; 2406 int flags; 2407 int segv = 0; 2408 int reg; 2409 int d; 2410 2411 addr = env->lladdr; 2412 page_addr = addr & TARGET_PAGE_MASK; 2413 start_exclusive(); 2414 mmap_lock(); 2415 flags = page_get_flags(page_addr); 2416 if ((flags & PAGE_READ) == 0) { 2417 segv = 1; 2418 } else { 2419 reg = env->llreg & 0x1f; 2420 d = (env->llreg & 0x20) != 0; 2421 if (d) { 2422 segv = get_user_s64(val, addr); 2423 } else { 2424 segv = get_user_s32(val, addr); 2425 } 2426 if (!segv) { 2427 if (val != env->llval) { 2428 env->active_tc.gpr[reg] = 0; 2429 } else { 2430 if (d) { 2431 segv = put_user_u64(env->llnewval, addr); 2432 } else { 2433 segv = put_user_u32(env->llnewval, addr); 2434 } 2435 if (!segv) { 2436 env->active_tc.gpr[reg] = 1; 2437 } 2438 } 2439 } 2440 } 2441 env->lladdr = -1; 2442 if (!segv) { 2443 env->active_tc.PC += 4; 2444 } 2445 mmap_unlock(); 2446 end_exclusive(); 2447 return segv; 2448 } 2449 2450 /* Break codes */ 2451 enum { 2452 BRK_OVERFLOW = 6, 2453 BRK_DIVZERO = 7 2454 }; 2455 2456 static int do_break(CPUMIPSState *env, target_siginfo_t *info, 2457 unsigned int code) 2458 { 2459 int ret = -1; 2460 2461 switch (code) { 2462 case BRK_OVERFLOW: 2463 case BRK_DIVZERO: 2464 info->si_signo = TARGET_SIGFPE; 2465 info->si_errno = 0; 2466 info->si_code = (code == BRK_OVERFLOW) ? FPE_INTOVF : FPE_INTDIV; 2467 queue_signal(env, info->si_signo, &*info); 2468 ret = 0; 2469 break; 2470 default: 2471 info->si_signo = TARGET_SIGTRAP; 2472 info->si_errno = 0; 2473 queue_signal(env, info->si_signo, &*info); 2474 ret = 0; 2475 break; 2476 } 2477 2478 return ret; 2479 } 2480 2481 void cpu_loop(CPUMIPSState *env) 2482 { 2483 CPUState *cs = CPU(mips_env_get_cpu(env)); 2484 target_siginfo_t info; 2485 int trapnr; 2486 abi_long ret; 2487 # ifdef TARGET_ABI_MIPSO32 2488 unsigned int syscall_num; 2489 # endif 2490 2491 for(;;) { 2492 cpu_exec_start(cs); 2493 trapnr = cpu_exec(cs); 2494 cpu_exec_end(cs); 2495 switch(trapnr) { 2496 case EXCP_SYSCALL: 2497 env->active_tc.PC += 4; 2498 # ifdef TARGET_ABI_MIPSO32 2499 syscall_num = env->active_tc.gpr[2] - 4000; 2500 if (syscall_num >= sizeof(mips_syscall_args)) { 2501 ret = -TARGET_ENOSYS; 2502 } else { 2503 int nb_args; 2504 abi_ulong sp_reg; 2505 abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0; 2506 2507 nb_args = mips_syscall_args[syscall_num]; 2508 sp_reg = env->active_tc.gpr[29]; 2509 switch (nb_args) { 2510 /* these arguments are taken from the stack */ 2511 case 8: 2512 if ((ret = get_user_ual(arg8, sp_reg + 28)) != 0) { 2513 goto done_syscall; 2514 } 2515 case 7: 2516 if ((ret = get_user_ual(arg7, sp_reg + 24)) != 0) { 2517 goto done_syscall; 2518 } 2519 case 6: 2520 if ((ret = get_user_ual(arg6, sp_reg + 20)) != 0) { 2521 goto done_syscall; 2522 } 2523 case 5: 2524 if ((ret = get_user_ual(arg5, sp_reg + 16)) != 0) { 2525 goto done_syscall; 2526 } 2527 default: 2528 break; 2529 } 2530 ret = do_syscall(env, env->active_tc.gpr[2], 2531 env->active_tc.gpr[4], 2532 env->active_tc.gpr[5], 2533 env->active_tc.gpr[6], 2534 env->active_tc.gpr[7], 2535 arg5, arg6, arg7, arg8); 2536 } 2537 done_syscall: 2538 # else 2539 ret = do_syscall(env, env->active_tc.gpr[2], 2540 env->active_tc.gpr[4], env->active_tc.gpr[5], 2541 env->active_tc.gpr[6], env->active_tc.gpr[7], 2542 env->active_tc.gpr[8], env->active_tc.gpr[9], 2543 env->active_tc.gpr[10], env->active_tc.gpr[11]); 2544 # endif /* O32 */ 2545 if (ret == -TARGET_ERESTARTSYS) { 2546 env->active_tc.PC -= 4; 2547 break; 2548 } 2549 if (ret == -TARGET_QEMU_ESIGRETURN) { 2550 /* Returning from a successful sigreturn syscall. 2551 Avoid clobbering register state. */ 2552 break; 2553 } 2554 if ((abi_ulong)ret >= (abi_ulong)-1133) { 2555 env->active_tc.gpr[7] = 1; /* error flag */ 2556 ret = -ret; 2557 } else { 2558 env->active_tc.gpr[7] = 0; /* error flag */ 2559 } 2560 env->active_tc.gpr[2] = ret; 2561 break; 2562 case EXCP_TLBL: 2563 case EXCP_TLBS: 2564 case EXCP_AdEL: 2565 case EXCP_AdES: 2566 info.si_signo = TARGET_SIGSEGV; 2567 info.si_errno = 0; 2568 /* XXX: check env->error_code */ 2569 info.si_code = TARGET_SEGV_MAPERR; 2570 info._sifields._sigfault._addr = env->CP0_BadVAddr; 2571 queue_signal(env, info.si_signo, &info); 2572 break; 2573 case EXCP_CpU: 2574 case EXCP_RI: 2575 info.si_signo = TARGET_SIGILL; 2576 info.si_errno = 0; 2577 info.si_code = 0; 2578 queue_signal(env, info.si_signo, &info); 2579 break; 2580 case EXCP_INTERRUPT: 2581 /* just indicate that signals should be handled asap */ 2582 break; 2583 case EXCP_DEBUG: 2584 { 2585 int sig; 2586 2587 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 2588 if (sig) 2589 { 2590 info.si_signo = sig; 2591 info.si_errno = 0; 2592 info.si_code = TARGET_TRAP_BRKPT; 2593 queue_signal(env, info.si_signo, &info); 2594 } 2595 } 2596 break; 2597 case EXCP_SC: 2598 if (do_store_exclusive(env)) { 2599 info.si_signo = TARGET_SIGSEGV; 2600 info.si_errno = 0; 2601 info.si_code = TARGET_SEGV_MAPERR; 2602 info._sifields._sigfault._addr = env->active_tc.PC; 2603 queue_signal(env, info.si_signo, &info); 2604 } 2605 break; 2606 case EXCP_DSPDIS: 2607 info.si_signo = TARGET_SIGILL; 2608 info.si_errno = 0; 2609 info.si_code = TARGET_ILL_ILLOPC; 2610 queue_signal(env, info.si_signo, &info); 2611 break; 2612 /* The code below was inspired by the MIPS Linux kernel trap 2613 * handling code in arch/mips/kernel/traps.c. 2614 */ 2615 case EXCP_BREAK: 2616 { 2617 abi_ulong trap_instr; 2618 unsigned int code; 2619 2620 if (env->hflags & MIPS_HFLAG_M16) { 2621 if (env->insn_flags & ASE_MICROMIPS) { 2622 /* microMIPS mode */ 2623 ret = get_user_u16(trap_instr, env->active_tc.PC); 2624 if (ret != 0) { 2625 goto error; 2626 } 2627 2628 if ((trap_instr >> 10) == 0x11) { 2629 /* 16-bit instruction */ 2630 code = trap_instr & 0xf; 2631 } else { 2632 /* 32-bit instruction */ 2633 abi_ulong instr_lo; 2634 2635 ret = get_user_u16(instr_lo, 2636 env->active_tc.PC + 2); 2637 if (ret != 0) { 2638 goto error; 2639 } 2640 trap_instr = (trap_instr << 16) | instr_lo; 2641 code = ((trap_instr >> 6) & ((1 << 20) - 1)); 2642 /* Unfortunately, microMIPS also suffers from 2643 the old assembler bug... */ 2644 if (code >= (1 << 10)) { 2645 code >>= 10; 2646 } 2647 } 2648 } else { 2649 /* MIPS16e mode */ 2650 ret = get_user_u16(trap_instr, env->active_tc.PC); 2651 if (ret != 0) { 2652 goto error; 2653 } 2654 code = (trap_instr >> 6) & 0x3f; 2655 } 2656 } else { 2657 ret = get_user_u32(trap_instr, env->active_tc.PC); 2658 if (ret != 0) { 2659 goto error; 2660 } 2661 2662 /* As described in the original Linux kernel code, the 2663 * below checks on 'code' are to work around an old 2664 * assembly bug. 2665 */ 2666 code = ((trap_instr >> 6) & ((1 << 20) - 1)); 2667 if (code >= (1 << 10)) { 2668 code >>= 10; 2669 } 2670 } 2671 2672 if (do_break(env, &info, code) != 0) { 2673 goto error; 2674 } 2675 } 2676 break; 2677 case EXCP_TRAP: 2678 { 2679 abi_ulong trap_instr; 2680 unsigned int code = 0; 2681 2682 if (env->hflags & MIPS_HFLAG_M16) { 2683 /* microMIPS mode */ 2684 abi_ulong instr[2]; 2685 2686 ret = get_user_u16(instr[0], env->active_tc.PC) || 2687 get_user_u16(instr[1], env->active_tc.PC + 2); 2688 2689 trap_instr = (instr[0] << 16) | instr[1]; 2690 } else { 2691 ret = get_user_u32(trap_instr, env->active_tc.PC); 2692 } 2693 2694 if (ret != 0) { 2695 goto error; 2696 } 2697 2698 /* The immediate versions don't provide a code. */ 2699 if (!(trap_instr & 0xFC000000)) { 2700 if (env->hflags & MIPS_HFLAG_M16) { 2701 /* microMIPS mode */ 2702 code = ((trap_instr >> 12) & ((1 << 4) - 1)); 2703 } else { 2704 code = ((trap_instr >> 6) & ((1 << 10) - 1)); 2705 } 2706 } 2707 2708 if (do_break(env, &info, code) != 0) { 2709 goto error; 2710 } 2711 } 2712 break; 2713 default: 2714 error: 2715 EXCP_DUMP(env, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr); 2716 abort(); 2717 } 2718 process_pending_signals(env); 2719 } 2720 } 2721 #endif 2722 2723 #ifdef TARGET_OPENRISC 2724 2725 void cpu_loop(CPUOpenRISCState *env) 2726 { 2727 CPUState *cs = CPU(openrisc_env_get_cpu(env)); 2728 int trapnr, gdbsig; 2729 abi_long ret; 2730 2731 for (;;) { 2732 cpu_exec_start(cs); 2733 trapnr = cpu_exec(cs); 2734 cpu_exec_end(cs); 2735 gdbsig = 0; 2736 2737 switch (trapnr) { 2738 case EXCP_RESET: 2739 qemu_log_mask(CPU_LOG_INT, "\nReset request, exit, pc is %#x\n", env->pc); 2740 exit(EXIT_FAILURE); 2741 break; 2742 case EXCP_BUSERR: 2743 qemu_log_mask(CPU_LOG_INT, "\nBus error, exit, pc is %#x\n", env->pc); 2744 gdbsig = TARGET_SIGBUS; 2745 break; 2746 case EXCP_DPF: 2747 case EXCP_IPF: 2748 cpu_dump_state(cs, stderr, fprintf, 0); 2749 gdbsig = TARGET_SIGSEGV; 2750 break; 2751 case EXCP_TICK: 2752 qemu_log_mask(CPU_LOG_INT, "\nTick time interrupt pc is %#x\n", env->pc); 2753 break; 2754 case EXCP_ALIGN: 2755 qemu_log_mask(CPU_LOG_INT, "\nAlignment pc is %#x\n", env->pc); 2756 gdbsig = TARGET_SIGBUS; 2757 break; 2758 case EXCP_ILLEGAL: 2759 qemu_log_mask(CPU_LOG_INT, "\nIllegal instructionpc is %#x\n", env->pc); 2760 gdbsig = TARGET_SIGILL; 2761 break; 2762 case EXCP_INT: 2763 qemu_log_mask(CPU_LOG_INT, "\nExternal interruptpc is %#x\n", env->pc); 2764 break; 2765 case EXCP_DTLBMISS: 2766 case EXCP_ITLBMISS: 2767 qemu_log_mask(CPU_LOG_INT, "\nTLB miss\n"); 2768 break; 2769 case EXCP_RANGE: 2770 qemu_log_mask(CPU_LOG_INT, "\nRange\n"); 2771 gdbsig = TARGET_SIGSEGV; 2772 break; 2773 case EXCP_SYSCALL: 2774 env->pc += 4; /* 0xc00; */ 2775 ret = do_syscall(env, 2776 env->gpr[11], /* return value */ 2777 env->gpr[3], /* r3 - r7 are params */ 2778 env->gpr[4], 2779 env->gpr[5], 2780 env->gpr[6], 2781 env->gpr[7], 2782 env->gpr[8], 0, 0); 2783 if (ret == -TARGET_ERESTARTSYS) { 2784 env->pc -= 4; 2785 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 2786 env->gpr[11] = ret; 2787 } 2788 break; 2789 case EXCP_FPE: 2790 qemu_log_mask(CPU_LOG_INT, "\nFloating point error\n"); 2791 break; 2792 case EXCP_TRAP: 2793 qemu_log_mask(CPU_LOG_INT, "\nTrap\n"); 2794 gdbsig = TARGET_SIGTRAP; 2795 break; 2796 case EXCP_NR: 2797 qemu_log_mask(CPU_LOG_INT, "\nNR\n"); 2798 break; 2799 default: 2800 EXCP_DUMP(env, "\nqemu: unhandled CPU exception %#x - aborting\n", 2801 trapnr); 2802 gdbsig = TARGET_SIGILL; 2803 break; 2804 } 2805 if (gdbsig) { 2806 gdb_handlesig(cs, gdbsig); 2807 if (gdbsig != TARGET_SIGTRAP) { 2808 exit(EXIT_FAILURE); 2809 } 2810 } 2811 2812 process_pending_signals(env); 2813 } 2814 } 2815 2816 #endif /* TARGET_OPENRISC */ 2817 2818 #ifdef TARGET_SH4 2819 void cpu_loop(CPUSH4State *env) 2820 { 2821 CPUState *cs = CPU(sh_env_get_cpu(env)); 2822 int trapnr, ret; 2823 target_siginfo_t info; 2824 2825 while (1) { 2826 cpu_exec_start(cs); 2827 trapnr = cpu_exec(cs); 2828 cpu_exec_end(cs); 2829 2830 switch (trapnr) { 2831 case 0x160: 2832 env->pc += 2; 2833 ret = do_syscall(env, 2834 env->gregs[3], 2835 env->gregs[4], 2836 env->gregs[5], 2837 env->gregs[6], 2838 env->gregs[7], 2839 env->gregs[0], 2840 env->gregs[1], 2841 0, 0); 2842 if (ret == -TARGET_ERESTARTSYS) { 2843 env->pc -= 2; 2844 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 2845 env->gregs[0] = ret; 2846 } 2847 break; 2848 case EXCP_INTERRUPT: 2849 /* just indicate that signals should be handled asap */ 2850 break; 2851 case EXCP_DEBUG: 2852 { 2853 int sig; 2854 2855 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 2856 if (sig) 2857 { 2858 info.si_signo = sig; 2859 info.si_errno = 0; 2860 info.si_code = TARGET_TRAP_BRKPT; 2861 queue_signal(env, info.si_signo, &info); 2862 } 2863 } 2864 break; 2865 case 0xa0: 2866 case 0xc0: 2867 info.si_signo = TARGET_SIGSEGV; 2868 info.si_errno = 0; 2869 info.si_code = TARGET_SEGV_MAPERR; 2870 info._sifields._sigfault._addr = env->tea; 2871 queue_signal(env, info.si_signo, &info); 2872 break; 2873 2874 default: 2875 printf ("Unhandled trap: 0x%x\n", trapnr); 2876 cpu_dump_state(cs, stderr, fprintf, 0); 2877 exit(EXIT_FAILURE); 2878 } 2879 process_pending_signals (env); 2880 } 2881 } 2882 #endif 2883 2884 #ifdef TARGET_CRIS 2885 void cpu_loop(CPUCRISState *env) 2886 { 2887 CPUState *cs = CPU(cris_env_get_cpu(env)); 2888 int trapnr, ret; 2889 target_siginfo_t info; 2890 2891 while (1) { 2892 cpu_exec_start(cs); 2893 trapnr = cpu_exec(cs); 2894 cpu_exec_end(cs); 2895 switch (trapnr) { 2896 case 0xaa: 2897 { 2898 info.si_signo = TARGET_SIGSEGV; 2899 info.si_errno = 0; 2900 /* XXX: check env->error_code */ 2901 info.si_code = TARGET_SEGV_MAPERR; 2902 info._sifields._sigfault._addr = env->pregs[PR_EDA]; 2903 queue_signal(env, info.si_signo, &info); 2904 } 2905 break; 2906 case EXCP_INTERRUPT: 2907 /* just indicate that signals should be handled asap */ 2908 break; 2909 case EXCP_BREAK: 2910 ret = do_syscall(env, 2911 env->regs[9], 2912 env->regs[10], 2913 env->regs[11], 2914 env->regs[12], 2915 env->regs[13], 2916 env->pregs[7], 2917 env->pregs[11], 2918 0, 0); 2919 if (ret == -TARGET_ERESTARTSYS) { 2920 env->pc -= 2; 2921 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 2922 env->regs[10] = ret; 2923 } 2924 break; 2925 case EXCP_DEBUG: 2926 { 2927 int sig; 2928 2929 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 2930 if (sig) 2931 { 2932 info.si_signo = sig; 2933 info.si_errno = 0; 2934 info.si_code = TARGET_TRAP_BRKPT; 2935 queue_signal(env, info.si_signo, &info); 2936 } 2937 } 2938 break; 2939 default: 2940 printf ("Unhandled trap: 0x%x\n", trapnr); 2941 cpu_dump_state(cs, stderr, fprintf, 0); 2942 exit(EXIT_FAILURE); 2943 } 2944 process_pending_signals (env); 2945 } 2946 } 2947 #endif 2948 2949 #ifdef TARGET_MICROBLAZE 2950 void cpu_loop(CPUMBState *env) 2951 { 2952 CPUState *cs = CPU(mb_env_get_cpu(env)); 2953 int trapnr, ret; 2954 target_siginfo_t info; 2955 2956 while (1) { 2957 cpu_exec_start(cs); 2958 trapnr = cpu_exec(cs); 2959 cpu_exec_end(cs); 2960 switch (trapnr) { 2961 case 0xaa: 2962 { 2963 info.si_signo = TARGET_SIGSEGV; 2964 info.si_errno = 0; 2965 /* XXX: check env->error_code */ 2966 info.si_code = TARGET_SEGV_MAPERR; 2967 info._sifields._sigfault._addr = 0; 2968 queue_signal(env, info.si_signo, &info); 2969 } 2970 break; 2971 case EXCP_INTERRUPT: 2972 /* just indicate that signals should be handled asap */ 2973 break; 2974 case EXCP_BREAK: 2975 /* Return address is 4 bytes after the call. */ 2976 env->regs[14] += 4; 2977 env->sregs[SR_PC] = env->regs[14]; 2978 ret = do_syscall(env, 2979 env->regs[12], 2980 env->regs[5], 2981 env->regs[6], 2982 env->regs[7], 2983 env->regs[8], 2984 env->regs[9], 2985 env->regs[10], 2986 0, 0); 2987 if (ret == -TARGET_ERESTARTSYS) { 2988 /* Wind back to before the syscall. */ 2989 env->sregs[SR_PC] -= 4; 2990 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 2991 env->regs[3] = ret; 2992 } 2993 /* All syscall exits result in guest r14 being equal to the 2994 * PC we return to, because the kernel syscall exit "rtbd" does 2995 * this. (This is true even for sigreturn(); note that r14 is 2996 * not a userspace-usable register, as the kernel may clobber it 2997 * at any point.) 2998 */ 2999 env->regs[14] = env->sregs[SR_PC]; 3000 break; 3001 case EXCP_HW_EXCP: 3002 env->regs[17] = env->sregs[SR_PC] + 4; 3003 if (env->iflags & D_FLAG) { 3004 env->sregs[SR_ESR] |= 1 << 12; 3005 env->sregs[SR_PC] -= 4; 3006 /* FIXME: if branch was immed, replay the imm as well. */ 3007 } 3008 3009 env->iflags &= ~(IMM_FLAG | D_FLAG); 3010 3011 switch (env->sregs[SR_ESR] & 31) { 3012 case ESR_EC_DIVZERO: 3013 info.si_signo = TARGET_SIGFPE; 3014 info.si_errno = 0; 3015 info.si_code = TARGET_FPE_FLTDIV; 3016 info._sifields._sigfault._addr = 0; 3017 queue_signal(env, info.si_signo, &info); 3018 break; 3019 case ESR_EC_FPU: 3020 info.si_signo = TARGET_SIGFPE; 3021 info.si_errno = 0; 3022 if (env->sregs[SR_FSR] & FSR_IO) { 3023 info.si_code = TARGET_FPE_FLTINV; 3024 } 3025 if (env->sregs[SR_FSR] & FSR_DZ) { 3026 info.si_code = TARGET_FPE_FLTDIV; 3027 } 3028 info._sifields._sigfault._addr = 0; 3029 queue_signal(env, info.si_signo, &info); 3030 break; 3031 default: 3032 printf ("Unhandled hw-exception: 0x%x\n", 3033 env->sregs[SR_ESR] & ESR_EC_MASK); 3034 cpu_dump_state(cs, stderr, fprintf, 0); 3035 exit(EXIT_FAILURE); 3036 break; 3037 } 3038 break; 3039 case EXCP_DEBUG: 3040 { 3041 int sig; 3042 3043 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 3044 if (sig) 3045 { 3046 info.si_signo = sig; 3047 info.si_errno = 0; 3048 info.si_code = TARGET_TRAP_BRKPT; 3049 queue_signal(env, info.si_signo, &info); 3050 } 3051 } 3052 break; 3053 default: 3054 printf ("Unhandled trap: 0x%x\n", trapnr); 3055 cpu_dump_state(cs, stderr, fprintf, 0); 3056 exit(EXIT_FAILURE); 3057 } 3058 process_pending_signals (env); 3059 } 3060 } 3061 #endif 3062 3063 #ifdef TARGET_M68K 3064 3065 void cpu_loop(CPUM68KState *env) 3066 { 3067 CPUState *cs = CPU(m68k_env_get_cpu(env)); 3068 int trapnr; 3069 unsigned int n; 3070 target_siginfo_t info; 3071 TaskState *ts = cs->opaque; 3072 3073 for(;;) { 3074 cpu_exec_start(cs); 3075 trapnr = cpu_exec(cs); 3076 cpu_exec_end(cs); 3077 switch(trapnr) { 3078 case EXCP_ILLEGAL: 3079 { 3080 if (ts->sim_syscalls) { 3081 uint16_t nr; 3082 get_user_u16(nr, env->pc + 2); 3083 env->pc += 4; 3084 do_m68k_simcall(env, nr); 3085 } else { 3086 goto do_sigill; 3087 } 3088 } 3089 break; 3090 case EXCP_HALT_INSN: 3091 /* Semihosing syscall. */ 3092 env->pc += 4; 3093 do_m68k_semihosting(env, env->dregs[0]); 3094 break; 3095 case EXCP_LINEA: 3096 case EXCP_LINEF: 3097 case EXCP_UNSUPPORTED: 3098 do_sigill: 3099 info.si_signo = TARGET_SIGILL; 3100 info.si_errno = 0; 3101 info.si_code = TARGET_ILL_ILLOPN; 3102 info._sifields._sigfault._addr = env->pc; 3103 queue_signal(env, info.si_signo, &info); 3104 break; 3105 case EXCP_TRAP0: 3106 { 3107 abi_long ret; 3108 ts->sim_syscalls = 0; 3109 n = env->dregs[0]; 3110 env->pc += 2; 3111 ret = do_syscall(env, 3112 n, 3113 env->dregs[1], 3114 env->dregs[2], 3115 env->dregs[3], 3116 env->dregs[4], 3117 env->dregs[5], 3118 env->aregs[0], 3119 0, 0); 3120 if (ret == -TARGET_ERESTARTSYS) { 3121 env->pc -= 2; 3122 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 3123 env->dregs[0] = ret; 3124 } 3125 } 3126 break; 3127 case EXCP_INTERRUPT: 3128 /* just indicate that signals should be handled asap */ 3129 break; 3130 case EXCP_ACCESS: 3131 { 3132 info.si_signo = TARGET_SIGSEGV; 3133 info.si_errno = 0; 3134 /* XXX: check env->error_code */ 3135 info.si_code = TARGET_SEGV_MAPERR; 3136 info._sifields._sigfault._addr = env->mmu.ar; 3137 queue_signal(env, info.si_signo, &info); 3138 } 3139 break; 3140 case EXCP_DEBUG: 3141 { 3142 int sig; 3143 3144 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 3145 if (sig) 3146 { 3147 info.si_signo = sig; 3148 info.si_errno = 0; 3149 info.si_code = TARGET_TRAP_BRKPT; 3150 queue_signal(env, info.si_signo, &info); 3151 } 3152 } 3153 break; 3154 default: 3155 EXCP_DUMP(env, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr); 3156 abort(); 3157 } 3158 process_pending_signals(env); 3159 } 3160 } 3161 #endif /* TARGET_M68K */ 3162 3163 #ifdef TARGET_ALPHA 3164 static void do_store_exclusive(CPUAlphaState *env, int reg, int quad) 3165 { 3166 target_ulong addr, val, tmp; 3167 target_siginfo_t info; 3168 int ret = 0; 3169 3170 addr = env->lock_addr; 3171 tmp = env->lock_st_addr; 3172 env->lock_addr = -1; 3173 env->lock_st_addr = 0; 3174 3175 start_exclusive(); 3176 mmap_lock(); 3177 3178 if (addr == tmp) { 3179 if (quad ? get_user_s64(val, addr) : get_user_s32(val, addr)) { 3180 goto do_sigsegv; 3181 } 3182 3183 if (val == env->lock_value) { 3184 tmp = env->ir[reg]; 3185 if (quad ? put_user_u64(tmp, addr) : put_user_u32(tmp, addr)) { 3186 goto do_sigsegv; 3187 } 3188 ret = 1; 3189 } 3190 } 3191 env->ir[reg] = ret; 3192 env->pc += 4; 3193 3194 mmap_unlock(); 3195 end_exclusive(); 3196 return; 3197 3198 do_sigsegv: 3199 mmap_unlock(); 3200 end_exclusive(); 3201 3202 info.si_signo = TARGET_SIGSEGV; 3203 info.si_errno = 0; 3204 info.si_code = TARGET_SEGV_MAPERR; 3205 info._sifields._sigfault._addr = addr; 3206 queue_signal(env, TARGET_SIGSEGV, &info); 3207 } 3208 3209 void cpu_loop(CPUAlphaState *env) 3210 { 3211 CPUState *cs = CPU(alpha_env_get_cpu(env)); 3212 int trapnr; 3213 target_siginfo_t info; 3214 abi_long sysret; 3215 3216 while (1) { 3217 cpu_exec_start(cs); 3218 trapnr = cpu_exec(cs); 3219 cpu_exec_end(cs); 3220 3221 /* All of the traps imply a transition through PALcode, which 3222 implies an REI instruction has been executed. Which means 3223 that the intr_flag should be cleared. */ 3224 env->intr_flag = 0; 3225 3226 switch (trapnr) { 3227 case EXCP_RESET: 3228 fprintf(stderr, "Reset requested. Exit\n"); 3229 exit(EXIT_FAILURE); 3230 break; 3231 case EXCP_MCHK: 3232 fprintf(stderr, "Machine check exception. Exit\n"); 3233 exit(EXIT_FAILURE); 3234 break; 3235 case EXCP_SMP_INTERRUPT: 3236 case EXCP_CLK_INTERRUPT: 3237 case EXCP_DEV_INTERRUPT: 3238 fprintf(stderr, "External interrupt. Exit\n"); 3239 exit(EXIT_FAILURE); 3240 break; 3241 case EXCP_MMFAULT: 3242 env->lock_addr = -1; 3243 info.si_signo = TARGET_SIGSEGV; 3244 info.si_errno = 0; 3245 info.si_code = (page_get_flags(env->trap_arg0) & PAGE_VALID 3246 ? TARGET_SEGV_ACCERR : TARGET_SEGV_MAPERR); 3247 info._sifields._sigfault._addr = env->trap_arg0; 3248 queue_signal(env, info.si_signo, &info); 3249 break; 3250 case EXCP_UNALIGN: 3251 env->lock_addr = -1; 3252 info.si_signo = TARGET_SIGBUS; 3253 info.si_errno = 0; 3254 info.si_code = TARGET_BUS_ADRALN; 3255 info._sifields._sigfault._addr = env->trap_arg0; 3256 queue_signal(env, info.si_signo, &info); 3257 break; 3258 case EXCP_OPCDEC: 3259 do_sigill: 3260 env->lock_addr = -1; 3261 info.si_signo = TARGET_SIGILL; 3262 info.si_errno = 0; 3263 info.si_code = TARGET_ILL_ILLOPC; 3264 info._sifields._sigfault._addr = env->pc; 3265 queue_signal(env, info.si_signo, &info); 3266 break; 3267 case EXCP_ARITH: 3268 env->lock_addr = -1; 3269 info.si_signo = TARGET_SIGFPE; 3270 info.si_errno = 0; 3271 info.si_code = TARGET_FPE_FLTINV; 3272 info._sifields._sigfault._addr = env->pc; 3273 queue_signal(env, info.si_signo, &info); 3274 break; 3275 case EXCP_FEN: 3276 /* No-op. Linux simply re-enables the FPU. */ 3277 break; 3278 case EXCP_CALL_PAL: 3279 env->lock_addr = -1; 3280 switch (env->error_code) { 3281 case 0x80: 3282 /* BPT */ 3283 info.si_signo = TARGET_SIGTRAP; 3284 info.si_errno = 0; 3285 info.si_code = TARGET_TRAP_BRKPT; 3286 info._sifields._sigfault._addr = env->pc; 3287 queue_signal(env, info.si_signo, &info); 3288 break; 3289 case 0x81: 3290 /* BUGCHK */ 3291 info.si_signo = TARGET_SIGTRAP; 3292 info.si_errno = 0; 3293 info.si_code = 0; 3294 info._sifields._sigfault._addr = env->pc; 3295 queue_signal(env, info.si_signo, &info); 3296 break; 3297 case 0x83: 3298 /* CALLSYS */ 3299 trapnr = env->ir[IR_V0]; 3300 sysret = do_syscall(env, trapnr, 3301 env->ir[IR_A0], env->ir[IR_A1], 3302 env->ir[IR_A2], env->ir[IR_A3], 3303 env->ir[IR_A4], env->ir[IR_A5], 3304 0, 0); 3305 if (sysret == -TARGET_ERESTARTSYS) { 3306 env->pc -= 4; 3307 break; 3308 } 3309 if (sysret == -TARGET_QEMU_ESIGRETURN) { 3310 break; 3311 } 3312 /* Syscall writes 0 to V0 to bypass error check, similar 3313 to how this is handled internal to Linux kernel. 3314 (Ab)use trapnr temporarily as boolean indicating error. */ 3315 trapnr = (env->ir[IR_V0] != 0 && sysret < 0); 3316 env->ir[IR_V0] = (trapnr ? -sysret : sysret); 3317 env->ir[IR_A3] = trapnr; 3318 break; 3319 case 0x86: 3320 /* IMB */ 3321 /* ??? We can probably elide the code using page_unprotect 3322 that is checking for self-modifying code. Instead we 3323 could simply call tb_flush here. Until we work out the 3324 changes required to turn off the extra write protection, 3325 this can be a no-op. */ 3326 break; 3327 case 0x9E: 3328 /* RDUNIQUE */ 3329 /* Handled in the translator for usermode. */ 3330 abort(); 3331 case 0x9F: 3332 /* WRUNIQUE */ 3333 /* Handled in the translator for usermode. */ 3334 abort(); 3335 case 0xAA: 3336 /* GENTRAP */ 3337 info.si_signo = TARGET_SIGFPE; 3338 switch (env->ir[IR_A0]) { 3339 case TARGET_GEN_INTOVF: 3340 info.si_code = TARGET_FPE_INTOVF; 3341 break; 3342 case TARGET_GEN_INTDIV: 3343 info.si_code = TARGET_FPE_INTDIV; 3344 break; 3345 case TARGET_GEN_FLTOVF: 3346 info.si_code = TARGET_FPE_FLTOVF; 3347 break; 3348 case TARGET_GEN_FLTUND: 3349 info.si_code = TARGET_FPE_FLTUND; 3350 break; 3351 case TARGET_GEN_FLTINV: 3352 info.si_code = TARGET_FPE_FLTINV; 3353 break; 3354 case TARGET_GEN_FLTINE: 3355 info.si_code = TARGET_FPE_FLTRES; 3356 break; 3357 case TARGET_GEN_ROPRAND: 3358 info.si_code = 0; 3359 break; 3360 default: 3361 info.si_signo = TARGET_SIGTRAP; 3362 info.si_code = 0; 3363 break; 3364 } 3365 info.si_errno = 0; 3366 info._sifields._sigfault._addr = env->pc; 3367 queue_signal(env, info.si_signo, &info); 3368 break; 3369 default: 3370 goto do_sigill; 3371 } 3372 break; 3373 case EXCP_DEBUG: 3374 info.si_signo = gdb_handlesig(cs, TARGET_SIGTRAP); 3375 if (info.si_signo) { 3376 env->lock_addr = -1; 3377 info.si_errno = 0; 3378 info.si_code = TARGET_TRAP_BRKPT; 3379 queue_signal(env, info.si_signo, &info); 3380 } 3381 break; 3382 case EXCP_STL_C: 3383 case EXCP_STQ_C: 3384 do_store_exclusive(env, env->error_code, trapnr - EXCP_STL_C); 3385 break; 3386 case EXCP_INTERRUPT: 3387 /* Just indicate that signals should be handled asap. */ 3388 break; 3389 default: 3390 printf ("Unhandled trap: 0x%x\n", trapnr); 3391 cpu_dump_state(cs, stderr, fprintf, 0); 3392 exit(EXIT_FAILURE); 3393 } 3394 process_pending_signals (env); 3395 } 3396 } 3397 #endif /* TARGET_ALPHA */ 3398 3399 #ifdef TARGET_S390X 3400 void cpu_loop(CPUS390XState *env) 3401 { 3402 CPUState *cs = CPU(s390_env_get_cpu(env)); 3403 int trapnr, n, sig; 3404 target_siginfo_t info; 3405 target_ulong addr; 3406 abi_long ret; 3407 3408 while (1) { 3409 cpu_exec_start(cs); 3410 trapnr = cpu_exec(cs); 3411 cpu_exec_end(cs); 3412 switch (trapnr) { 3413 case EXCP_INTERRUPT: 3414 /* Just indicate that signals should be handled asap. */ 3415 break; 3416 3417 case EXCP_SVC: 3418 n = env->int_svc_code; 3419 if (!n) { 3420 /* syscalls > 255 */ 3421 n = env->regs[1]; 3422 } 3423 env->psw.addr += env->int_svc_ilen; 3424 ret = do_syscall(env, n, env->regs[2], env->regs[3], 3425 env->regs[4], env->regs[5], 3426 env->regs[6], env->regs[7], 0, 0); 3427 if (ret == -TARGET_ERESTARTSYS) { 3428 env->psw.addr -= env->int_svc_ilen; 3429 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 3430 env->regs[2] = ret; 3431 } 3432 break; 3433 3434 case EXCP_DEBUG: 3435 sig = gdb_handlesig(cs, TARGET_SIGTRAP); 3436 if (sig) { 3437 n = TARGET_TRAP_BRKPT; 3438 goto do_signal_pc; 3439 } 3440 break; 3441 case EXCP_PGM: 3442 n = env->int_pgm_code; 3443 switch (n) { 3444 case PGM_OPERATION: 3445 case PGM_PRIVILEGED: 3446 sig = TARGET_SIGILL; 3447 n = TARGET_ILL_ILLOPC; 3448 goto do_signal_pc; 3449 case PGM_PROTECTION: 3450 case PGM_ADDRESSING: 3451 sig = TARGET_SIGSEGV; 3452 /* XXX: check env->error_code */ 3453 n = TARGET_SEGV_MAPERR; 3454 addr = env->__excp_addr; 3455 goto do_signal; 3456 case PGM_EXECUTE: 3457 case PGM_SPECIFICATION: 3458 case PGM_SPECIAL_OP: 3459 case PGM_OPERAND: 3460 do_sigill_opn: 3461 sig = TARGET_SIGILL; 3462 n = TARGET_ILL_ILLOPN; 3463 goto do_signal_pc; 3464 3465 case PGM_FIXPT_OVERFLOW: 3466 sig = TARGET_SIGFPE; 3467 n = TARGET_FPE_INTOVF; 3468 goto do_signal_pc; 3469 case PGM_FIXPT_DIVIDE: 3470 sig = TARGET_SIGFPE; 3471 n = TARGET_FPE_INTDIV; 3472 goto do_signal_pc; 3473 3474 case PGM_DATA: 3475 n = (env->fpc >> 8) & 0xff; 3476 if (n == 0xff) { 3477 /* compare-and-trap */ 3478 goto do_sigill_opn; 3479 } else { 3480 /* An IEEE exception, simulated or otherwise. */ 3481 if (n & 0x80) { 3482 n = TARGET_FPE_FLTINV; 3483 } else if (n & 0x40) { 3484 n = TARGET_FPE_FLTDIV; 3485 } else if (n & 0x20) { 3486 n = TARGET_FPE_FLTOVF; 3487 } else if (n & 0x10) { 3488 n = TARGET_FPE_FLTUND; 3489 } else if (n & 0x08) { 3490 n = TARGET_FPE_FLTRES; 3491 } else { 3492 /* ??? Quantum exception; BFP, DFP error. */ 3493 goto do_sigill_opn; 3494 } 3495 sig = TARGET_SIGFPE; 3496 goto do_signal_pc; 3497 } 3498 3499 default: 3500 fprintf(stderr, "Unhandled program exception: %#x\n", n); 3501 cpu_dump_state(cs, stderr, fprintf, 0); 3502 exit(EXIT_FAILURE); 3503 } 3504 break; 3505 3506 do_signal_pc: 3507 addr = env->psw.addr; 3508 do_signal: 3509 info.si_signo = sig; 3510 info.si_errno = 0; 3511 info.si_code = n; 3512 info._sifields._sigfault._addr = addr; 3513 queue_signal(env, info.si_signo, &info); 3514 break; 3515 3516 default: 3517 fprintf(stderr, "Unhandled trap: 0x%x\n", trapnr); 3518 cpu_dump_state(cs, stderr, fprintf, 0); 3519 exit(EXIT_FAILURE); 3520 } 3521 process_pending_signals (env); 3522 } 3523 } 3524 3525 #endif /* TARGET_S390X */ 3526 3527 #ifdef TARGET_TILEGX 3528 3529 static void gen_sigill_reg(CPUTLGState *env) 3530 { 3531 target_siginfo_t info; 3532 3533 info.si_signo = TARGET_SIGILL; 3534 info.si_errno = 0; 3535 info.si_code = TARGET_ILL_PRVREG; 3536 info._sifields._sigfault._addr = env->pc; 3537 queue_signal(env, info.si_signo, &info); 3538 } 3539 3540 static void do_signal(CPUTLGState *env, int signo, int sigcode) 3541 { 3542 target_siginfo_t info; 3543 3544 info.si_signo = signo; 3545 info.si_errno = 0; 3546 info._sifields._sigfault._addr = env->pc; 3547 3548 if (signo == TARGET_SIGSEGV) { 3549 /* The passed in sigcode is a dummy; check for a page mapping 3550 and pass either MAPERR or ACCERR. */ 3551 target_ulong addr = env->excaddr; 3552 info._sifields._sigfault._addr = addr; 3553 if (page_check_range(addr, 1, PAGE_VALID) < 0) { 3554 sigcode = TARGET_SEGV_MAPERR; 3555 } else { 3556 sigcode = TARGET_SEGV_ACCERR; 3557 } 3558 } 3559 info.si_code = sigcode; 3560 3561 queue_signal(env, info.si_signo, &info); 3562 } 3563 3564 static void gen_sigsegv_maperr(CPUTLGState *env, target_ulong addr) 3565 { 3566 env->excaddr = addr; 3567 do_signal(env, TARGET_SIGSEGV, 0); 3568 } 3569 3570 static void set_regval(CPUTLGState *env, uint8_t reg, uint64_t val) 3571 { 3572 if (unlikely(reg >= TILEGX_R_COUNT)) { 3573 switch (reg) { 3574 case TILEGX_R_SN: 3575 case TILEGX_R_ZERO: 3576 return; 3577 case TILEGX_R_IDN0: 3578 case TILEGX_R_IDN1: 3579 case TILEGX_R_UDN0: 3580 case TILEGX_R_UDN1: 3581 case TILEGX_R_UDN2: 3582 case TILEGX_R_UDN3: 3583 gen_sigill_reg(env); 3584 return; 3585 default: 3586 g_assert_not_reached(); 3587 } 3588 } 3589 env->regs[reg] = val; 3590 } 3591 3592 /* 3593 * Compare the 8-byte contents of the CmpValue SPR with the 8-byte value in 3594 * memory at the address held in the first source register. If the values are 3595 * not equal, then no memory operation is performed. If the values are equal, 3596 * the 8-byte quantity from the second source register is written into memory 3597 * at the address held in the first source register. In either case, the result 3598 * of the instruction is the value read from memory. The compare and write to 3599 * memory are atomic and thus can be used for synchronization purposes. This 3600 * instruction only operates for addresses aligned to a 8-byte boundary. 3601 * Unaligned memory access causes an Unaligned Data Reference interrupt. 3602 * 3603 * Functional Description (64-bit) 3604 * uint64_t memVal = memoryReadDoubleWord (rf[SrcA]); 3605 * rf[Dest] = memVal; 3606 * if (memVal == SPR[CmpValueSPR]) 3607 * memoryWriteDoubleWord (rf[SrcA], rf[SrcB]); 3608 * 3609 * Functional Description (32-bit) 3610 * uint64_t memVal = signExtend32 (memoryReadWord (rf[SrcA])); 3611 * rf[Dest] = memVal; 3612 * if (memVal == signExtend32 (SPR[CmpValueSPR])) 3613 * memoryWriteWord (rf[SrcA], rf[SrcB]); 3614 * 3615 * 3616 * This function also processes exch and exch4 which need not process SPR. 3617 */ 3618 static void do_exch(CPUTLGState *env, bool quad, bool cmp) 3619 { 3620 target_ulong addr; 3621 target_long val, sprval; 3622 3623 start_exclusive(); 3624 3625 addr = env->atomic_srca; 3626 if (quad ? get_user_s64(val, addr) : get_user_s32(val, addr)) { 3627 goto sigsegv_maperr; 3628 } 3629 3630 if (cmp) { 3631 if (quad) { 3632 sprval = env->spregs[TILEGX_SPR_CMPEXCH]; 3633 } else { 3634 sprval = sextract64(env->spregs[TILEGX_SPR_CMPEXCH], 0, 32); 3635 } 3636 } 3637 3638 if (!cmp || val == sprval) { 3639 target_long valb = env->atomic_srcb; 3640 if (quad ? put_user_u64(valb, addr) : put_user_u32(valb, addr)) { 3641 goto sigsegv_maperr; 3642 } 3643 } 3644 3645 set_regval(env, env->atomic_dstr, val); 3646 end_exclusive(); 3647 return; 3648 3649 sigsegv_maperr: 3650 end_exclusive(); 3651 gen_sigsegv_maperr(env, addr); 3652 } 3653 3654 static void do_fetch(CPUTLGState *env, int trapnr, bool quad) 3655 { 3656 int8_t write = 1; 3657 target_ulong addr; 3658 target_long val, valb; 3659 3660 start_exclusive(); 3661 3662 addr = env->atomic_srca; 3663 valb = env->atomic_srcb; 3664 if (quad ? get_user_s64(val, addr) : get_user_s32(val, addr)) { 3665 goto sigsegv_maperr; 3666 } 3667 3668 switch (trapnr) { 3669 case TILEGX_EXCP_OPCODE_FETCHADD: 3670 case TILEGX_EXCP_OPCODE_FETCHADD4: 3671 valb += val; 3672 break; 3673 case TILEGX_EXCP_OPCODE_FETCHADDGEZ: 3674 valb += val; 3675 if (valb < 0) { 3676 write = 0; 3677 } 3678 break; 3679 case TILEGX_EXCP_OPCODE_FETCHADDGEZ4: 3680 valb += val; 3681 if ((int32_t)valb < 0) { 3682 write = 0; 3683 } 3684 break; 3685 case TILEGX_EXCP_OPCODE_FETCHAND: 3686 case TILEGX_EXCP_OPCODE_FETCHAND4: 3687 valb &= val; 3688 break; 3689 case TILEGX_EXCP_OPCODE_FETCHOR: 3690 case TILEGX_EXCP_OPCODE_FETCHOR4: 3691 valb |= val; 3692 break; 3693 default: 3694 g_assert_not_reached(); 3695 } 3696 3697 if (write) { 3698 if (quad ? put_user_u64(valb, addr) : put_user_u32(valb, addr)) { 3699 goto sigsegv_maperr; 3700 } 3701 } 3702 3703 set_regval(env, env->atomic_dstr, val); 3704 end_exclusive(); 3705 return; 3706 3707 sigsegv_maperr: 3708 end_exclusive(); 3709 gen_sigsegv_maperr(env, addr); 3710 } 3711 3712 void cpu_loop(CPUTLGState *env) 3713 { 3714 CPUState *cs = CPU(tilegx_env_get_cpu(env)); 3715 int trapnr; 3716 3717 while (1) { 3718 cpu_exec_start(cs); 3719 trapnr = cpu_exec(cs); 3720 cpu_exec_end(cs); 3721 switch (trapnr) { 3722 case TILEGX_EXCP_SYSCALL: 3723 { 3724 abi_ulong ret = do_syscall(env, env->regs[TILEGX_R_NR], 3725 env->regs[0], env->regs[1], 3726 env->regs[2], env->regs[3], 3727 env->regs[4], env->regs[5], 3728 env->regs[6], env->regs[7]); 3729 if (ret == -TARGET_ERESTARTSYS) { 3730 env->pc -= 8; 3731 } else if (ret != -TARGET_QEMU_ESIGRETURN) { 3732 env->regs[TILEGX_R_RE] = ret; 3733 env->regs[TILEGX_R_ERR] = TILEGX_IS_ERRNO(ret) ? -ret : 0; 3734 } 3735 break; 3736 } 3737 case TILEGX_EXCP_OPCODE_EXCH: 3738 do_exch(env, true, false); 3739 break; 3740 case TILEGX_EXCP_OPCODE_EXCH4: 3741 do_exch(env, false, false); 3742 break; 3743 case TILEGX_EXCP_OPCODE_CMPEXCH: 3744 do_exch(env, true, true); 3745 break; 3746 case TILEGX_EXCP_OPCODE_CMPEXCH4: 3747 do_exch(env, false, true); 3748 break; 3749 case TILEGX_EXCP_OPCODE_FETCHADD: 3750 case TILEGX_EXCP_OPCODE_FETCHADDGEZ: 3751 case TILEGX_EXCP_OPCODE_FETCHAND: 3752 case TILEGX_EXCP_OPCODE_FETCHOR: 3753 do_fetch(env, trapnr, true); 3754 break; 3755 case TILEGX_EXCP_OPCODE_FETCHADD4: 3756 case TILEGX_EXCP_OPCODE_FETCHADDGEZ4: 3757 case TILEGX_EXCP_OPCODE_FETCHAND4: 3758 case TILEGX_EXCP_OPCODE_FETCHOR4: 3759 do_fetch(env, trapnr, false); 3760 break; 3761 case TILEGX_EXCP_SIGNAL: 3762 do_signal(env, env->signo, env->sigcode); 3763 break; 3764 case TILEGX_EXCP_REG_IDN_ACCESS: 3765 case TILEGX_EXCP_REG_UDN_ACCESS: 3766 gen_sigill_reg(env); 3767 break; 3768 default: 3769 fprintf(stderr, "trapnr is %d[0x%x].\n", trapnr, trapnr); 3770 g_assert_not_reached(); 3771 } 3772 process_pending_signals(env); 3773 } 3774 } 3775 3776 #endif 3777 3778 THREAD CPUState *thread_cpu; 3779 3780 void task_settid(TaskState *ts) 3781 { 3782 if (ts->ts_tid == 0) { 3783 ts->ts_tid = (pid_t)syscall(SYS_gettid); 3784 } 3785 } 3786 3787 void stop_all_tasks(void) 3788 { 3789 /* 3790 * We trust that when using NPTL, start_exclusive() 3791 * handles thread stopping correctly. 3792 */ 3793 start_exclusive(); 3794 } 3795 3796 /* Assumes contents are already zeroed. */ 3797 void init_task_state(TaskState *ts) 3798 { 3799 ts->used = 1; 3800 } 3801 3802 CPUArchState *cpu_copy(CPUArchState *env) 3803 { 3804 CPUState *cpu = ENV_GET_CPU(env); 3805 CPUState *new_cpu = cpu_init(cpu_model); 3806 CPUArchState *new_env = new_cpu->env_ptr; 3807 CPUBreakpoint *bp; 3808 CPUWatchpoint *wp; 3809 3810 /* Reset non arch specific state */ 3811 cpu_reset(new_cpu); 3812 3813 memcpy(new_env, env, sizeof(CPUArchState)); 3814 3815 /* Clone all break/watchpoints. 3816 Note: Once we support ptrace with hw-debug register access, make sure 3817 BP_CPU break/watchpoints are handled correctly on clone. */ 3818 QTAILQ_INIT(&new_cpu->breakpoints); 3819 QTAILQ_INIT(&new_cpu->watchpoints); 3820 QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) { 3821 cpu_breakpoint_insert(new_cpu, bp->pc, bp->flags, NULL); 3822 } 3823 QTAILQ_FOREACH(wp, &cpu->watchpoints, entry) { 3824 cpu_watchpoint_insert(new_cpu, wp->vaddr, wp->len, wp->flags, NULL); 3825 } 3826 3827 return new_env; 3828 } 3829 3830 static void handle_arg_help(const char *arg) 3831 { 3832 usage(EXIT_SUCCESS); 3833 } 3834 3835 static void handle_arg_log(const char *arg) 3836 { 3837 int mask; 3838 3839 mask = qemu_str_to_log_mask(arg); 3840 if (!mask) { 3841 qemu_print_log_usage(stdout); 3842 exit(EXIT_FAILURE); 3843 } 3844 qemu_log_needs_buffers(); 3845 qemu_set_log(mask); 3846 } 3847 3848 static void handle_arg_log_filename(const char *arg) 3849 { 3850 qemu_set_log_filename(arg, &error_fatal); 3851 } 3852 3853 static void handle_arg_set_env(const char *arg) 3854 { 3855 char *r, *p, *token; 3856 r = p = strdup(arg); 3857 while ((token = strsep(&p, ",")) != NULL) { 3858 if (envlist_setenv(envlist, token) != 0) { 3859 usage(EXIT_FAILURE); 3860 } 3861 } 3862 free(r); 3863 } 3864 3865 static void handle_arg_unset_env(const char *arg) 3866 { 3867 char *r, *p, *token; 3868 r = p = strdup(arg); 3869 while ((token = strsep(&p, ",")) != NULL) { 3870 if (envlist_unsetenv(envlist, token) != 0) { 3871 usage(EXIT_FAILURE); 3872 } 3873 } 3874 free(r); 3875 } 3876 3877 static void handle_arg_argv0(const char *arg) 3878 { 3879 argv0 = strdup(arg); 3880 } 3881 3882 static void handle_arg_stack_size(const char *arg) 3883 { 3884 char *p; 3885 guest_stack_size = strtoul(arg, &p, 0); 3886 if (guest_stack_size == 0) { 3887 usage(EXIT_FAILURE); 3888 } 3889 3890 if (*p == 'M') { 3891 guest_stack_size *= 1024 * 1024; 3892 } else if (*p == 'k' || *p == 'K') { 3893 guest_stack_size *= 1024; 3894 } 3895 } 3896 3897 static void handle_arg_ld_prefix(const char *arg) 3898 { 3899 interp_prefix = strdup(arg); 3900 } 3901 3902 static void handle_arg_pagesize(const char *arg) 3903 { 3904 qemu_host_page_size = atoi(arg); 3905 if (qemu_host_page_size == 0 || 3906 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) { 3907 fprintf(stderr, "page size must be a power of two\n"); 3908 exit(EXIT_FAILURE); 3909 } 3910 } 3911 3912 static void handle_arg_randseed(const char *arg) 3913 { 3914 unsigned long long seed; 3915 3916 if (parse_uint_full(arg, &seed, 0) != 0 || seed > UINT_MAX) { 3917 fprintf(stderr, "Invalid seed number: %s\n", arg); 3918 exit(EXIT_FAILURE); 3919 } 3920 srand(seed); 3921 } 3922 3923 static void handle_arg_gdb(const char *arg) 3924 { 3925 gdbstub_port = atoi(arg); 3926 } 3927 3928 static void handle_arg_uname(const char *arg) 3929 { 3930 qemu_uname_release = strdup(arg); 3931 } 3932 3933 static void handle_arg_cpu(const char *arg) 3934 { 3935 cpu_model = strdup(arg); 3936 if (cpu_model == NULL || is_help_option(cpu_model)) { 3937 /* XXX: implement xxx_cpu_list for targets that still miss it */ 3938 #if defined(cpu_list) 3939 cpu_list(stdout, &fprintf); 3940 #endif 3941 exit(EXIT_FAILURE); 3942 } 3943 } 3944 3945 static void handle_arg_guest_base(const char *arg) 3946 { 3947 guest_base = strtol(arg, NULL, 0); 3948 have_guest_base = 1; 3949 } 3950 3951 static void handle_arg_reserved_va(const char *arg) 3952 { 3953 char *p; 3954 int shift = 0; 3955 reserved_va = strtoul(arg, &p, 0); 3956 switch (*p) { 3957 case 'k': 3958 case 'K': 3959 shift = 10; 3960 break; 3961 case 'M': 3962 shift = 20; 3963 break; 3964 case 'G': 3965 shift = 30; 3966 break; 3967 } 3968 if (shift) { 3969 unsigned long unshifted = reserved_va; 3970 p++; 3971 reserved_va <<= shift; 3972 if (((reserved_va >> shift) != unshifted) 3973 #if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS 3974 || (reserved_va > (1ul << TARGET_VIRT_ADDR_SPACE_BITS)) 3975 #endif 3976 ) { 3977 fprintf(stderr, "Reserved virtual address too big\n"); 3978 exit(EXIT_FAILURE); 3979 } 3980 } 3981 if (*p) { 3982 fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p); 3983 exit(EXIT_FAILURE); 3984 } 3985 } 3986 3987 static void handle_arg_singlestep(const char *arg) 3988 { 3989 singlestep = 1; 3990 } 3991 3992 static void handle_arg_strace(const char *arg) 3993 { 3994 do_strace = 1; 3995 } 3996 3997 static void handle_arg_version(const char *arg) 3998 { 3999 printf("qemu-" TARGET_NAME " version " QEMU_VERSION QEMU_PKGVERSION 4000 ", Copyright (c) 2003-2008 Fabrice Bellard\n"); 4001 exit(EXIT_SUCCESS); 4002 } 4003 4004 struct qemu_argument { 4005 const char *argv; 4006 const char *env; 4007 bool has_arg; 4008 void (*handle_opt)(const char *arg); 4009 const char *example; 4010 const char *help; 4011 }; 4012 4013 static const struct qemu_argument arg_table[] = { 4014 {"h", "", false, handle_arg_help, 4015 "", "print this help"}, 4016 {"help", "", false, handle_arg_help, 4017 "", ""}, 4018 {"g", "QEMU_GDB", true, handle_arg_gdb, 4019 "port", "wait gdb connection to 'port'"}, 4020 {"L", "QEMU_LD_PREFIX", true, handle_arg_ld_prefix, 4021 "path", "set the elf interpreter prefix to 'path'"}, 4022 {"s", "QEMU_STACK_SIZE", true, handle_arg_stack_size, 4023 "size", "set the stack size to 'size' bytes"}, 4024 {"cpu", "QEMU_CPU", true, handle_arg_cpu, 4025 "model", "select CPU (-cpu help for list)"}, 4026 {"E", "QEMU_SET_ENV", true, handle_arg_set_env, 4027 "var=value", "sets targets environment variable (see below)"}, 4028 {"U", "QEMU_UNSET_ENV", true, handle_arg_unset_env, 4029 "var", "unsets targets environment variable (see below)"}, 4030 {"0", "QEMU_ARGV0", true, handle_arg_argv0, 4031 "argv0", "forces target process argv[0] to be 'argv0'"}, 4032 {"r", "QEMU_UNAME", true, handle_arg_uname, 4033 "uname", "set qemu uname release string to 'uname'"}, 4034 {"B", "QEMU_GUEST_BASE", true, handle_arg_guest_base, 4035 "address", "set guest_base address to 'address'"}, 4036 {"R", "QEMU_RESERVED_VA", true, handle_arg_reserved_va, 4037 "size", "reserve 'size' bytes for guest virtual address space"}, 4038 {"d", "QEMU_LOG", true, handle_arg_log, 4039 "item[,...]", "enable logging of specified items " 4040 "(use '-d help' for a list of items)"}, 4041 {"D", "QEMU_LOG_FILENAME", true, handle_arg_log_filename, 4042 "logfile", "write logs to 'logfile' (default stderr)"}, 4043 {"p", "QEMU_PAGESIZE", true, handle_arg_pagesize, 4044 "pagesize", "set the host page size to 'pagesize'"}, 4045 {"singlestep", "QEMU_SINGLESTEP", false, handle_arg_singlestep, 4046 "", "run in singlestep mode"}, 4047 {"strace", "QEMU_STRACE", false, handle_arg_strace, 4048 "", "log system calls"}, 4049 {"seed", "QEMU_RAND_SEED", true, handle_arg_randseed, 4050 "", "Seed for pseudo-random number generator"}, 4051 {"version", "QEMU_VERSION", false, handle_arg_version, 4052 "", "display version information and exit"}, 4053 {NULL, NULL, false, NULL, NULL, NULL} 4054 }; 4055 4056 static void usage(int exitcode) 4057 { 4058 const struct qemu_argument *arginfo; 4059 int maxarglen; 4060 int maxenvlen; 4061 4062 printf("usage: qemu-" TARGET_NAME " [options] program [arguments...]\n" 4063 "Linux CPU emulator (compiled for " TARGET_NAME " emulation)\n" 4064 "\n" 4065 "Options and associated environment variables:\n" 4066 "\n"); 4067 4068 /* Calculate column widths. We must always have at least enough space 4069 * for the column header. 4070 */ 4071 maxarglen = strlen("Argument"); 4072 maxenvlen = strlen("Env-variable"); 4073 4074 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 4075 int arglen = strlen(arginfo->argv); 4076 if (arginfo->has_arg) { 4077 arglen += strlen(arginfo->example) + 1; 4078 } 4079 if (strlen(arginfo->env) > maxenvlen) { 4080 maxenvlen = strlen(arginfo->env); 4081 } 4082 if (arglen > maxarglen) { 4083 maxarglen = arglen; 4084 } 4085 } 4086 4087 printf("%-*s %-*s Description\n", maxarglen+1, "Argument", 4088 maxenvlen, "Env-variable"); 4089 4090 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 4091 if (arginfo->has_arg) { 4092 printf("-%s %-*s %-*s %s\n", arginfo->argv, 4093 (int)(maxarglen - strlen(arginfo->argv) - 1), 4094 arginfo->example, maxenvlen, arginfo->env, arginfo->help); 4095 } else { 4096 printf("-%-*s %-*s %s\n", maxarglen, arginfo->argv, 4097 maxenvlen, arginfo->env, 4098 arginfo->help); 4099 } 4100 } 4101 4102 printf("\n" 4103 "Defaults:\n" 4104 "QEMU_LD_PREFIX = %s\n" 4105 "QEMU_STACK_SIZE = %ld byte\n", 4106 interp_prefix, 4107 guest_stack_size); 4108 4109 printf("\n" 4110 "You can use -E and -U options or the QEMU_SET_ENV and\n" 4111 "QEMU_UNSET_ENV environment variables to set and unset\n" 4112 "environment variables for the target process.\n" 4113 "It is possible to provide several variables by separating them\n" 4114 "by commas in getsubopt(3) style. Additionally it is possible to\n" 4115 "provide the -E and -U options multiple times.\n" 4116 "The following lines are equivalent:\n" 4117 " -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n" 4118 " -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n" 4119 " QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n" 4120 "Note that if you provide several changes to a single variable\n" 4121 "the last change will stay in effect.\n"); 4122 4123 exit(exitcode); 4124 } 4125 4126 static int parse_args(int argc, char **argv) 4127 { 4128 const char *r; 4129 int optind; 4130 const struct qemu_argument *arginfo; 4131 4132 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 4133 if (arginfo->env == NULL) { 4134 continue; 4135 } 4136 4137 r = getenv(arginfo->env); 4138 if (r != NULL) { 4139 arginfo->handle_opt(r); 4140 } 4141 } 4142 4143 optind = 1; 4144 for (;;) { 4145 if (optind >= argc) { 4146 break; 4147 } 4148 r = argv[optind]; 4149 if (r[0] != '-') { 4150 break; 4151 } 4152 optind++; 4153 r++; 4154 if (!strcmp(r, "-")) { 4155 break; 4156 } 4157 /* Treat --foo the same as -foo. */ 4158 if (r[0] == '-') { 4159 r++; 4160 } 4161 4162 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) { 4163 if (!strcmp(r, arginfo->argv)) { 4164 if (arginfo->has_arg) { 4165 if (optind >= argc) { 4166 (void) fprintf(stderr, 4167 "qemu: missing argument for option '%s'\n", r); 4168 exit(EXIT_FAILURE); 4169 } 4170 arginfo->handle_opt(argv[optind]); 4171 optind++; 4172 } else { 4173 arginfo->handle_opt(NULL); 4174 } 4175 break; 4176 } 4177 } 4178 4179 /* no option matched the current argv */ 4180 if (arginfo->handle_opt == NULL) { 4181 (void) fprintf(stderr, "qemu: unknown option '%s'\n", r); 4182 exit(EXIT_FAILURE); 4183 } 4184 } 4185 4186 if (optind >= argc) { 4187 (void) fprintf(stderr, "qemu: no user program specified\n"); 4188 exit(EXIT_FAILURE); 4189 } 4190 4191 filename = argv[optind]; 4192 exec_path = argv[optind]; 4193 4194 return optind; 4195 } 4196 4197 int main(int argc, char **argv, char **envp) 4198 { 4199 struct target_pt_regs regs1, *regs = ®s1; 4200 struct image_info info1, *info = &info1; 4201 struct linux_binprm bprm; 4202 TaskState *ts; 4203 CPUArchState *env; 4204 CPUState *cpu; 4205 int optind; 4206 char **target_environ, **wrk; 4207 char **target_argv; 4208 int target_argc; 4209 int i; 4210 int ret; 4211 int execfd; 4212 4213 module_call_init(MODULE_INIT_QOM); 4214 4215 if ((envlist = envlist_create()) == NULL) { 4216 (void) fprintf(stderr, "Unable to allocate envlist\n"); 4217 exit(EXIT_FAILURE); 4218 } 4219 4220 /* add current environment into the list */ 4221 for (wrk = environ; *wrk != NULL; wrk++) { 4222 (void) envlist_setenv(envlist, *wrk); 4223 } 4224 4225 /* Read the stack limit from the kernel. If it's "unlimited", 4226 then we can do little else besides use the default. */ 4227 { 4228 struct rlimit lim; 4229 if (getrlimit(RLIMIT_STACK, &lim) == 0 4230 && lim.rlim_cur != RLIM_INFINITY 4231 && lim.rlim_cur == (target_long)lim.rlim_cur) { 4232 guest_stack_size = lim.rlim_cur; 4233 } 4234 } 4235 4236 cpu_model = NULL; 4237 4238 srand(time(NULL)); 4239 4240 optind = parse_args(argc, argv); 4241 4242 /* Zero out regs */ 4243 memset(regs, 0, sizeof(struct target_pt_regs)); 4244 4245 /* Zero out image_info */ 4246 memset(info, 0, sizeof(struct image_info)); 4247 4248 memset(&bprm, 0, sizeof (bprm)); 4249 4250 /* Scan interp_prefix dir for replacement files. */ 4251 init_paths(interp_prefix); 4252 4253 init_qemu_uname_release(); 4254 4255 if (cpu_model == NULL) { 4256 #if defined(TARGET_I386) 4257 #ifdef TARGET_X86_64 4258 cpu_model = "qemu64"; 4259 #else 4260 cpu_model = "qemu32"; 4261 #endif 4262 #elif defined(TARGET_ARM) 4263 cpu_model = "any"; 4264 #elif defined(TARGET_UNICORE32) 4265 cpu_model = "any"; 4266 #elif defined(TARGET_M68K) 4267 cpu_model = "any"; 4268 #elif defined(TARGET_SPARC) 4269 #ifdef TARGET_SPARC64 4270 cpu_model = "TI UltraSparc II"; 4271 #else 4272 cpu_model = "Fujitsu MB86904"; 4273 #endif 4274 #elif defined(TARGET_MIPS) 4275 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64) 4276 cpu_model = "5KEf"; 4277 #else 4278 cpu_model = "24Kf"; 4279 #endif 4280 #elif defined TARGET_OPENRISC 4281 cpu_model = "or1200"; 4282 #elif defined(TARGET_PPC) 4283 # ifdef TARGET_PPC64 4284 cpu_model = "POWER8"; 4285 # else 4286 cpu_model = "750"; 4287 # endif 4288 #elif defined TARGET_SH4 4289 cpu_model = TYPE_SH7785_CPU; 4290 #else 4291 cpu_model = "any"; 4292 #endif 4293 } 4294 tcg_exec_init(0); 4295 /* NOTE: we need to init the CPU at this stage to get 4296 qemu_host_page_size */ 4297 cpu = cpu_init(cpu_model); 4298 if (!cpu) { 4299 fprintf(stderr, "Unable to find CPU definition\n"); 4300 exit(EXIT_FAILURE); 4301 } 4302 env = cpu->env_ptr; 4303 cpu_reset(cpu); 4304 4305 thread_cpu = cpu; 4306 4307 if (getenv("QEMU_STRACE")) { 4308 do_strace = 1; 4309 } 4310 4311 if (getenv("QEMU_RAND_SEED")) { 4312 handle_arg_randseed(getenv("QEMU_RAND_SEED")); 4313 } 4314 4315 target_environ = envlist_to_environ(envlist, NULL); 4316 envlist_free(envlist); 4317 4318 /* 4319 * Now that page sizes are configured in cpu_init() we can do 4320 * proper page alignment for guest_base. 4321 */ 4322 guest_base = HOST_PAGE_ALIGN(guest_base); 4323 4324 if (reserved_va || have_guest_base) { 4325 guest_base = init_guest_space(guest_base, reserved_va, 0, 4326 have_guest_base); 4327 if (guest_base == (unsigned long)-1) { 4328 fprintf(stderr, "Unable to reserve 0x%lx bytes of virtual address " 4329 "space for use as guest address space (check your virtual " 4330 "memory ulimit setting or reserve less using -R option)\n", 4331 reserved_va); 4332 exit(EXIT_FAILURE); 4333 } 4334 4335 if (reserved_va) { 4336 mmap_next_start = reserved_va; 4337 } 4338 } 4339 4340 /* 4341 * Read in mmap_min_addr kernel parameter. This value is used 4342 * When loading the ELF image to determine whether guest_base 4343 * is needed. It is also used in mmap_find_vma. 4344 */ 4345 { 4346 FILE *fp; 4347 4348 if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) { 4349 unsigned long tmp; 4350 if (fscanf(fp, "%lu", &tmp) == 1) { 4351 mmap_min_addr = tmp; 4352 qemu_log_mask(CPU_LOG_PAGE, "host mmap_min_addr=0x%lx\n", mmap_min_addr); 4353 } 4354 fclose(fp); 4355 } 4356 } 4357 4358 /* 4359 * Prepare copy of argv vector for target. 4360 */ 4361 target_argc = argc - optind; 4362 target_argv = calloc(target_argc + 1, sizeof (char *)); 4363 if (target_argv == NULL) { 4364 (void) fprintf(stderr, "Unable to allocate memory for target_argv\n"); 4365 exit(EXIT_FAILURE); 4366 } 4367 4368 /* 4369 * If argv0 is specified (using '-0' switch) we replace 4370 * argv[0] pointer with the given one. 4371 */ 4372 i = 0; 4373 if (argv0 != NULL) { 4374 target_argv[i++] = strdup(argv0); 4375 } 4376 for (; i < target_argc; i++) { 4377 target_argv[i] = strdup(argv[optind + i]); 4378 } 4379 target_argv[target_argc] = NULL; 4380 4381 ts = g_new0(TaskState, 1); 4382 init_task_state(ts); 4383 /* build Task State */ 4384 ts->info = info; 4385 ts->bprm = &bprm; 4386 cpu->opaque = ts; 4387 task_settid(ts); 4388 4389 execfd = qemu_getauxval(AT_EXECFD); 4390 if (execfd == 0) { 4391 execfd = open(filename, O_RDONLY); 4392 if (execfd < 0) { 4393 printf("Error while loading %s: %s\n", filename, strerror(errno)); 4394 _exit(EXIT_FAILURE); 4395 } 4396 } 4397 4398 ret = loader_exec(execfd, filename, target_argv, target_environ, regs, 4399 info, &bprm); 4400 if (ret != 0) { 4401 printf("Error while loading %s: %s\n", filename, strerror(-ret)); 4402 _exit(EXIT_FAILURE); 4403 } 4404 4405 for (wrk = target_environ; *wrk; wrk++) { 4406 free(*wrk); 4407 } 4408 4409 free(target_environ); 4410 4411 if (qemu_loglevel_mask(CPU_LOG_PAGE)) { 4412 qemu_log("guest_base 0x%lx\n", guest_base); 4413 log_page_dump(); 4414 4415 qemu_log("start_brk 0x" TARGET_ABI_FMT_lx "\n", info->start_brk); 4416 qemu_log("end_code 0x" TARGET_ABI_FMT_lx "\n", info->end_code); 4417 qemu_log("start_code 0x" TARGET_ABI_FMT_lx "\n", 4418 info->start_code); 4419 qemu_log("start_data 0x" TARGET_ABI_FMT_lx "\n", 4420 info->start_data); 4421 qemu_log("end_data 0x" TARGET_ABI_FMT_lx "\n", info->end_data); 4422 qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n", 4423 info->start_stack); 4424 qemu_log("brk 0x" TARGET_ABI_FMT_lx "\n", info->brk); 4425 qemu_log("entry 0x" TARGET_ABI_FMT_lx "\n", info->entry); 4426 } 4427 4428 target_set_brk(info->brk); 4429 syscall_init(); 4430 signal_init(); 4431 4432 /* Now that we've loaded the binary, GUEST_BASE is fixed. Delay 4433 generating the prologue until now so that the prologue can take 4434 the real value of GUEST_BASE into account. */ 4435 tcg_prologue_init(&tcg_ctx); 4436 4437 #if defined(TARGET_I386) 4438 env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK; 4439 env->hflags |= HF_PE_MASK | HF_CPL_MASK; 4440 if (env->features[FEAT_1_EDX] & CPUID_SSE) { 4441 env->cr[4] |= CR4_OSFXSR_MASK; 4442 env->hflags |= HF_OSFXSR_MASK; 4443 } 4444 #ifndef TARGET_ABI32 4445 /* enable 64 bit mode if possible */ 4446 if (!(env->features[FEAT_8000_0001_EDX] & CPUID_EXT2_LM)) { 4447 fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n"); 4448 exit(EXIT_FAILURE); 4449 } 4450 env->cr[4] |= CR4_PAE_MASK; 4451 env->efer |= MSR_EFER_LMA | MSR_EFER_LME; 4452 env->hflags |= HF_LMA_MASK; 4453 #endif 4454 4455 /* flags setup : we activate the IRQs by default as in user mode */ 4456 env->eflags |= IF_MASK; 4457 4458 /* linux register setup */ 4459 #ifndef TARGET_ABI32 4460 env->regs[R_EAX] = regs->rax; 4461 env->regs[R_EBX] = regs->rbx; 4462 env->regs[R_ECX] = regs->rcx; 4463 env->regs[R_EDX] = regs->rdx; 4464 env->regs[R_ESI] = regs->rsi; 4465 env->regs[R_EDI] = regs->rdi; 4466 env->regs[R_EBP] = regs->rbp; 4467 env->regs[R_ESP] = regs->rsp; 4468 env->eip = regs->rip; 4469 #else 4470 env->regs[R_EAX] = regs->eax; 4471 env->regs[R_EBX] = regs->ebx; 4472 env->regs[R_ECX] = regs->ecx; 4473 env->regs[R_EDX] = regs->edx; 4474 env->regs[R_ESI] = regs->esi; 4475 env->regs[R_EDI] = regs->edi; 4476 env->regs[R_EBP] = regs->ebp; 4477 env->regs[R_ESP] = regs->esp; 4478 env->eip = regs->eip; 4479 #endif 4480 4481 /* linux interrupt setup */ 4482 #ifndef TARGET_ABI32 4483 env->idt.limit = 511; 4484 #else 4485 env->idt.limit = 255; 4486 #endif 4487 env->idt.base = target_mmap(0, sizeof(uint64_t) * (env->idt.limit + 1), 4488 PROT_READ|PROT_WRITE, 4489 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); 4490 idt_table = g2h(env->idt.base); 4491 set_idt(0, 0); 4492 set_idt(1, 0); 4493 set_idt(2, 0); 4494 set_idt(3, 3); 4495 set_idt(4, 3); 4496 set_idt(5, 0); 4497 set_idt(6, 0); 4498 set_idt(7, 0); 4499 set_idt(8, 0); 4500 set_idt(9, 0); 4501 set_idt(10, 0); 4502 set_idt(11, 0); 4503 set_idt(12, 0); 4504 set_idt(13, 0); 4505 set_idt(14, 0); 4506 set_idt(15, 0); 4507 set_idt(16, 0); 4508 set_idt(17, 0); 4509 set_idt(18, 0); 4510 set_idt(19, 0); 4511 set_idt(0x80, 3); 4512 4513 /* linux segment setup */ 4514 { 4515 uint64_t *gdt_table; 4516 env->gdt.base = target_mmap(0, sizeof(uint64_t) * TARGET_GDT_ENTRIES, 4517 PROT_READ|PROT_WRITE, 4518 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0); 4519 env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1; 4520 gdt_table = g2h(env->gdt.base); 4521 #ifdef TARGET_ABI32 4522 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, 4523 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 4524 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT)); 4525 #else 4526 /* 64 bit code segment */ 4527 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff, 4528 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 4529 DESC_L_MASK | 4530 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT)); 4531 #endif 4532 write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff, 4533 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK | 4534 (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT)); 4535 } 4536 cpu_x86_load_seg(env, R_CS, __USER_CS); 4537 cpu_x86_load_seg(env, R_SS, __USER_DS); 4538 #ifdef TARGET_ABI32 4539 cpu_x86_load_seg(env, R_DS, __USER_DS); 4540 cpu_x86_load_seg(env, R_ES, __USER_DS); 4541 cpu_x86_load_seg(env, R_FS, __USER_DS); 4542 cpu_x86_load_seg(env, R_GS, __USER_DS); 4543 /* This hack makes Wine work... */ 4544 env->segs[R_FS].selector = 0; 4545 #else 4546 cpu_x86_load_seg(env, R_DS, 0); 4547 cpu_x86_load_seg(env, R_ES, 0); 4548 cpu_x86_load_seg(env, R_FS, 0); 4549 cpu_x86_load_seg(env, R_GS, 0); 4550 #endif 4551 #elif defined(TARGET_AARCH64) 4552 { 4553 int i; 4554 4555 if (!(arm_feature(env, ARM_FEATURE_AARCH64))) { 4556 fprintf(stderr, 4557 "The selected ARM CPU does not support 64 bit mode\n"); 4558 exit(EXIT_FAILURE); 4559 } 4560 4561 for (i = 0; i < 31; i++) { 4562 env->xregs[i] = regs->regs[i]; 4563 } 4564 env->pc = regs->pc; 4565 env->xregs[31] = regs->sp; 4566 } 4567 #elif defined(TARGET_ARM) 4568 { 4569 int i; 4570 cpsr_write(env, regs->uregs[16], CPSR_USER | CPSR_EXEC, 4571 CPSRWriteByInstr); 4572 for(i = 0; i < 16; i++) { 4573 env->regs[i] = regs->uregs[i]; 4574 } 4575 #ifdef TARGET_WORDS_BIGENDIAN 4576 /* Enable BE8. */ 4577 if (EF_ARM_EABI_VERSION(info->elf_flags) >= EF_ARM_EABI_VER4 4578 && (info->elf_flags & EF_ARM_BE8)) { 4579 env->uncached_cpsr |= CPSR_E; 4580 env->cp15.sctlr_el[1] |= SCTLR_E0E; 4581 } else { 4582 env->cp15.sctlr_el[1] |= SCTLR_B; 4583 } 4584 #endif 4585 } 4586 #elif defined(TARGET_UNICORE32) 4587 { 4588 int i; 4589 cpu_asr_write(env, regs->uregs[32], 0xffffffff); 4590 for (i = 0; i < 32; i++) { 4591 env->regs[i] = regs->uregs[i]; 4592 } 4593 } 4594 #elif defined(TARGET_SPARC) 4595 { 4596 int i; 4597 env->pc = regs->pc; 4598 env->npc = regs->npc; 4599 env->y = regs->y; 4600 for(i = 0; i < 8; i++) 4601 env->gregs[i] = regs->u_regs[i]; 4602 for(i = 0; i < 8; i++) 4603 env->regwptr[i] = regs->u_regs[i + 8]; 4604 } 4605 #elif defined(TARGET_PPC) 4606 { 4607 int i; 4608 4609 #if defined(TARGET_PPC64) 4610 #if defined(TARGET_ABI32) 4611 env->msr &= ~((target_ulong)1 << MSR_SF); 4612 #else 4613 env->msr |= (target_ulong)1 << MSR_SF; 4614 #endif 4615 #endif 4616 env->nip = regs->nip; 4617 for(i = 0; i < 32; i++) { 4618 env->gpr[i] = regs->gpr[i]; 4619 } 4620 } 4621 #elif defined(TARGET_M68K) 4622 { 4623 env->pc = regs->pc; 4624 env->dregs[0] = regs->d0; 4625 env->dregs[1] = regs->d1; 4626 env->dregs[2] = regs->d2; 4627 env->dregs[3] = regs->d3; 4628 env->dregs[4] = regs->d4; 4629 env->dregs[5] = regs->d5; 4630 env->dregs[6] = regs->d6; 4631 env->dregs[7] = regs->d7; 4632 env->aregs[0] = regs->a0; 4633 env->aregs[1] = regs->a1; 4634 env->aregs[2] = regs->a2; 4635 env->aregs[3] = regs->a3; 4636 env->aregs[4] = regs->a4; 4637 env->aregs[5] = regs->a5; 4638 env->aregs[6] = regs->a6; 4639 env->aregs[7] = regs->usp; 4640 env->sr = regs->sr; 4641 ts->sim_syscalls = 1; 4642 } 4643 #elif defined(TARGET_MICROBLAZE) 4644 { 4645 env->regs[0] = regs->r0; 4646 env->regs[1] = regs->r1; 4647 env->regs[2] = regs->r2; 4648 env->regs[3] = regs->r3; 4649 env->regs[4] = regs->r4; 4650 env->regs[5] = regs->r5; 4651 env->regs[6] = regs->r6; 4652 env->regs[7] = regs->r7; 4653 env->regs[8] = regs->r8; 4654 env->regs[9] = regs->r9; 4655 env->regs[10] = regs->r10; 4656 env->regs[11] = regs->r11; 4657 env->regs[12] = regs->r12; 4658 env->regs[13] = regs->r13; 4659 env->regs[14] = regs->r14; 4660 env->regs[15] = regs->r15; 4661 env->regs[16] = regs->r16; 4662 env->regs[17] = regs->r17; 4663 env->regs[18] = regs->r18; 4664 env->regs[19] = regs->r19; 4665 env->regs[20] = regs->r20; 4666 env->regs[21] = regs->r21; 4667 env->regs[22] = regs->r22; 4668 env->regs[23] = regs->r23; 4669 env->regs[24] = regs->r24; 4670 env->regs[25] = regs->r25; 4671 env->regs[26] = regs->r26; 4672 env->regs[27] = regs->r27; 4673 env->regs[28] = regs->r28; 4674 env->regs[29] = regs->r29; 4675 env->regs[30] = regs->r30; 4676 env->regs[31] = regs->r31; 4677 env->sregs[SR_PC] = regs->pc; 4678 } 4679 #elif defined(TARGET_MIPS) 4680 { 4681 int i; 4682 4683 for(i = 0; i < 32; i++) { 4684 env->active_tc.gpr[i] = regs->regs[i]; 4685 } 4686 env->active_tc.PC = regs->cp0_epc & ~(target_ulong)1; 4687 if (regs->cp0_epc & 1) { 4688 env->hflags |= MIPS_HFLAG_M16; 4689 } 4690 } 4691 #elif defined(TARGET_OPENRISC) 4692 { 4693 int i; 4694 4695 for (i = 0; i < 32; i++) { 4696 env->gpr[i] = regs->gpr[i]; 4697 } 4698 4699 env->sr = regs->sr; 4700 env->pc = regs->pc; 4701 } 4702 #elif defined(TARGET_SH4) 4703 { 4704 int i; 4705 4706 for(i = 0; i < 16; i++) { 4707 env->gregs[i] = regs->regs[i]; 4708 } 4709 env->pc = regs->pc; 4710 } 4711 #elif defined(TARGET_ALPHA) 4712 { 4713 int i; 4714 4715 for(i = 0; i < 28; i++) { 4716 env->ir[i] = ((abi_ulong *)regs)[i]; 4717 } 4718 env->ir[IR_SP] = regs->usp; 4719 env->pc = regs->pc; 4720 } 4721 #elif defined(TARGET_CRIS) 4722 { 4723 env->regs[0] = regs->r0; 4724 env->regs[1] = regs->r1; 4725 env->regs[2] = regs->r2; 4726 env->regs[3] = regs->r3; 4727 env->regs[4] = regs->r4; 4728 env->regs[5] = regs->r5; 4729 env->regs[6] = regs->r6; 4730 env->regs[7] = regs->r7; 4731 env->regs[8] = regs->r8; 4732 env->regs[9] = regs->r9; 4733 env->regs[10] = regs->r10; 4734 env->regs[11] = regs->r11; 4735 env->regs[12] = regs->r12; 4736 env->regs[13] = regs->r13; 4737 env->regs[14] = info->start_stack; 4738 env->regs[15] = regs->acr; 4739 env->pc = regs->erp; 4740 } 4741 #elif defined(TARGET_S390X) 4742 { 4743 int i; 4744 for (i = 0; i < 16; i++) { 4745 env->regs[i] = regs->gprs[i]; 4746 } 4747 env->psw.mask = regs->psw.mask; 4748 env->psw.addr = regs->psw.addr; 4749 } 4750 #elif defined(TARGET_TILEGX) 4751 { 4752 int i; 4753 for (i = 0; i < TILEGX_R_COUNT; i++) { 4754 env->regs[i] = regs->regs[i]; 4755 } 4756 for (i = 0; i < TILEGX_SPR_COUNT; i++) { 4757 env->spregs[i] = 0; 4758 } 4759 env->pc = regs->pc; 4760 } 4761 #else 4762 #error unsupported target CPU 4763 #endif 4764 4765 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32) 4766 ts->stack_base = info->start_stack; 4767 ts->heap_base = info->brk; 4768 /* This will be filled in on the first SYS_HEAPINFO call. */ 4769 ts->heap_limit = 0; 4770 #endif 4771 4772 if (gdbstub_port) { 4773 if (gdbserver_start(gdbstub_port) < 0) { 4774 fprintf(stderr, "qemu: could not open gdbserver on port %d\n", 4775 gdbstub_port); 4776 exit(EXIT_FAILURE); 4777 } 4778 gdb_handlesig(cpu, 0); 4779 } 4780 cpu_loop(env); 4781 /* never exits */ 4782 return 0; 4783 } 4784