]> git.proxmox.com Git - qemu.git/blob - linux-user/main.c
projects / qemu.git / blob
? search:


e7dad547b81c42b9aecf2f37adf857788dd3e374
[qemu.git] / linux-user / main.c
1 /*
2 * qemu user main
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include <stdlib.h>
20 #include <stdio.h>
21 #include <stdarg.h>
22 #include <string.h>
23 #include <errno.h>
24 #include <unistd.h>
25 #include <sys/mman.h>
26 #include <sys/syscall.h>
27 #include <sys/resource.h>
28
29 #include "qemu.h"
30 #include "qemu-common.h"
31 #include "cache-utils.h"
32 #include "cpu.h"
33 #include "tcg.h"
34 #include "qemu-timer.h"
35 #include "envlist.h"
36
37 #define DEBUG_LOGFILE "/tmp/qemu.log"
38
39 char *exec_path;
40
41 int singlestep;
42 const char *filename;
43 const char *argv0;
44 int gdbstub_port;
45 envlist_t *envlist;
46 const char *cpu_model;
47 unsigned long mmap_min_addr;
48 #if defined(CONFIG_USE_GUEST_BASE)
49 unsigned long guest_base;
50 int have_guest_base;
51 unsigned long reserved_va;
52 #endif
53
54 static void usage(void);
55
56 static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
57 const char *qemu_uname_release = CONFIG_UNAME_RELEASE;
58
59 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
60 we allocate a bigger stack. Need a better solution, for example
61 by remapping the process stack directly at the right place */
62 unsigned long guest_stack_size = 8 * 1024 * 1024UL;
63
64 void gemu_log(const char *fmt, ...)
65 {
66 va_list ap;
67
68 va_start(ap, fmt);
69 vfprintf(stderr, fmt, ap);
70 va_end(ap);
71 }
72
73 #if defined(TARGET_I386)
74 int cpu_get_pic_interrupt(CPUState *env)
75 {
76 return -1;
77 }
78 #endif
79
80 /* timers for rdtsc */
81
82 #if 0
83
84 static uint64_t emu_time;
85
86 int64_t cpu_get_real_ticks(void)
87 {
88 return emu_time++;
89 }
90
91 #endif
92
93 #if defined(CONFIG_USE_NPTL)
94 /***********************************************************/
95 /* Helper routines for implementing atomic operations. */
96
97 /* To implement exclusive operations we force all cpus to syncronise.
98 We don't require a full sync, only that no cpus are executing guest code.
99 The alternative is to map target atomic ops onto host equivalents,
100 which requires quite a lot of per host/target work. */
101 static pthread_mutex_t cpu_list_mutex = PTHREAD_MUTEX_INITIALIZER;
102 static pthread_mutex_t exclusive_lock = PTHREAD_MUTEX_INITIALIZER;
103 static pthread_cond_t exclusive_cond = PTHREAD_COND_INITIALIZER;
104 static pthread_cond_t exclusive_resume = PTHREAD_COND_INITIALIZER;
105 static int pending_cpus;
106
107 /* Make sure everything is in a consistent state for calling fork(). */
108 void fork_start(void)
109 {
110 pthread_mutex_lock(&tb_lock);
111 pthread_mutex_lock(&exclusive_lock);
112 mmap_fork_start();
113 }
114
115 void fork_end(int child)
116 {
117 mmap_fork_end(child);
118 if (child) {
119 /* Child processes created by fork() only have a single thread.
120 Discard information about the parent threads. */
121 first_cpu = thread_env;
122 thread_env->next_cpu = NULL;
123 pending_cpus = 0;
124 pthread_mutex_init(&exclusive_lock, NULL);
125 pthread_mutex_init(&cpu_list_mutex, NULL);
126 pthread_cond_init(&exclusive_cond, NULL);
127 pthread_cond_init(&exclusive_resume, NULL);
128 pthread_mutex_init(&tb_lock, NULL);
129 gdbserver_fork(thread_env);
130 } else {
131 pthread_mutex_unlock(&exclusive_lock);
132 pthread_mutex_unlock(&tb_lock);
133 }
134 }
135
136 /* Wait for pending exclusive operations to complete. The exclusive lock
137 must be held. */
138 static inline void exclusive_idle(void)
139 {
140 while (pending_cpus) {
141 pthread_cond_wait(&exclusive_resume, &exclusive_lock);
142 }
143 }
144
145 /* Start an exclusive operation.
146 Must only be called from outside cpu_arm_exec. */
147 static inline void start_exclusive(void)
148 {
149 CPUState *other;
150 pthread_mutex_lock(&exclusive_lock);
151 exclusive_idle();
152
153 pending_cpus = 1;
154 /* Make all other cpus stop executing. */
155 for (other = first_cpu; other; other = other->next_cpu) {
156 if (other->running) {
157 pending_cpus++;
158 cpu_exit(other);
159 }
160 }
161 if (pending_cpus > 1) {
162 pthread_cond_wait(&exclusive_cond, &exclusive_lock);
163 }
164 }
165
166 /* Finish an exclusive operation. */
167 static inline void end_exclusive(void)
168 {
169 pending_cpus = 0;
170 pthread_cond_broadcast(&exclusive_resume);
171 pthread_mutex_unlock(&exclusive_lock);
172 }
173
174 /* Wait for exclusive ops to finish, and begin cpu execution. */
175 static inline void cpu_exec_start(CPUState *env)
176 {
177 pthread_mutex_lock(&exclusive_lock);
178 exclusive_idle();
179 env->running = 1;
180 pthread_mutex_unlock(&exclusive_lock);
181 }
182
183 /* Mark cpu as not executing, and release pending exclusive ops. */
184 static inline void cpu_exec_end(CPUState *env)
185 {
186 pthread_mutex_lock(&exclusive_lock);
187 env->running = 0;
188 if (pending_cpus > 1) {
189 pending_cpus--;
190 if (pending_cpus == 1) {
191 pthread_cond_signal(&exclusive_cond);
192 }
193 }
194 exclusive_idle();
195 pthread_mutex_unlock(&exclusive_lock);
196 }
197
198 void cpu_list_lock(void)
199 {
200 pthread_mutex_lock(&cpu_list_mutex);
201 }
202
203 void cpu_list_unlock(void)
204 {
205 pthread_mutex_unlock(&cpu_list_mutex);
206 }
207 #else /* if !CONFIG_USE_NPTL */
208 /* These are no-ops because we are not threadsafe. */
209 static inline void cpu_exec_start(CPUState *env)
210 {
211 }
212
213 static inline void cpu_exec_end(CPUState *env)
214 {
215 }
216
217 static inline void start_exclusive(void)
218 {
219 }
220
221 static inline void end_exclusive(void)
222 {
223 }
224
225 void fork_start(void)
226 {
227 }
228
229 void fork_end(int child)
230 {
231 if (child) {
232 gdbserver_fork(thread_env);
233 }
234 }
235
236 void cpu_list_lock(void)
237 {
238 }
239
240 void cpu_list_unlock(void)
241 {
242 }
243 #endif
244
245
246 #ifdef TARGET_I386
247 /***********************************************************/
248 /* CPUX86 core interface */
249
250 void cpu_smm_update(CPUState *env)
251 {
252 }
253
254 uint64_t cpu_get_tsc(CPUX86State *env)
255 {
256 return cpu_get_real_ticks();
257 }
258
259 static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
260 int flags)
261 {
262 unsigned int e1, e2;
263 uint32_t *p;
264 e1 = (addr << 16) | (limit & 0xffff);
265 e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
266 e2 |= flags;
267 p = ptr;
268 p[0] = tswap32(e1);
269 p[1] = tswap32(e2);
270 }
271
272 static uint64_t *idt_table;
273 #ifdef TARGET_X86_64
274 static void set_gate64(void *ptr, unsigned int type, unsigned int dpl,
275 uint64_t addr, unsigned int sel)
276 {
277 uint32_t *p, e1, e2;
278 e1 = (addr & 0xffff) | (sel << 16);
279 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
280 p = ptr;
281 p[0] = tswap32(e1);
282 p[1] = tswap32(e2);
283 p[2] = tswap32(addr >> 32);
284 p[3] = 0;
285 }
286 /* only dpl matters as we do only user space emulation */
287 static void set_idt(int n, unsigned int dpl)
288 {
289 set_gate64(idt_table + n * 2, 0, dpl, 0, 0);
290 }
291 #else
292 static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
293 uint32_t addr, unsigned int sel)
294 {
295 uint32_t *p, e1, e2;
296 e1 = (addr & 0xffff) | (sel << 16);
297 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
298 p = ptr;
299 p[0] = tswap32(e1);
300 p[1] = tswap32(e2);
301 }
302
303 /* only dpl matters as we do only user space emulation */
304 static void set_idt(int n, unsigned int dpl)
305 {
306 set_gate(idt_table + n, 0, dpl, 0, 0);
307 }
308 #endif
309
310 void cpu_loop(CPUX86State *env)
311 {
312 int trapnr;
313 abi_ulong pc;
314 target_siginfo_t info;
315
316 for(;;) {
317 trapnr = cpu_x86_exec(env);
318 switch(trapnr) {
319 case 0x80:
320 /* linux syscall from int $0x80 */
321 env->regs[R_EAX] = do_syscall(env,
322 env->regs[R_EAX],
323 env->regs[R_EBX],
324 env->regs[R_ECX],
325 env->regs[R_EDX],
326 env->regs[R_ESI],
327 env->regs[R_EDI],
328 env->regs[R_EBP],
329 0, 0);
330 break;
331 #ifndef TARGET_ABI32
332 case EXCP_SYSCALL:
333 /* linux syscall from syscall instruction */
334 env->regs[R_EAX] = do_syscall(env,
335 env->regs[R_EAX],
336 env->regs[R_EDI],
337 env->regs[R_ESI],
338 env->regs[R_EDX],
339 env->regs[10],
340 env->regs[8],
341 env->regs[9],
342 0, 0);
343 env->eip = env->exception_next_eip;
344 break;
345 #endif
346 case EXCP0B_NOSEG:
347 case EXCP0C_STACK:
348 info.si_signo = SIGBUS;
349 info.si_errno = 0;
350 info.si_code = TARGET_SI_KERNEL;
351 info._sifields._sigfault._addr = 0;
352 queue_signal(env, info.si_signo, &info);
353 break;
354 case EXCP0D_GPF:
355 /* XXX: potential problem if ABI32 */
356 #ifndef TARGET_X86_64
357 if (env->eflags & VM_MASK) {
358 handle_vm86_fault(env);
359 } else
360 #endif
361 {
362 info.si_signo = SIGSEGV;
363 info.si_errno = 0;
364 info.si_code = TARGET_SI_KERNEL;
365 info._sifields._sigfault._addr = 0;
366 queue_signal(env, info.si_signo, &info);
367 }
368 break;
369 case EXCP0E_PAGE:
370 info.si_signo = SIGSEGV;
371 info.si_errno = 0;
372 if (!(env->error_code & 1))
373 info.si_code = TARGET_SEGV_MAPERR;
374 else
375 info.si_code = TARGET_SEGV_ACCERR;
376 info._sifields._sigfault._addr = env->cr[2];
377 queue_signal(env, info.si_signo, &info);
378 break;
379 case EXCP00_DIVZ:
380 #ifndef TARGET_X86_64
381 if (env->eflags & VM_MASK) {
382 handle_vm86_trap(env, trapnr);
383 } else
384 #endif
385 {
386 /* division by zero */
387 info.si_signo = SIGFPE;
388 info.si_errno = 0;
389 info.si_code = TARGET_FPE_INTDIV;
390 info._sifields._sigfault._addr = env->eip;
391 queue_signal(env, info.si_signo, &info);
392 }
393 break;
394 case EXCP01_DB:
395 case EXCP03_INT3:
396 #ifndef TARGET_X86_64
397 if (env->eflags & VM_MASK) {
398 handle_vm86_trap(env, trapnr);
399 } else
400 #endif
401 {
402 info.si_signo = SIGTRAP;
403 info.si_errno = 0;
404 if (trapnr == EXCP01_DB) {
405 info.si_code = TARGET_TRAP_BRKPT;
406 info._sifields._sigfault._addr = env->eip;
407 } else {
408 info.si_code = TARGET_SI_KERNEL;
409 info._sifields._sigfault._addr = 0;
410 }
411 queue_signal(env, info.si_signo, &info);
412 }
413 break;
414 case EXCP04_INTO:
415 case EXCP05_BOUND:
416 #ifndef TARGET_X86_64
417 if (env->eflags & VM_MASK) {
418 handle_vm86_trap(env, trapnr);
419 } else
420 #endif
421 {
422 info.si_signo = SIGSEGV;
423 info.si_errno = 0;
424 info.si_code = TARGET_SI_KERNEL;
425 info._sifields._sigfault._addr = 0;
426 queue_signal(env, info.si_signo, &info);
427 }
428 break;
429 case EXCP06_ILLOP:
430 info.si_signo = SIGILL;
431 info.si_errno = 0;
432 info.si_code = TARGET_ILL_ILLOPN;
433 info._sifields._sigfault._addr = env->eip;
434 queue_signal(env, info.si_signo, &info);
435 break;
436 case EXCP_INTERRUPT:
437 /* just indicate that signals should be handled asap */
438 break;
439 case EXCP_DEBUG:
440 {
441 int sig;
442
443 sig = gdb_handlesig (env, TARGET_SIGTRAP);
444 if (sig)
445 {
446 info.si_signo = sig;
447 info.si_errno = 0;
448 info.si_code = TARGET_TRAP_BRKPT;
449 queue_signal(env, info.si_signo, &info);
450 }
451 }
452 break;
453 default:
454 pc = env->segs[R_CS].base + env->eip;
455 fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
456 (long)pc, trapnr);
457 abort();
458 }
459 process_pending_signals(env);
460 }
461 }
462 #endif
463
464 #ifdef TARGET_ARM
465
466 /*
467 * See the Linux kernel's Documentation/arm/kernel_user_helpers.txt
468 * Input:
469 * r0 = pointer to oldval
470 * r1 = pointer to newval
471 * r2 = pointer to target value
472 *
473 * Output:
474 * r0 = 0 if *ptr was changed, non-0 if no exchange happened
475 * C set if *ptr was changed, clear if no exchange happened
476 *
477 * Note segv's in kernel helpers are a bit tricky, we can set the
478 * data address sensibly but the PC address is just the entry point.
479 */
480 static void arm_kernel_cmpxchg64_helper(CPUARMState *env)
481 {
482 uint64_t oldval, newval, val;
483 uint32_t addr, cpsr;
484 target_siginfo_t info;
485
486 /* Based on the 32 bit code in do_kernel_trap */
487
488 /* XXX: This only works between threads, not between processes.
489 It's probably possible to implement this with native host
490 operations. However things like ldrex/strex are much harder so
491 there's not much point trying. */
492 start_exclusive();
493 cpsr = cpsr_read(env);
494 addr = env->regs[2];
495
496 if (get_user_u64(oldval, env->regs[0])) {
497 env->cp15.c6_data = env->regs[0];
498 goto segv;
499 };
500
501 if (get_user_u64(newval, env->regs[1])) {
502 env->cp15.c6_data = env->regs[1];
503 goto segv;
504 };
505
506 if (get_user_u64(val, addr)) {
507 env->cp15.c6_data = addr;
508 goto segv;
509 }
510
511 if (val == oldval) {
512 val = newval;
513
514 if (put_user_u64(val, addr)) {
515 env->cp15.c6_data = addr;
516 goto segv;
517 };
518
519 env->regs[0] = 0;
520 cpsr |= CPSR_C;
521 } else {
522 env->regs[0] = -1;
523 cpsr &= ~CPSR_C;
524 }
525 cpsr_write(env, cpsr, CPSR_C);
526 end_exclusive();
527 return;
528
529 segv:
530 end_exclusive();
531 /* We get the PC of the entry address - which is as good as anything,
532 on a real kernel what you get depends on which mode it uses. */
533 info.si_signo = SIGSEGV;
534 info.si_errno = 0;
535 /* XXX: check env->error_code */
536 info.si_code = TARGET_SEGV_MAPERR;
537 info._sifields._sigfault._addr = env->cp15.c6_data;
538 queue_signal(env, info.si_signo, &info);
539
540 end_exclusive();
541 }
542
543 /* Handle a jump to the kernel code page. */
544 static int
545 do_kernel_trap(CPUARMState *env)
546 {
547 uint32_t addr;
548 uint32_t cpsr;
549 uint32_t val;
550
551 switch (env->regs[15]) {
552 case 0xffff0fa0: /* __kernel_memory_barrier */
553 /* ??? No-op. Will need to do better for SMP. */
554 break;
555 case 0xffff0fc0: /* __kernel_cmpxchg */
556 /* XXX: This only works between threads, not between processes.
557 It's probably possible to implement this with native host
558 operations. However things like ldrex/strex are much harder so
559 there's not much point trying. */
560 start_exclusive();
561 cpsr = cpsr_read(env);
562 addr = env->regs[2];
563 /* FIXME: This should SEGV if the access fails. */
564 if (get_user_u32(val, addr))
565 val = ~env->regs[0];
566 if (val == env->regs[0]) {
567 val = env->regs[1];
568 /* FIXME: Check for segfaults. */
569 put_user_u32(val, addr);
570 env->regs[0] = 0;
571 cpsr |= CPSR_C;
572 } else {
573 env->regs[0] = -1;
574 cpsr &= ~CPSR_C;
575 }
576 cpsr_write(env, cpsr, CPSR_C);
577 end_exclusive();
578 break;
579 case 0xffff0fe0: /* __kernel_get_tls */
580 env->regs[0] = env->cp15.c13_tls2;
581 break;
582 case 0xffff0f60: /* __kernel_cmpxchg64 */
583 arm_kernel_cmpxchg64_helper(env);
584 break;
585
586 default:
587 return 1;
588 }
589 /* Jump back to the caller. */
590 addr = env->regs[14];
591 if (addr & 1) {
592 env->thumb = 1;
593 addr &= ~1;
594 }
595 env->regs[15] = addr;
596
597 return 0;
598 }
599
600 static int do_strex(CPUARMState *env)
601 {
602 uint32_t val;
603 int size;
604 int rc = 1;
605 int segv = 0;
606 uint32_t addr;
607 start_exclusive();
608 addr = env->exclusive_addr;
609 if (addr != env->exclusive_test) {
610 goto fail;
611 }
612 size = env->exclusive_info & 0xf;
613 switch (size) {
614 case 0:
615 segv = get_user_u8(val, addr);
616 break;
617 case 1:
618 segv = get_user_u16(val, addr);
619 break;
620 case 2:
621 case 3:
622 segv = get_user_u32(val, addr);
623 break;
624 default:
625 abort();
626 }
627 if (segv) {
628 env->cp15.c6_data = addr;
629 goto done;
630 }
631 if (val != env->exclusive_val) {
632 goto fail;
633 }
634 if (size == 3) {
635 segv = get_user_u32(val, addr + 4);
636 if (segv) {
637 env->cp15.c6_data = addr + 4;
638 goto done;
639 }
640 if (val != env->exclusive_high) {
641 goto fail;
642 }
643 }
644 val = env->regs[(env->exclusive_info >> 8) & 0xf];
645 switch (size) {
646 case 0:
647 segv = put_user_u8(val, addr);
648 break;
649 case 1:
650 segv = put_user_u16(val, addr);
651 break;
652 case 2:
653 case 3:
654 segv = put_user_u32(val, addr);
655 break;
656 }
657 if (segv) {
658 env->cp15.c6_data = addr;
659 goto done;
660 }
661 if (size == 3) {
662 val = env->regs[(env->exclusive_info >> 12) & 0xf];
663 segv = put_user_u32(val, addr + 4);
664 if (segv) {
665 env->cp15.c6_data = addr + 4;
666 goto done;
667 }
668 }
669 rc = 0;
670 fail:
671 env->regs[15] += 4;
672 env->regs[(env->exclusive_info >> 4) & 0xf] = rc;
673 done:
674 end_exclusive();
675 return segv;
676 }
677
678 void cpu_loop(CPUARMState *env)
679 {
680 int trapnr;
681 unsigned int n, insn;
682 target_siginfo_t info;
683 uint32_t addr;
684
685 for(;;) {
686 cpu_exec_start(env);
687 trapnr = cpu_arm_exec(env);
688 cpu_exec_end(env);
689 switch(trapnr) {
690 case EXCP_UDEF:
691 {
692 TaskState *ts = env->opaque;
693 uint32_t opcode;
694 int rc;
695
696 /* we handle the FPU emulation here, as Linux */
697 /* we get the opcode */
698 /* FIXME - what to do if get_user() fails? */
699 get_user_u32(opcode, env->regs[15]);
700
701 rc = EmulateAll(opcode, &ts->fpa, env);
702 if (rc == 0) { /* illegal instruction */
703 info.si_signo = SIGILL;
704 info.si_errno = 0;
705 info.si_code = TARGET_ILL_ILLOPN;
706 info._sifields._sigfault._addr = env->regs[15];
707 queue_signal(env, info.si_signo, &info);
708 } else if (rc < 0) { /* FP exception */
709 int arm_fpe=0;
710
711 /* translate softfloat flags to FPSR flags */
712 if (-rc & float_flag_invalid)
713 arm_fpe |= BIT_IOC;
714 if (-rc & float_flag_divbyzero)
715 arm_fpe |= BIT_DZC;
716 if (-rc & float_flag_overflow)
717 arm_fpe |= BIT_OFC;
718 if (-rc & float_flag_underflow)
719 arm_fpe |= BIT_UFC;
720 if (-rc & float_flag_inexact)
721 arm_fpe |= BIT_IXC;
722
723 FPSR fpsr = ts->fpa.fpsr;
724 //printf("fpsr 0x%x, arm_fpe 0x%x\n",fpsr,arm_fpe);
725
726 if (fpsr & (arm_fpe << 16)) { /* exception enabled? */
727 info.si_signo = SIGFPE;
728 info.si_errno = 0;
729
730 /* ordered by priority, least first */
731 if (arm_fpe & BIT_IXC) info.si_code = TARGET_FPE_FLTRES;
732 if (arm_fpe & BIT_UFC) info.si_code = TARGET_FPE_FLTUND;
733 if (arm_fpe & BIT_OFC) info.si_code = TARGET_FPE_FLTOVF;
734 if (arm_fpe & BIT_DZC) info.si_code = TARGET_FPE_FLTDIV;
735 if (arm_fpe & BIT_IOC) info.si_code = TARGET_FPE_FLTINV;
736
737 info._sifields._sigfault._addr = env->regs[15];
738 queue_signal(env, info.si_signo, &info);
739 } else {
740 env->regs[15] += 4;
741 }
742
743 /* accumulate unenabled exceptions */
744 if ((!(fpsr & BIT_IXE)) && (arm_fpe & BIT_IXC))
745 fpsr |= BIT_IXC;
746 if ((!(fpsr & BIT_UFE)) && (arm_fpe & BIT_UFC))
747 fpsr |= BIT_UFC;
748 if ((!(fpsr & BIT_OFE)) && (arm_fpe & BIT_OFC))
749 fpsr |= BIT_OFC;
750 if ((!(fpsr & BIT_DZE)) && (arm_fpe & BIT_DZC))
751 fpsr |= BIT_DZC;
752 if ((!(fpsr & BIT_IOE)) && (arm_fpe & BIT_IOC))
753 fpsr |= BIT_IOC;
754 ts->fpa.fpsr=fpsr;
755 } else { /* everything OK */
756 /* increment PC */
757 env->regs[15] += 4;
758 }
759 }
760 break;
761 case EXCP_SWI:
762 case EXCP_BKPT:
763 {
764 env->eabi = 1;
765 /* system call */
766 if (trapnr == EXCP_BKPT) {
767 if (env->thumb) {
768 /* FIXME - what to do if get_user() fails? */
769 get_user_u16(insn, env->regs[15]);
770 n = insn & 0xff;
771 env->regs[15] += 2;
772 } else {
773 /* FIXME - what to do if get_user() fails? */
774 get_user_u32(insn, env->regs[15]);
775 n = (insn & 0xf) | ((insn >> 4) & 0xff0);
776 env->regs[15] += 4;
777 }
778 } else {
779 if (env->thumb) {
780 /* FIXME - what to do if get_user() fails? */
781 get_user_u16(insn, env->regs[15] - 2);
782 n = insn & 0xff;
783 } else {
784 /* FIXME - what to do if get_user() fails? */
785 get_user_u32(insn, env->regs[15] - 4);
786 n = insn & 0xffffff;
787 }
788 }
789
790 if (n == ARM_NR_cacheflush) {
791 /* nop */
792 } else if (n == ARM_NR_semihosting
793 || n == ARM_NR_thumb_semihosting) {
794 env->regs[0] = do_arm_semihosting (env);
795 } else if (n == 0 || n >= ARM_SYSCALL_BASE
796 || (env->thumb && n == ARM_THUMB_SYSCALL)) {
797 /* linux syscall */
798 if (env->thumb || n == 0) {
799 n = env->regs[7];
800 } else {
801 n -= ARM_SYSCALL_BASE;
802 env->eabi = 0;
803 }
804 if ( n > ARM_NR_BASE) {
805 switch (n) {
806 case ARM_NR_cacheflush:
807 /* nop */
808 break;
809 case ARM_NR_set_tls:
810 cpu_set_tls(env, env->regs[0]);
811 env->regs[0] = 0;
812 break;
813 default:
814 gemu_log("qemu: Unsupported ARM syscall: 0x%x\n",
815 n);
816 env->regs[0] = -TARGET_ENOSYS;
817 break;
818 }
819 } else {
820 env->regs[0] = do_syscall(env,
821 n,
822 env->regs[0],
823 env->regs[1],
824 env->regs[2],
825 env->regs[3],
826 env->regs[4],
827 env->regs[5],
828 0, 0);
829 }
830 } else {
831 goto error;
832 }
833 }
834 break;
835 case EXCP_INTERRUPT:
836 /* just indicate that signals should be handled asap */
837 break;
838 case EXCP_PREFETCH_ABORT:
839 addr = env->cp15.c6_insn;
840 goto do_segv;
841 case EXCP_DATA_ABORT:
842 addr = env->cp15.c6_data;
843 do_segv:
844 {
845 info.si_signo = SIGSEGV;
846 info.si_errno = 0;
847 /* XXX: check env->error_code */
848 info.si_code = TARGET_SEGV_MAPERR;
849 info._sifields._sigfault._addr = addr;
850 queue_signal(env, info.si_signo, &info);
851 }
852 break;
853 case EXCP_DEBUG:
854 {
855 int sig;
856
857 sig = gdb_handlesig (env, TARGET_SIGTRAP);
858 if (sig)
859 {
860 info.si_signo = sig;
861 info.si_errno = 0;
862 info.si_code = TARGET_TRAP_BRKPT;
863 queue_signal(env, info.si_signo, &info);
864 }
865 }
866 break;
867 case EXCP_KERNEL_TRAP:
868 if (do_kernel_trap(env))
869 goto error;
870 break;
871 case EXCP_STREX:
872 if (do_strex(env)) {
873 addr = env->cp15.c6_data;
874 goto do_segv;
875 }
876 break;
877 default:
878 error:
879 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
880 trapnr);
881 cpu_dump_state(env, stderr, fprintf, 0);
882 abort();
883 }
884 process_pending_signals(env);
885 }
886 }
887
888 #endif
889
890 #ifdef TARGET_UNICORE32
891
892 void cpu_loop(CPUState *env)
893 {
894 int trapnr;
895 unsigned int n, insn;
896 target_siginfo_t info;
897
898 for (;;) {
899 cpu_exec_start(env);
900 trapnr = uc32_cpu_exec(env);
901 cpu_exec_end(env);
902 switch (trapnr) {
903 case UC32_EXCP_PRIV:
904 {
905 /* system call */
906 get_user_u32(insn, env->regs[31] - 4);
907 n = insn & 0xffffff;
908
909 if (n >= UC32_SYSCALL_BASE) {
910 /* linux syscall */
911 n -= UC32_SYSCALL_BASE;
912 if (n == UC32_SYSCALL_NR_set_tls) {
913 cpu_set_tls(env, env->regs[0]);
914 env->regs[0] = 0;
915 } else {
916 env->regs[0] = do_syscall(env,
917 n,
918 env->regs[0],
919 env->regs[1],
920 env->regs[2],
921 env->regs[3],
922 env->regs[4],
923 env->regs[5],
924 0, 0);
925 }
926 } else {
927 goto error;
928 }
929 }
930 break;
931 case UC32_EXCP_TRAP:
932 info.si_signo = SIGSEGV;
933 info.si_errno = 0;
934 /* XXX: check env->error_code */
935 info.si_code = TARGET_SEGV_MAPERR;
936 info._sifields._sigfault._addr = env->cp0.c4_faultaddr;
937 queue_signal(env, info.si_signo, &info);
938 break;
939 case EXCP_INTERRUPT:
940 /* just indicate that signals should be handled asap */
941 break;
942 case EXCP_DEBUG:
943 {
944 int sig;
945
946 sig = gdb_handlesig(env, TARGET_SIGTRAP);
947 if (sig) {
948 info.si_signo = sig;
949 info.si_errno = 0;
950 info.si_code = TARGET_TRAP_BRKPT;
951 queue_signal(env, info.si_signo, &info);
952 }
953 }
954 break;
955 default:
956 goto error;
957 }
958 process_pending_signals(env);
959 }
960
961 error:
962 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n", trapnr);
963 cpu_dump_state(env, stderr, fprintf, 0);
964 abort();
965 }
966 #endif
967
968 #ifdef TARGET_SPARC
969 #define SPARC64_STACK_BIAS 2047
970
971 //#define DEBUG_WIN
972
973 /* WARNING: dealing with register windows _is_ complicated. More info
974 can be found at http://www.sics.se/~psm/sparcstack.html */
975 static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
976 {
977 index = (index + cwp * 16) % (16 * env->nwindows);
978 /* wrap handling : if cwp is on the last window, then we use the
979 registers 'after' the end */
980 if (index < 8 && env->cwp == env->nwindows - 1)
981 index += 16 * env->nwindows;
982 return index;
983 }
984
985 /* save the register window 'cwp1' */
986 static inline void save_window_offset(CPUSPARCState *env, int cwp1)
987 {
988 unsigned int i;
989 abi_ulong sp_ptr;
990
991 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
992 #ifdef TARGET_SPARC64
993 if (sp_ptr & 3)
994 sp_ptr += SPARC64_STACK_BIAS;
995 #endif
996 #if defined(DEBUG_WIN)
997 printf("win_overflow: sp_ptr=0x" TARGET_ABI_FMT_lx " save_cwp=%d\n",
998 sp_ptr, cwp1);
999 #endif
1000 for(i = 0; i < 16; i++) {
1001 /* FIXME - what to do if put_user() fails? */
1002 put_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
1003 sp_ptr += sizeof(abi_ulong);
1004 }
1005 }
1006
1007 static void save_window(CPUSPARCState *env)
1008 {
1009 #ifndef TARGET_SPARC64
1010 unsigned int new_wim;
1011 new_wim = ((env->wim >> 1) | (env->wim << (env->nwindows - 1))) &
1012 ((1LL << env->nwindows) - 1);
1013 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
1014 env->wim = new_wim;
1015 #else
1016 save_window_offset(env, cpu_cwp_dec(env, env->cwp - 2));
1017 env->cansave++;
1018 env->canrestore--;
1019 #endif
1020 }
1021
1022 static void restore_window(CPUSPARCState *env)
1023 {
1024 #ifndef TARGET_SPARC64
1025 unsigned int new_wim;
1026 #endif
1027 unsigned int i, cwp1;
1028 abi_ulong sp_ptr;
1029
1030 #ifndef TARGET_SPARC64
1031 new_wim = ((env->wim << 1) | (env->wim >> (env->nwindows - 1))) &
1032 ((1LL << env->nwindows) - 1);
1033 #endif
1034
1035 /* restore the invalid window */
1036 cwp1 = cpu_cwp_inc(env, env->cwp + 1);
1037 sp_ptr = env->regbase[get_reg_index(env, cwp1, 6)];
1038 #ifdef TARGET_SPARC64
1039 if (sp_ptr & 3)
1040 sp_ptr += SPARC64_STACK_BIAS;
1041 #endif
1042 #if defined(DEBUG_WIN)
1043 printf("win_underflow: sp_ptr=0x" TARGET_ABI_FMT_lx " load_cwp=%d\n",
1044 sp_ptr, cwp1);
1045 #endif
1046 for(i = 0; i < 16; i++) {
1047 /* FIXME - what to do if get_user() fails? */
1048 get_user_ual(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
1049 sp_ptr += sizeof(abi_ulong);
1050 }
1051 #ifdef TARGET_SPARC64
1052 env->canrestore++;
1053 if (env->cleanwin < env->nwindows - 1)
1054 env->cleanwin++;
1055 env->cansave--;
1056 #else
1057 env->wim = new_wim;
1058 #endif
1059 }
1060
1061 static void flush_windows(CPUSPARCState *env)
1062 {
1063 int offset, cwp1;
1064
1065 offset = 1;
1066 for(;;) {
1067 /* if restore would invoke restore_window(), then we can stop */
1068 cwp1 = cpu_cwp_inc(env, env->cwp + offset);
1069 #ifndef TARGET_SPARC64
1070 if (env->wim & (1 << cwp1))
1071 break;
1072 #else
1073 if (env->canrestore == 0)
1074 break;
1075 env->cansave++;
1076 env->canrestore--;
1077 #endif
1078 save_window_offset(env, cwp1);
1079 offset++;
1080 }
1081 cwp1 = cpu_cwp_inc(env, env->cwp + 1);
1082 #ifndef TARGET_SPARC64
1083 /* set wim so that restore will reload the registers */
1084 env->wim = 1 << cwp1;
1085 #endif
1086 #if defined(DEBUG_WIN)
1087 printf("flush_windows: nb=%d\n", offset - 1);
1088 #endif
1089 }
1090
1091 void cpu_loop (CPUSPARCState *env)
1092 {
1093 int trapnr;
1094 abi_long ret;
1095 target_siginfo_t info;
1096
1097 while (1) {
1098 trapnr = cpu_sparc_exec (env);
1099
1100 switch (trapnr) {
1101 #ifndef TARGET_SPARC64
1102 case 0x88:
1103 case 0x90:
1104 #else
1105 case 0x110:
1106 case 0x16d:
1107 #endif
1108 ret = do_syscall (env, env->gregs[1],
1109 env->regwptr[0], env->regwptr[1],
1110 env->regwptr[2], env->regwptr[3],
1111 env->regwptr[4], env->regwptr[5],
1112 0, 0);
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 /* next instruction */
1129 env->pc = env->npc;
1130 env->npc = env->npc + 4;
1131 break;
1132 case 0x83: /* flush windows */
1133 #ifdef TARGET_ABI32
1134 case 0x103:
1135 #endif
1136 flush_windows(env);
1137 /* next instruction */
1138 env->pc = env->npc;
1139 env->npc = env->npc + 4;
1140 break;
1141 #ifndef TARGET_SPARC64
1142 case TT_WIN_OVF: /* window overflow */
1143 save_window(env);
1144 break;
1145 case TT_WIN_UNF: /* window underflow */
1146 restore_window(env);
1147 break;
1148 case TT_TFAULT:
1149 case TT_DFAULT:
1150 {
1151 info.si_signo = SIGSEGV;
1152 info.si_errno = 0;
1153 /* XXX: check env->error_code */
1154 info.si_code = TARGET_SEGV_MAPERR;
1155 info._sifields._sigfault._addr = env->mmuregs[4];
1156 queue_signal(env, info.si_signo, &info);
1157 }
1158 break;
1159 #else
1160 case TT_SPILL: /* window overflow */
1161 save_window(env);
1162 break;
1163 case TT_FILL: /* window underflow */
1164 restore_window(env);
1165 break;
1166 case TT_TFAULT:
1167 case TT_DFAULT:
1168 {
1169 info.si_signo = SIGSEGV;
1170 info.si_errno = 0;
1171 /* XXX: check env->error_code */
1172 info.si_code = TARGET_SEGV_MAPERR;
1173 if (trapnr == TT_DFAULT)
1174 info._sifields._sigfault._addr = env->dmmuregs[4];
1175 else
1176 info._sifields._sigfault._addr = cpu_tsptr(env)->tpc;
1177 queue_signal(env, info.si_signo, &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 /* just indicate that signals should be handled asap */
1193 break;
1194 case EXCP_DEBUG:
1195 {
1196 int sig;
1197
1198 sig = gdb_handlesig (env, TARGET_SIGTRAP);
1199 if (sig)
1200 {
1201 info.si_signo = sig;
1202 info.si_errno = 0;
1203 info.si_code = TARGET_TRAP_BRKPT;
1204 queue_signal(env, info.si_signo, &info);
1205 }
1206 }
1207 break;
1208 default:
1209 printf ("Unhandled trap: 0x%x\n", trapnr);
1210 cpu_dump_state(env, stderr, fprintf, 0);
1211 exit (1);
1212 }
1213 process_pending_signals (env);
1214 }
1215 }
1216
1217 #endif
1218
1219 #ifdef TARGET_PPC
1220 static inline uint64_t cpu_ppc_get_tb (CPUState *env)
1221 {
1222 /* TO FIX */
1223 return 0;
1224 }
1225
1226 uint64_t cpu_ppc_load_tbl (CPUState *env)
1227 {
1228 return cpu_ppc_get_tb(env);
1229 }
1230
1231 uint32_t cpu_ppc_load_tbu (CPUState *env)
1232 {
1233 return cpu_ppc_get_tb(env) >> 32;
1234 }
1235
1236 uint64_t cpu_ppc_load_atbl (CPUState *env)
1237 {
1238 return cpu_ppc_get_tb(env);
1239 }
1240
1241 uint32_t cpu_ppc_load_atbu (CPUState *env)
1242 {
1243 return cpu_ppc_get_tb(env) >> 32;
1244 }
1245
1246 uint32_t cpu_ppc601_load_rtcu (CPUState *env)
1247 __attribute__ (( alias ("cpu_ppc_load_tbu") ));
1248
1249 uint32_t cpu_ppc601_load_rtcl (CPUState *env)
1250 {
1251 return cpu_ppc_load_tbl(env) & 0x3FFFFF80;
1252 }
1253
1254 /* XXX: to be fixed */
1255 int ppc_dcr_read (ppc_dcr_t *dcr_env, int dcrn, uint32_t *valp)
1256 {
1257 return -1;
1258 }
1259
1260 int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, uint32_t val)
1261 {
1262 return -1;
1263 }
1264
1265 #define EXCP_DUMP(env, fmt, ...) \
1266 do { \
1267 fprintf(stderr, fmt , ## __VA_ARGS__); \
1268 cpu_dump_state(env, stderr, fprintf, 0); \
1269 qemu_log(fmt, ## __VA_ARGS__); \
1270 if (logfile) \
1271 log_cpu_state(env, 0); \
1272 } while (0)
1273
1274 static int do_store_exclusive(CPUPPCState *env)
1275 {
1276 target_ulong addr;
1277 target_ulong page_addr;
1278 target_ulong val;
1279 int flags;
1280 int segv = 0;
1281
1282 addr = env->reserve_ea;
1283 page_addr = addr & TARGET_PAGE_MASK;
1284 start_exclusive();
1285 mmap_lock();
1286 flags = page_get_flags(page_addr);
1287 if ((flags & PAGE_READ) == 0) {
1288 segv = 1;
1289 } else {
1290 int reg = env->reserve_info & 0x1f;
1291 int size = (env->reserve_info >> 5) & 0xf;
1292 int stored = 0;
1293
1294 if (addr == env->reserve_addr) {
1295 switch (size) {
1296 case 1: segv = get_user_u8(val, addr); break;
1297 case 2: segv = get_user_u16(val, addr); break;
1298 case 4: segv = get_user_u32(val, addr); break;
1299 #if defined(TARGET_PPC64)
1300 case 8: segv = get_user_u64(val, addr); break;
1301 #endif
1302 default: abort();
1303 }
1304 if (!segv && val == env->reserve_val) {
1305 val = env->gpr[reg];
1306 switch (size) {
1307 case 1: segv = put_user_u8(val, addr); break;
1308 case 2: segv = put_user_u16(val, addr); break;
1309 case 4: segv = put_user_u32(val, addr); break;
1310 #if defined(TARGET_PPC64)
1311 case 8: segv = put_user_u64(val, addr); break;
1312 #endif
1313 default: abort();
1314 }
1315 if (!segv) {
1316 stored = 1;
1317 }
1318 }
1319 }
1320 env->crf[0] = (stored << 1) | xer_so;
1321 env->reserve_addr = (target_ulong)-1;
1322 }
1323 if (!segv) {
1324 env->nip += 4;
1325 }
1326 mmap_unlock();
1327 end_exclusive();
1328 return segv;
1329 }
1330
1331 void cpu_loop(CPUPPCState *env)
1332 {
1333 target_siginfo_t info;
1334 int trapnr;
1335 uint32_t ret;
1336
1337 for(;;) {
1338 cpu_exec_start(env);
1339 trapnr = cpu_ppc_exec(env);
1340 cpu_exec_end(env);
1341 switch(trapnr) {
1342 case POWERPC_EXCP_NONE:
1343 /* Just go on */
1344 break;
1345 case POWERPC_EXCP_CRITICAL: /* Critical input */
1346 cpu_abort(env, "Critical interrupt while in user mode. "
1347 "Aborting\n");
1348 break;
1349 case POWERPC_EXCP_MCHECK: /* Machine check exception */
1350 cpu_abort(env, "Machine check exception while in user mode. "
1351 "Aborting\n");
1352 break;
1353 case POWERPC_EXCP_DSI: /* Data storage exception */
1354 EXCP_DUMP(env, "Invalid data memory access: 0x" TARGET_FMT_lx "\n",
1355 env->spr[SPR_DAR]);
1356 /* XXX: check this. Seems bugged */
1357 switch (env->error_code & 0xFF000000) {
1358 case 0x40000000:
1359 info.si_signo = TARGET_SIGSEGV;
1360 info.si_errno = 0;
1361 info.si_code = TARGET_SEGV_MAPERR;
1362 break;
1363 case 0x04000000:
1364 info.si_signo = TARGET_SIGILL;
1365 info.si_errno = 0;
1366 info.si_code = TARGET_ILL_ILLADR;
1367 break;
1368 case 0x08000000:
1369 info.si_signo = TARGET_SIGSEGV;
1370 info.si_errno = 0;
1371 info.si_code = TARGET_SEGV_ACCERR;
1372 break;
1373 default:
1374 /* Let's send a regular segfault... */
1375 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
1376 env->error_code);
1377 info.si_signo = TARGET_SIGSEGV;
1378 info.si_errno = 0;
1379 info.si_code = TARGET_SEGV_MAPERR;
1380 break;
1381 }
1382 info._sifields._sigfault._addr = env->nip;
1383 queue_signal(env, info.si_signo, &info);
1384 break;
1385 case POWERPC_EXCP_ISI: /* Instruction storage exception */
1386 EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" TARGET_FMT_lx
1387 "\n", env->spr[SPR_SRR0]);
1388 /* XXX: check this */
1389 switch (env->error_code & 0xFF000000) {
1390 case 0x40000000:
1391 info.si_signo = TARGET_SIGSEGV;
1392 info.si_errno = 0;
1393 info.si_code = TARGET_SEGV_MAPERR;
1394 break;
1395 case 0x10000000:
1396 case 0x08000000:
1397 info.si_signo = TARGET_SIGSEGV;
1398 info.si_errno = 0;
1399 info.si_code = TARGET_SEGV_ACCERR;
1400 break;
1401 default:
1402 /* Let's send a regular segfault... */
1403 EXCP_DUMP(env, "Invalid segfault errno (%02x)\n",
1404 env->error_code);
1405 info.si_signo = TARGET_SIGSEGV;
1406 info.si_errno = 0;
1407 info.si_code = TARGET_SEGV_MAPERR;
1408 break;
1409 }
1410 info._sifields._sigfault._addr = env->nip - 4;
1411 queue_signal(env, info.si_signo, &info);
1412 break;
1413 case POWERPC_EXCP_EXTERNAL: /* External input */
1414 cpu_abort(env, "External interrupt while in user mode. "
1415 "Aborting\n");
1416 break;
1417 case POWERPC_EXCP_ALIGN: /* Alignment exception */
1418 EXCP_DUMP(env, "Unaligned memory access\n");
1419 /* XXX: check this */
1420 info.si_signo = TARGET_SIGBUS;
1421 info.si_errno = 0;
1422 info.si_code = TARGET_BUS_ADRALN;
1423 info._sifields._sigfault._addr = env->nip - 4;
1424 queue_signal(env, info.si_signo, &info);
1425 break;
1426 case POWERPC_EXCP_PROGRAM: /* Program exception */
1427 /* XXX: check this */
1428 switch (env->error_code & ~0xF) {
1429 case POWERPC_EXCP_FP:
1430 EXCP_DUMP(env, "Floating point program exception\n");
1431 info.si_signo = TARGET_SIGFPE;
1432 info.si_errno = 0;
1433 switch (env->error_code & 0xF) {
1434 case POWERPC_EXCP_FP_OX:
1435 info.si_code = TARGET_FPE_FLTOVF;
1436 break;
1437 case POWERPC_EXCP_FP_UX:
1438 info.si_code = TARGET_FPE_FLTUND;
1439 break;
1440 case POWERPC_EXCP_FP_ZX:
1441 case POWERPC_EXCP_FP_VXZDZ:
1442 info.si_code = TARGET_FPE_FLTDIV;
1443 break;
1444 case POWERPC_EXCP_FP_XX:
1445 info.si_code = TARGET_FPE_FLTRES;
1446 break;
1447 case POWERPC_EXCP_FP_VXSOFT:
1448 info.si_code = TARGET_FPE_FLTINV;
1449 break;
1450 case POWERPC_EXCP_FP_VXSNAN:
1451 case POWERPC_EXCP_FP_VXISI:
1452 case POWERPC_EXCP_FP_VXIDI:
1453 case POWERPC_EXCP_FP_VXIMZ:
1454 case POWERPC_EXCP_FP_VXVC:
1455 case POWERPC_EXCP_FP_VXSQRT:
1456 case POWERPC_EXCP_FP_VXCVI:
1457 info.si_code = TARGET_FPE_FLTSUB;
1458 break;
1459 default:
1460 EXCP_DUMP(env, "Unknown floating point exception (%02x)\n",
1461 env->error_code);
1462 break;
1463 }
1464 break;
1465 case POWERPC_EXCP_INVAL:
1466 EXCP_DUMP(env, "Invalid instruction\n");
1467 info.si_signo = TARGET_SIGILL;
1468 info.si_errno = 0;
1469 switch (env->error_code & 0xF) {
1470 case POWERPC_EXCP_INVAL_INVAL:
1471 info.si_code = TARGET_ILL_ILLOPC;
1472 break;
1473 case POWERPC_EXCP_INVAL_LSWX:
1474 info.si_code = TARGET_ILL_ILLOPN;
1475 break;
1476 case POWERPC_EXCP_INVAL_SPR:
1477 info.si_code = TARGET_ILL_PRVREG;
1478 break;
1479 case POWERPC_EXCP_INVAL_FP:
1480 info.si_code = TARGET_ILL_COPROC;
1481 break;
1482 default:
1483 EXCP_DUMP(env, "Unknown invalid operation (%02x)\n",
1484 env->error_code & 0xF);
1485 info.si_code = TARGET_ILL_ILLADR;
1486 break;
1487 }
1488 break;
1489 case POWERPC_EXCP_PRIV:
1490 EXCP_DUMP(env, "Privilege violation\n");
1491 info.si_signo = TARGET_SIGILL;
1492 info.si_errno = 0;
1493 switch (env->error_code & 0xF) {
1494 case POWERPC_EXCP_PRIV_OPC:
1495 info.si_code = TARGET_ILL_PRVOPC;
1496 break;
1497 case POWERPC_EXCP_PRIV_REG:
1498 info.si_code = TARGET_ILL_PRVREG;
1499 break;
1500 default:
1501 EXCP_DUMP(env, "Unknown privilege violation (%02x)\n",
1502 env->error_code & 0xF);
1503 info.si_code = TARGET_ILL_PRVOPC;
1504 break;
1505 }
1506 break;
1507 case POWERPC_EXCP_TRAP:
1508 cpu_abort(env, "Tried to call a TRAP\n");
1509 break;
1510 default:
1511 /* Should not happen ! */
1512 cpu_abort(env, "Unknown program exception (%02x)\n",
1513 env->error_code);
1514 break;
1515 }
1516 info._sifields._sigfault._addr = env->nip - 4;
1517 queue_signal(env, info.si_signo, &info);
1518 break;
1519 case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
1520 EXCP_DUMP(env, "No floating point allowed\n");
1521 info.si_signo = TARGET_SIGILL;
1522 info.si_errno = 0;
1523 info.si_code = TARGET_ILL_COPROC;
1524 info._sifields._sigfault._addr = env->nip - 4;
1525 queue_signal(env, info.si_signo, &info);
1526 break;
1527 case POWERPC_EXCP_SYSCALL: /* System call exception */
1528 cpu_abort(env, "Syscall exception while in user mode. "
1529 "Aborting\n");
1530 break;
1531 case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
1532 EXCP_DUMP(env, "No APU instruction allowed\n");
1533 info.si_signo = TARGET_SIGILL;
1534 info.si_errno = 0;
1535 info.si_code = TARGET_ILL_COPROC;
1536 info._sifields._sigfault._addr = env->nip - 4;
1537 queue_signal(env, info.si_signo, &info);
1538 break;
1539 case POWERPC_EXCP_DECR: /* Decrementer exception */
1540 cpu_abort(env, "Decrementer interrupt while in user mode. "
1541 "Aborting\n");
1542 break;
1543 case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
1544 cpu_abort(env, "Fix interval timer interrupt while in user mode. "
1545 "Aborting\n");
1546 break;
1547 case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
1548 cpu_abort(env, "Watchdog timer interrupt while in user mode. "
1549 "Aborting\n");
1550 break;
1551 case POWERPC_EXCP_DTLB: /* Data TLB error */
1552 cpu_abort(env, "Data TLB exception while in user mode. "
1553 "Aborting\n");
1554 break;
1555 case POWERPC_EXCP_ITLB: /* Instruction TLB error */
1556 cpu_abort(env, "Instruction TLB exception while in user mode. "
1557 "Aborting\n");
1558 break;
1559 case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavail. */
1560 EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");
1561 info.si_signo = TARGET_SIGILL;
1562 info.si_errno = 0;
1563 info.si_code = TARGET_ILL_COPROC;
1564 info._sifields._sigfault._addr = env->nip - 4;
1565 queue_signal(env, info.si_signo, &info);
1566 break;
1567 case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */
1568 cpu_abort(env, "Embedded floating-point data IRQ not handled\n");
1569 break;
1570 case POWERPC_EXCP_EFPRI: /* Embedded floating-point round IRQ */
1571 cpu_abort(env, "Embedded floating-point round IRQ not handled\n");
1572 break;
1573 case POWERPC_EXCP_EPERFM: /* Embedded performance monitor IRQ */
1574 cpu_abort(env, "Performance monitor exception not handled\n");
1575 break;
1576 case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
1577 cpu_abort(env, "Doorbell interrupt while in user mode. "
1578 "Aborting\n");
1579 break;
1580 case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
1581 cpu_abort(env, "Doorbell critical interrupt while in user mode. "
1582 "Aborting\n");
1583 break;
1584 case POWERPC_EXCP_RESET: /* System reset exception */
1585 cpu_abort(env, "Reset interrupt while in user mode. "
1586 "Aborting\n");
1587 break;
1588 case POWERPC_EXCP_DSEG: /* Data segment exception */
1589 cpu_abort(env, "Data segment exception while in user mode. "
1590 "Aborting\n");
1591 break;
1592 case POWERPC_EXCP_ISEG: /* Instruction segment exception */
1593 cpu_abort(env, "Instruction segment exception "
1594 "while in user mode. Aborting\n");
1595 break;
1596 /* PowerPC 64 with hypervisor mode support */
1597 case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
1598 cpu_abort(env, "Hypervisor decrementer interrupt "
1599 "while in user mode. Aborting\n");
1600 break;
1601 case POWERPC_EXCP_TRACE: /* Trace exception */
1602 /* Nothing to do:
1603 * we use this exception to emulate step-by-step execution mode.
1604 */
1605 break;
1606 /* PowerPC 64 with hypervisor mode support */
1607 case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
1608 cpu_abort(env, "Hypervisor data storage exception "
1609 "while in user mode. Aborting\n");
1610 break;
1611 case POWERPC_EXCP_HISI: /* Hypervisor instruction storage excp */
1612 cpu_abort(env, "Hypervisor instruction storage exception "
1613 "while in user mode. Aborting\n");
1614 break;
1615 case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
1616 cpu_abort(env, "Hypervisor data segment exception "
1617 "while in user mode. Aborting\n");
1618 break;
1619 case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment excp */
1620 cpu_abort(env, "Hypervisor instruction segment exception "
1621 "while in user mode. Aborting\n");
1622 break;
1623 case POWERPC_EXCP_VPU: /* Vector unavailable exception */
1624 EXCP_DUMP(env, "No Altivec instructions allowed\n");
1625 info.si_signo = TARGET_SIGILL;
1626 info.si_errno = 0;
1627 info.si_code = TARGET_ILL_COPROC;
1628 info._sifields._sigfault._addr = env->nip - 4;
1629 queue_signal(env, info.si_signo, &info);
1630 break;
1631 case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */
1632 cpu_abort(env, "Programable interval timer interrupt "
1633 "while in user mode. Aborting\n");
1634 break;
1635 case POWERPC_EXCP_IO: /* IO error exception */
1636 cpu_abort(env, "IO error exception while in user mode. "
1637 "Aborting\n");
1638 break;
1639 case POWERPC_EXCP_RUNM: /* Run mode exception */
1640 cpu_abort(env, "Run mode exception while in user mode. "
1641 "Aborting\n");
1642 break;
1643 case POWERPC_EXCP_EMUL: /* Emulation trap exception */
1644 cpu_abort(env, "Emulation trap exception not handled\n");
1645 break;
1646 case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
1647 cpu_abort(env, "Instruction fetch TLB exception "
1648 "while in user-mode. Aborting");
1649 break;
1650 case POWERPC_EXCP_DLTLB: /* Data load TLB miss */
1651 cpu_abort(env, "Data load TLB exception while in user-mode. "
1652 "Aborting");
1653 break;
1654 case POWERPC_EXCP_DSTLB: /* Data store TLB miss */
1655 cpu_abort(env, "Data store TLB exception while in user-mode. "
1656 "Aborting");
1657 break;
1658 case POWERPC_EXCP_FPA: /* Floating-point assist exception */
1659 cpu_abort(env, "Floating-point assist exception not handled\n");
1660 break;
1661 case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
1662 cpu_abort(env, "Instruction address breakpoint exception "
1663 "not handled\n");
1664 break;
1665 case POWERPC_EXCP_SMI: /* System management interrupt */
1666 cpu_abort(env, "System management interrupt while in user mode. "
1667 "Aborting\n");
1668 break;
1669 case POWERPC_EXCP_THERM: /* Thermal interrupt */
1670 cpu_abort(env, "Thermal interrupt interrupt while in user mode. "
1671 "Aborting\n");
1672 break;
1673 case POWERPC_EXCP_PERFM: /* Embedded performance monitor IRQ */
1674 cpu_abort(env, "Performance monitor exception not handled\n");
1675 break;
1676 case POWERPC_EXCP_VPUA: /* Vector assist exception */
1677 cpu_abort(env, "Vector assist exception not handled\n");
1678 break;
1679 case POWERPC_EXCP_SOFTP: /* Soft patch exception */
1680 cpu_abort(env, "Soft patch exception not handled\n");
1681 break;
1682 case POWERPC_EXCP_MAINT: /* Maintenance exception */
1683 cpu_abort(env, "Maintenance exception while in user mode. "
1684 "Aborting\n");
1685 break;
1686 case POWERPC_EXCP_STOP: /* stop translation */
1687 /* We did invalidate the instruction cache. Go on */
1688 break;
1689 case POWERPC_EXCP_BRANCH: /* branch instruction: */
1690 /* We just stopped because of a branch. Go on */
1691 break;
1692 case POWERPC_EXCP_SYSCALL_USER:
1693 /* system call in user-mode emulation */
1694 /* WARNING:
1695 * PPC ABI uses overflow flag in cr0 to signal an error
1696 * in syscalls.
1697 */
1698 #if 0
1699 printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0],
1700 env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]);
1701 #endif
1702 env->crf[0] &= ~0x1;
1703 ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
1704 env->gpr[5], env->gpr[6], env->gpr[7],
1705 env->gpr[8], 0, 0);
1706 if (ret == (uint32_t)(-TARGET_QEMU_ESIGRETURN)) {
1707 /* Returning from a successful sigreturn syscall.
1708 Avoid corrupting register state. */
1709 break;
1710 }
1711 if (ret > (uint32_t)(-515)) {
1712 env->crf[0] |= 0x1;
1713 ret = -ret;
1714 }
1715 env->gpr[3] = ret;
1716 #if 0
1717 printf("syscall returned 0x%08x (%d)\n", ret, ret);
1718 #endif
1719 break;
1720 case POWERPC_EXCP_STCX:
1721 if (do_store_exclusive(env)) {
1722 info.si_signo = TARGET_SIGSEGV;
1723 info.si_errno = 0;
1724 info.si_code = TARGET_SEGV_MAPERR;
1725 info._sifields._sigfault._addr = env->nip;
1726 queue_signal(env, info.si_signo, &info);
1727 }
1728 break;
1729 case EXCP_DEBUG:
1730 {
1731 int sig;
1732
1733 sig = gdb_handlesig(env, TARGET_SIGTRAP);
1734 if (sig) {
1735 info.si_signo = sig;
1736 info.si_errno = 0;
1737 info.si_code = TARGET_TRAP_BRKPT;
1738 queue_signal(env, info.si_signo, &info);
1739 }
1740 }
1741 break;
1742 case EXCP_INTERRUPT:
1743 /* just indicate that signals should be handled asap */
1744 break;
1745 default:
1746 cpu_abort(env, "Unknown exception 0x%d. Aborting\n", trapnr);
1747 break;
1748 }
1749 process_pending_signals(env);
1750 }
1751 }
1752 #endif
1753
1754 #ifdef TARGET_MIPS
1755
1756 #define MIPS_SYS(name, args) args,
1757
1758 static const uint8_t mips_syscall_args[] = {
1759 MIPS_SYS(sys_syscall , 8) /* 4000 */
1760 MIPS_SYS(sys_exit , 1)
1761 MIPS_SYS(sys_fork , 0)
1762 MIPS_SYS(sys_read , 3)
1763 MIPS_SYS(sys_write , 3)
1764 MIPS_SYS(sys_open , 3) /* 4005 */
1765 MIPS_SYS(sys_close , 1)
1766 MIPS_SYS(sys_waitpid , 3)
1767 MIPS_SYS(sys_creat , 2)
1768 MIPS_SYS(sys_link , 2)
1769 MIPS_SYS(sys_unlink , 1) /* 4010 */
1770 MIPS_SYS(sys_execve , 0)
1771 MIPS_SYS(sys_chdir , 1)
1772 MIPS_SYS(sys_time , 1)
1773 MIPS_SYS(sys_mknod , 3)
1774 MIPS_SYS(sys_chmod , 2) /* 4015 */
1775 MIPS_SYS(sys_lchown , 3)
1776 MIPS_SYS(sys_ni_syscall , 0)
1777 MIPS_SYS(sys_ni_syscall , 0) /* was sys_stat */
1778 MIPS_SYS(sys_lseek , 3)
1779 MIPS_SYS(sys_getpid , 0) /* 4020 */
1780 MIPS_SYS(sys_mount , 5)
1781 MIPS_SYS(sys_oldumount , 1)
1782 MIPS_SYS(sys_setuid , 1)
1783 MIPS_SYS(sys_getuid , 0)
1784 MIPS_SYS(sys_stime , 1) /* 4025 */
1785 MIPS_SYS(sys_ptrace , 4)
1786 MIPS_SYS(sys_alarm , 1)
1787 MIPS_SYS(sys_ni_syscall , 0) /* was sys_fstat */
1788 MIPS_SYS(sys_pause , 0)
1789 MIPS_SYS(sys_utime , 2) /* 4030 */
1790 MIPS_SYS(sys_ni_syscall , 0)
1791 MIPS_SYS(sys_ni_syscall , 0)
1792 MIPS_SYS(sys_access , 2)
1793 MIPS_SYS(sys_nice , 1)
1794 MIPS_SYS(sys_ni_syscall , 0) /* 4035 */
1795 MIPS_SYS(sys_sync , 0)
1796 MIPS_SYS(sys_kill , 2)
1797 MIPS_SYS(sys_rename , 2)
1798 MIPS_SYS(sys_mkdir , 2)
1799 MIPS_SYS(sys_rmdir , 1) /* 4040 */
1800 MIPS_SYS(sys_dup , 1)
1801 MIPS_SYS(sys_pipe , 0)
1802 MIPS_SYS(sys_times , 1)
1803 MIPS_SYS(sys_ni_syscall , 0)
1804 MIPS_SYS(sys_brk , 1) /* 4045 */
1805 MIPS_SYS(sys_setgid , 1)
1806 MIPS_SYS(sys_getgid , 0)
1807 MIPS_SYS(sys_ni_syscall , 0) /* was signal(2) */
1808 MIPS_SYS(sys_geteuid , 0)
1809 MIPS_SYS(sys_getegid , 0) /* 4050 */
1810 MIPS_SYS(sys_acct , 0)
1811 MIPS_SYS(sys_umount , 2)
1812 MIPS_SYS(sys_ni_syscall , 0)
1813 MIPS_SYS(sys_ioctl , 3)
1814 MIPS_SYS(sys_fcntl , 3) /* 4055 */
1815 MIPS_SYS(sys_ni_syscall , 2)
1816 MIPS_SYS(sys_setpgid , 2)
1817 MIPS_SYS(sys_ni_syscall , 0)
1818 MIPS_SYS(sys_olduname , 1)
1819 MIPS_SYS(sys_umask , 1) /* 4060 */
1820 MIPS_SYS(sys_chroot , 1)
1821 MIPS_SYS(sys_ustat , 2)
1822 MIPS_SYS(sys_dup2 , 2)
1823 MIPS_SYS(sys_getppid , 0)
1824 MIPS_SYS(sys_getpgrp , 0) /* 4065 */
1825 MIPS_SYS(sys_setsid , 0)
1826 MIPS_SYS(sys_sigaction , 3)
1827 MIPS_SYS(sys_sgetmask , 0)
1828 MIPS_SYS(sys_ssetmask , 1)
1829 MIPS_SYS(sys_setreuid , 2) /* 4070 */
1830 MIPS_SYS(sys_setregid , 2)
1831 MIPS_SYS(sys_sigsuspend , 0)
1832 MIPS_SYS(sys_sigpending , 1)
1833 MIPS_SYS(sys_sethostname , 2)
1834 MIPS_SYS(sys_setrlimit , 2) /* 4075 */
1835 MIPS_SYS(sys_getrlimit , 2)
1836 MIPS_SYS(sys_getrusage , 2)
1837 MIPS_SYS(sys_gettimeofday, 2)
1838 MIPS_SYS(sys_settimeofday, 2)
1839 MIPS_SYS(sys_getgroups , 2) /* 4080 */
1840 MIPS_SYS(sys_setgroups , 2)
1841 MIPS_SYS(sys_ni_syscall , 0) /* old_select */
1842 MIPS_SYS(sys_symlink , 2)
1843 MIPS_SYS(sys_ni_syscall , 0) /* was sys_lstat */
1844 MIPS_SYS(sys_readlink , 3) /* 4085 */
1845 MIPS_SYS(sys_uselib , 1)
1846 MIPS_SYS(sys_swapon , 2)
1847 MIPS_SYS(sys_reboot , 3)
1848 MIPS_SYS(old_readdir , 3)
1849 MIPS_SYS(old_mmap , 6) /* 4090 */
1850 MIPS_SYS(sys_munmap , 2)
1851 MIPS_SYS(sys_truncate , 2)
1852 MIPS_SYS(sys_ftruncate , 2)
1853 MIPS_SYS(sys_fchmod , 2)
1854 MIPS_SYS(sys_fchown , 3) /* 4095 */
1855 MIPS_SYS(sys_getpriority , 2)
1856 MIPS_SYS(sys_setpriority , 3)
1857 MIPS_SYS(sys_ni_syscall , 0)
1858 MIPS_SYS(sys_statfs , 2)
1859 MIPS_SYS(sys_fstatfs , 2) /* 4100 */
1860 MIPS_SYS(sys_ni_syscall , 0) /* was ioperm(2) */
1861 MIPS_SYS(sys_socketcall , 2)
1862 MIPS_SYS(sys_syslog , 3)
1863 MIPS_SYS(sys_setitimer , 3)
1864 MIPS_SYS(sys_getitimer , 2) /* 4105 */
1865 MIPS_SYS(sys_newstat , 2)
1866 MIPS_SYS(sys_newlstat , 2)
1867 MIPS_SYS(sys_newfstat , 2)
1868 MIPS_SYS(sys_uname , 1)
1869 MIPS_SYS(sys_ni_syscall , 0) /* 4110 was iopl(2) */
1870 MIPS_SYS(sys_vhangup , 0)
1871 MIPS_SYS(sys_ni_syscall , 0) /* was sys_idle() */
1872 MIPS_SYS(sys_ni_syscall , 0) /* was sys_vm86 */
1873 MIPS_SYS(sys_wait4 , 4)
1874 MIPS_SYS(sys_swapoff , 1) /* 4115 */
1875 MIPS_SYS(sys_sysinfo , 1)
1876 MIPS_SYS(sys_ipc , 6)
1877 MIPS_SYS(sys_fsync , 1)
1878 MIPS_SYS(sys_sigreturn , 0)
1879 MIPS_SYS(sys_clone , 6) /* 4120 */
1880 MIPS_SYS(sys_setdomainname, 2)
1881 MIPS_SYS(sys_newuname , 1)
1882 MIPS_SYS(sys_ni_syscall , 0) /* sys_modify_ldt */
1883 MIPS_SYS(sys_adjtimex , 1)
1884 MIPS_SYS(sys_mprotect , 3) /* 4125 */
1885 MIPS_SYS(sys_sigprocmask , 3)
1886 MIPS_SYS(sys_ni_syscall , 0) /* was create_module */
1887 MIPS_SYS(sys_init_module , 5)
1888 MIPS_SYS(sys_delete_module, 1)
1889 MIPS_SYS(sys_ni_syscall , 0) /* 4130 was get_kernel_syms */
1890 MIPS_SYS(sys_quotactl , 0)
1891 MIPS_SYS(sys_getpgid , 1)
1892 MIPS_SYS(sys_fchdir , 1)
1893 MIPS_SYS(sys_bdflush , 2)
1894 MIPS_SYS(sys_sysfs , 3) /* 4135 */
1895 MIPS_SYS(sys_personality , 1)
1896 MIPS_SYS(sys_ni_syscall , 0) /* for afs_syscall */
1897 MIPS_SYS(sys_setfsuid , 1)
1898 MIPS_SYS(sys_setfsgid , 1)
1899 MIPS_SYS(sys_llseek , 5) /* 4140 */
1900 MIPS_SYS(sys_getdents , 3)
1901 MIPS_SYS(sys_select , 5)
1902 MIPS_SYS(sys_flock , 2)
1903 MIPS_SYS(sys_msync , 3)
1904 MIPS_SYS(sys_readv , 3) /* 4145 */
1905 MIPS_SYS(sys_writev , 3)
1906 MIPS_SYS(sys_cacheflush , 3)
1907 MIPS_SYS(sys_cachectl , 3)
1908 MIPS_SYS(sys_sysmips , 4)
1909 MIPS_SYS(sys_ni_syscall , 0) /* 4150 */
1910 MIPS_SYS(sys_getsid , 1)
1911 MIPS_SYS(sys_fdatasync , 0)
1912 MIPS_SYS(sys_sysctl , 1)
1913 MIPS_SYS(sys_mlock , 2)
1914 MIPS_SYS(sys_munlock , 2) /* 4155 */
1915 MIPS_SYS(sys_mlockall , 1)
1916 MIPS_SYS(sys_munlockall , 0)
1917 MIPS_SYS(sys_sched_setparam, 2)
1918 MIPS_SYS(sys_sched_getparam, 2)
1919 MIPS_SYS(sys_sched_setscheduler, 3) /* 4160 */
1920 MIPS_SYS(sys_sched_getscheduler, 1)
1921 MIPS_SYS(sys_sched_yield , 0)
1922 MIPS_SYS(sys_sched_get_priority_max, 1)
1923 MIPS_SYS(sys_sched_get_priority_min, 1)
1924 MIPS_SYS(sys_sched_rr_get_interval, 2) /* 4165 */
1925 MIPS_SYS(sys_nanosleep, 2)
1926 MIPS_SYS(sys_mremap , 4)
1927 MIPS_SYS(sys_accept , 3)
1928 MIPS_SYS(sys_bind , 3)
1929 MIPS_SYS(sys_connect , 3) /* 4170 */
1930 MIPS_SYS(sys_getpeername , 3)
1931 MIPS_SYS(sys_getsockname , 3)
1932 MIPS_SYS(sys_getsockopt , 5)
1933 MIPS_SYS(sys_listen , 2)
1934 MIPS_SYS(sys_recv , 4) /* 4175 */
1935 MIPS_SYS(sys_recvfrom , 6)
1936 MIPS_SYS(sys_recvmsg , 3)
1937 MIPS_SYS(sys_send , 4)
1938 MIPS_SYS(sys_sendmsg , 3)
1939 MIPS_SYS(sys_sendto , 6) /* 4180 */
1940 MIPS_SYS(sys_setsockopt , 5)
1941 MIPS_SYS(sys_shutdown , 2)
1942 MIPS_SYS(sys_socket , 3)
1943 MIPS_SYS(sys_socketpair , 4)
1944 MIPS_SYS(sys_setresuid , 3) /* 4185 */
1945 MIPS_SYS(sys_getresuid , 3)
1946 MIPS_SYS(sys_ni_syscall , 0) /* was sys_query_module */
1947 MIPS_SYS(sys_poll , 3)
1948 MIPS_SYS(sys_nfsservctl , 3)
1949 MIPS_SYS(sys_setresgid , 3) /* 4190 */
1950 MIPS_SYS(sys_getresgid , 3)
1951 MIPS_SYS(sys_prctl , 5)
1952 MIPS_SYS(sys_rt_sigreturn, 0)
1953 MIPS_SYS(sys_rt_sigaction, 4)
1954 MIPS_SYS(sys_rt_sigprocmask, 4) /* 4195 */
1955 MIPS_SYS(sys_rt_sigpending, 2)
1956 MIPS_SYS(sys_rt_sigtimedwait, 4)
1957 MIPS_SYS(sys_rt_sigqueueinfo, 3)
1958 MIPS_SYS(sys_rt_sigsuspend, 0)
1959 MIPS_SYS(sys_pread64 , 6) /* 4200 */
1960 MIPS_SYS(sys_pwrite64 , 6)
1961 MIPS_SYS(sys_chown , 3)
1962 MIPS_SYS(sys_getcwd , 2)
1963 MIPS_SYS(sys_capget , 2)
1964 MIPS_SYS(sys_capset , 2) /* 4205 */
1965 MIPS_SYS(sys_sigaltstack , 2)
1966 MIPS_SYS(sys_sendfile , 4)
1967 MIPS_SYS(sys_ni_syscall , 0)
1968 MIPS_SYS(sys_ni_syscall , 0)
1969 MIPS_SYS(sys_mmap2 , 6) /* 4210 */
1970 MIPS_SYS(sys_truncate64 , 4)
1971 MIPS_SYS(sys_ftruncate64 , 4)
1972 MIPS_SYS(sys_stat64 , 2)
1973 MIPS_SYS(sys_lstat64 , 2)
1974 MIPS_SYS(sys_fstat64 , 2) /* 4215 */
1975 MIPS_SYS(sys_pivot_root , 2)
1976 MIPS_SYS(sys_mincore , 3)
1977 MIPS_SYS(sys_madvise , 3)
1978 MIPS_SYS(sys_getdents64 , 3)
1979 MIPS_SYS(sys_fcntl64 , 3) /* 4220 */
1980 MIPS_SYS(sys_ni_syscall , 0)
1981 MIPS_SYS(sys_gettid , 0)
1982 MIPS_SYS(sys_readahead , 5)
1983 MIPS_SYS(sys_setxattr , 5)
1984 MIPS_SYS(sys_lsetxattr , 5) /* 4225 */
1985 MIPS_SYS(sys_fsetxattr , 5)
1986 MIPS_SYS(sys_getxattr , 4)
1987 MIPS_SYS(sys_lgetxattr , 4)
1988 MIPS_SYS(sys_fgetxattr , 4)
1989 MIPS_SYS(sys_listxattr , 3) /* 4230 */
1990 MIPS_SYS(sys_llistxattr , 3)
1991 MIPS_SYS(sys_flistxattr , 3)
1992 MIPS_SYS(sys_removexattr , 2)
1993 MIPS_SYS(sys_lremovexattr, 2)
1994 MIPS_SYS(sys_fremovexattr, 2) /* 4235 */
1995 MIPS_SYS(sys_tkill , 2)
1996 MIPS_SYS(sys_sendfile64 , 5)
1997 MIPS_SYS(sys_futex , 2)
1998 MIPS_SYS(sys_sched_setaffinity, 3)
1999 MIPS_SYS(sys_sched_getaffinity, 3) /* 4240 */
2000 MIPS_SYS(sys_io_setup , 2)
2001 MIPS_SYS(sys_io_destroy , 1)
2002 MIPS_SYS(sys_io_getevents, 5)
2003 MIPS_SYS(sys_io_submit , 3)
2004 MIPS_SYS(sys_io_cancel , 3) /* 4245 */
2005 MIPS_SYS(sys_exit_group , 1)
2006 MIPS_SYS(sys_lookup_dcookie, 3)
2007 MIPS_SYS(sys_epoll_create, 1)
2008 MIPS_SYS(sys_epoll_ctl , 4)
2009 MIPS_SYS(sys_epoll_wait , 3) /* 4250 */
2010 MIPS_SYS(sys_remap_file_pages, 5)
2011 MIPS_SYS(sys_set_tid_address, 1)
2012 MIPS_SYS(sys_restart_syscall, 0)
2013 MIPS_SYS(sys_fadvise64_64, 7)
2014 MIPS_SYS(sys_statfs64 , 3) /* 4255 */
2015 MIPS_SYS(sys_fstatfs64 , 2)
2016 MIPS_SYS(sys_timer_create, 3)
2017 MIPS_SYS(sys_timer_settime, 4)
2018 MIPS_SYS(sys_timer_gettime, 2)
2019 MIPS_SYS(sys_timer_getoverrun, 1) /* 4260 */
2020 MIPS_SYS(sys_timer_delete, 1)
2021 MIPS_SYS(sys_clock_settime, 2)
2022 MIPS_SYS(sys_clock_gettime, 2)
2023 MIPS_SYS(sys_clock_getres, 2)
2024 MIPS_SYS(sys_clock_nanosleep, 4) /* 4265 */
2025 MIPS_SYS(sys_tgkill , 3)
2026 MIPS_SYS(sys_utimes , 2)
2027 MIPS_SYS(sys_mbind , 4)
2028 MIPS_SYS(sys_ni_syscall , 0) /* sys_get_mempolicy */
2029 MIPS_SYS(sys_ni_syscall , 0) /* 4270 sys_set_mempolicy */
2030 MIPS_SYS(sys_mq_open , 4)
2031 MIPS_SYS(sys_mq_unlink , 1)
2032 MIPS_SYS(sys_mq_timedsend, 5)
2033 MIPS_SYS(sys_mq_timedreceive, 5)
2034 MIPS_SYS(sys_mq_notify , 2) /* 4275 */
2035 MIPS_SYS(sys_mq_getsetattr, 3)
2036 MIPS_SYS(sys_ni_syscall , 0) /* sys_vserver */
2037 MIPS_SYS(sys_waitid , 4)
2038 MIPS_SYS(sys_ni_syscall , 0) /* available, was setaltroot */
2039 MIPS_SYS(sys_add_key , 5)
2040 MIPS_SYS(sys_request_key, 4)
2041 MIPS_SYS(sys_keyctl , 5)
2042 MIPS_SYS(sys_set_thread_area, 1)
2043 MIPS_SYS(sys_inotify_init, 0)
2044 MIPS_SYS(sys_inotify_add_watch, 3) /* 4285 */
2045 MIPS_SYS(sys_inotify_rm_watch, 2)
2046 MIPS_SYS(sys_migrate_pages, 4)
2047 MIPS_SYS(sys_openat, 4)
2048 MIPS_SYS(sys_mkdirat, 3)
2049 MIPS_SYS(sys_mknodat, 4) /* 4290 */
2050 MIPS_SYS(sys_fchownat, 5)
2051 MIPS_SYS(sys_futimesat, 3)
2052 MIPS_SYS(sys_fstatat64, 4)
2053 MIPS_SYS(sys_unlinkat, 3)
2054 MIPS_SYS(sys_renameat, 4) /* 4295 */
2055 MIPS_SYS(sys_linkat, 5)
2056 MIPS_SYS(sys_symlinkat, 3)
2057 MIPS_SYS(sys_readlinkat, 4)
2058 MIPS_SYS(sys_fchmodat, 3)
2059 MIPS_SYS(sys_faccessat, 3) /* 4300 */
2060 MIPS_SYS(sys_pselect6, 6)
2061 MIPS_SYS(sys_ppoll, 5)
2062 MIPS_SYS(sys_unshare, 1)
2063 MIPS_SYS(sys_splice, 4)
2064 MIPS_SYS(sys_sync_file_range, 7) /* 4305 */
2065 MIPS_SYS(sys_tee, 4)
2066 MIPS_SYS(sys_vmsplice, 4)
2067 MIPS_SYS(sys_move_pages, 6)
2068 MIPS_SYS(sys_set_robust_list, 2)
2069 MIPS_SYS(sys_get_robust_list, 3) /* 4310 */
2070 MIPS_SYS(sys_kexec_load, 4)
2071 MIPS_SYS(sys_getcpu, 3)
2072 MIPS_SYS(sys_epoll_pwait, 6)
2073 MIPS_SYS(sys_ioprio_set, 3)
2074 MIPS_SYS(sys_ioprio_get, 2)
2075 MIPS_SYS(sys_utimensat, 4)
2076 MIPS_SYS(sys_signalfd, 3)
2077 MIPS_SYS(sys_ni_syscall, 0) /* was timerfd */
2078 MIPS_SYS(sys_eventfd, 1)
2079 MIPS_SYS(sys_fallocate, 6) /* 4320 */
2080 MIPS_SYS(sys_timerfd_create, 2)
2081 MIPS_SYS(sys_timerfd_gettime, 2)
2082 MIPS_SYS(sys_timerfd_settime, 4)
2083 MIPS_SYS(sys_signalfd4, 4)
2084 MIPS_SYS(sys_eventfd2, 2) /* 4325 */
2085 MIPS_SYS(sys_epoll_create1, 1)
2086 MIPS_SYS(sys_dup3, 3)
2087 MIPS_SYS(sys_pipe2, 2)
2088 MIPS_SYS(sys_inotify_init1, 1)
2089 MIPS_SYS(sys_preadv, 6) /* 4330 */
2090 MIPS_SYS(sys_pwritev, 6)
2091 MIPS_SYS(sys_rt_tgsigqueueinfo, 4)
2092 MIPS_SYS(sys_perf_event_open, 5)
2093 MIPS_SYS(sys_accept4, 4)
2094 MIPS_SYS(sys_recvmmsg, 5) /* 4335 */
2095 MIPS_SYS(sys_fanotify_init, 2)
2096 MIPS_SYS(sys_fanotify_mark, 6)
2097 MIPS_SYS(sys_prlimit64, 4)
2098 MIPS_SYS(sys_name_to_handle_at, 5)
2099 MIPS_SYS(sys_open_by_handle_at, 3) /* 4340 */
2100 MIPS_SYS(sys_clock_adjtime, 2)
2101 MIPS_SYS(sys_syncfs, 1)
2102 };
2103
2104 #undef MIPS_SYS
2105
2106 static int do_store_exclusive(CPUMIPSState *env)
2107 {
2108 target_ulong addr;
2109 target_ulong page_addr;
2110 target_ulong val;
2111 int flags;
2112 int segv = 0;
2113 int reg;
2114 int d;
2115
2116 addr = env->lladdr;
2117 page_addr = addr & TARGET_PAGE_MASK;
2118 start_exclusive();
2119 mmap_lock();
2120 flags = page_get_flags(page_addr);
2121 if ((flags & PAGE_READ) == 0) {
2122 segv = 1;
2123 } else {
2124 reg = env->llreg & 0x1f;
2125 d = (env->llreg & 0x20) != 0;
2126 if (d) {
2127 segv = get_user_s64(val, addr);
2128 } else {
2129 segv = get_user_s32(val, addr);
2130 }
2131 if (!segv) {
2132 if (val != env->llval) {
2133 env->active_tc.gpr[reg] = 0;
2134 } else {
2135 if (d) {
2136 segv = put_user_u64(env->llnewval, addr);
2137 } else {
2138 segv = put_user_u32(env->llnewval, addr);
2139 }
2140 if (!segv) {
2141 env->active_tc.gpr[reg] = 1;
2142 }
2143 }
2144 }
2145 }
2146 env->lladdr = -1;
2147 if (!segv) {
2148 env->active_tc.PC += 4;
2149 }
2150 mmap_unlock();
2151 end_exclusive();
2152 return segv;
2153 }
2154
2155 void cpu_loop(CPUMIPSState *env)
2156 {
2157 target_siginfo_t info;
2158 int trapnr, ret;
2159 unsigned int syscall_num;
2160
2161 for(;;) {
2162 cpu_exec_start(env);
2163 trapnr = cpu_mips_exec(env);
2164 cpu_exec_end(env);
2165 switch(trapnr) {
2166 case EXCP_SYSCALL:
2167 syscall_num = env->active_tc.gpr[2] - 4000;
2168 env->active_tc.PC += 4;
2169 if (syscall_num >= sizeof(mips_syscall_args)) {
2170 ret = -TARGET_ENOSYS;
2171 } else {
2172 int nb_args;
2173 abi_ulong sp_reg;
2174 abi_ulong arg5 = 0, arg6 = 0, arg7 = 0, arg8 = 0;
2175
2176 nb_args = mips_syscall_args[syscall_num];
2177 sp_reg = env->active_tc.gpr[29];
2178 switch (nb_args) {
2179 /* these arguments are taken from the stack */
2180 case 8:
2181 if ((ret = get_user_ual(arg8, sp_reg + 28)) != 0) {
2182 goto done_syscall;
2183 }
2184 case 7:
2185 if ((ret = get_user_ual(arg7, sp_reg + 24)) != 0) {
2186 goto done_syscall;
2187 }
2188 case 6:
2189 if ((ret = get_user_ual(arg6, sp_reg + 20)) != 0) {
2190 goto done_syscall;
2191 }
2192 case 5:
2193 if ((ret = get_user_ual(arg5, sp_reg + 16)) != 0) {
2194 goto done_syscall;
2195 }
2196 default:
2197 break;
2198 }
2199 ret = do_syscall(env, env->active_tc.gpr[2],
2200 env->active_tc.gpr[4],
2201 env->active_tc.gpr[5],
2202 env->active_tc.gpr[6],
2203 env->active_tc.gpr[7],
2204 arg5, arg6, arg7, arg8);
2205 }
2206 done_syscall:
2207 if (ret == -TARGET_QEMU_ESIGRETURN) {
2208 /* Returning from a successful sigreturn syscall.
2209 Avoid clobbering register state. */
2210 break;
2211 }
2212 if ((unsigned int)ret >= (unsigned int)(-1133)) {
2213 env->active_tc.gpr[7] = 1; /* error flag */
2214 ret = -ret;
2215 } else {
2216 env->active_tc.gpr[7] = 0; /* error flag */
2217 }
2218 env->active_tc.gpr[2] = ret;
2219 break;
2220 case EXCP_TLBL:
2221 case EXCP_TLBS:
2222 case EXCP_AdEL:
2223 case EXCP_AdES:
2224 info.si_signo = TARGET_SIGSEGV;
2225 info.si_errno = 0;
2226 /* XXX: check env->error_code */
2227 info.si_code = TARGET_SEGV_MAPERR;
2228 info._sifields._sigfault._addr = env->CP0_BadVAddr;
2229 queue_signal(env, info.si_signo, &info);
2230 break;
2231 case EXCP_CpU:
2232 case EXCP_RI:
2233 info.si_signo = TARGET_SIGILL;
2234 info.si_errno = 0;
2235 info.si_code = 0;
2236 queue_signal(env, info.si_signo, &info);
2237 break;
2238 case EXCP_INTERRUPT:
2239 /* just indicate that signals should be handled asap */
2240 break;
2241 case EXCP_DEBUG:
2242 {
2243 int sig;
2244
2245 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2246 if (sig)
2247 {
2248 info.si_signo = sig;
2249 info.si_errno = 0;
2250 info.si_code = TARGET_TRAP_BRKPT;
2251 queue_signal(env, info.si_signo, &info);
2252 }
2253 }
2254 break;
2255 case EXCP_SC:
2256 if (do_store_exclusive(env)) {
2257 info.si_signo = TARGET_SIGSEGV;
2258 info.si_errno = 0;
2259 info.si_code = TARGET_SEGV_MAPERR;
2260 info._sifields._sigfault._addr = env->active_tc.PC;
2261 queue_signal(env, info.si_signo, &info);
2262 }
2263 break;
2264 default:
2265 // error:
2266 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
2267 trapnr);
2268 cpu_dump_state(env, stderr, fprintf, 0);
2269 abort();
2270 }
2271 process_pending_signals(env);
2272 }
2273 }
2274 #endif
2275
2276 #ifdef TARGET_SH4
2277 void cpu_loop (CPUState *env)
2278 {
2279 int trapnr, ret;
2280 target_siginfo_t info;
2281
2282 while (1) {
2283 trapnr = cpu_sh4_exec (env);
2284
2285 switch (trapnr) {
2286 case 0x160:
2287 env->pc += 2;
2288 ret = do_syscall(env,
2289 env->gregs[3],
2290 env->gregs[4],
2291 env->gregs[5],
2292 env->gregs[6],
2293 env->gregs[7],
2294 env->gregs[0],
2295 env->gregs[1],
2296 0, 0);
2297 env->gregs[0] = ret;
2298 break;
2299 case EXCP_INTERRUPT:
2300 /* just indicate that signals should be handled asap */
2301 break;
2302 case EXCP_DEBUG:
2303 {
2304 int sig;
2305
2306 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2307 if (sig)
2308 {
2309 info.si_signo = sig;
2310 info.si_errno = 0;
2311 info.si_code = TARGET_TRAP_BRKPT;
2312 queue_signal(env, info.si_signo, &info);
2313 }
2314 }
2315 break;
2316 case 0xa0:
2317 case 0xc0:
2318 info.si_signo = SIGSEGV;
2319 info.si_errno = 0;
2320 info.si_code = TARGET_SEGV_MAPERR;
2321 info._sifields._sigfault._addr = env->tea;
2322 queue_signal(env, info.si_signo, &info);
2323 break;
2324
2325 default:
2326 printf ("Unhandled trap: 0x%x\n", trapnr);
2327 cpu_dump_state(env, stderr, fprintf, 0);
2328 exit (1);
2329 }
2330 process_pending_signals (env);
2331 }
2332 }
2333 #endif
2334
2335 #ifdef TARGET_CRIS
2336 void cpu_loop (CPUState *env)
2337 {
2338 int trapnr, ret;
2339 target_siginfo_t info;
2340
2341 while (1) {
2342 trapnr = cpu_cris_exec (env);
2343 switch (trapnr) {
2344 case 0xaa:
2345 {
2346 info.si_signo = SIGSEGV;
2347 info.si_errno = 0;
2348 /* XXX: check env->error_code */
2349 info.si_code = TARGET_SEGV_MAPERR;
2350 info._sifields._sigfault._addr = env->pregs[PR_EDA];
2351 queue_signal(env, info.si_signo, &info);
2352 }
2353 break;
2354 case EXCP_INTERRUPT:
2355 /* just indicate that signals should be handled asap */
2356 break;
2357 case EXCP_BREAK:
2358 ret = do_syscall(env,
2359 env->regs[9],
2360 env->regs[10],
2361 env->regs[11],
2362 env->regs[12],
2363 env->regs[13],
2364 env->pregs[7],
2365 env->pregs[11],
2366 0, 0);
2367 env->regs[10] = ret;
2368 break;
2369 case EXCP_DEBUG:
2370 {
2371 int sig;
2372
2373 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2374 if (sig)
2375 {
2376 info.si_signo = sig;
2377 info.si_errno = 0;
2378 info.si_code = TARGET_TRAP_BRKPT;
2379 queue_signal(env, info.si_signo, &info);
2380 }
2381 }
2382 break;
2383 default:
2384 printf ("Unhandled trap: 0x%x\n", trapnr);
2385 cpu_dump_state(env, stderr, fprintf, 0);
2386 exit (1);
2387 }
2388 process_pending_signals (env);
2389 }
2390 }
2391 #endif
2392
2393 #ifdef TARGET_MICROBLAZE
2394 void cpu_loop (CPUState *env)
2395 {
2396 int trapnr, ret;
2397 target_siginfo_t info;
2398
2399 while (1) {
2400 trapnr = cpu_mb_exec (env);
2401 switch (trapnr) {
2402 case 0xaa:
2403 {
2404 info.si_signo = SIGSEGV;
2405 info.si_errno = 0;
2406 /* XXX: check env->error_code */
2407 info.si_code = TARGET_SEGV_MAPERR;
2408 info._sifields._sigfault._addr = 0;
2409 queue_signal(env, info.si_signo, &info);
2410 }
2411 break;
2412 case EXCP_INTERRUPT:
2413 /* just indicate that signals should be handled asap */
2414 break;
2415 case EXCP_BREAK:
2416 /* Return address is 4 bytes after the call. */
2417 env->regs[14] += 4;
2418 ret = do_syscall(env,
2419 env->regs[12],
2420 env->regs[5],
2421 env->regs[6],
2422 env->regs[7],
2423 env->regs[8],
2424 env->regs[9],
2425 env->regs[10],
2426 0, 0);
2427 env->regs[3] = ret;
2428 env->sregs[SR_PC] = env->regs[14];
2429 break;
2430 case EXCP_HW_EXCP:
2431 env->regs[17] = env->sregs[SR_PC] + 4;
2432 if (env->iflags & D_FLAG) {
2433 env->sregs[SR_ESR] |= 1 << 12;
2434 env->sregs[SR_PC] -= 4;
2435 /* FIXME: if branch was immed, replay the imm aswell. */
2436 }
2437
2438 env->iflags &= ~(IMM_FLAG | D_FLAG);
2439
2440 switch (env->sregs[SR_ESR] & 31) {
2441 case ESR_EC_DIVZERO:
2442 info.si_signo = SIGFPE;
2443 info.si_errno = 0;
2444 info.si_code = TARGET_FPE_FLTDIV;
2445 info._sifields._sigfault._addr = 0;
2446 queue_signal(env, info.si_signo, &info);
2447 break;
2448 case ESR_EC_FPU:
2449 info.si_signo = SIGFPE;
2450 info.si_errno = 0;
2451 if (env->sregs[SR_FSR] & FSR_IO) {
2452 info.si_code = TARGET_FPE_FLTINV;
2453 }
2454 if (env->sregs[SR_FSR] & FSR_DZ) {
2455 info.si_code = TARGET_FPE_FLTDIV;
2456 }
2457 info._sifields._sigfault._addr = 0;
2458 queue_signal(env, info.si_signo, &info);
2459 break;
2460 default:
2461 printf ("Unhandled hw-exception: 0x%x\n",
2462 env->sregs[SR_ESR] & ESR_EC_MASK);
2463 cpu_dump_state(env, stderr, fprintf, 0);
2464 exit (1);
2465 break;
2466 }
2467 break;
2468 case EXCP_DEBUG:
2469 {
2470 int sig;
2471
2472 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2473 if (sig)
2474 {
2475 info.si_signo = sig;
2476 info.si_errno = 0;
2477 info.si_code = TARGET_TRAP_BRKPT;
2478 queue_signal(env, info.si_signo, &info);
2479 }
2480 }
2481 break;
2482 default:
2483 printf ("Unhandled trap: 0x%x\n", trapnr);
2484 cpu_dump_state(env, stderr, fprintf, 0);
2485 exit (1);
2486 }
2487 process_pending_signals (env);
2488 }
2489 }
2490 #endif
2491
2492 #ifdef TARGET_M68K
2493
2494 void cpu_loop(CPUM68KState *env)
2495 {
2496 int trapnr;
2497 unsigned int n;
2498 target_siginfo_t info;
2499 TaskState *ts = env->opaque;
2500
2501 for(;;) {
2502 trapnr = cpu_m68k_exec(env);
2503 switch(trapnr) {
2504 case EXCP_ILLEGAL:
2505 {
2506 if (ts->sim_syscalls) {
2507 uint16_t nr;
2508 nr = lduw(env->pc + 2);
2509 env->pc += 4;
2510 do_m68k_simcall(env, nr);
2511 } else {
2512 goto do_sigill;
2513 }
2514 }
2515 break;
2516 case EXCP_HALT_INSN:
2517 /* Semihosing syscall. */
2518 env->pc += 4;
2519 do_m68k_semihosting(env, env->dregs[0]);
2520 break;
2521 case EXCP_LINEA:
2522 case EXCP_LINEF:
2523 case EXCP_UNSUPPORTED:
2524 do_sigill:
2525 info.si_signo = SIGILL;
2526 info.si_errno = 0;
2527 info.si_code = TARGET_ILL_ILLOPN;
2528 info._sifields._sigfault._addr = env->pc;
2529 queue_signal(env, info.si_signo, &info);
2530 break;
2531 case EXCP_TRAP0:
2532 {
2533 ts->sim_syscalls = 0;
2534 n = env->dregs[0];
2535 env->pc += 2;
2536 env->dregs[0] = do_syscall(env,
2537 n,
2538 env->dregs[1],
2539 env->dregs[2],
2540 env->dregs[3],
2541 env->dregs[4],
2542 env->dregs[5],
2543 env->aregs[0],
2544 0, 0);
2545 }
2546 break;
2547 case EXCP_INTERRUPT:
2548 /* just indicate that signals should be handled asap */
2549 break;
2550 case EXCP_ACCESS:
2551 {
2552 info.si_signo = SIGSEGV;
2553 info.si_errno = 0;
2554 /* XXX: check env->error_code */
2555 info.si_code = TARGET_SEGV_MAPERR;
2556 info._sifields._sigfault._addr = env->mmu.ar;
2557 queue_signal(env, info.si_signo, &info);
2558 }
2559 break;
2560 case EXCP_DEBUG:
2561 {
2562 int sig;
2563
2564 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2565 if (sig)
2566 {
2567 info.si_signo = sig;
2568 info.si_errno = 0;
2569 info.si_code = TARGET_TRAP_BRKPT;
2570 queue_signal(env, info.si_signo, &info);
2571 }
2572 }
2573 break;
2574 default:
2575 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
2576 trapnr);
2577 cpu_dump_state(env, stderr, fprintf, 0);
2578 abort();
2579 }
2580 process_pending_signals(env);
2581 }
2582 }
2583 #endif /* TARGET_M68K */
2584
2585 #ifdef TARGET_ALPHA
2586 static void do_store_exclusive(CPUAlphaState *env, int reg, int quad)
2587 {
2588 target_ulong addr, val, tmp;
2589 target_siginfo_t info;
2590 int ret = 0;
2591
2592 addr = env->lock_addr;
2593 tmp = env->lock_st_addr;
2594 env->lock_addr = -1;
2595 env->lock_st_addr = 0;
2596
2597 start_exclusive();
2598 mmap_lock();
2599
2600 if (addr == tmp) {
2601 if (quad ? get_user_s64(val, addr) : get_user_s32(val, addr)) {
2602 goto do_sigsegv;
2603 }
2604
2605 if (val == env->lock_value) {
2606 tmp = env->ir[reg];
2607 if (quad ? put_user_u64(tmp, addr) : put_user_u32(tmp, addr)) {
2608 goto do_sigsegv;
2609 }
2610 ret = 1;
2611 }
2612 }
2613 env->ir[reg] = ret;
2614 env->pc += 4;
2615
2616 mmap_unlock();
2617 end_exclusive();
2618 return;
2619
2620 do_sigsegv:
2621 mmap_unlock();
2622 end_exclusive();
2623
2624 info.si_signo = TARGET_SIGSEGV;
2625 info.si_errno = 0;
2626 info.si_code = TARGET_SEGV_MAPERR;
2627 info._sifields._sigfault._addr = addr;
2628 queue_signal(env, TARGET_SIGSEGV, &info);
2629 }
2630
2631 void cpu_loop (CPUState *env)
2632 {
2633 int trapnr;
2634 target_siginfo_t info;
2635 abi_long sysret;
2636
2637 while (1) {
2638 trapnr = cpu_alpha_exec (env);
2639
2640 /* All of the traps imply a transition through PALcode, which
2641 implies an REI instruction has been executed. Which means
2642 that the intr_flag should be cleared. */
2643 env->intr_flag = 0;
2644
2645 switch (trapnr) {
2646 case EXCP_RESET:
2647 fprintf(stderr, "Reset requested. Exit\n");
2648 exit(1);
2649 break;
2650 case EXCP_MCHK:
2651 fprintf(stderr, "Machine check exception. Exit\n");
2652 exit(1);
2653 break;
2654 case EXCP_SMP_INTERRUPT:
2655 case EXCP_CLK_INTERRUPT:
2656 case EXCP_DEV_INTERRUPT:
2657 fprintf(stderr, "External interrupt. Exit\n");
2658 exit(1);
2659 break;
2660 case EXCP_MMFAULT:
2661 env->lock_addr = -1;
2662 info.si_signo = TARGET_SIGSEGV;
2663 info.si_errno = 0;
2664 info.si_code = (page_get_flags(env->trap_arg0) & PAGE_VALID
2665 ? TARGET_SEGV_ACCERR : TARGET_SEGV_MAPERR);
2666 info._sifields._sigfault._addr = env->trap_arg0;
2667 queue_signal(env, info.si_signo, &info);
2668 break;
2669 case EXCP_UNALIGN:
2670 env->lock_addr = -1;
2671 info.si_signo = TARGET_SIGBUS;
2672 info.si_errno = 0;
2673 info.si_code = TARGET_BUS_ADRALN;
2674 info._sifields._sigfault._addr = env->trap_arg0;
2675 queue_signal(env, info.si_signo, &info);
2676 break;
2677 case EXCP_OPCDEC:
2678 do_sigill:
2679 env->lock_addr = -1;
2680 info.si_signo = TARGET_SIGILL;
2681 info.si_errno = 0;
2682 info.si_code = TARGET_ILL_ILLOPC;
2683 info._sifields._sigfault._addr = env->pc;
2684 queue_signal(env, info.si_signo, &info);
2685 break;
2686 case EXCP_ARITH:
2687 env->lock_addr = -1;
2688 info.si_signo = TARGET_SIGFPE;
2689 info.si_errno = 0;
2690 info.si_code = TARGET_FPE_FLTINV;
2691 info._sifields._sigfault._addr = env->pc;
2692 queue_signal(env, info.si_signo, &info);
2693 break;
2694 case EXCP_FEN:
2695 /* No-op. Linux simply re-enables the FPU. */
2696 break;
2697 case EXCP_CALL_PAL:
2698 env->lock_addr = -1;
2699 switch (env->error_code) {
2700 case 0x80:
2701 /* BPT */
2702 info.si_signo = TARGET_SIGTRAP;
2703 info.si_errno = 0;
2704 info.si_code = TARGET_TRAP_BRKPT;
2705 info._sifields._sigfault._addr = env->pc;
2706 queue_signal(env, info.si_signo, &info);
2707 break;
2708 case 0x81:
2709 /* BUGCHK */
2710 info.si_signo = TARGET_SIGTRAP;
2711 info.si_errno = 0;
2712 info.si_code = 0;
2713 info._sifields._sigfault._addr = env->pc;
2714 queue_signal(env, info.si_signo, &info);
2715 break;
2716 case 0x83:
2717 /* CALLSYS */
2718 trapnr = env->ir[IR_V0];
2719 sysret = do_syscall(env, trapnr,
2720 env->ir[IR_A0], env->ir[IR_A1],
2721 env->ir[IR_A2], env->ir[IR_A3],
2722 env->ir[IR_A4], env->ir[IR_A5],
2723 0, 0);
2724 if (trapnr == TARGET_NR_sigreturn
2725 || trapnr == TARGET_NR_rt_sigreturn) {
2726 break;
2727 }
2728 /* Syscall writes 0 to V0 to bypass error check, similar
2729 to how this is handled internal to Linux kernel. */
2730 if (env->ir[IR_V0] == 0) {
2731 env->ir[IR_V0] = sysret;
2732 } else {
2733 env->ir[IR_V0] = (sysret < 0 ? -sysret : sysret);
2734 env->ir[IR_A3] = (sysret < 0);
2735 }
2736 break;
2737 case 0x86:
2738 /* IMB */
2739 /* ??? We can probably elide the code using page_unprotect
2740 that is checking for self-modifying code. Instead we
2741 could simply call tb_flush here. Until we work out the
2742 changes required to turn off the extra write protection,
2743 this can be a no-op. */
2744 break;
2745 case 0x9E:
2746 /* RDUNIQUE */
2747 /* Handled in the translator for usermode. */
2748 abort();
2749 case 0x9F:
2750 /* WRUNIQUE */
2751 /* Handled in the translator for usermode. */
2752 abort();
2753 case 0xAA:
2754 /* GENTRAP */
2755 info.si_signo = TARGET_SIGFPE;
2756 switch (env->ir[IR_A0]) {
2757 case TARGET_GEN_INTOVF:
2758 info.si_code = TARGET_FPE_INTOVF;
2759 break;
2760 case TARGET_GEN_INTDIV:
2761 info.si_code = TARGET_FPE_INTDIV;
2762 break;
2763 case TARGET_GEN_FLTOVF:
2764 info.si_code = TARGET_FPE_FLTOVF;
2765 break;
2766 case TARGET_GEN_FLTUND:
2767 info.si_code = TARGET_FPE_FLTUND;
2768 break;
2769 case TARGET_GEN_FLTINV:
2770 info.si_code = TARGET_FPE_FLTINV;
2771 break;
2772 case TARGET_GEN_FLTINE:
2773 info.si_code = TARGET_FPE_FLTRES;
2774 break;
2775 case TARGET_GEN_ROPRAND:
2776 info.si_code = 0;
2777 break;
2778 default:
2779 info.si_signo = TARGET_SIGTRAP;
2780 info.si_code = 0;
2781 break;
2782 }
2783 info.si_errno = 0;
2784 info._sifields._sigfault._addr = env->pc;
2785 queue_signal(env, info.si_signo, &info);
2786 break;
2787 default:
2788 goto do_sigill;
2789 }
2790 break;
2791 case EXCP_DEBUG:
2792 info.si_signo = gdb_handlesig (env, TARGET_SIGTRAP);
2793 if (info.si_signo) {
2794 env->lock_addr = -1;
2795 info.si_errno = 0;
2796 info.si_code = TARGET_TRAP_BRKPT;
2797 queue_signal(env, info.si_signo, &info);
2798 }
2799 break;
2800 case EXCP_STL_C:
2801 case EXCP_STQ_C:
2802 do_store_exclusive(env, env->error_code, trapnr - EXCP_STL_C);
2803 break;
2804 default:
2805 printf ("Unhandled trap: 0x%x\n", trapnr);
2806 cpu_dump_state(env, stderr, fprintf, 0);
2807 exit (1);
2808 }
2809 process_pending_signals (env);
2810 }
2811 }
2812 #endif /* TARGET_ALPHA */
2813
2814 #ifdef TARGET_S390X
2815 void cpu_loop(CPUS390XState *env)
2816 {
2817 int trapnr;
2818 target_siginfo_t info;
2819
2820 while (1) {
2821 trapnr = cpu_s390x_exec (env);
2822
2823 switch (trapnr) {
2824 case EXCP_INTERRUPT:
2825 /* just indicate that signals should be handled asap */
2826 break;
2827 case EXCP_DEBUG:
2828 {
2829 int sig;
2830
2831 sig = gdb_handlesig (env, TARGET_SIGTRAP);
2832 if (sig) {
2833 info.si_signo = sig;
2834 info.si_errno = 0;
2835 info.si_code = TARGET_TRAP_BRKPT;
2836 queue_signal(env, info.si_signo, &info);
2837 }
2838 }
2839 break;
2840 case EXCP_SVC:
2841 {
2842 int n = env->int_svc_code;
2843 if (!n) {
2844 /* syscalls > 255 */
2845 n = env->regs[1];
2846 }
2847 env->psw.addr += env->int_svc_ilc;
2848 env->regs[2] = do_syscall(env, n,
2849 env->regs[2],
2850 env->regs[3],
2851 env->regs[4],
2852 env->regs[5],
2853 env->regs[6],
2854 env->regs[7],
2855 0, 0);
2856 }
2857 break;
2858 case EXCP_ADDR:
2859 {
2860 info.si_signo = SIGSEGV;
2861 info.si_errno = 0;
2862 /* XXX: check env->error_code */
2863 info.si_code = TARGET_SEGV_MAPERR;
2864 info._sifields._sigfault._addr = env->__excp_addr;
2865 queue_signal(env, info.si_signo, &info);
2866 }
2867 break;
2868 case EXCP_SPEC:
2869 {
2870 fprintf(stderr,"specification exception insn 0x%08x%04x\n", ldl(env->psw.addr), lduw(env->psw.addr + 4));
2871 info.si_signo = SIGILL;
2872 info.si_errno = 0;
2873 info.si_code = TARGET_ILL_ILLOPC;
2874 info._sifields._sigfault._addr = env->__excp_addr;
2875 queue_signal(env, info.si_signo, &info);
2876 }
2877 break;
2878 default:
2879 printf ("Unhandled trap: 0x%x\n", trapnr);
2880 cpu_dump_state(env, stderr, fprintf, 0);
2881 exit (1);
2882 }
2883 process_pending_signals (env);
2884 }
2885 }
2886
2887 #endif /* TARGET_S390X */
2888
2889 THREAD CPUState *thread_env;
2890
2891 void task_settid(TaskState *ts)
2892 {
2893 if (ts->ts_tid == 0) {
2894 #ifdef CONFIG_USE_NPTL
2895 ts->ts_tid = (pid_t)syscall(SYS_gettid);
2896 #else
2897 /* when no threads are used, tid becomes pid */
2898 ts->ts_tid = getpid();
2899 #endif
2900 }
2901 }
2902
2903 void stop_all_tasks(void)
2904 {
2905 /*
2906 * We trust that when using NPTL, start_exclusive()
2907 * handles thread stopping correctly.
2908 */
2909 start_exclusive();
2910 }
2911
2912 /* Assumes contents are already zeroed. */
2913 void init_task_state(TaskState *ts)
2914 {
2915 int i;
2916
2917 ts->used = 1;
2918 ts->first_free = ts->sigqueue_table;
2919 for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) {
2920 ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1];
2921 }
2922 ts->sigqueue_table[i].next = NULL;
2923 }
2924
2925 static void handle_arg_help(const char *arg)
2926 {
2927 usage();
2928 }
2929
2930 static void handle_arg_log(const char *arg)
2931 {
2932 int mask;
2933 const CPULogItem *item;
2934
2935 mask = cpu_str_to_log_mask(arg);
2936 if (!mask) {
2937 printf("Log items (comma separated):\n");
2938 for (item = cpu_log_items; item->mask != 0; item++) {
2939 printf("%-10s %s\n", item->name, item->help);
2940 }
2941 exit(1);
2942 }
2943 cpu_set_log(mask);
2944 }
2945
2946 static void handle_arg_set_env(const char *arg)
2947 {
2948 char *r, *p, *token;
2949 r = p = strdup(arg);
2950 while ((token = strsep(&p, ",")) != NULL) {
2951 if (envlist_setenv(envlist, token) != 0) {
2952 usage();
2953 }
2954 }
2955 free(r);
2956 }
2957
2958 static void handle_arg_unset_env(const char *arg)
2959 {
2960 char *r, *p, *token;
2961 r = p = strdup(arg);
2962 while ((token = strsep(&p, ",")) != NULL) {
2963 if (envlist_unsetenv(envlist, token) != 0) {
2964 usage();
2965 }
2966 }
2967 free(r);
2968 }
2969
2970 static void handle_arg_argv0(const char *arg)
2971 {
2972 argv0 = strdup(arg);
2973 }
2974
2975 static void handle_arg_stack_size(const char *arg)
2976 {
2977 char *p;
2978 guest_stack_size = strtoul(arg, &p, 0);
2979 if (guest_stack_size == 0) {
2980 usage();
2981 }
2982
2983 if (*p == 'M') {
2984 guest_stack_size *= 1024 * 1024;
2985 } else if (*p == 'k' || *p == 'K') {
2986 guest_stack_size *= 1024;
2987 }
2988 }
2989
2990 static void handle_arg_ld_prefix(const char *arg)
2991 {
2992 interp_prefix = strdup(arg);
2993 }
2994
2995 static void handle_arg_pagesize(const char *arg)
2996 {
2997 qemu_host_page_size = atoi(arg);
2998 if (qemu_host_page_size == 0 ||
2999 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
3000 fprintf(stderr, "page size must be a power of two\n");
3001 exit(1);
3002 }
3003 }
3004
3005 static void handle_arg_gdb(const char *arg)
3006 {
3007 gdbstub_port = atoi(arg);
3008 }
3009
3010 static void handle_arg_uname(const char *arg)
3011 {
3012 qemu_uname_release = strdup(arg);
3013 }
3014
3015 static void handle_arg_cpu(const char *arg)
3016 {
3017 cpu_model = strdup(arg);
3018 if (cpu_model == NULL || strcmp(cpu_model, "?") == 0) {
3019 /* XXX: implement xxx_cpu_list for targets that still miss it */
3020 #if defined(cpu_list_id)
3021 cpu_list_id(stdout, &fprintf, "");
3022 #elif defined(cpu_list)
3023 cpu_list(stdout, &fprintf); /* deprecated */
3024 #endif
3025 exit(1);
3026 }
3027 }
3028
3029 #if defined(CONFIG_USE_GUEST_BASE)
3030 static void handle_arg_guest_base(const char *arg)
3031 {
3032 guest_base = strtol(arg, NULL, 0);
3033 have_guest_base = 1;
3034 }
3035
3036 static void handle_arg_reserved_va(const char *arg)
3037 {
3038 char *p;
3039 int shift = 0;
3040 reserved_va = strtoul(arg, &p, 0);
3041 switch (*p) {
3042 case 'k':
3043 case 'K':
3044 shift = 10;
3045 break;
3046 case 'M':
3047 shift = 20;
3048 break;
3049 case 'G':
3050 shift = 30;
3051 break;
3052 }
3053 if (shift) {
3054 unsigned long unshifted = reserved_va;
3055 p++;
3056 reserved_va <<= shift;
3057 if (((reserved_va >> shift) != unshifted)
3058 #if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
3059 || (reserved_va > (1ul << TARGET_VIRT_ADDR_SPACE_BITS))
3060 #endif
3061 ) {
3062 fprintf(stderr, "Reserved virtual address too big\n");
3063 exit(1);
3064 }
3065 }
3066 if (*p) {
3067 fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p);
3068 exit(1);
3069 }
3070 }
3071 #endif
3072
3073 static void handle_arg_singlestep(const char *arg)
3074 {
3075 singlestep = 1;
3076 }
3077
3078 static void handle_arg_strace(const char *arg)
3079 {
3080 do_strace = 1;
3081 }
3082
3083 static void handle_arg_version(const char *arg)
3084 {
3085 printf("qemu-" TARGET_ARCH " version " QEMU_VERSION QEMU_PKGVERSION
3086 ", Copyright (c) 2003-2008 Fabrice Bellard\n");
3087 exit(0);
3088 }
3089
3090 struct qemu_argument {
3091 const char *argv;
3092 const char *env;
3093 bool has_arg;
3094 void (*handle_opt)(const char *arg);
3095 const char *example;
3096 const char *help;
3097 };
3098
3099 struct qemu_argument arg_table[] = {
3100 {"h", "", false, handle_arg_help,
3101 "", "print this help"},
3102 {"g", "QEMU_GDB", true, handle_arg_gdb,
3103 "port", "wait gdb connection to 'port'"},
3104 {"L", "QEMU_LD_PREFIX", true, handle_arg_ld_prefix,
3105 "path", "set the elf interpreter prefix to 'path'"},
3106 {"s", "QEMU_STACK_SIZE", true, handle_arg_stack_size,
3107 "size", "set the stack size to 'size' bytes"},
3108 {"cpu", "QEMU_CPU", true, handle_arg_cpu,
3109 "model", "select CPU (-cpu ? for list)"},
3110 {"E", "QEMU_SET_ENV", true, handle_arg_set_env,
3111 "var=value", "sets targets environment variable (see below)"},
3112 {"U", "QEMU_UNSET_ENV", true, handle_arg_unset_env,
3113 "var", "unsets targets environment variable (see below)"},
3114 {"0", "QEMU_ARGV0", true, handle_arg_argv0,
3115 "argv0", "forces target process argv[0] to be 'argv0'"},
3116 {"r", "QEMU_UNAME", true, handle_arg_uname,
3117 "uname", "set qemu uname release string to 'uname'"},
3118 #if defined(CONFIG_USE_GUEST_BASE)
3119 {"B", "QEMU_GUEST_BASE", true, handle_arg_guest_base,
3120 "address", "set guest_base address to 'address'"},
3121 {"R", "QEMU_RESERVED_VA", true, handle_arg_reserved_va,
3122 "size", "reserve 'size' bytes for guest virtual address space"},
3123 #endif
3124 {"d", "QEMU_LOG", true, handle_arg_log,
3125 "options", "activate log"},
3126 {"p", "QEMU_PAGESIZE", true, handle_arg_pagesize,
3127 "pagesize", "set the host page size to 'pagesize'"},
3128 {"singlestep", "QEMU_SINGLESTEP", false, handle_arg_singlestep,
3129 "", "run in singlestep mode"},
3130 {"strace", "QEMU_STRACE", false, handle_arg_strace,
3131 "", "log system calls"},
3132 {"version", "QEMU_VERSION", false, handle_arg_version,
3133 "", "display version information and exit"},
3134 {NULL, NULL, false, NULL, NULL, NULL}
3135 };
3136
3137 static void usage(void)
3138 {
3139 struct qemu_argument *arginfo;
3140 int maxarglen;
3141 int maxenvlen;
3142
3143 printf("usage: qemu-" TARGET_ARCH " [options] program [arguments...]\n"
3144 "Linux CPU emulator (compiled for " TARGET_ARCH " emulation)\n"
3145 "\n"
3146 "Options and associated environment variables:\n"
3147 "\n");
3148
3149 maxarglen = maxenvlen = 0;
3150
3151 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
3152 if (strlen(arginfo->env) > maxenvlen) {
3153 maxenvlen = strlen(arginfo->env);
3154 }
3155 if (strlen(arginfo->argv) > maxarglen) {
3156 maxarglen = strlen(arginfo->argv);
3157 }
3158 }
3159
3160 printf("%-*s%-*sDescription\n", maxarglen+3, "Argument",
3161 maxenvlen+1, "Env-variable");
3162
3163 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
3164 if (arginfo->has_arg) {
3165 printf("-%s %-*s %-*s %s\n", arginfo->argv,
3166 (int)(maxarglen-strlen(arginfo->argv)), arginfo->example,
3167 maxenvlen, arginfo->env, arginfo->help);
3168 } else {
3169 printf("-%-*s %-*s %s\n", maxarglen+1, arginfo->argv,
3170 maxenvlen, arginfo->env,
3171 arginfo->help);
3172 }
3173 }
3174
3175 printf("\n"
3176 "Defaults:\n"
3177 "QEMU_LD_PREFIX = %s\n"
3178 "QEMU_STACK_SIZE = %ld byte\n"
3179 "QEMU_LOG = %s\n",
3180 interp_prefix,
3181 guest_stack_size,
3182 DEBUG_LOGFILE);
3183
3184 printf("\n"
3185 "You can use -E and -U options or the QEMU_SET_ENV and\n"
3186 "QEMU_UNSET_ENV environment variables to set and unset\n"
3187 "environment variables for the target process.\n"
3188 "It is possible to provide several variables by separating them\n"
3189 "by commas in getsubopt(3) style. Additionally it is possible to\n"
3190 "provide the -E and -U options multiple times.\n"
3191 "The following lines are equivalent:\n"
3192 " -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
3193 " -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n"
3194 " QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n"
3195 "Note that if you provide several changes to a single variable\n"
3196 "the last change will stay in effect.\n");
3197
3198 exit(1);
3199 }
3200
3201 static int parse_args(int argc, char **argv)
3202 {
3203 const char *r;
3204 int optind;
3205 struct qemu_argument *arginfo;
3206
3207 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
3208 if (arginfo->env == NULL) {
3209 continue;
3210 }
3211
3212 r = getenv(arginfo->env);
3213 if (r != NULL) {
3214 arginfo->handle_opt(r);
3215 }
3216 }
3217
3218 optind = 1;
3219 for (;;) {
3220 if (optind >= argc) {
3221 break;
3222 }
3223 r = argv[optind];
3224 if (r[0] != '-') {
3225 break;
3226 }
3227 optind++;
3228 r++;
3229 if (!strcmp(r, "-")) {
3230 break;
3231 }
3232
3233 for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
3234 if (!strcmp(r, arginfo->argv)) {
3235 if (arginfo->has_arg) {
3236 if (optind >= argc) {
3237 usage();
3238 }
3239 arginfo->handle_opt(argv[optind]);
3240 optind++;
3241 } else {
3242 arginfo->handle_opt(NULL);
3243 }
3244 break;
3245 }
3246 }
3247
3248 /* no option matched the current argv */
3249 if (arginfo->handle_opt == NULL) {
3250 usage();
3251 }
3252 }
3253
3254 if (optind >= argc) {
3255 usage();
3256 }
3257
3258 filename = argv[optind];
3259 exec_path = argv[optind];
3260
3261 return optind;
3262 }
3263
3264 int main(int argc, char **argv, char **envp)
3265 {
3266 const char *log_file = DEBUG_LOGFILE;
3267 struct target_pt_regs regs1, *regs = &regs1;
3268 struct image_info info1, *info = &info1;
3269 struct linux_binprm bprm;
3270 TaskState *ts;
3271 CPUState *env;
3272 int optind;
3273 char **target_environ, **wrk;
3274 char **target_argv;
3275 int target_argc;
3276 int i;
3277 int ret;
3278
3279 qemu_cache_utils_init(envp);
3280
3281 if ((envlist = envlist_create()) == NULL) {
3282 (void) fprintf(stderr, "Unable to allocate envlist\n");
3283 exit(1);
3284 }
3285
3286 /* add current environment into the list */
3287 for (wrk = environ; *wrk != NULL; wrk++) {
3288 (void) envlist_setenv(envlist, *wrk);
3289 }
3290
3291 /* Read the stack limit from the kernel. If it's "unlimited",
3292 then we can do little else besides use the default. */
3293 {
3294 struct rlimit lim;
3295 if (getrlimit(RLIMIT_STACK, &lim) == 0
3296 && lim.rlim_cur != RLIM_INFINITY
3297 && lim.rlim_cur == (target_long)lim.rlim_cur) {
3298 guest_stack_size = lim.rlim_cur;
3299 }
3300 }
3301
3302 cpu_model = NULL;
3303 #if defined(cpudef_setup)
3304 cpudef_setup(); /* parse cpu definitions in target config file (TBD) */
3305 #endif
3306
3307 /* init debug */
3308 cpu_set_log_filename(log_file);
3309 optind = parse_args(argc, argv);
3310
3311 /* Zero out regs */
3312 memset(regs, 0, sizeof(struct target_pt_regs));
3313
3314 /* Zero out image_info */
3315 memset(info, 0, sizeof(struct image_info));
3316
3317 memset(&bprm, 0, sizeof (bprm));
3318
3319 /* Scan interp_prefix dir for replacement files. */
3320 init_paths(interp_prefix);
3321
3322 if (cpu_model == NULL) {
3323 #if defined(TARGET_I386)
3324 #ifdef TARGET_X86_64
3325 cpu_model = "qemu64";
3326 #else
3327 cpu_model = "qemu32";
3328 #endif
3329 #elif defined(TARGET_ARM)
3330 cpu_model = "any";
3331 #elif defined(TARGET_UNICORE32)
3332 cpu_model = "any";
3333 #elif defined(TARGET_M68K)
3334 cpu_model = "any";
3335 #elif defined(TARGET_SPARC)
3336 #ifdef TARGET_SPARC64
3337 cpu_model = "TI UltraSparc II";
3338 #else
3339 cpu_model = "Fujitsu MB86904";
3340 #endif
3341 #elif defined(TARGET_MIPS)
3342 #if defined(TARGET_ABI_MIPSN32) || defined(TARGET_ABI_MIPSN64)
3343 cpu_model = "20Kc";
3344 #else
3345 cpu_model = "24Kf";
3346 #endif
3347 #elif defined(TARGET_PPC)
3348 #ifdef TARGET_PPC64
3349 cpu_model = "970fx";
3350 #else
3351 cpu_model = "750";
3352 #endif
3353 #else
3354 cpu_model = "any";
3355 #endif
3356 }
3357 tcg_exec_init(0);
3358 cpu_exec_init_all();
3359 /* NOTE: we need to init the CPU at this stage to get
3360 qemu_host_page_size */
3361 env = cpu_init(cpu_model);
3362 if (!env) {
3363 fprintf(stderr, "Unable to find CPU definition\n");
3364 exit(1);
3365 }
3366 #if defined(TARGET_I386) || defined(TARGET_SPARC) || defined(TARGET_PPC)
3367 cpu_reset(env);
3368 #endif
3369
3370 thread_env = env;
3371
3372 if (getenv("QEMU_STRACE")) {
3373 do_strace = 1;
3374 }
3375
3376 target_environ = envlist_to_environ(envlist, NULL);
3377 envlist_free(envlist);
3378
3379 #if defined(CONFIG_USE_GUEST_BASE)
3380 /*
3381 * Now that page sizes are configured in cpu_init() we can do
3382 * proper page alignment for guest_base.
3383 */
3384 guest_base = HOST_PAGE_ALIGN(guest_base);
3385
3386 if (reserved_va) {
3387 void *p;
3388 int flags;
3389
3390 flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE;
3391 if (have_guest_base) {
3392 flags |= MAP_FIXED;
3393 }
3394 p = mmap((void *)guest_base, reserved_va, PROT_NONE, flags, -1, 0);
3395 if (p == MAP_FAILED) {
3396 fprintf(stderr, "Unable to reserve guest address space\n");
3397 exit(1);
3398 }
3399 guest_base = (unsigned long)p;
3400 /* Make sure the address is properly aligned. */
3401 if (guest_base & ~qemu_host_page_mask) {
3402 munmap(p, reserved_va);
3403 p = mmap((void *)guest_base, reserved_va + qemu_host_page_size,
3404 PROT_NONE, flags, -1, 0);
3405 if (p == MAP_FAILED) {
3406 fprintf(stderr, "Unable to reserve guest address space\n");
3407 exit(1);
3408 }
3409 guest_base = HOST_PAGE_ALIGN((unsigned long)p);
3410 }
3411 qemu_log("Reserved 0x%lx bytes of guest address space\n", reserved_va);
3412 }
3413
3414 if (reserved_va || have_guest_base) {
3415 if (!guest_validate_base(guest_base)) {
3416 fprintf(stderr, "Guest base/Reserved VA rejected by guest code\n");
3417 exit(1);
3418 }
3419 }
3420 #endif /* CONFIG_USE_GUEST_BASE */
3421
3422 /*
3423 * Read in mmap_min_addr kernel parameter. This value is used
3424 * When loading the ELF image to determine whether guest_base
3425 * is needed. It is also used in mmap_find_vma.
3426 */
3427 {
3428 FILE *fp;
3429
3430 if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) {
3431 unsigned long tmp;
3432 if (fscanf(fp, "%lu", &tmp) == 1) {
3433 mmap_min_addr = tmp;
3434 qemu_log("host mmap_min_addr=0x%lx\n", mmap_min_addr);
3435 }
3436 fclose(fp);
3437 }
3438 }
3439
3440 /*
3441 * Prepare copy of argv vector for target.
3442 */
3443 target_argc = argc - optind;
3444 target_argv = calloc(target_argc + 1, sizeof (char *));
3445 if (target_argv == NULL) {
3446 (void) fprintf(stderr, "Unable to allocate memory for target_argv\n");
3447 exit(1);
3448 }
3449
3450 /*
3451 * If argv0 is specified (using '-0' switch) we replace
3452 * argv[0] pointer with the given one.
3453 */
3454 i = 0;
3455 if (argv0 != NULL) {
3456 target_argv[i++] = strdup(argv0);
3457 }
3458 for (; i < target_argc; i++) {
3459 target_argv[i] = strdup(argv[optind + i]);
3460 }
3461 target_argv[target_argc] = NULL;
3462
3463 ts = g_malloc0 (sizeof(TaskState));
3464 init_task_state(ts);
3465 /* build Task State */
3466 ts->info = info;
3467 ts->bprm = &bprm;
3468 env->opaque = ts;
3469 task_settid(ts);
3470
3471 ret = loader_exec(filename, target_argv, target_environ, regs,
3472 info, &bprm);
3473 if (ret != 0) {
3474 printf("Error %d while loading %s\n", ret, filename);
3475 _exit(1);
3476 }
3477
3478 for (i = 0; i < target_argc; i++) {
3479 free(target_argv[i]);
3480 }
3481 free(target_argv);
3482
3483 for (wrk = target_environ; *wrk; wrk++) {
3484 free(*wrk);
3485 }
3486
3487 free(target_environ);
3488
3489 if (qemu_log_enabled()) {
3490 #if defined(CONFIG_USE_GUEST_BASE)
3491 qemu_log("guest_base 0x%lx\n", guest_base);
3492 #endif
3493 log_page_dump();
3494
3495 qemu_log("start_brk 0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
3496 qemu_log("end_code 0x" TARGET_ABI_FMT_lx "\n", info->end_code);
3497 qemu_log("start_code 0x" TARGET_ABI_FMT_lx "\n",
3498 info->start_code);
3499 qemu_log("start_data 0x" TARGET_ABI_FMT_lx "\n",
3500 info->start_data);
3501 qemu_log("end_data 0x" TARGET_ABI_FMT_lx "\n", info->end_data);
3502 qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n",
3503 info->start_stack);
3504 qemu_log("brk 0x" TARGET_ABI_FMT_lx "\n", info->brk);
3505 qemu_log("entry 0x" TARGET_ABI_FMT_lx "\n", info->entry);
3506 }
3507
3508 target_set_brk(info->brk);
3509 syscall_init();
3510 signal_init();
3511
3512 #if defined(CONFIG_USE_GUEST_BASE)
3513 /* Now that we've loaded the binary, GUEST_BASE is fixed. Delay
3514 generating the prologue until now so that the prologue can take
3515 the real value of GUEST_BASE into account. */
3516 tcg_prologue_init(&tcg_ctx);
3517 #endif
3518
3519 #if defined(TARGET_I386)
3520 cpu_x86_set_cpl(env, 3);
3521
3522 env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
3523 env->hflags |= HF_PE_MASK;
3524 if (env->cpuid_features & CPUID_SSE) {
3525 env->cr[4] |= CR4_OSFXSR_MASK;
3526 env->hflags |= HF_OSFXSR_MASK;
3527 }
3528 #ifndef TARGET_ABI32
3529 /* enable 64 bit mode if possible */
3530 if (!(env->cpuid_ext2_features & CPUID_EXT2_LM)) {
3531 fprintf(stderr, "The selected x86 CPU does not support 64 bit mode\n");
3532 exit(1);
3533 }
3534 env->cr[4] |= CR4_PAE_MASK;
3535 env->efer |= MSR_EFER_LMA | MSR_EFER_LME;
3536 env->hflags |= HF_LMA_MASK;
3537 #endif
3538
3539 /* flags setup : we activate the IRQs by default as in user mode */
3540 env->eflags |= IF_MASK;
3541
3542 /* linux register setup */
3543 #ifndef TARGET_ABI32
3544 env->regs[R_EAX] = regs->rax;
3545 env->regs[R_EBX] = regs->rbx;
3546 env->regs[R_ECX] = regs->rcx;
3547 env->regs[R_EDX] = regs->rdx;
3548 env->regs[R_ESI] = regs->rsi;
3549 env->regs[R_EDI] = regs->rdi;
3550 env->regs[R_EBP] = regs->rbp;
3551 env->regs[R_ESP] = regs->rsp;
3552 env->eip = regs->rip;
3553 #else
3554 env->regs[R_EAX] = regs->eax;
3555 env->regs[R_EBX] = regs->ebx;
3556 env->regs[R_ECX] = regs->ecx;
3557 env->regs[R_EDX] = regs->edx;
3558 env->regs[R_ESI] = regs->esi;
3559 env->regs[R_EDI] = regs->edi;
3560 env->regs[R_EBP] = regs->ebp;
3561 env->regs[R_ESP] = regs->esp;
3562 env->eip = regs->eip;
3563 #endif
3564
3565 /* linux interrupt setup */
3566 #ifndef TARGET_ABI32
3567 env->idt.limit = 511;
3568 #else
3569 env->idt.limit = 255;
3570 #endif
3571 env->idt.base = target_mmap(0, sizeof(uint64_t) * (env->idt.limit + 1),
3572 PROT_READ|PROT_WRITE,
3573 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
3574 idt_table = g2h(env->idt.base);
3575 set_idt(0, 0);
3576 set_idt(1, 0);
3577 set_idt(2, 0);
3578 set_idt(3, 3);
3579 set_idt(4, 3);
3580 set_idt(5, 0);
3581 set_idt(6, 0);
3582 set_idt(7, 0);
3583 set_idt(8, 0);
3584 set_idt(9, 0);
3585 set_idt(10, 0);
3586 set_idt(11, 0);
3587 set_idt(12, 0);
3588 set_idt(13, 0);
3589 set_idt(14, 0);
3590 set_idt(15, 0);
3591 set_idt(16, 0);
3592 set_idt(17, 0);
3593 set_idt(18, 0);
3594 set_idt(19, 0);
3595 set_idt(0x80, 3);
3596
3597 /* linux segment setup */
3598 {
3599 uint64_t *gdt_table;
3600 env->gdt.base = target_mmap(0, sizeof(uint64_t) * TARGET_GDT_ENTRIES,
3601 PROT_READ|PROT_WRITE,
3602 MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
3603 env->gdt.limit = sizeof(uint64_t) * TARGET_GDT_ENTRIES - 1;
3604 gdt_table = g2h(env->gdt.base);
3605 #ifdef TARGET_ABI32
3606 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
3607 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
3608 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
3609 #else
3610 /* 64 bit code segment */
3611 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
3612 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
3613 DESC_L_MASK |
3614 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
3615 #endif
3616 write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
3617 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
3618 (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
3619 }
3620 cpu_x86_load_seg(env, R_CS, __USER_CS);
3621 cpu_x86_load_seg(env, R_SS, __USER_DS);
3622 #ifdef TARGET_ABI32
3623 cpu_x86_load_seg(env, R_DS, __USER_DS);
3624 cpu_x86_load_seg(env, R_ES, __USER_DS);
3625 cpu_x86_load_seg(env, R_FS, __USER_DS);
3626 cpu_x86_load_seg(env, R_GS, __USER_DS);
3627 /* This hack makes Wine work... */
3628 env->segs[R_FS].selector = 0;
3629 #else
3630 cpu_x86_load_seg(env, R_DS, 0);
3631 cpu_x86_load_seg(env, R_ES, 0);
3632 cpu_x86_load_seg(env, R_FS, 0);
3633 cpu_x86_load_seg(env, R_GS, 0);
3634 #endif
3635 #elif defined(TARGET_ARM)
3636 {
3637 int i;
3638 cpsr_write(env, regs->uregs[16], 0xffffffff);
3639 for(i = 0; i < 16; i++) {
3640 env->regs[i] = regs->uregs[i];
3641 }
3642 }
3643 #elif defined(TARGET_UNICORE32)
3644 {
3645 int i;
3646 cpu_asr_write(env, regs->uregs[32], 0xffffffff);
3647 for (i = 0; i < 32; i++) {
3648 env->regs[i] = regs->uregs[i];
3649 }
3650 }
3651 #elif defined(TARGET_SPARC)
3652 {
3653 int i;
3654 env->pc = regs->pc;
3655 env->npc = regs->npc;
3656 env->y = regs->y;
3657 for(i = 0; i < 8; i++)
3658 env->gregs[i] = regs->u_regs[i];
3659 for(i = 0; i < 8; i++)
3660 env->regwptr[i] = regs->u_regs[i + 8];
3661 }
3662 #elif defined(TARGET_PPC)
3663 {
3664 int i;
3665
3666 #if defined(TARGET_PPC64)
3667 #if defined(TARGET_ABI32)
3668 env->msr &= ~((target_ulong)1 << MSR_SF);
3669 #else
3670 env->msr |= (target_ulong)1 << MSR_SF;
3671 #endif
3672 #endif
3673 env->nip = regs->nip;
3674 for(i = 0; i < 32; i++) {
3675 env->gpr[i] = regs->gpr[i];
3676 }
3677 }
3678 #elif defined(TARGET_M68K)
3679 {
3680 env->pc = regs->pc;
3681 env->dregs[0] = regs->d0;
3682 env->dregs[1] = regs->d1;
3683 env->dregs[2] = regs->d2;
3684 env->dregs[3] = regs->d3;
3685 env->dregs[4] = regs->d4;
3686 env->dregs[5] = regs->d5;
3687 env->dregs[6] = regs->d6;
3688 env->dregs[7] = regs->d7;
3689 env->aregs[0] = regs->a0;
3690 env->aregs[1] = regs->a1;
3691 env->aregs[2] = regs->a2;
3692 env->aregs[3] = regs->a3;
3693 env->aregs[4] = regs->a4;
3694 env->aregs[5] = regs->a5;
3695 env->aregs[6] = regs->a6;
3696 env->aregs[7] = regs->usp;
3697 env->sr = regs->sr;
3698 ts->sim_syscalls = 1;
3699 }
3700 #elif defined(TARGET_MICROBLAZE)
3701 {
3702 env->regs[0] = regs->r0;
3703 env->regs[1] = regs->r1;
3704 env->regs[2] = regs->r2;
3705 env->regs[3] = regs->r3;
3706 env->regs[4] = regs->r4;
3707 env->regs[5] = regs->r5;
3708 env->regs[6] = regs->r6;
3709 env->regs[7] = regs->r7;
3710 env->regs[8] = regs->r8;
3711 env->regs[9] = regs->r9;
3712 env->regs[10] = regs->r10;
3713 env->regs[11] = regs->r11;
3714 env->regs[12] = regs->r12;
3715 env->regs[13] = regs->r13;
3716 env->regs[14] = regs->r14;
3717 env->regs[15] = regs->r15;
3718 env->regs[16] = regs->r16;
3719 env->regs[17] = regs->r17;
3720 env->regs[18] = regs->r18;
3721 env->regs[19] = regs->r19;
3722 env->regs[20] = regs->r20;
3723 env->regs[21] = regs->r21;
3724 env->regs[22] = regs->r22;
3725 env->regs[23] = regs->r23;
3726 env->regs[24] = regs->r24;
3727 env->regs[25] = regs->r25;
3728 env->regs[26] = regs->r26;
3729 env->regs[27] = regs->r27;
3730 env->regs[28] = regs->r28;
3731 env->regs[29] = regs->r29;
3732 env->regs[30] = regs->r30;
3733 env->regs[31] = regs->r31;
3734 env->sregs[SR_PC] = regs->pc;
3735 }
3736 #elif defined(TARGET_MIPS)
3737 {
3738 int i;
3739
3740 for(i = 0; i < 32; i++) {
3741 env->active_tc.gpr[i] = regs->regs[i];
3742 }
3743 env->active_tc.PC = regs->cp0_epc & ~(target_ulong)1;
3744 if (regs->cp0_epc & 1) {
3745 env->hflags |= MIPS_HFLAG_M16;
3746 }
3747 }
3748 #elif defined(TARGET_SH4)
3749 {
3750 int i;
3751
3752 for(i = 0; i < 16; i++) {
3753 env->gregs[i] = regs->regs[i];
3754 }
3755 env->pc = regs->pc;
3756 }
3757 #elif defined(TARGET_ALPHA)
3758 {
3759 int i;
3760
3761 for(i = 0; i < 28; i++) {
3762 env->ir[i] = ((abi_ulong *)regs)[i];
3763 }
3764 env->ir[IR_SP] = regs->usp;
3765 env->pc = regs->pc;
3766 }
3767 #elif defined(TARGET_CRIS)
3768 {
3769 env->regs[0] = regs->r0;
3770 env->regs[1] = regs->r1;
3771 env->regs[2] = regs->r2;
3772 env->regs[3] = regs->r3;
3773 env->regs[4] = regs->r4;
3774 env->regs[5] = regs->r5;
3775 env->regs[6] = regs->r6;
3776 env->regs[7] = regs->r7;
3777 env->regs[8] = regs->r8;
3778 env->regs[9] = regs->r9;
3779 env->regs[10] = regs->r10;
3780 env->regs[11] = regs->r11;
3781 env->regs[12] = regs->r12;
3782 env->regs[13] = regs->r13;
3783 env->regs[14] = info->start_stack;
3784 env->regs[15] = regs->acr;
3785 env->pc = regs->erp;
3786 }
3787 #elif defined(TARGET_S390X)
3788 {
3789 int i;
3790 for (i = 0; i < 16; i++) {
3791 env->regs[i] = regs->gprs[i];
3792 }
3793 env->psw.mask = regs->psw.mask;
3794 env->psw.addr = regs->psw.addr;
3795 }
3796 #else
3797 #error unsupported target CPU
3798 #endif
3799
3800 #if defined(TARGET_ARM) || defined(TARGET_M68K) || defined(TARGET_UNICORE32)
3801 ts->stack_base = info->start_stack;
3802 ts->heap_base = info->brk;
3803 /* This will be filled in on the first SYS_HEAPINFO call. */
3804 ts->heap_limit = 0;
3805 #endif
3806
3807 if (gdbstub_port) {
3808 if (gdbserver_start(gdbstub_port) < 0) {
3809 fprintf(stderr, "qemu: could not open gdbserver on port %d\n",
3810 gdbstub_port);
3811 exit(1);
3812 }
3813 gdb_handlesig(env, 0);
3814 }
3815 cpu_loop(env);
3816 /* never exits */
3817 return 0;
3818 }
Qemu copy for testing