?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Change -drive parsing so that paths don't have to be double-escaped (Laurent Vivier...
[qemu/qemu_0_9_1_stable.git] / cpu-exec.c
blob8134c229c5ea0cee864da59daf11a26b75b5bd5c
1 /*
2 * i386 emulator main execution loop
3 *
4 * Copyright (c) 2003-2005 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20 #include "config.h"
21 #include "exec.h"
22 #include "disas.h"
23
24 #if !defined(CONFIG_SOFTMMU)
25 #undef EAX
26 #undef ECX
27 #undef EDX
28 #undef EBX
29 #undef ESP
30 #undef EBP
31 #undef ESI
32 #undef EDI
33 #undef EIP
34 #include <signal.h>
35 #include <sys/ucontext.h>
36 #endif
37
38 int tb_invalidated_flag;
39
40 //#define DEBUG_EXEC
41 //#define DEBUG_SIGNAL
42
43 #define SAVE_GLOBALS()
44 #define RESTORE_GLOBALS()
45
46 #if defined(__sparc__) && !defined(HOST_SOLARIS)
47 #include <features.h>
48 #if defined(__GLIBC__) && ((__GLIBC__ < 2) || \
49 ((__GLIBC__ == 2) && (__GLIBC_MINOR__ <= 90)))
50 // Work around ugly bugs in glibc that mangle global register contents
51
52 static volatile void *saved_env;
53 static volatile unsigned long saved_t0, saved_i7;
54 #undef SAVE_GLOBALS
55 #define SAVE_GLOBALS() do { \
56 saved_env = env; \
57 saved_t0 = T0; \
58 asm volatile ("st %%i7, [%0]" : : "r" (&saved_i7)); \
59 } while(0)
60
61 #undef RESTORE_GLOBALS
62 #define RESTORE_GLOBALS() do { \
63 env = (void *)saved_env; \
64 T0 = saved_t0; \
65 asm volatile ("ld [%0], %%i7" : : "r" (&saved_i7)); \
66 } while(0)
67
68 static int sparc_setjmp(jmp_buf buf)
69 {
70 int ret;
71
72 SAVE_GLOBALS();
73 ret = setjmp(buf);
74 RESTORE_GLOBALS();
75 return ret;
76 }
77 #undef setjmp
78 #define setjmp(jmp_buf) sparc_setjmp(jmp_buf)
79
80 static void sparc_longjmp(jmp_buf buf, int val)
81 {
82 SAVE_GLOBALS();
83 longjmp(buf, val);
84 }
85 #define longjmp(jmp_buf, val) sparc_longjmp(jmp_buf, val)
86 #endif
87 #endif
88
89 void cpu_loop_exit(void)
90 {
91 /* NOTE: the register at this point must be saved by hand because
92 longjmp restore them */
93 regs_to_env();
94 longjmp(env->jmp_env, 1);
95 }
96
97 #if !(defined(TARGET_SPARC) || defined(TARGET_SH4) || defined(TARGET_M68K))
98 #define reg_T2
99 #endif
100
101 /* exit the current TB from a signal handler. The host registers are
102 restored in a state compatible with the CPU emulator
103 */
104 void cpu_resume_from_signal(CPUState *env1, void *puc)
105 {
106 #if !defined(CONFIG_SOFTMMU)
107 struct ucontext *uc = puc;
108 #endif
109
110 env = env1;
111
112 /* XXX: restore cpu registers saved in host registers */
113
114 #if !defined(CONFIG_SOFTMMU)
115 if (puc) {
116 /* XXX: use siglongjmp ? */
117 sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
118 }
119 #endif
120 longjmp(env->jmp_env, 1);
121 }
122
123
124 static TranslationBlock *tb_find_slow(target_ulong pc,
125 target_ulong cs_base,
126 uint64_t flags)
127 {
128 TranslationBlock *tb, **ptb1;
129 int code_gen_size;
130 unsigned int h;
131 target_ulong phys_pc, phys_page1, phys_page2, virt_page2;
132 uint8_t *tc_ptr;
133
134 spin_lock(&tb_lock);
135
136 tb_invalidated_flag = 0;
137
138 regs_to_env(); /* XXX: do it just before cpu_gen_code() */
139
140 /* find translated block using physical mappings */
141 phys_pc = get_phys_addr_code(env, pc);
142 phys_page1 = phys_pc & TARGET_PAGE_MASK;
143 phys_page2 = -1;
144 h = tb_phys_hash_func(phys_pc);
145 ptb1 = &tb_phys_hash[h];
146 for(;;) {
147 tb = *ptb1;
148 if (!tb)
149 goto not_found;
150 if (tb->pc == pc &&
151 tb->page_addr[0] == phys_page1 &&
152 tb->cs_base == cs_base &&
153 tb->flags == flags) {
154 /* check next page if needed */
155 if (tb->page_addr[1] != -1) {
156 virt_page2 = (pc & TARGET_PAGE_MASK) +
157 TARGET_PAGE_SIZE;
158 phys_page2 = get_phys_addr_code(env, virt_page2);
159 if (tb->page_addr[1] == phys_page2)
160 goto found;
161 } else {
162 goto found;
163 }
164 }
165 ptb1 = &tb->phys_hash_next;
166 }
167 not_found:
168 /* if no translated code available, then translate it now */
169 tb = tb_alloc(pc);
170 if (!tb) {
171 /* flush must be done */
172 tb_flush(env);
173 /* cannot fail at this point */
174 tb = tb_alloc(pc);
175 /* don't forget to invalidate previous TB info */
176 tb_invalidated_flag = 1;
177 }
178 tc_ptr = code_gen_ptr;
179 tb->tc_ptr = tc_ptr;
180 tb->cs_base = cs_base;
181 tb->flags = flags;
182 SAVE_GLOBALS();
183 cpu_gen_code(env, tb, &code_gen_size);
184 RESTORE_GLOBALS();
185 code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1));
186
187 /* check next page if needed */
188 virt_page2 = (pc + tb->size - 1) & TARGET_PAGE_MASK;
189 phys_page2 = -1;
190 if ((pc & TARGET_PAGE_MASK) != virt_page2) {
191 phys_page2 = get_phys_addr_code(env, virt_page2);
192 }
193 tb_link_phys(tb, phys_pc, phys_page2);
194
195 found:
196 /* we add the TB in the virtual pc hash table */
197 env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)] = tb;
198 spin_unlock(&tb_lock);
199 return tb;
200 }
201
202 static inline TranslationBlock *tb_find_fast(void)
203 {
204 TranslationBlock *tb;
205 target_ulong cs_base, pc;
206 uint64_t flags;
207
208 /* we record a subset of the CPU state. It will
209 always be the same before a given translated block
210 is executed. */
211 #if defined(TARGET_I386)
212 flags = env->hflags;
213 flags |= (env->eflags & (IOPL_MASK | TF_MASK | VM_MASK));
214 flags |= env->intercept;
215 cs_base = env->segs[R_CS].base;
216 pc = cs_base + env->eip;
217 #elif defined(TARGET_ARM)
218 flags = env->thumb | (env->vfp.vec_len << 1)
219 | (env->vfp.vec_stride << 4);
220 if ((env->uncached_cpsr & CPSR_M) != ARM_CPU_MODE_USR)
221 flags |= (1 << 6);
222 if (env->vfp.xregs[ARM_VFP_FPEXC] & (1 << 30))
223 flags |= (1 << 7);
224 flags |= (env->condexec_bits << 8);
225 cs_base = 0;
226 pc = env->regs[15];
227 #elif defined(TARGET_SPARC)
228 #ifdef TARGET_SPARC64
229 // Combined FPU enable bits . PRIV . DMMU enabled . IMMU enabled
230 flags = (((env->pstate & PS_PEF) >> 1) | ((env->fprs & FPRS_FEF) << 2))
231 | (env->pstate & PS_PRIV) | ((env->lsu & (DMMU_E | IMMU_E)) >> 2);
232 #else
233 // FPU enable . Supervisor
234 flags = (env->psref << 4) | env->psrs;
235 #endif
236 cs_base = env->npc;
237 pc = env->pc;
238 #elif defined(TARGET_PPC)
239 flags = env->hflags;
240 cs_base = 0;
241 pc = env->nip;
242 #elif defined(TARGET_MIPS)
243 flags = env->hflags & (MIPS_HFLAG_TMASK | MIPS_HFLAG_BMASK);
244 cs_base = 0;
245 pc = env->PC[env->current_tc];
246 #elif defined(TARGET_M68K)
247 flags = (env->fpcr & M68K_FPCR_PREC) /* Bit 6 */
248 | (env->sr & SR_S) /* Bit 13 */
249 | ((env->macsr >> 4) & 0xf); /* Bits 0-3 */
250 cs_base = 0;
251 pc = env->pc;
252 #elif defined(TARGET_SH4)
253 flags = env->flags;
254 cs_base = 0;
255 pc = env->pc;
256 #elif defined(TARGET_ALPHA)
257 flags = env->ps;
258 cs_base = 0;
259 pc = env->pc;
260 #elif defined(TARGET_CRIS)
261 flags = 0;
262 cs_base = 0;
263 pc = env->pc;
264 #else
265 #error unsupported CPU
266 #endif
267 tb = env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)];
268 if (__builtin_expect(!tb || tb->pc != pc || tb->cs_base != cs_base ||
269 tb->flags != flags, 0)) {
270 tb = tb_find_slow(pc, cs_base, flags);
271 /* Note: we do it here to avoid a gcc bug on Mac OS X when
272 doing it in tb_find_slow */
273 if (tb_invalidated_flag) {
274 /* as some TB could have been invalidated because
275 of memory exceptions while generating the code, we
276 must recompute the hash index here */
277 T0 = 0;
278 }
279 }
280 return tb;
281 }
282
283 #define BREAK_CHAIN T0 = 0
284
285 /* main execution loop */
286
287 int cpu_exec(CPUState *env1)
288 {
289 #define DECLARE_HOST_REGS 1
290 #include "hostregs_helper.h"
291 #if defined(TARGET_SPARC)
292 #if defined(reg_REGWPTR)
293 uint32_t *saved_regwptr;
294 #endif
295 #endif
296 int ret, interrupt_request;
297 void (*gen_func)(void);
298 TranslationBlock *tb;
299 uint8_t *tc_ptr;
300
301 if (cpu_halted(env1) == EXCP_HALTED)
302 return EXCP_HALTED;
303
304 cpu_single_env = env1;
305
306 /* first we save global registers */
307 #define SAVE_HOST_REGS 1
308 #include "hostregs_helper.h"
309 env = env1;
310 SAVE_GLOBALS();
311
312 env_to_regs();
313 #if defined(TARGET_I386)
314 /* put eflags in CPU temporary format */
315 CC_SRC = env->eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
316 DF = 1 - (2 * ((env->eflags >> 10) & 1));
317 CC_OP = CC_OP_EFLAGS;
318 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
319 #elif defined(TARGET_SPARC)
320 #if defined(reg_REGWPTR)
321 saved_regwptr = REGWPTR;
322 #endif
323 #elif defined(TARGET_M68K)
324 env->cc_op = CC_OP_FLAGS;
325 env->cc_dest = env->sr & 0xf;
326 env->cc_x = (env->sr >> 4) & 1;
327 #elif defined(TARGET_ALPHA)
328 #elif defined(TARGET_ARM)
329 #elif defined(TARGET_PPC)
330 #elif defined(TARGET_MIPS)
331 #elif defined(TARGET_SH4)
332 #elif defined(TARGET_CRIS)
333 /* XXXXX */
334 #else
335 #error unsupported target CPU
336 #endif
337 env->exception_index = -1;
338
339 /* prepare setjmp context for exception handling */
340 for(;;) {
341 if (setjmp(env->jmp_env) == 0) {
342 env->current_tb = NULL;
343 /* if an exception is pending, we execute it here */
344 if (env->exception_index >= 0) {
345 if (env->exception_index >= EXCP_INTERRUPT) {
346 /* exit request from the cpu execution loop */
347 ret = env->exception_index;
348 break;
349 } else if (env->user_mode_only) {
350 /* if user mode only, we simulate a fake exception
351 which will be handled outside the cpu execution
352 loop */
353 #if defined(TARGET_I386)
354 do_interrupt_user(env->exception_index,
355 env->exception_is_int,
356 env->error_code,
357 env->exception_next_eip);
358 #endif
359 ret = env->exception_index;
360 break;
361 } else {
362 #if defined(TARGET_I386)
363 /* simulate a real cpu exception. On i386, it can
364 trigger new exceptions, but we do not handle
365 double or triple faults yet. */
366 do_interrupt(env->exception_index,
367 env->exception_is_int,
368 env->error_code,
369 env->exception_next_eip, 0);
370 /* successfully delivered */
371 env->old_exception = -1;
372 #elif defined(TARGET_PPC)
373 do_interrupt(env);
374 #elif defined(TARGET_MIPS)
375 do_interrupt(env);
376 #elif defined(TARGET_SPARC)
377 do_interrupt(env->exception_index);
378 #elif defined(TARGET_ARM)
379 do_interrupt(env);
380 #elif defined(TARGET_SH4)
381 do_interrupt(env);
382 #elif defined(TARGET_ALPHA)
383 do_interrupt(env);
384 #elif defined(TARGET_CRIS)
385 do_interrupt(env);
386 #elif defined(TARGET_M68K)
387 do_interrupt(0);
388 #endif
389 }
390 env->exception_index = -1;
391 }
392 #ifdef USE_KQEMU
393 if (kqemu_is_ok(env) && env->interrupt_request == 0) {
394 int ret;
395 env->eflags = env->eflags | cc_table[CC_OP].compute_all() | (DF & DF_MASK);
396 ret = kqemu_cpu_exec(env);
397 /* put eflags in CPU temporary format */
398 CC_SRC = env->eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
399 DF = 1 - (2 * ((env->eflags >> 10) & 1));
400 CC_OP = CC_OP_EFLAGS;
401 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
402 if (ret == 1) {
403 /* exception */
404 longjmp(env->jmp_env, 1);
405 } else if (ret == 2) {
406 /* softmmu execution needed */
407 } else {
408 if (env->interrupt_request != 0) {
409 /* hardware interrupt will be executed just after */
410 } else {
411 /* otherwise, we restart */
412 longjmp(env->jmp_env, 1);
413 }
414 }
415 }
416 #endif
417
418 T0 = 0; /* force lookup of first TB */
419 for(;;) {
420 SAVE_GLOBALS();
421 interrupt_request = env->interrupt_request;
422 if (__builtin_expect(interrupt_request, 0)
423 #if defined(TARGET_I386)
424 && env->hflags & HF_GIF_MASK
425 #endif
426 ) {
427 if (interrupt_request & CPU_INTERRUPT_DEBUG) {
428 env->interrupt_request &= ~CPU_INTERRUPT_DEBUG;
429 env->exception_index = EXCP_DEBUG;
430 cpu_loop_exit();
431 }
432 #if defined(TARGET_ARM) || defined(TARGET_SPARC) || defined(TARGET_MIPS) || \
433 defined(TARGET_PPC) || defined(TARGET_ALPHA) || defined(TARGET_CRIS)
434 if (interrupt_request & CPU_INTERRUPT_HALT) {
435 env->interrupt_request &= ~CPU_INTERRUPT_HALT;
436 env->halted = 1;
437 env->exception_index = EXCP_HLT;
438 cpu_loop_exit();
439 }
440 #endif
441 #if defined(TARGET_I386)
442 if ((interrupt_request & CPU_INTERRUPT_SMI) &&
443 !(env->hflags & HF_SMM_MASK)) {
444 svm_check_intercept(SVM_EXIT_SMI);
445 env->interrupt_request &= ~CPU_INTERRUPT_SMI;
446 do_smm_enter();
447 BREAK_CHAIN;
448 } else if ((interrupt_request & CPU_INTERRUPT_HARD) &&
449 (env->eflags & IF_MASK || env->hflags & HF_HIF_MASK) &&
450 !(env->hflags & HF_INHIBIT_IRQ_MASK)) {
451 int intno;
452 svm_check_intercept(SVM_EXIT_INTR);
453 env->interrupt_request &= ~(CPU_INTERRUPT_HARD | CPU_INTERRUPT_VIRQ);
454 intno = cpu_get_pic_interrupt(env);
455 if (loglevel & CPU_LOG_TB_IN_ASM) {
456 fprintf(logfile, "Servicing hardware INT=0x%02x\n", intno);
457 }
458 do_interrupt(intno, 0, 0, 0, 1);
459 /* ensure that no TB jump will be modified as
460 the program flow was changed */
461 BREAK_CHAIN;
462 #if !defined(CONFIG_USER_ONLY)
463 } else if ((interrupt_request & CPU_INTERRUPT_VIRQ) &&
464 (env->eflags & IF_MASK) && !(env->hflags & HF_INHIBIT_IRQ_MASK)) {
465 int intno;
466 /* FIXME: this should respect TPR */
467 env->interrupt_request &= ~CPU_INTERRUPT_VIRQ;
468 svm_check_intercept(SVM_EXIT_VINTR);
469 intno = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_vector));
470 if (loglevel & CPU_LOG_TB_IN_ASM)
471 fprintf(logfile, "Servicing virtual hardware INT=0x%02x\n", intno);
472 do_interrupt(intno, 0, 0, -1, 1);
473 stl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl),
474 ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_ctl)) & ~V_IRQ_MASK);
475 BREAK_CHAIN;
476 #endif
477 }
478 #elif defined(TARGET_PPC)
479 #if 0
480 if ((interrupt_request & CPU_INTERRUPT_RESET)) {
481 cpu_ppc_reset(env);
482 }
483 #endif
484 if (interrupt_request & CPU_INTERRUPT_HARD) {
485 ppc_hw_interrupt(env);
486 if (env->pending_interrupts == 0)
487 env->interrupt_request &= ~CPU_INTERRUPT_HARD;
488 BREAK_CHAIN;
489 }
490 #elif defined(TARGET_MIPS)
491 if ((interrupt_request & CPU_INTERRUPT_HARD) &&
492 (env->CP0_Status & env->CP0_Cause & CP0Ca_IP_mask) &&
493 (env->CP0_Status & (1 << CP0St_IE)) &&
494 !(env->CP0_Status & (1 << CP0St_EXL)) &&
495 !(env->CP0_Status & (1 << CP0St_ERL)) &&
496 !(env->hflags & MIPS_HFLAG_DM)) {
497 /* Raise it */
498 env->exception_index = EXCP_EXT_INTERRUPT;
499 env->error_code = 0;
500 do_interrupt(env);
501 BREAK_CHAIN;
502 }
503 #elif defined(TARGET_SPARC)
504 if ((interrupt_request & CPU_INTERRUPT_HARD) &&
505 (env->psret != 0)) {
506 int pil = env->interrupt_index & 15;
507 int type = env->interrupt_index & 0xf0;
508
509 if (((type == TT_EXTINT) &&
510 (pil == 15 || pil > env->psrpil)) ||
511 type != TT_EXTINT) {
512 env->interrupt_request &= ~CPU_INTERRUPT_HARD;
513 do_interrupt(env->interrupt_index);
514 env->interrupt_index = 0;
515 #if !defined(TARGET_SPARC64) && !defined(CONFIG_USER_ONLY)
516 cpu_check_irqs(env);
517 #endif
518 BREAK_CHAIN;
519 }
520 } else if (interrupt_request & CPU_INTERRUPT_TIMER) {
521 //do_interrupt(0, 0, 0, 0, 0);
522 env->interrupt_request &= ~CPU_INTERRUPT_TIMER;
523 }
524 #elif defined(TARGET_ARM)
525 if (interrupt_request & CPU_INTERRUPT_FIQ
526 && !(env->uncached_cpsr & CPSR_F)) {
527 env->exception_index = EXCP_FIQ;
528 do_interrupt(env);
529 BREAK_CHAIN;
530 }
531 /* ARMv7-M interrupt return works by loading a magic value
532 into the PC. On real hardware the load causes the
533 return to occur. The qemu implementation performs the
534 jump normally, then does the exception return when the
535 CPU tries to execute code at the magic address.
536 This will cause the magic PC value to be pushed to
537 the stack if an interrupt occured at the wrong time.
538 We avoid this by disabling interrupts when
539 pc contains a magic address. */
540 if (interrupt_request & CPU_INTERRUPT_HARD
541 && ((IS_M(env) && env->regs[15] < 0xfffffff0)
542 || !(env->uncached_cpsr & CPSR_I))) {
543 env->exception_index = EXCP_IRQ;
544 do_interrupt(env);
545 BREAK_CHAIN;
546 }
547 #elif defined(TARGET_SH4)
548 if (interrupt_request & CPU_INTERRUPT_HARD) {
549 do_interrupt(env);
550 BREAK_CHAIN;
551 }
552 #elif defined(TARGET_ALPHA)
553 if (interrupt_request & CPU_INTERRUPT_HARD) {
554 do_interrupt(env);
555 BREAK_CHAIN;
556 }
557 #elif defined(TARGET_CRIS)
558 if (interrupt_request & CPU_INTERRUPT_HARD) {
559 do_interrupt(env);
560 env->interrupt_request &= ~CPU_INTERRUPT_HARD;
561 BREAK_CHAIN;
562 }
563 #elif defined(TARGET_M68K)
564 if (interrupt_request & CPU_INTERRUPT_HARD
565 && ((env->sr & SR_I) >> SR_I_SHIFT)
566 < env->pending_level) {
567 /* Real hardware gets the interrupt vector via an
568 IACK cycle at this point. Current emulated
569 hardware doesn't rely on this, so we
570 provide/save the vector when the interrupt is
571 first signalled. */
572 env->exception_index = env->pending_vector;
573 do_interrupt(1);
574 BREAK_CHAIN;
575 }
576 #endif
577 /* Don't use the cached interupt_request value,
578 do_interrupt may have updated the EXITTB flag. */
579 if (env->interrupt_request & CPU_INTERRUPT_EXITTB) {
580 env->interrupt_request &= ~CPU_INTERRUPT_EXITTB;
581 /* ensure that no TB jump will be modified as
582 the program flow was changed */
583 BREAK_CHAIN;
584 }
585 if (interrupt_request & CPU_INTERRUPT_EXIT) {
586 env->interrupt_request &= ~CPU_INTERRUPT_EXIT;
587 env->exception_index = EXCP_INTERRUPT;
588 cpu_loop_exit();
589 }
590 }
591 #ifdef DEBUG_EXEC
592 if ((loglevel & CPU_LOG_TB_CPU)) {
593 /* restore flags in standard format */
594 regs_to_env();
595 #if defined(TARGET_I386)
596 env->eflags = env->eflags | cc_table[CC_OP].compute_all() | (DF & DF_MASK);
597 cpu_dump_state(env, logfile, fprintf, X86_DUMP_CCOP);
598 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
599 #elif defined(TARGET_ARM)
600 cpu_dump_state(env, logfile, fprintf, 0);
601 #elif defined(TARGET_SPARC)
602 REGWPTR = env->regbase + (env->cwp * 16);
603 env->regwptr = REGWPTR;
604 cpu_dump_state(env, logfile, fprintf, 0);
605 #elif defined(TARGET_PPC)
606 cpu_dump_state(env, logfile, fprintf, 0);
607 #elif defined(TARGET_M68K)
608 cpu_m68k_flush_flags(env, env->cc_op);
609 env->cc_op = CC_OP_FLAGS;
610 env->sr = (env->sr & 0xffe0)
611 | env->cc_dest | (env->cc_x << 4);
612 cpu_dump_state(env, logfile, fprintf, 0);
613 #elif defined(TARGET_MIPS)
614 cpu_dump_state(env, logfile, fprintf, 0);
615 #elif defined(TARGET_SH4)
616 cpu_dump_state(env, logfile, fprintf, 0);
617 #elif defined(TARGET_ALPHA)
618 cpu_dump_state(env, logfile, fprintf, 0);
619 #elif defined(TARGET_CRIS)
620 cpu_dump_state(env, logfile, fprintf, 0);
621 #else
622 #error unsupported target CPU
623 #endif
624 }
625 #endif
626 tb = tb_find_fast();
627 #ifdef DEBUG_EXEC
628 if ((loglevel & CPU_LOG_EXEC)) {
629 fprintf(logfile, "Trace 0x%08lx [" TARGET_FMT_lx "] %s\n",
630 (long)tb->tc_ptr, tb->pc,
631 lookup_symbol(tb->pc));
632 }
633 #endif
634 RESTORE_GLOBALS();
635 /* see if we can patch the calling TB. When the TB
636 spans two pages, we cannot safely do a direct
637 jump. */
638 {
639 if (T0 != 0 &&
640 #if USE_KQEMU
641 (env->kqemu_enabled != 2) &&
642 #endif
643 tb->page_addr[1] == -1) {
644 spin_lock(&tb_lock);
645 tb_add_jump((TranslationBlock *)(long)(T0 & ~3), T0 & 3, tb);
646 spin_unlock(&tb_lock);
647 }
648 }
649 tc_ptr = tb->tc_ptr;
650 env->current_tb = tb;
651 /* execute the generated code */
652 gen_func = (void *)tc_ptr;
653 #if defined(__sparc__)
654 __asm__ __volatile__("call %0\n\t"
655 "mov %%o7,%%i0"
656 : /* no outputs */
657 : "r" (gen_func)
658 : "i0", "i1", "i2", "i3", "i4", "i5",
659 "o0", "o1", "o2", "o3", "o4", "o5",
660 "l0", "l1", "l2", "l3", "l4", "l5",
661 "l6", "l7");
662 #elif defined(__arm__)
663 asm volatile ("mov pc, %0\n\t"
664 ".global exec_loop\n\t"
665 "exec_loop:\n\t"
666 : /* no outputs */
667 : "r" (gen_func)
668 : "r1", "r2", "r3", "r8", "r9", "r10", "r12", "r14");
669 #elif defined(__ia64)
670 struct fptr {
671 void *ip;
672 void *gp;
673 } fp;
674
675 fp.ip = tc_ptr;
676 fp.gp = code_gen_buffer + 2 * (1 << 20);
677 (*(void (*)(void)) &fp)();
678 #else
679 gen_func();
680 #endif
681 env->current_tb = NULL;
682 /* reset soft MMU for next block (it can currently
683 only be set by a memory fault) */
684 #if defined(TARGET_I386) && !defined(CONFIG_SOFTMMU)
685 if (env->hflags & HF_SOFTMMU_MASK) {
686 env->hflags &= ~HF_SOFTMMU_MASK;
687 /* do not allow linking to another block */
688 T0 = 0;
689 }
690 #endif
691 #if defined(USE_KQEMU)
692 #define MIN_CYCLE_BEFORE_SWITCH (100 * 1000)
693 if (kqemu_is_ok(env) &&
694 (cpu_get_time_fast() - env->last_io_time) >= MIN_CYCLE_BEFORE_SWITCH) {
695 cpu_loop_exit();
696 }
697 #endif
698 } /* for(;;) */
699 } else {
700 env_to_regs();
701 }
702 } /* for(;;) */
703
704
705 #if defined(TARGET_I386)
706 /* restore flags in standard format */
707 env->eflags = env->eflags | cc_table[CC_OP].compute_all() | (DF & DF_MASK);
708 #elif defined(TARGET_ARM)
709 /* XXX: Save/restore host fpu exception state?. */
710 #elif defined(TARGET_SPARC)
711 #if defined(reg_REGWPTR)
712 REGWPTR = saved_regwptr;
713 #endif
714 #elif defined(TARGET_PPC)
715 #elif defined(TARGET_M68K)
716 cpu_m68k_flush_flags(env, env->cc_op);
717 env->cc_op = CC_OP_FLAGS;
718 env->sr = (env->sr & 0xffe0)
719 | env->cc_dest | (env->cc_x << 4);
720 #elif defined(TARGET_MIPS)
721 #elif defined(TARGET_SH4)
722 #elif defined(TARGET_ALPHA)
723 #elif defined(TARGET_CRIS)
724 /* XXXXX */
725 #else
726 #error unsupported target CPU
727 #endif
728
729 /* restore global registers */
730 RESTORE_GLOBALS();
731 #include "hostregs_helper.h"
732
733 /* fail safe : never use cpu_single_env outside cpu_exec() */
734 cpu_single_env = NULL;
735 return ret;
736 }
737
738 /* must only be called from the generated code as an exception can be
739 generated */
740 void tb_invalidate_page_range(target_ulong start, target_ulong end)
741 {
742 /* XXX: cannot enable it yet because it yields to MMU exception
743 where NIP != read address on PowerPC */
744 #if 0
745 target_ulong phys_addr;
746 phys_addr = get_phys_addr_code(env, start);
747 tb_invalidate_phys_page_range(phys_addr, phys_addr + end - start, 0);
748 #endif
749 }
750
751 #if defined(TARGET_I386) && defined(CONFIG_USER_ONLY)
752
753 void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector)
754 {
755 CPUX86State *saved_env;
756
757 saved_env = env;
758 env = s;
759 if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK)) {
760 selector &= 0xffff;
761 cpu_x86_load_seg_cache(env, seg_reg, selector,
762 (selector << 4), 0xffff, 0);
763 } else {
764 load_seg(seg_reg, selector);
765 }
766 env = saved_env;
767 }
768
769 void cpu_x86_fsave(CPUX86State *s, target_ulong ptr, int data32)
770 {
771 CPUX86State *saved_env;
772
773 saved_env = env;
774 env = s;
775
776 helper_fsave(ptr, data32);
777
778 env = saved_env;
779 }
780
781 void cpu_x86_frstor(CPUX86State *s, target_ulong ptr, int data32)
782 {
783 CPUX86State *saved_env;
784
785 saved_env = env;
786 env = s;
787
788 helper_frstor(ptr, data32);
789
790 env = saved_env;
791 }
792
793 #endif /* TARGET_I386 */
794
795 #if !defined(CONFIG_SOFTMMU)
796
797 #if defined(TARGET_I386)
798
799 /* 'pc' is the host PC at which the exception was raised. 'address' is
800 the effective address of the memory exception. 'is_write' is 1 if a
801 write caused the exception and otherwise 0'. 'old_set' is the
802 signal set which should be restored */
803 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
804 int is_write, sigset_t *old_set,
805 void *puc)
806 {
807 TranslationBlock *tb;
808 int ret;
809
810 if (cpu_single_env)
811 env = cpu_single_env; /* XXX: find a correct solution for multithread */
812 #if defined(DEBUG_SIGNAL)
813 qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
814 pc, address, is_write, *(unsigned long *)old_set);
815 #endif
816 /* XXX: locking issue */
817 if (is_write && page_unprotect(h2g(address), pc, puc)) {
818 return 1;
819 }
820
821 /* see if it is an MMU fault */
822 ret = cpu_x86_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
823 if (ret < 0)
824 return 0; /* not an MMU fault */
825 if (ret == 0)
826 return 1; /* the MMU fault was handled without causing real CPU fault */
827 /* now we have a real cpu fault */
828 tb = tb_find_pc(pc);
829 if (tb) {
830 /* the PC is inside the translated code. It means that we have
831 a virtual CPU fault */
832 cpu_restore_state(tb, env, pc, puc);
833 }
834 if (ret == 1) {
835 #if 0
836 printf("PF exception: EIP=0x%08x CR2=0x%08x error=0x%x\n",
837 env->eip, env->cr[2], env->error_code);
838 #endif
839 /* we restore the process signal mask as the sigreturn should
840 do it (XXX: use sigsetjmp) */
841 sigprocmask(SIG_SETMASK, old_set, NULL);
842 raise_exception_err(env->exception_index, env->error_code);
843 } else {
844 /* activate soft MMU for this block */
845 env->hflags |= HF_SOFTMMU_MASK;
846 cpu_resume_from_signal(env, puc);
847 }
848 /* never comes here */
849 return 1;
850 }
851
852 #elif defined(TARGET_ARM)
853 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
854 int is_write, sigset_t *old_set,
855 void *puc)
856 {
857 TranslationBlock *tb;
858 int ret;
859
860 if (cpu_single_env)
861 env = cpu_single_env; /* XXX: find a correct solution for multithread */
862 #if defined(DEBUG_SIGNAL)
863 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
864 pc, address, is_write, *(unsigned long *)old_set);
865 #endif
866 /* XXX: locking issue */
867 if (is_write && page_unprotect(h2g(address), pc, puc)) {
868 return 1;
869 }
870 /* see if it is an MMU fault */
871 ret = cpu_arm_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
872 if (ret < 0)
873 return 0; /* not an MMU fault */
874 if (ret == 0)
875 return 1; /* the MMU fault was handled without causing real CPU fault */
876 /* now we have a real cpu fault */
877 tb = tb_find_pc(pc);
878 if (tb) {
879 /* the PC is inside the translated code. It means that we have
880 a virtual CPU fault */
881 cpu_restore_state(tb, env, pc, puc);
882 }
883 /* we restore the process signal mask as the sigreturn should
884 do it (XXX: use sigsetjmp) */
885 sigprocmask(SIG_SETMASK, old_set, NULL);
886 cpu_loop_exit();
887 }
888 #elif defined(TARGET_SPARC)
889 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
890 int is_write, sigset_t *old_set,
891 void *puc)
892 {
893 TranslationBlock *tb;
894 int ret;
895
896 if (cpu_single_env)
897 env = cpu_single_env; /* XXX: find a correct solution for multithread */
898 #if defined(DEBUG_SIGNAL)
899 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
900 pc, address, is_write, *(unsigned long *)old_set);
901 #endif
902 /* XXX: locking issue */
903 if (is_write && page_unprotect(h2g(address), pc, puc)) {
904 return 1;
905 }
906 /* see if it is an MMU fault */
907 ret = cpu_sparc_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
908 if (ret < 0)
909 return 0; /* not an MMU fault */
910 if (ret == 0)
911 return 1; /* the MMU fault was handled without causing real CPU fault */
912 /* now we have a real cpu fault */
913 tb = tb_find_pc(pc);
914 if (tb) {
915 /* the PC is inside the translated code. It means that we have
916 a virtual CPU fault */
917 cpu_restore_state(tb, env, pc, puc);
918 }
919 /* we restore the process signal mask as the sigreturn should
920 do it (XXX: use sigsetjmp) */
921 sigprocmask(SIG_SETMASK, old_set, NULL);
922 cpu_loop_exit();
923 }
924 #elif defined (TARGET_PPC)
925 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
926 int is_write, sigset_t *old_set,
927 void *puc)
928 {
929 TranslationBlock *tb;
930 int ret;
931
932 if (cpu_single_env)
933 env = cpu_single_env; /* XXX: find a correct solution for multithread */
934 #if defined(DEBUG_SIGNAL)
935 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
936 pc, address, is_write, *(unsigned long *)old_set);
937 #endif
938 /* XXX: locking issue */
939 if (is_write && page_unprotect(h2g(address), pc, puc)) {
940 return 1;
941 }
942
943 /* see if it is an MMU fault */
944 ret = cpu_ppc_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
945 if (ret < 0)
946 return 0; /* not an MMU fault */
947 if (ret == 0)
948 return 1; /* the MMU fault was handled without causing real CPU fault */
949
950 /* now we have a real cpu fault */
951 tb = tb_find_pc(pc);
952 if (tb) {
953 /* the PC is inside the translated code. It means that we have
954 a virtual CPU fault */
955 cpu_restore_state(tb, env, pc, puc);
956 }
957 if (ret == 1) {
958 #if 0
959 printf("PF exception: NIP=0x%08x error=0x%x %p\n",
960 env->nip, env->error_code, tb);
961 #endif
962 /* we restore the process signal mask as the sigreturn should
963 do it (XXX: use sigsetjmp) */
964 sigprocmask(SIG_SETMASK, old_set, NULL);
965 do_raise_exception_err(env->exception_index, env->error_code);
966 } else {
967 /* activate soft MMU for this block */
968 cpu_resume_from_signal(env, puc);
969 }
970 /* never comes here */
971 return 1;
972 }
973
974 #elif defined(TARGET_M68K)
975 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
976 int is_write, sigset_t *old_set,
977 void *puc)
978 {
979 TranslationBlock *tb;
980 int ret;
981
982 if (cpu_single_env)
983 env = cpu_single_env; /* XXX: find a correct solution for multithread */
984 #if defined(DEBUG_SIGNAL)
985 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
986 pc, address, is_write, *(unsigned long *)old_set);
987 #endif
988 /* XXX: locking issue */
989 if (is_write && page_unprotect(address, pc, puc)) {
990 return 1;
991 }
992 /* see if it is an MMU fault */
993 ret = cpu_m68k_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
994 if (ret < 0)
995 return 0; /* not an MMU fault */
996 if (ret == 0)
997 return 1; /* the MMU fault was handled without causing real CPU fault */
998 /* now we have a real cpu fault */
999 tb = tb_find_pc(pc);
1000 if (tb) {
1001 /* the PC is inside the translated code. It means that we have
1002 a virtual CPU fault */
1003 cpu_restore_state(tb, env, pc, puc);
1004 }
1005 /* we restore the process signal mask as the sigreturn should
1006 do it (XXX: use sigsetjmp) */
1007 sigprocmask(SIG_SETMASK, old_set, NULL);
1008 cpu_loop_exit();
1009 /* never comes here */
1010 return 1;
1011 }
1012
1013 #elif defined (TARGET_MIPS)
1014 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1015 int is_write, sigset_t *old_set,
1016 void *puc)
1017 {
1018 TranslationBlock *tb;
1019 int ret;
1020
1021 if (cpu_single_env)
1022 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1023 #if defined(DEBUG_SIGNAL)
1024 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1025 pc, address, is_write, *(unsigned long *)old_set);
1026 #endif
1027 /* XXX: locking issue */
1028 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1029 return 1;
1030 }
1031
1032 /* see if it is an MMU fault */
1033 ret = cpu_mips_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1034 if (ret < 0)
1035 return 0; /* not an MMU fault */
1036 if (ret == 0)
1037 return 1; /* the MMU fault was handled without causing real CPU fault */
1038
1039 /* now we have a real cpu fault */
1040 tb = tb_find_pc(pc);
1041 if (tb) {
1042 /* the PC is inside the translated code. It means that we have
1043 a virtual CPU fault */
1044 cpu_restore_state(tb, env, pc, puc);
1045 }
1046 if (ret == 1) {
1047 #if 0
1048 printf("PF exception: PC=0x" TARGET_FMT_lx " error=0x%x %p\n",
1049 env->PC, env->error_code, tb);
1050 #endif
1051 /* we restore the process signal mask as the sigreturn should
1052 do it (XXX: use sigsetjmp) */
1053 sigprocmask(SIG_SETMASK, old_set, NULL);
1054 do_raise_exception_err(env->exception_index, env->error_code);
1055 } else {
1056 /* activate soft MMU for this block */
1057 cpu_resume_from_signal(env, puc);
1058 }
1059 /* never comes here */
1060 return 1;
1061 }
1062
1063 #elif defined (TARGET_SH4)
1064 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1065 int is_write, sigset_t *old_set,
1066 void *puc)
1067 {
1068 TranslationBlock *tb;
1069 int ret;
1070
1071 if (cpu_single_env)
1072 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1073 #if defined(DEBUG_SIGNAL)
1074 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1075 pc, address, is_write, *(unsigned long *)old_set);
1076 #endif
1077 /* XXX: locking issue */
1078 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1079 return 1;
1080 }
1081
1082 /* see if it is an MMU fault */
1083 ret = cpu_sh4_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1084 if (ret < 0)
1085 return 0; /* not an MMU fault */
1086 if (ret == 0)
1087 return 1; /* the MMU fault was handled without causing real CPU fault */
1088
1089 /* now we have a real cpu fault */
1090 tb = tb_find_pc(pc);
1091 if (tb) {
1092 /* the PC is inside the translated code. It means that we have
1093 a virtual CPU fault */
1094 cpu_restore_state(tb, env, pc, puc);
1095 }
1096 #if 0
1097 printf("PF exception: NIP=0x%08x error=0x%x %p\n",
1098 env->nip, env->error_code, tb);
1099 #endif
1100 /* we restore the process signal mask as the sigreturn should
1101 do it (XXX: use sigsetjmp) */
1102 sigprocmask(SIG_SETMASK, old_set, NULL);
1103 cpu_loop_exit();
1104 /* never comes here */
1105 return 1;
1106 }
1107
1108 #elif defined (TARGET_ALPHA)
1109 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1110 int is_write, sigset_t *old_set,
1111 void *puc)
1112 {
1113 TranslationBlock *tb;
1114 int ret;
1115
1116 if (cpu_single_env)
1117 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1118 #if defined(DEBUG_SIGNAL)
1119 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1120 pc, address, is_write, *(unsigned long *)old_set);
1121 #endif
1122 /* XXX: locking issue */
1123 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1124 return 1;
1125 }
1126
1127 /* see if it is an MMU fault */
1128 ret = cpu_alpha_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1129 if (ret < 0)
1130 return 0; /* not an MMU fault */
1131 if (ret == 0)
1132 return 1; /* the MMU fault was handled without causing real CPU fault */
1133
1134 /* now we have a real cpu fault */
1135 tb = tb_find_pc(pc);
1136 if (tb) {
1137 /* the PC is inside the translated code. It means that we have
1138 a virtual CPU fault */
1139 cpu_restore_state(tb, env, pc, puc);
1140 }
1141 #if 0
1142 printf("PF exception: NIP=0x%08x error=0x%x %p\n",
1143 env->nip, env->error_code, tb);
1144 #endif
1145 /* we restore the process signal mask as the sigreturn should
1146 do it (XXX: use sigsetjmp) */
1147 sigprocmask(SIG_SETMASK, old_set, NULL);
1148 cpu_loop_exit();
1149 /* never comes here */
1150 return 1;
1151 }
1152 #elif defined (TARGET_CRIS)
1153 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1154 int is_write, sigset_t *old_set,
1155 void *puc)
1156 {
1157 TranslationBlock *tb;
1158 int ret;
1159
1160 if (cpu_single_env)
1161 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1162 #if defined(DEBUG_SIGNAL)
1163 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1164 pc, address, is_write, *(unsigned long *)old_set);
1165 #endif
1166 /* XXX: locking issue */
1167 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1168 return 1;
1169 }
1170
1171 /* see if it is an MMU fault */
1172 ret = cpu_cris_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1173 if (ret < 0)
1174 return 0; /* not an MMU fault */
1175 if (ret == 0)
1176 return 1; /* the MMU fault was handled without causing real CPU fault */
1177
1178 /* now we have a real cpu fault */
1179 tb = tb_find_pc(pc);
1180 if (tb) {
1181 /* the PC is inside the translated code. It means that we have
1182 a virtual CPU fault */
1183 cpu_restore_state(tb, env, pc, puc);
1184 }
1185 #if 0
1186 printf("PF exception: NIP=0x%08x error=0x%x %p\n",
1187 env->nip, env->error_code, tb);
1188 #endif
1189 /* we restore the process signal mask as the sigreturn should
1190 do it (XXX: use sigsetjmp) */
1191 sigprocmask(SIG_SETMASK, old_set, NULL);
1192 cpu_loop_exit();
1193 /* never comes here */
1194 return 1;
1195 }
1196
1197 #else
1198 #error unsupported target CPU
1199 #endif
1200
1201 #if defined(__i386__)
1202
1203 #if defined(__APPLE__)
1204 # include <sys/ucontext.h>
1205
1206 # define EIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->ss.eip))
1207 # define TRAP_sig(context) ((context)->uc_mcontext->es.trapno)
1208 # define ERROR_sig(context) ((context)->uc_mcontext->es.err)
1209 #else
1210 # define EIP_sig(context) ((context)->uc_mcontext.gregs[REG_EIP])
1211 # define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
1212 # define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
1213 #endif
1214
1215 int cpu_signal_handler(int host_signum, void *pinfo,
1216 void *puc)
1217 {
1218 siginfo_t *info = pinfo;
1219 struct ucontext *uc = puc;
1220 unsigned long pc;
1221 int trapno;
1222
1223 #ifndef REG_EIP
1224 /* for glibc 2.1 */
1225 #define REG_EIP EIP
1226 #define REG_ERR ERR
1227 #define REG_TRAPNO TRAPNO
1228 #endif
1229 pc = EIP_sig(uc);
1230 trapno = TRAP_sig(uc);
1231 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1232 trapno == 0xe ?
1233 (ERROR_sig(uc) >> 1) & 1 : 0,
1234 &uc->uc_sigmask, puc);
1235 }
1236
1237 #elif defined(__x86_64__)
1238
1239 int cpu_signal_handler(int host_signum, void *pinfo,
1240 void *puc)
1241 {
1242 siginfo_t *info = pinfo;
1243 struct ucontext *uc = puc;
1244 unsigned long pc;
1245
1246 pc = uc->uc_mcontext.gregs[REG_RIP];
1247 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1248 uc->uc_mcontext.gregs[REG_TRAPNO] == 0xe ?
1249 (uc->uc_mcontext.gregs[REG_ERR] >> 1) & 1 : 0,
1250 &uc->uc_sigmask, puc);
1251 }
1252
1253 #elif defined(__powerpc__)
1254
1255 /***********************************************************************
1256 * signal context platform-specific definitions
1257 * From Wine
1258 */
1259 #ifdef linux
1260 /* All Registers access - only for local access */
1261 # define REG_sig(reg_name, context) ((context)->uc_mcontext.regs->reg_name)
1262 /* Gpr Registers access */
1263 # define GPR_sig(reg_num, context) REG_sig(gpr[reg_num], context)
1264 # define IAR_sig(context) REG_sig(nip, context) /* Program counter */
1265 # define MSR_sig(context) REG_sig(msr, context) /* Machine State Register (Supervisor) */
1266 # define CTR_sig(context) REG_sig(ctr, context) /* Count register */
1267 # define XER_sig(context) REG_sig(xer, context) /* User's integer exception register */
1268 # define LR_sig(context) REG_sig(link, context) /* Link register */
1269 # define CR_sig(context) REG_sig(ccr, context) /* Condition register */
1270 /* Float Registers access */
1271 # define FLOAT_sig(reg_num, context) (((double*)((char*)((context)->uc_mcontext.regs+48*4)))[reg_num])
1272 # define FPSCR_sig(context) (*(int*)((char*)((context)->uc_mcontext.regs+(48+32*2)*4)))
1273 /* Exception Registers access */
1274 # define DAR_sig(context) REG_sig(dar, context)
1275 # define DSISR_sig(context) REG_sig(dsisr, context)
1276 # define TRAP_sig(context) REG_sig(trap, context)
1277 #endif /* linux */
1278
1279 #ifdef __APPLE__
1280 # include <sys/ucontext.h>
1281 typedef struct ucontext SIGCONTEXT;
1282 /* All Registers access - only for local access */
1283 # define REG_sig(reg_name, context) ((context)->uc_mcontext->ss.reg_name)
1284 # define FLOATREG_sig(reg_name, context) ((context)->uc_mcontext->fs.reg_name)
1285 # define EXCEPREG_sig(reg_name, context) ((context)->uc_mcontext->es.reg_name)
1286 # define VECREG_sig(reg_name, context) ((context)->uc_mcontext->vs.reg_name)
1287 /* Gpr Registers access */
1288 # define GPR_sig(reg_num, context) REG_sig(r##reg_num, context)
1289 # define IAR_sig(context) REG_sig(srr0, context) /* Program counter */
1290 # define MSR_sig(context) REG_sig(srr1, context) /* Machine State Register (Supervisor) */
1291 # define CTR_sig(context) REG_sig(ctr, context)
1292 # define XER_sig(context) REG_sig(xer, context) /* Link register */
1293 # define LR_sig(context) REG_sig(lr, context) /* User's integer exception register */
1294 # define CR_sig(context) REG_sig(cr, context) /* Condition register */
1295 /* Float Registers access */
1296 # define FLOAT_sig(reg_num, context) FLOATREG_sig(fpregs[reg_num], context)
1297 # define FPSCR_sig(context) ((double)FLOATREG_sig(fpscr, context))
1298 /* Exception Registers access */
1299 # define DAR_sig(context) EXCEPREG_sig(dar, context) /* Fault registers for coredump */
1300 # define DSISR_sig(context) EXCEPREG_sig(dsisr, context)
1301 # define TRAP_sig(context) EXCEPREG_sig(exception, context) /* number of powerpc exception taken */
1302 #endif /* __APPLE__ */
1303
1304 int cpu_signal_handler(int host_signum, void *pinfo,
1305 void *puc)
1306 {
1307 siginfo_t *info = pinfo;
1308 struct ucontext *uc = puc;
1309 unsigned long pc;
1310 int is_write;
1311
1312 pc = IAR_sig(uc);
1313 is_write = 0;
1314 #if 0
1315 /* ppc 4xx case */
1316 if (DSISR_sig(uc) & 0x00800000)
1317 is_write = 1;
1318 #else
1319 if (TRAP_sig(uc) != 0x400 && (DSISR_sig(uc) & 0x02000000))
1320 is_write = 1;
1321 #endif
1322 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1323 is_write, &uc->uc_sigmask, puc);
1324 }
1325
1326 #elif defined(__alpha__)
1327
1328 int cpu_signal_handler(int host_signum, void *pinfo,
1329 void *puc)
1330 {
1331 siginfo_t *info = pinfo;
1332 struct ucontext *uc = puc;
1333 uint32_t *pc = uc->uc_mcontext.sc_pc;
1334 uint32_t insn = *pc;
1335 int is_write = 0;
1336
1337 /* XXX: need kernel patch to get write flag faster */
1338 switch (insn >> 26) {
1339 case 0x0d: // stw
1340 case 0x0e: // stb
1341 case 0x0f: // stq_u
1342 case 0x24: // stf
1343 case 0x25: // stg
1344 case 0x26: // sts
1345 case 0x27: // stt
1346 case 0x2c: // stl
1347 case 0x2d: // stq
1348 case 0x2e: // stl_c
1349 case 0x2f: // stq_c
1350 is_write = 1;
1351 }
1352
1353 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1354 is_write, &uc->uc_sigmask, puc);
1355 }
1356 #elif defined(__sparc__)
1357
1358 int cpu_signal_handler(int host_signum, void *pinfo,
1359 void *puc)
1360 {
1361 siginfo_t *info = pinfo;
1362 uint32_t *regs = (uint32_t *)(info + 1);
1363 void *sigmask = (regs + 20);
1364 unsigned long pc;
1365 int is_write;
1366 uint32_t insn;
1367
1368 /* XXX: is there a standard glibc define ? */
1369 pc = regs[1];
1370 /* XXX: need kernel patch to get write flag faster */
1371 is_write = 0;
1372 insn = *(uint32_t *)pc;
1373 if ((insn >> 30) == 3) {
1374 switch((insn >> 19) & 0x3f) {
1375 case 0x05: // stb
1376 case 0x06: // sth
1377 case 0x04: // st
1378 case 0x07: // std
1379 case 0x24: // stf
1380 case 0x27: // stdf
1381 case 0x25: // stfsr
1382 is_write = 1;
1383 break;
1384 }
1385 }
1386 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1387 is_write, sigmask, NULL);
1388 }
1389
1390 #elif defined(__arm__)
1391
1392 int cpu_signal_handler(int host_signum, void *pinfo,
1393 void *puc)
1394 {
1395 siginfo_t *info = pinfo;
1396 struct ucontext *uc = puc;
1397 unsigned long pc;
1398 int is_write;
1399
1400 pc = uc->uc_mcontext.gregs[R15];
1401 /* XXX: compute is_write */
1402 is_write = 0;
1403 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1404 is_write,
1405 &uc->uc_sigmask, puc);
1406 }
1407
1408 #elif defined(__mc68000)
1409
1410 int cpu_signal_handler(int host_signum, void *pinfo,
1411 void *puc)
1412 {
1413 siginfo_t *info = pinfo;
1414 struct ucontext *uc = puc;
1415 unsigned long pc;
1416 int is_write;
1417
1418 pc = uc->uc_mcontext.gregs[16];
1419 /* XXX: compute is_write */
1420 is_write = 0;
1421 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1422 is_write,
1423 &uc->uc_sigmask, puc);
1424 }
1425
1426 #elif defined(__ia64)
1427
1428 #ifndef __ISR_VALID
1429 /* This ought to be in <bits/siginfo.h>... */
1430 # define __ISR_VALID 1
1431 #endif
1432
1433 int cpu_signal_handler(int host_signum, void *pinfo, void *puc)
1434 {
1435 siginfo_t *info = pinfo;
1436 struct ucontext *uc = puc;
1437 unsigned long ip;
1438 int is_write = 0;
1439
1440 ip = uc->uc_mcontext.sc_ip;
1441 switch (host_signum) {
1442 case SIGILL:
1443 case SIGFPE:
1444 case SIGSEGV:
1445 case SIGBUS:
1446 case SIGTRAP:
1447 if (info->si_code && (info->si_segvflags & __ISR_VALID))
1448 /* ISR.W (write-access) is bit 33: */
1449 is_write = (info->si_isr >> 33) & 1;
1450 break;
1451
1452 default:
1453 break;
1454 }
1455 return handle_cpu_signal(ip, (unsigned long)info->si_addr,
1456 is_write,
1457 &uc->uc_sigmask, puc);
1458 }
1459
1460 #elif defined(__s390__)
1461
1462 int cpu_signal_handler(int host_signum, void *pinfo,
1463 void *puc)
1464 {
1465 siginfo_t *info = pinfo;
1466 struct ucontext *uc = puc;
1467 unsigned long pc;
1468 int is_write;
1469
1470 pc = uc->uc_mcontext.psw.addr;
1471 /* XXX: compute is_write */
1472 is_write = 0;
1473 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1474 is_write, &uc->uc_sigmask, puc);
1475 }
1476
1477 #elif defined(__mips__)
1478
1479 int cpu_signal_handler(int host_signum, void *pinfo,
1480 void *puc)
1481 {
1482 siginfo_t *info = pinfo;
1483 struct ucontext *uc = puc;
1484 greg_t pc = uc->uc_mcontext.pc;
1485 int is_write;
1486
1487 /* XXX: compute is_write */
1488 is_write = 0;
1489 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1490 is_write, &uc->uc_sigmask, puc);
1491 }
1492
1493 #else
1494
1495 #error host CPU specific signal handler needed
1496
1497 #endif
1498
1499 #endif /* !defined(CONFIG_SOFTMMU) */
Stable branch of Qemu 0.9.1