]> git.proxmox.com Git - mirror_qemu.git/blame - linux-user/main.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
VMDK disk image creation (Filip Navara)
[mirror_qemu.git] / linux-user / main.c
CommitLineData
31e31b8a 1/*
93ac68bc 2 * qemu user main
31e31b8a
FB		 3 *
4 * Copyright (c) 2003 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, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 */
20#include <stdlib.h>
21#include <stdio.h>
22#include <stdarg.h>
04369ff2 23#include <string.h>
31e31b8a 24#include <errno.h>
0ecfa993 25#include <unistd.h>
31e31b8a 26
3ef693a0 27#include "qemu.h"
31e31b8a 28
3ef693a0 29#define DEBUG_LOGFILE "/tmp/qemu.log"
586314f2 30
83fb7adf
FB		 31#ifdef __APPLE__
32#include <crt_externs.h>
33# define environ (*_NSGetEnviron())
34#endif
35
74cd30b8 36static const char *interp_prefix = CONFIG_QEMU_PREFIX;
586314f2 37
3a4739d6 38#if defined(__i386__) && !defined(CONFIG_STATIC)
f801f97e
FB		 39/* Force usage of an ELF interpreter even if it is an ELF shared
40 object ! */
41const char interp[] __attribute__((section(".interp"))) = "/lib/ld-linux.so.2";
4304763b 42#endif
74cd30b8 43
93ac68bc 44/* for recent libc, we add these dummy symbols which are not declared
74cd30b8 45 when generating a linked object (bug in ld ?) */
fbf59244 46#if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 3)) && !defined(CONFIG_STATIC)
c6981055
FB		 47long __preinit_array_start[0];
48long __preinit_array_end[0];
74cd30b8
FB		 49long __init_array_start[0];
50long __init_array_end[0];
51long __fini_array_start[0];
52long __fini_array_end[0];
53#endif
54
9de5e440
FB		 55/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
56 we allocate a bigger stack. Need a better solution, for example
57 by remapping the process stack directly at the right place */
58unsigned long x86_stack_size = 512 * 1024;
31e31b8a
FB		 59
60void gemu_log(const char *fmt, ...)
61{
62 va_list ap;
63
64 va_start(ap, fmt);
65 vfprintf(stderr, fmt, ap);
66 va_end(ap);
67}
68
61190b14 69void cpu_outb(CPUState *env, int addr, int val)
367e86e8
FB		 70{
71 fprintf(stderr, "outb: port=0x%04x, data=%02x\n", addr, val);
72}
73
61190b14 74void cpu_outw(CPUState *env, int addr, int val)
367e86e8
FB		 75{
76 fprintf(stderr, "outw: port=0x%04x, data=%04x\n", addr, val);
77}
78
61190b14 79void cpu_outl(CPUState *env, int addr, int val)
367e86e8
FB		 80{
81 fprintf(stderr, "outl: port=0x%04x, data=%08x\n", addr, val);
82}
83
61190b14 84int cpu_inb(CPUState *env, int addr)
367e86e8
FB		 85{
86 fprintf(stderr, "inb: port=0x%04x\n", addr);
87 return 0;
88}
89
61190b14 90int cpu_inw(CPUState *env, int addr)
367e86e8
FB		 91{
92 fprintf(stderr, "inw: port=0x%04x\n", addr);
93 return 0;
94}
95
61190b14 96int cpu_inl(CPUState *env, int addr)
367e86e8
FB		 97{
98 fprintf(stderr, "inl: port=0x%04x\n", addr);
99 return 0;
100}
101
a541f297 102int cpu_get_pic_interrupt(CPUState *env)
92ccca6a
FB		 103{
104 return -1;
105}
106
28ab0e2e
FB		 107/* timers for rdtsc */
108
109#if defined(__i386__)
110
111int64_t cpu_get_real_ticks(void)
112{
113 int64_t val;
114 asm volatile ("rdtsc" : "=A" (val));
115 return val;
116}
117
118#elif defined(__x86_64__)
119
120int64_t cpu_get_real_ticks(void)
121{
122 uint32_t low,high;
123 int64_t val;
124 asm volatile("rdtsc" : "=a" (low), "=d" (high));
125 val = high;
126 val <<= 32;
127 val |= low;
128 return val;
129}
130
131#else
132
133static uint64_t emu_time;
134
135int64_t cpu_get_real_ticks(void)
136{
137 return emu_time++;
138}
139
140#endif
141
a541f297
FB		 142#ifdef TARGET_I386
143/***********************************************************/
144/* CPUX86 core interface */
145
28ab0e2e
FB		 146uint64_t cpu_get_tsc(CPUX86State *env)
147{
148 return cpu_get_real_ticks();
149}
150
f4beb510
FB		 151static void write_dt(void *ptr, unsigned long addr, unsigned long limit,
152 int flags)
6dbad63e 153{
f4beb510 154 unsigned int e1, e2;
6dbad63e
FB		 155 e1 = (addr << 16) | (limit & 0xffff);
156 e2 = ((addr >> 16) & 0xff) | (addr & 0xff000000) | (limit & 0x000f0000);
f4beb510
FB		 157 e2 |= flags;
158 stl((uint8_t *)ptr, e1);
159 stl((uint8_t *)ptr + 4, e2);
160}
161
162static void set_gate(void *ptr, unsigned int type, unsigned int dpl,
163 unsigned long addr, unsigned int sel)
164{
165 unsigned int e1, e2;
166 e1 = (addr & 0xffff) | (sel << 16);
167 e2 = (addr & 0xffff0000) | 0x8000 | (dpl << 13) | (type << 8);
6dbad63e
FB		 168 stl((uint8_t *)ptr, e1);
169 stl((uint8_t *)ptr + 4, e2);
170}
171
172uint64_t gdt_table[6];
f4beb510
FB		 173uint64_t idt_table[256];
174
175/* only dpl matters as we do only user space emulation */
176static void set_idt(int n, unsigned int dpl)
177{
178 set_gate(idt_table + n, 0, dpl, 0, 0);
179}
31e31b8a 180
89e957e7 181void cpu_loop(CPUX86State *env)
1b6b029e 182{
bc8a22cc 183 int trapnr;
80a9d035 184 target_ulong pc;
9de5e440 185 target_siginfo_t info;
851e67a1 186
1b6b029e 187 for(;;) {
bc8a22cc 188 trapnr = cpu_x86_exec(env);
bc8a22cc 189 switch(trapnr) {
f4beb510
FB		 190 case 0x80:
191 /* linux syscall */
192 env->regs[R_EAX] = do_syscall(env,
193 env->regs[R_EAX],
194 env->regs[R_EBX],
195 env->regs[R_ECX],
196 env->regs[R_EDX],
197 env->regs[R_ESI],
198 env->regs[R_EDI],
199 env->regs[R_EBP]);
200 break;
201 case EXCP0B_NOSEG:
202 case EXCP0C_STACK:
203 info.si_signo = SIGBUS;
204 info.si_errno = 0;
205 info.si_code = TARGET_SI_KERNEL;
206 info._sifields._sigfault._addr = 0;
207 queue_signal(info.si_signo, &info);
208 break;
1b6b029e 209 case EXCP0D_GPF:
851e67a1 210 if (env->eflags & VM_MASK) {
89e957e7 211 handle_vm86_fault(env);
1b6b029e 212 } else {
f4beb510
FB		 213 info.si_signo = SIGSEGV;
214 info.si_errno = 0;
215 info.si_code = TARGET_SI_KERNEL;
216 info._sifields._sigfault._addr = 0;
217 queue_signal(info.si_signo, &info);
1b6b029e
FB		 218 }
219 break;
b689bc57
FB		 220 case EXCP0E_PAGE:
221 info.si_signo = SIGSEGV;
222 info.si_errno = 0;
223 if (!(env->error_code & 1))
224 info.si_code = TARGET_SEGV_MAPERR;
225 else
226 info.si_code = TARGET_SEGV_ACCERR;
970a87a6 227 info._sifields._sigfault._addr = env->cr[2];
b689bc57
FB		 228 queue_signal(info.si_signo, &info);
229 break;
9de5e440 230 case EXCP00_DIVZ:
bc8a22cc 231 if (env->eflags & VM_MASK) {
447db213 232 handle_vm86_trap(env, trapnr);
bc8a22cc
FB		 233 } else {
234 /* division by zero */
235 info.si_signo = SIGFPE;
236 info.si_errno = 0;
237 info.si_code = TARGET_FPE_INTDIV;
238 info._sifields._sigfault._addr = env->eip;
239 queue_signal(info.si_signo, &info);
240 }
9de5e440 241 break;
447db213
FB		 242 case EXCP01_SSTP:
243 case EXCP03_INT3:
244 if (env->eflags & VM_MASK) {
245 handle_vm86_trap(env, trapnr);
246 } else {
247 info.si_signo = SIGTRAP;
248 info.si_errno = 0;
249 if (trapnr == EXCP01_SSTP) {
250 info.si_code = TARGET_TRAP_BRKPT;
251 info._sifields._sigfault._addr = env->eip;
252 } else {
253 info.si_code = TARGET_SI_KERNEL;
254 info._sifields._sigfault._addr = 0;
255 }
256 queue_signal(info.si_signo, &info);
257 }
258 break;
9de5e440
FB		 259 case EXCP04_INTO:
260 case EXCP05_BOUND:
bc8a22cc 261 if (env->eflags & VM_MASK) {
447db213 262 handle_vm86_trap(env, trapnr);
bc8a22cc
FB		 263 } else {
264 info.si_signo = SIGSEGV;
265 info.si_errno = 0;
b689bc57 266 info.si_code = TARGET_SI_KERNEL;
bc8a22cc
FB		 267 info._sifields._sigfault._addr = 0;
268 queue_signal(info.si_signo, &info);
269 }
9de5e440
FB		 270 break;
271 case EXCP06_ILLOP:
272 info.si_signo = SIGILL;
273 info.si_errno = 0;
274 info.si_code = TARGET_ILL_ILLOPN;
275 info._sifields._sigfault._addr = env->eip;
276 queue_signal(info.si_signo, &info);
277 break;
278 case EXCP_INTERRUPT:
279 /* just indicate that signals should be handled asap */
280 break;
1fddef4b
FB		 281 case EXCP_DEBUG:
282 {
283 int sig;
284
285 sig = gdb_handlesig (env, TARGET_SIGTRAP);
286 if (sig)
287 {
288 info.si_signo = sig;
289 info.si_errno = 0;
290 info.si_code = TARGET_TRAP_BRKPT;
291 queue_signal(info.si_signo, &info);
292 }
293 }
294 break;
1b6b029e 295 default:
970a87a6 296 pc = env->segs[R_CS].base + env->eip;
bc8a22cc
FB		 297 fprintf(stderr, "qemu: 0x%08lx: unhandled CPU exception 0x%x - aborting\n",
298 (long)pc, trapnr);
1b6b029e
FB		 299 abort();
300 }
66fb9763 301 process_pending_signals(env);
1b6b029e
FB		 302 }
303}
b346ff46
FB		 304#endif
305
306#ifdef TARGET_ARM
307
6f1f31c0
FB		 308/* XXX: find a better solution */
309extern void tb_invalidate_page_range(target_ulong start, target_ulong end);
310
311static void arm_cache_flush(target_ulong start, target_ulong last)
312{
313 target_ulong addr, last1;
314
315 if (last < start)
316 return;
317 addr = start;
318 for(;;) {
319 last1 = ((addr + TARGET_PAGE_SIZE) & TARGET_PAGE_MASK) - 1;
320 if (last1 > last)
321 last1 = last;
322 tb_invalidate_page_range(addr, last1 + 1);
323 if (last1 == last)
324 break;
325 addr = last1 + 1;
326 }
327}
328
b346ff46
FB		 329void cpu_loop(CPUARMState *env)
330{
331 int trapnr;
332 unsigned int n, insn;
333 target_siginfo_t info;
334
335 for(;;) {
336 trapnr = cpu_arm_exec(env);
337 switch(trapnr) {
338 case EXCP_UDEF:
c6981055
FB		 339 {
340 TaskState *ts = env->opaque;
341 uint32_t opcode;
342
343 /* we handle the FPU emulation here, as Linux */
344 /* we get the opcode */
345 opcode = ldl_raw((uint8_t *)env->regs[15]);
346
347 if (EmulateAll(opcode, &ts->fpa, env->regs) == 0) {
348 info.si_signo = SIGILL;
349 info.si_errno = 0;
350 info.si_code = TARGET_ILL_ILLOPN;
351 info._sifields._sigfault._addr = env->regs[15];
352 queue_signal(info.si_signo, &info);
353 } else {
354 /* increment PC */
355 env->regs[15] += 4;
356 }
357 }
b346ff46
FB		 358 break;
359 case EXCP_SWI:
360 {
361 /* system call */
192c7bd9
FB		 362 if (env->thumb) {
363 insn = lduw((void *)(env->regs[15] - 2));
364 n = insn & 0xff;
365 } else {
366 insn = ldl((void *)(env->regs[15] - 4));
367 n = insn & 0xffffff;
368 }
369
6f1f31c0
FB		 370 if (n == ARM_NR_cacheflush) {
371 arm_cache_flush(env->regs[0], env->regs[1]);
a4f81979
FB		 372 } else if (n == ARM_NR_semihosting
373 || n == ARM_NR_thumb_semihosting) {
374 env->regs[0] = do_arm_semihosting (env);
192c7bd9
FB		 375 } else if (n >= ARM_SYSCALL_BASE
376 || (env->thumb && n == ARM_THUMB_SYSCALL)) {
b346ff46 377 /* linux syscall */
192c7bd9
FB		 378 if (env->thumb) {
379 n = env->regs[7];
380 } else {
381 n -= ARM_SYSCALL_BASE;
382 }
b346ff46
FB		 383 env->regs[0] = do_syscall(env,
384 n,
385 env->regs[0],
386 env->regs[1],
387 env->regs[2],
388 env->regs[3],
389 env->regs[4],
e1a2849c 390 env->regs[5]);
b346ff46
FB		 391 } else {
392 goto error;
393 }
394 }
395 break;
43fff238
FB		 396 case EXCP_INTERRUPT:
397 /* just indicate that signals should be handled asap */
398 break;
68016c62
FB		 399 case EXCP_PREFETCH_ABORT:
400 case EXCP_DATA_ABORT:
401 {
402 info.si_signo = SIGSEGV;
403 info.si_errno = 0;
404 /* XXX: check env->error_code */
405 info.si_code = TARGET_SEGV_MAPERR;
406 info._sifields._sigfault._addr = env->cp15_6;
407 queue_signal(info.si_signo, &info);
408 }
409 break;
1fddef4b
FB		 410 case EXCP_DEBUG:
411 {
412 int sig;
413
414 sig = gdb_handlesig (env, TARGET_SIGTRAP);
415 if (sig)
416 {
417 info.si_signo = sig;
418 info.si_errno = 0;
419 info.si_code = TARGET_TRAP_BRKPT;
420 queue_signal(info.si_signo, &info);
421 }
422 }
423 break;
b346ff46
FB		 424 default:
425 error:
426 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
427 trapnr);
7fe48483 428 cpu_dump_state(env, stderr, fprintf, 0);
b346ff46
FB		 429 abort();
430 }
431 process_pending_signals(env);
432 }
433}
434
435#endif
1b6b029e 436
93ac68bc
FB		 437#ifdef TARGET_SPARC
438
060366c5
FB		 439//#define DEBUG_WIN
440
2623cbaf
FB		 441/* WARNING: dealing with register windows _is_ complicated. More info
442 can be found at http://www.sics.se/~psm/sparcstack.html */
060366c5
FB		 443static inline int get_reg_index(CPUSPARCState *env, int cwp, int index)
444{
445 index = (index + cwp * 16) & (16 * NWINDOWS - 1);
446 /* wrap handling : if cwp is on the last window, then we use the
447 registers 'after' the end */
448 if (index < 8 && env->cwp == (NWINDOWS - 1))
449 index += (16 * NWINDOWS);
450 return index;
451}
452
2623cbaf
FB		 453/* save the register window 'cwp1' */
454static inline void save_window_offset(CPUSPARCState *env, int cwp1)
060366c5 455{
2623cbaf 456 unsigned int i;
060366c5
FB		 457 uint32_t *sp_ptr;
458
060366c5
FB		 459 sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]);
460#if defined(DEBUG_WIN)
461 printf("win_overflow: sp_ptr=0x%x save_cwp=%d\n",
462 (int)sp_ptr, cwp1);
463#endif
2623cbaf
FB		 464 for(i = 0; i < 16; i++) {
465 put_user(env->regbase[get_reg_index(env, cwp1, 8 + i)], sp_ptr);
466 sp_ptr++;
467 }
060366c5
FB		 468}
469
470static void save_window(CPUSPARCState *env)
471{
2623cbaf
FB		 472 unsigned int new_wim;
473 new_wim = ((env->wim >> 1) | (env->wim << (NWINDOWS - 1))) &
474 ((1LL << NWINDOWS) - 1);
475 save_window_offset(env, (env->cwp - 2) & (NWINDOWS - 1));
476 env->wim = new_wim;
060366c5
FB		 477}
478
479static void restore_window(CPUSPARCState *env)
480{
481 unsigned int new_wim, i, cwp1;
2623cbaf 482 uint32_t *sp_ptr, reg;
060366c5
FB		 483
484 new_wim = ((env->wim << 1) | (env->wim >> (NWINDOWS - 1))) &
485 ((1LL << NWINDOWS) - 1);
486
487 /* restore the invalid window */
488 cwp1 = (env->cwp + 1) & (NWINDOWS - 1);
489 sp_ptr = (uint32_t *)(env->regbase[get_reg_index(env, cwp1, 6)]);
490#if defined(DEBUG_WIN)
491 printf("win_underflow: sp_ptr=0x%x load_cwp=%d\n",
492 (int)sp_ptr, cwp1);
493#endif
2623cbaf
FB		 494 for(i = 0; i < 16; i++) {
495 get_user(reg, sp_ptr);
496 env->regbase[get_reg_index(env, cwp1, 8 + i)] = reg;
497 sp_ptr++;
498 }
060366c5
FB		 499 env->wim = new_wim;
500}
501
502static void flush_windows(CPUSPARCState *env)
503{
504 int offset, cwp1;
2623cbaf
FB		 505
506 offset = 1;
060366c5
FB		 507 for(;;) {
508 /* if restore would invoke restore_window(), then we can stop */
2623cbaf 509 cwp1 = (env->cwp + offset) & (NWINDOWS - 1);
060366c5
FB		 510 if (env->wim & (1 << cwp1))
511 break;
2623cbaf 512 save_window_offset(env, cwp1);
060366c5
FB		 513 offset++;
514 }
2623cbaf
FB		 515 /* set wim so that restore will reload the registers */
516 cwp1 = (env->cwp + 1) & (NWINDOWS - 1);
517 env->wim = 1 << cwp1;
518#if defined(DEBUG_WIN)
519 printf("flush_windows: nb=%d\n", offset - 1);
80a9d035 520#endif
2623cbaf 521}
060366c5 522
93ac68bc
FB		 523void cpu_loop (CPUSPARCState *env)
524{
060366c5 525 int trapnr, ret;
61ff6f58 526 target_siginfo_t info;
060366c5
FB		 527
528 while (1) {
529 trapnr = cpu_sparc_exec (env);
530
531 switch (trapnr) {
532 case 0x88:
533 case 0x90:
534 ret = do_syscall (env, env->gregs[1],
535 env->regwptr[0], env->regwptr[1],
536 env->regwptr[2], env->regwptr[3],
537 env->regwptr[4], env->regwptr[5]);
538 if ((unsigned int)ret >= (unsigned int)(-515)) {
539 env->psr |= PSR_CARRY;
540 ret = -ret;
541 } else {
542 env->psr &= ~PSR_CARRY;
543 }
544 env->regwptr[0] = ret;
545 /* next instruction */
546 env->pc = env->npc;
547 env->npc = env->npc + 4;
548 break;
549 case 0x83: /* flush windows */
2623cbaf 550 flush_windows(env);
060366c5
FB		 551 /* next instruction */
552 env->pc = env->npc;
553 env->npc = env->npc + 4;
554 break;
555 case TT_WIN_OVF: /* window overflow */
556 save_window(env);
557 break;
558 case TT_WIN_UNF: /* window underflow */
559 restore_window(env);
560 break;
61ff6f58
FB		 561 case TT_TFAULT:
562 case TT_DFAULT:
563 {
564 info.si_signo = SIGSEGV;
565 info.si_errno = 0;
566 /* XXX: check env->error_code */
567 info.si_code = TARGET_SEGV_MAPERR;
568 info._sifields._sigfault._addr = env->mmuregs[4];
569 queue_signal(info.si_signo, &info);
570 }
571 break;
e80cfcfc
FB		 572 case 0x100: // XXX, why do we get these?
573 break;
1fddef4b
FB		 574 case EXCP_DEBUG:
575 {
576 int sig;
577
578 sig = gdb_handlesig (env, TARGET_SIGTRAP);
579 if (sig)
580 {
581 info.si_signo = sig;
582 info.si_errno = 0;
583 info.si_code = TARGET_TRAP_BRKPT;
584 queue_signal(info.si_signo, &info);
585 }
586 }
587 break;
060366c5
FB		 588 default:
589 printf ("Unhandled trap: 0x%x\n", trapnr);
7fe48483 590 cpu_dump_state(env, stderr, fprintf, 0);
060366c5
FB		 591 exit (1);
592 }
593 process_pending_signals (env);
594 }
93ac68bc
FB		 595}
596
597#endif
598
67867308 599#ifdef TARGET_PPC
9fddaa0c
FB		 600
601static inline uint64_t cpu_ppc_get_tb (CPUState *env)
602{
603 /* TO FIX */
604 return 0;
605}
606
607uint32_t cpu_ppc_load_tbl (CPUState *env)
608{
609 return cpu_ppc_get_tb(env) & 0xFFFFFFFF;
610}
611
612uint32_t cpu_ppc_load_tbu (CPUState *env)
613{
614 return cpu_ppc_get_tb(env) >> 32;
615}
616
617static void cpu_ppc_store_tb (CPUState *env, uint64_t value)
618{
619 /* TO FIX */
620}
621
622void cpu_ppc_store_tbu (CPUState *env, uint32_t value)
623{
624 cpu_ppc_store_tb(env, ((uint64_t)value << 32) | cpu_ppc_load_tbl(env));
625}
626
627void cpu_ppc_store_tbl (CPUState *env, uint32_t value)
628{
629 cpu_ppc_store_tb(env, ((uint64_t)cpu_ppc_load_tbl(env) << 32) | value);
630}
631
632uint32_t cpu_ppc_load_decr (CPUState *env)
633{
634 /* TO FIX */
635 return -1;
636}
637
638void cpu_ppc_store_decr (CPUState *env, uint32_t value)
639{
640 /* TO FIX */
641}
642
67867308
FB		 643void cpu_loop(CPUPPCState *env)
644{
67867308 645 target_siginfo_t info;
61190b14
FB		 646 int trapnr;
647 uint32_t ret;
67867308
FB		 648
649 for(;;) {
650 trapnr = cpu_ppc_exec(env);
61190b14
FB		 651 if (trapnr != EXCP_SYSCALL_USER && trapnr != EXCP_BRANCH &&
652 trapnr != EXCP_TRACE) {
653 if (loglevel > 0) {
7fe48483 654 cpu_dump_state(env, logfile, fprintf, 0);
61190b14
FB		 655 }
656 }
67867308
FB		 657 switch(trapnr) {
658 case EXCP_NONE:
67867308 659 break;
61190b14
FB		 660 case EXCP_SYSCALL_USER:
661 /* system call */
662 /* WARNING:
663 * PPC ABI uses overflow flag in cr0 to signal an error
664 * in syscalls.
665 */
67867308 666#if 0
61190b14
FB		 667 printf("syscall %d 0x%08x 0x%08x 0x%08x 0x%08x\n", env->gpr[0],
668 env->gpr[3], env->gpr[4], env->gpr[5], env->gpr[6]);
67867308 669#endif
61190b14
FB		 670 env->crf[0] &= ~0x1;
671 ret = do_syscall(env, env->gpr[0], env->gpr[3], env->gpr[4],
672 env->gpr[5], env->gpr[6], env->gpr[7],
673 env->gpr[8]);
674 if (ret > (uint32_t)(-515)) {
675 env->crf[0] |= 0x1;
676 ret = -ret;
677 }
678 env->gpr[3] = ret;
679#if 0
680 printf("syscall returned 0x%08x (%d)\n", ret, ret);
681#endif
682 break;
683 case EXCP_RESET:
684 /* Should not happen ! */
685 fprintf(stderr, "RESET asked... Stop emulation\n");
686 if (loglevel)
687 fprintf(logfile, "RESET asked... Stop emulation\n");
67867308 688 abort();
61190b14
FB		 689 case EXCP_MACHINE_CHECK:
690 fprintf(stderr, "Machine check exeption... Stop emulation\n");
691 if (loglevel)
692 fprintf(logfile, "RESET asked... Stop emulation\n");
693 info.si_signo = TARGET_SIGBUS;
67867308 694 info.si_errno = 0;
61190b14
FB		 695 info.si_code = TARGET_BUS_OBJERR;
696 info._sifields._sigfault._addr = env->nip - 4;
697 queue_signal(info.si_signo, &info);
698 case EXCP_DSI:
699 fprintf(stderr, "Invalid data memory access: 0x%08x\n", env->spr[DAR]);
700 if (loglevel) {
701 fprintf(logfile, "Invalid data memory access: 0x%08x\n",
702 env->spr[DAR]);
703 }
704 switch (env->error_code & 0xF) {
705 case EXCP_DSI_TRANSLATE:
706 info.si_signo = TARGET_SIGSEGV;
707 info.si_errno = 0;
708 info.si_code = TARGET_SEGV_MAPERR;
709 break;
710 case EXCP_DSI_NOTSUP:
711 case EXCP_DSI_EXTERNAL:
712 info.si_signo = TARGET_SIGILL;
713 info.si_errno = 0;
714 info.si_code = TARGET_ILL_ILLADR;
715 break;
716 case EXCP_DSI_PROT:
717 info.si_signo = TARGET_SIGSEGV;
718 info.si_errno = 0;
719 info.si_code = TARGET_SEGV_ACCERR;
720 break;
721 case EXCP_DSI_DABR:
722 info.si_signo = TARGET_SIGTRAP;
723 info.si_errno = 0;
724 info.si_code = TARGET_TRAP_BRKPT;
725 break;
726 default:
727 /* Let's send a regular segfault... */
728 fprintf(stderr, "Invalid segfault errno (%02x)\n",
729 env->error_code);
730 if (loglevel) {
731 fprintf(logfile, "Invalid segfault errno (%02x)\n",
732 env->error_code);
733 }
734 info.si_signo = TARGET_SIGSEGV;
735 info.si_errno = 0;
736 info.si_code = TARGET_SEGV_MAPERR;
737 break;
738 }
67867308
FB		 739 info._sifields._sigfault._addr = env->nip;
740 queue_signal(info.si_signo, &info);
741 break;
61190b14 742 case EXCP_ISI:
67867308 743 fprintf(stderr, "Invalid instruction fetch\n");
61190b14
FB		 744 if (loglevel)
745 fprintf(logfile, "Invalid instruction fetch\n");
746 switch (env->error_code) {
747 case EXCP_ISI_TRANSLATE:
748 info.si_signo = TARGET_SIGSEGV;
67867308 749 info.si_errno = 0;
61190b14
FB		 750 info.si_code = TARGET_SEGV_MAPERR;
751 break;
752 case EXCP_ISI_GUARD:
753 info.si_signo = TARGET_SIGILL;
754 info.si_errno = 0;
755 info.si_code = TARGET_ILL_ILLADR;
756 break;
757 case EXCP_ISI_NOEXEC:
758 case EXCP_ISI_PROT:
759 info.si_signo = TARGET_SIGSEGV;
760 info.si_errno = 0;
761 info.si_code = TARGET_SEGV_ACCERR;
762 break;
763 default:
764 /* Let's send a regular segfault... */
765 fprintf(stderr, "Invalid segfault errno (%02x)\n",
766 env->error_code);
767 if (loglevel) {
768 fprintf(logfile, "Invalid segfault errno (%02x)\n",
769 env->error_code);
770 }
771 info.si_signo = TARGET_SIGSEGV;
772 info.si_errno = 0;
773 info.si_code = TARGET_SEGV_MAPERR;
774 break;
775 }
776 info._sifields._sigfault._addr = env->nip - 4;
67867308
FB		 777 queue_signal(info.si_signo, &info);
778 break;
61190b14
FB		 779 case EXCP_EXTERNAL:
780 /* Should not happen ! */
781 fprintf(stderr, "External interruption... Stop emulation\n");
782 if (loglevel)
783 fprintf(logfile, "External interruption... Stop emulation\n");
67867308 784 abort();
61190b14
FB		 785 case EXCP_ALIGN:
786 fprintf(stderr, "Invalid unaligned memory access\n");
787 if (loglevel)
788 fprintf(logfile, "Invalid unaligned memory access\n");
789 info.si_signo = TARGET_SIGBUS;
67867308 790 info.si_errno = 0;
61190b14
FB		 791 info.si_code = TARGET_BUS_ADRALN;
792 info._sifields._sigfault._addr = env->nip - 4;
67867308
FB		 793 queue_signal(info.si_signo, &info);
794 break;
61190b14
FB		 795 case EXCP_PROGRAM:
796 switch (env->error_code & ~0xF) {
797 case EXCP_FP:
798 fprintf(stderr, "Program exception\n");
799 if (loglevel)
800 fprintf(logfile, "Program exception\n");
801 /* Set FX */
802 env->fpscr[7] |= 0x8;
803 /* Finally, update FEX */
804 if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
805 ((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
806 env->fpscr[7] |= 0x4;
807 info.si_signo = TARGET_SIGFPE;
808 info.si_errno = 0;
809 switch (env->error_code & 0xF) {
810 case EXCP_FP_OX:
811 info.si_code = TARGET_FPE_FLTOVF;
812 break;
813 case EXCP_FP_UX:
814 info.si_code = TARGET_FPE_FLTUND;
815 break;
816 case EXCP_FP_ZX:
817 case EXCP_FP_VXZDZ:
818 info.si_code = TARGET_FPE_FLTDIV;
819 break;
820 case EXCP_FP_XX:
821 info.si_code = TARGET_FPE_FLTRES;
822 break;
823 case EXCP_FP_VXSOFT:
824 info.si_code = TARGET_FPE_FLTINV;
825 break;
826 case EXCP_FP_VXNAN:
827 case EXCP_FP_VXISI:
828 case EXCP_FP_VXIDI:
829 case EXCP_FP_VXIMZ:
830 case EXCP_FP_VXVC:
831 case EXCP_FP_VXSQRT:
832 case EXCP_FP_VXCVI:
833 info.si_code = TARGET_FPE_FLTSUB;
834 break;
835 default:
836 fprintf(stderr, "Unknown floating point exception "
837 "(%02x)\n", env->error_code);
838 if (loglevel) {
839 fprintf(logfile, "Unknown floating point exception "
840 "(%02x)\n", env->error_code & 0xF);
841 }
842 }
843 break;
67867308 844 case EXCP_INVAL:
61190b14
FB		 845 fprintf(stderr, "Invalid instruction\n");
846 if (loglevel)
847 fprintf(logfile, "Invalid instruction\n");
848 info.si_signo = TARGET_SIGILL;
849 info.si_errno = 0;
850 switch (env->error_code & 0xF) {
851 case EXCP_INVAL_INVAL:
852 info.si_code = TARGET_ILL_ILLOPC;
853 break;
854 case EXCP_INVAL_LSWX:
67867308 855 info.si_code = TARGET_ILL_ILLOPN;
61190b14
FB		 856 break;
857 case EXCP_INVAL_SPR:
858 info.si_code = TARGET_ILL_PRVREG;
859 break;
860 case EXCP_INVAL_FP:
861 info.si_code = TARGET_ILL_COPROC;
862 break;
863 default:
864 fprintf(stderr, "Unknown invalid operation (%02x)\n",
865 env->error_code & 0xF);
866 if (loglevel) {
867 fprintf(logfile, "Unknown invalid operation (%02x)\n",
868 env->error_code & 0xF);
869 }
870 info.si_code = TARGET_ILL_ILLADR;
871 break;
872 }
873 break;
874 case EXCP_PRIV:
875 fprintf(stderr, "Privilege violation\n");
876 if (loglevel)
877 fprintf(logfile, "Privilege violation\n");
878 info.si_signo = TARGET_SIGILL;
879 info.si_errno = 0;
880 switch (env->error_code & 0xF) {
881 case EXCP_PRIV_OPC:
882 info.si_code = TARGET_ILL_PRVOPC;
883 break;
884 case EXCP_PRIV_REG:
885 info.si_code = TARGET_ILL_PRVREG;
886 break;
887 default:
888 fprintf(stderr, "Unknown privilege violation (%02x)\n",
889 env->error_code & 0xF);
890 info.si_code = TARGET_ILL_PRVOPC;
891 break;
892 }
893 break;
894 case EXCP_TRAP:
895 fprintf(stderr, "Tried to call a TRAP\n");
896 if (loglevel)
897 fprintf(logfile, "Tried to call a TRAP\n");
898 abort();
899 default:
900 /* Should not happen ! */
901 fprintf(stderr, "Unknown program exception (%02x)\n",
902 env->error_code);
903 if (loglevel) {
904 fprintf(logfile, "Unknwon program exception (%02x)\n",
905 env->error_code);
906 }
907 abort();
908 }
909 info._sifields._sigfault._addr = env->nip - 4;
67867308
FB		 910 queue_signal(info.si_signo, &info);
911 break;
61190b14
FB		 912 case EXCP_NO_FP:
913 fprintf(stderr, "No floating point allowed\n");
914 if (loglevel)
915 fprintf(logfile, "No floating point allowed\n");
916 info.si_signo = TARGET_SIGILL;
67867308 917 info.si_errno = 0;
61190b14
FB		 918 info.si_code = TARGET_ILL_COPROC;
919 info._sifields._sigfault._addr = env->nip - 4;
67867308
FB		 920 queue_signal(info.si_signo, &info);
921 break;
61190b14
FB		 922 case EXCP_DECR:
923 /* Should not happen ! */
924 fprintf(stderr, "Decrementer exception\n");
925 if (loglevel)
926 fprintf(logfile, "Decrementer exception\n");
927 abort();
67867308 928 case EXCP_RESA: /* Implementation specific */
61190b14
FB		 929 /* Should not happen ! */
930 fprintf(stderr, "RESA exception should never happen !\n");
931 if (loglevel)
932 fprintf(logfile, "RESA exception should never happen !\n");
933 abort();
67867308 934 case EXCP_RESB: /* Implementation specific */
61190b14
FB		 935 /* Should not happen ! */
936 fprintf(stderr, "RESB exception should never happen !\n");
937 if (loglevel)
938 fprintf(logfile, "RESB exception should never happen !\n");
67867308 939 abort();
61190b14
FB		 940 case EXCP_TRACE:
941 /* Do nothing: we use this to trace execution */
67867308 942 break;
61190b14
FB		 943 case EXCP_FP_ASSIST:
944 /* Should not happen ! */
945 fprintf(stderr, "Floating point assist exception\n");
946 if (loglevel)
947 fprintf(logfile, "Floating point assist exception\n");
948 abort();
949 case EXCP_MTMSR:
950 /* We reloaded the msr, just go on */
9fddaa0c 951 if (msr_pr == 0) {
61190b14
FB		 952 fprintf(stderr, "Tried to go into supervisor mode !\n");
953 if (loglevel)
954 fprintf(logfile, "Tried to go into supervisor mode !\n");
955 abort();
67867308 956 }
61190b14
FB		 957 break;
958 case EXCP_BRANCH:
959 /* We stopped because of a jump... */
960 break;
961 case EXCP_RFI:
962 /* Should not occur: we always are in user mode */
963 fprintf(stderr, "Return from interrupt ?\n");
964 if (loglevel)
965 fprintf(logfile, "Return from interrupt ?\n");
966 abort();
967 case EXCP_INTERRUPT:
968 /* Don't know why this should ever happen... */
969 break;
1fddef4b
FB		 970 case EXCP_DEBUG:
971 {
972 int sig;
973
974 sig = gdb_handlesig (env, TARGET_SIGTRAP);
975 if (sig)
976 {
977 info.si_signo = sig;
978 info.si_errno = 0;
979 info.si_code = TARGET_TRAP_BRKPT;
980 queue_signal(info.si_signo, &info);
981 }
982 }
983 break;
67867308 984 default:
67867308
FB		 985 fprintf(stderr, "qemu: unhandled CPU exception 0x%x - aborting\n",
986 trapnr);
61190b14
FB		 987 if (loglevel) {
988 fprintf(logfile, "qemu: unhandled CPU exception 0x%02x - "
989 "0x%02x - aborting\n", trapnr, env->error_code);
990 }
67867308
FB		 991 abort();
992 }
993 process_pending_signals(env);
994 }
995}
996#endif
997
31e31b8a
FB		 998void usage(void)
999{
4606bb3f 1000 printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n"
1fddef4b 1001 "usage: qemu-" TARGET_ARCH " [-h] [-g] [-d opts] [-L path] [-s size] program [arguments...]\n"
b346ff46 1002 "Linux CPU emulator (compiled for %s emulation)\n"
d691f669 1003 "\n"
54936004 1004 "-h print this help\n"
1fddef4b 1005 "-g wait gdb connection to port %d\n"
b346ff46
FB		 1006 "-L path set the elf interpreter prefix (default=%s)\n"
1007 "-s size set the stack size in bytes (default=%ld)\n"
54936004
FB		 1008 "\n"
1009 "debug options:\n"
c6981055
FB		 1010#ifdef USE_CODE_COPY
1011 "-no-code-copy disable code copy acceleration\n"
1012#endif
6f1f31c0 1013 "-d options activate log (logfile=%s)\n"
54936004 1014 "-p pagesize set the host page size to 'pagesize'\n",
b346ff46 1015 TARGET_ARCH,
1fddef4b 1016 DEFAULT_GDBSTUB_PORT,
d691f669 1017 interp_prefix,
54936004
FB		 1018 x86_stack_size,
1019 DEBUG_LOGFILE);
74cd30b8 1020 _exit(1);
31e31b8a
FB		 1021}
1022
9de5e440 1023/* XXX: currently only used for async signals (see signal.c) */
b346ff46 1024CPUState *global_env;
59faf6d6
FB		 1025/* used only if single thread */
1026CPUState *cpu_single_env = NULL;
1027
851e67a1
FB		 1028/* used to free thread contexts */
1029TaskState *first_task_state;
9de5e440 1030
31e31b8a
FB		 1031int main(int argc, char **argv)
1032{
1033 const char *filename;
01ffc75b 1034 struct target_pt_regs regs1, *regs = &regs1;
31e31b8a 1035 struct image_info info1, *info = &info1;
851e67a1 1036 TaskState ts1, *ts = &ts1;
b346ff46 1037 CPUState *env;
586314f2 1038 int optind;
d691f669 1039 const char *r;
1fddef4b 1040 int use_gdbstub = 0;
d691f669 1041
31e31b8a
FB		 1042 if (argc <= 1)
1043 usage();
f801f97e 1044
cc38b844
FB		 1045 /* init debug */
1046 cpu_set_log_filename(DEBUG_LOGFILE);
1047
586314f2 1048 optind = 1;
d691f669
FB		 1049 for(;;) {
1050 if (optind >= argc)
1051 break;
1052 r = argv[optind];
1053 if (r[0] != '-')
1054 break;
586314f2 1055 optind++;
d691f669
FB		 1056 r++;
1057 if (!strcmp(r, "-")) {
1058 break;
1059 } else if (!strcmp(r, "d")) {
e19e89a5
FB		 1060 int mask;
1061 CPULogItem *item;
6f1f31c0
FB		 1062
1063 if (optind >= argc)
1064 break;
e19e89a5 1065
6f1f31c0
FB		 1066 r = argv[optind++];
1067 mask = cpu_str_to_log_mask(r);
e19e89a5
FB		 1068 if (!mask) {
1069 printf("Log items (comma separated):\n");
1070 for(item = cpu_log_items; item->mask != 0; item++) {
1071 printf("%-10s %s\n", item->name, item->help);
1072 }
1073 exit(1);
1074 }
1075 cpu_set_log(mask);
d691f669
FB		 1076 } else if (!strcmp(r, "s")) {
1077 r = argv[optind++];
1078 x86_stack_size = strtol(r, (char **)&r, 0);
1079 if (x86_stack_size <= 0)
1080 usage();
1081 if (*r == 'M')
1082 x86_stack_size *= 1024 * 1024;
1083 else if (*r == 'k' || *r == 'K')
1084 x86_stack_size *= 1024;
1085 } else if (!strcmp(r, "L")) {
1086 interp_prefix = argv[optind++];
54936004 1087 } else if (!strcmp(r, "p")) {
83fb7adf
FB		 1088 qemu_host_page_size = atoi(argv[optind++]);
1089 if (qemu_host_page_size == 0 ||
1090 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
54936004
FB		 1091 fprintf(stderr, "page size must be a power of two\n");
1092 exit(1);
1093 }
1fddef4b
FB		 1094 } else if (!strcmp(r, "g")) {
1095 use_gdbstub = 1;
c6981055
FB		 1096 } else
1097#ifdef USE_CODE_COPY
1098 if (!strcmp(r, "no-code-copy")) {
1099 code_copy_enabled = 0;
1100 } else
1101#endif
1102 {
d691f669
FB		 1103 usage();
1104 }
586314f2 1105 }
d691f669
FB		 1106 if (optind >= argc)
1107 usage();
586314f2
FB		 1108 filename = argv[optind];
1109
31e31b8a 1110 /* Zero out regs */
01ffc75b 1111 memset(regs, 0, sizeof(struct target_pt_regs));
31e31b8a
FB		 1112
1113 /* Zero out image_info */
1114 memset(info, 0, sizeof(struct image_info));
1115
74cd30b8
FB		 1116 /* Scan interp_prefix dir for replacement files. */
1117 init_paths(interp_prefix);
1118
83fb7adf
FB		 1119 /* NOTE: we need to init the CPU at this stage to get
1120 qemu_host_page_size */
b346ff46 1121 env = cpu_init();
92ccca6a 1122
74cd30b8 1123 if (elf_exec(filename, argv+optind, environ, regs, info) != 0) {
31e31b8a 1124 printf("Error loading %s\n", filename);
74cd30b8 1125 _exit(1);
31e31b8a
FB		 1126 }
1127
4b74fe1f 1128 if (loglevel) {
54936004
FB		 1129 page_dump(logfile);
1130
4b74fe1f
FB		 1131 fprintf(logfile, "start_brk 0x%08lx\n" , info->start_brk);
1132 fprintf(logfile, "end_code 0x%08lx\n" , info->end_code);
1133 fprintf(logfile, "start_code 0x%08lx\n" , info->start_code);
1134 fprintf(logfile, "end_data 0x%08lx\n" , info->end_data);
1135 fprintf(logfile, "start_stack 0x%08lx\n" , info->start_stack);
1136 fprintf(logfile, "brk 0x%08lx\n" , info->brk);
b346ff46 1137 fprintf(logfile, "entry 0x%08lx\n" , info->entry);
4b74fe1f 1138 }
31e31b8a
FB		 1139
1140 target_set_brk((char *)info->brk);
1141 syscall_init();
66fb9763 1142 signal_init();
31e31b8a 1143
9de5e440 1144 global_env = env;
0ecfa993 1145
851e67a1
FB		 1146 /* build Task State */
1147 memset(ts, 0, sizeof(TaskState));
1148 env->opaque = ts;
1149 ts->used = 1;
59faf6d6 1150 env->user_mode_only = 1;
851e67a1 1151
b346ff46 1152#if defined(TARGET_I386)
2e255c6b
FB		 1153 cpu_x86_set_cpl(env, 3);
1154
3802ce26 1155 env->cr[0] = CR0_PG_MASK | CR0_WP_MASK | CR0_PE_MASK;
1bde465e
FB		 1156 env->hflags |= HF_PE_MASK;
1157 if (env->cpuid_features & CPUID_SSE) {
1158 env->cr[4] |= CR4_OSFXSR_MASK;
1159 env->hflags |= HF_OSFXSR_MASK;
1160 }
1161
415e561f
FB		 1162 /* flags setup : we activate the IRQs by default as in user mode */
1163 env->eflags |= IF_MASK;
1164
6dbad63e 1165 /* linux register setup */
0ecfa993
FB		 1166 env->regs[R_EAX] = regs->eax;
1167 env->regs[R_EBX] = regs->ebx;
1168 env->regs[R_ECX] = regs->ecx;
1169 env->regs[R_EDX] = regs->edx;
1170 env->regs[R_ESI] = regs->esi;
1171 env->regs[R_EDI] = regs->edi;
1172 env->regs[R_EBP] = regs->ebp;
1173 env->regs[R_ESP] = regs->esp;
dab2ed99 1174 env->eip = regs->eip;
31e31b8a 1175
f4beb510 1176 /* linux interrupt setup */
80a9d035 1177 env->idt.base = (long)idt_table;
f4beb510
FB		 1178 env->idt.limit = sizeof(idt_table) - 1;
1179 set_idt(0, 0);
1180 set_idt(1, 0);
1181 set_idt(2, 0);
1182 set_idt(3, 3);
1183 set_idt(4, 3);
1184 set_idt(5, 3);
1185 set_idt(6, 0);
1186 set_idt(7, 0);
1187 set_idt(8, 0);
1188 set_idt(9, 0);
1189 set_idt(10, 0);
1190 set_idt(11, 0);
1191 set_idt(12, 0);
1192 set_idt(13, 0);
1193 set_idt(14, 0);
1194 set_idt(15, 0);
1195 set_idt(16, 0);
1196 set_idt(17, 0);
1197 set_idt(18, 0);
1198 set_idt(19, 0);
1199 set_idt(0x80, 3);
1200
6dbad63e 1201 /* linux segment setup */
80a9d035 1202 env->gdt.base = (long)gdt_table;
6dbad63e 1203 env->gdt.limit = sizeof(gdt_table) - 1;
f4beb510
FB		 1204 write_dt(&gdt_table[__USER_CS >> 3], 0, 0xfffff,
1205 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
1206 (3 << DESC_DPL_SHIFT) | (0xa << DESC_TYPE_SHIFT));
1207 write_dt(&gdt_table[__USER_DS >> 3], 0, 0xfffff,
1208 DESC_G_MASK | DESC_B_MASK | DESC_P_MASK | DESC_S_MASK |
1209 (3 << DESC_DPL_SHIFT) | (0x2 << DESC_TYPE_SHIFT));
6dbad63e
FB		 1210 cpu_x86_load_seg(env, R_CS, __USER_CS);
1211 cpu_x86_load_seg(env, R_DS, __USER_DS);
1212 cpu_x86_load_seg(env, R_ES, __USER_DS);
1213 cpu_x86_load_seg(env, R_SS, __USER_DS);
1214 cpu_x86_load_seg(env, R_FS, __USER_DS);
1215 cpu_x86_load_seg(env, R_GS, __USER_DS);
92ccca6a 1216
b346ff46
FB		 1217#elif defined(TARGET_ARM)
1218 {
1219 int i;
1220 for(i = 0; i < 16; i++) {
1221 env->regs[i] = regs->uregs[i];
1222 }
1223 env->cpsr = regs->uregs[16];
a4f81979
FB		 1224 ts->stack_base = info->start_stack;
1225 ts->heap_base = info->brk;
1226 /* This will be filled in on the first SYS_HEAPINFO call. */
1227 ts->heap_limit = 0;
b346ff46 1228 }
93ac68bc 1229#elif defined(TARGET_SPARC)
060366c5
FB		 1230 {
1231 int i;
1232 env->pc = regs->pc;
1233 env->npc = regs->npc;
1234 env->y = regs->y;
1235 for(i = 0; i < 8; i++)
1236 env->gregs[i] = regs->u_regs[i];
1237 for(i = 0; i < 8; i++)
1238 env->regwptr[i] = regs->u_regs[i + 8];
1239 }
67867308
FB		 1240#elif defined(TARGET_PPC)
1241 {
1242 int i;
61190b14 1243 for (i = 0; i < 32; i++) {
4c2e770f 1244 if (i != 12 && i != 6 && i != 13)
61190b14
FB		 1245 env->msr[i] = (regs->msr >> i) & 1;
1246 }
67867308
FB		 1247 env->nip = regs->nip;
1248 for(i = 0; i < 32; i++) {
1249 env->gpr[i] = regs->gpr[i];
1250 }
1251 }
b346ff46
FB		 1252#else
1253#error unsupported target CPU
1254#endif
31e31b8a 1255
1fddef4b
FB		 1256 if (use_gdbstub) {
1257 gdbserver_start (DEFAULT_GDBSTUB_PORT);
1258 gdb_handlesig(env, 0);
1259 }
1b6b029e
FB		 1260 cpu_loop(env);
1261 /* never exits */
31e31b8a
FB		 1262 return 0;
1263}
QEMU mirror