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