?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
block/vvfat: Fix compiler warning in debug code
[qemu.git] / cpu-exec.c
blobdbdfdccd8cc3d788c2065e16fc1dc9679aaf539c
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, see <http://www.gnu.org/licenses/>.
18 */
19 #include "config.h"
20 #include "exec.h"
21 #include "disas.h"
22 #include "tcg.h"
23 #include "kvm.h"
24 #include "qemu-barrier.h"
25
26 #if !defined(CONFIG_SOFTMMU)
27 #undef EAX
28 #undef ECX
29 #undef EDX
30 #undef EBX
31 #undef ESP
32 #undef EBP
33 #undef ESI
34 #undef EDI
35 #undef EIP
36 #include <signal.h>
37 #ifdef __linux__
38 #include <sys/ucontext.h>
39 #endif
40 #endif
41
42 #if defined(__sparc__) && !defined(CONFIG_SOLARIS)
43 // Work around ugly bugs in glibc that mangle global register contents
44 #undef env
45 #define env cpu_single_env
46 #endif
47
48 int tb_invalidated_flag;
49
50 //#define CONFIG_DEBUG_EXEC
51 //#define DEBUG_SIGNAL
52
53 int qemu_cpu_has_work(CPUState *env)
54 {
55 return cpu_has_work(env);
56 }
57
58 void cpu_loop_exit(void)
59 {
60 env->current_tb = NULL;
61 longjmp(env->jmp_env, 1);
62 }
63
64 /* exit the current TB from a signal handler. The host registers are
65 restored in a state compatible with the CPU emulator
66 */
67 void cpu_resume_from_signal(CPUState *env1, void *puc)
68 {
69 #if !defined(CONFIG_SOFTMMU)
70 #ifdef __linux__
71 struct ucontext *uc = puc;
72 #elif defined(__OpenBSD__)
73 struct sigcontext *uc = puc;
74 #endif
75 #endif
76
77 env = env1;
78
79 /* XXX: restore cpu registers saved in host registers */
80
81 #if !defined(CONFIG_SOFTMMU)
82 if (puc) {
83 /* XXX: use siglongjmp ? */
84 #ifdef __linux__
85 #ifdef __ia64
86 sigprocmask(SIG_SETMASK, (sigset_t *)&uc->uc_sigmask, NULL);
87 #else
88 sigprocmask(SIG_SETMASK, &uc->uc_sigmask, NULL);
89 #endif
90 #elif defined(__OpenBSD__)
91 sigprocmask(SIG_SETMASK, &uc->sc_mask, NULL);
92 #endif
93 }
94 #endif
95 env->exception_index = -1;
96 longjmp(env->jmp_env, 1);
97 }
98
99 /* Execute the code without caching the generated code. An interpreter
100 could be used if available. */
101 static void cpu_exec_nocache(int max_cycles, TranslationBlock *orig_tb)
102 {
103 unsigned long next_tb;
104 TranslationBlock *tb;
105
106 /* Should never happen.
107 We only end up here when an existing TB is too long. */
108 if (max_cycles > CF_COUNT_MASK)
109 max_cycles = CF_COUNT_MASK;
110
111 tb = tb_gen_code(env, orig_tb->pc, orig_tb->cs_base, orig_tb->flags,
112 max_cycles);
113 env->current_tb = tb;
114 /* execute the generated code */
115 next_tb = tcg_qemu_tb_exec(tb->tc_ptr);
116 env->current_tb = NULL;
117
118 if ((next_tb & 3) == 2) {
119 /* Restore PC. This may happen if async event occurs before
120 the TB starts executing. */
121 cpu_pc_from_tb(env, tb);
122 }
123 tb_phys_invalidate(tb, -1);
124 tb_free(tb);
125 }
126
127 static TranslationBlock *tb_find_slow(target_ulong pc,
128 target_ulong cs_base,
129 uint64_t flags)
130 {
131 TranslationBlock *tb, **ptb1;
132 unsigned int h;
133 tb_page_addr_t phys_pc, phys_page1, phys_page2;
134 target_ulong virt_page2;
135
136 tb_invalidated_flag = 0;
137
138 /* find translated block using physical mappings */
139 phys_pc = get_page_addr_code(env, pc);
140 phys_page1 = phys_pc & TARGET_PAGE_MASK;
141 phys_page2 = -1;
142 h = tb_phys_hash_func(phys_pc);
143 ptb1 = &tb_phys_hash[h];
144 for(;;) {
145 tb = *ptb1;
146 if (!tb)
147 goto not_found;
148 if (tb->pc == pc &&
149 tb->page_addr[0] == phys_page1 &&
150 tb->cs_base == cs_base &&
151 tb->flags == flags) {
152 /* check next page if needed */
153 if (tb->page_addr[1] != -1) {
154 virt_page2 = (pc & TARGET_PAGE_MASK) +
155 TARGET_PAGE_SIZE;
156 phys_page2 = get_page_addr_code(env, virt_page2);
157 if (tb->page_addr[1] == phys_page2)
158 goto found;
159 } else {
160 goto found;
161 }
162 }
163 ptb1 = &tb->phys_hash_next;
164 }
165 not_found:
166 /* if no translated code available, then translate it now */
167 tb = tb_gen_code(env, pc, cs_base, flags, 0);
168
169 found:
170 /* we add the TB in the virtual pc hash table */
171 env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)] = tb;
172 return tb;
173 }
174
175 static inline TranslationBlock *tb_find_fast(void)
176 {
177 TranslationBlock *tb;
178 target_ulong cs_base, pc;
179 int flags;
180
181 /* we record a subset of the CPU state. It will
182 always be the same before a given translated block
183 is executed. */
184 cpu_get_tb_cpu_state(env, &pc, &cs_base, &flags);
185 tb = env->tb_jmp_cache[tb_jmp_cache_hash_func(pc)];
186 if (unlikely(!tb || tb->pc != pc || tb->cs_base != cs_base ||
187 tb->flags != flags)) {
188 tb = tb_find_slow(pc, cs_base, flags);
189 }
190 return tb;
191 }
192
193 static CPUDebugExcpHandler *debug_excp_handler;
194
195 CPUDebugExcpHandler *cpu_set_debug_excp_handler(CPUDebugExcpHandler *handler)
196 {
197 CPUDebugExcpHandler *old_handler = debug_excp_handler;
198
199 debug_excp_handler = handler;
200 return old_handler;
201 }
202
203 static void cpu_handle_debug_exception(CPUState *env)
204 {
205 CPUWatchpoint *wp;
206
207 if (!env->watchpoint_hit)
208 QTAILQ_FOREACH(wp, &env->watchpoints, entry)
209 wp->flags &= ~BP_WATCHPOINT_HIT;
210
211 if (debug_excp_handler)
212 debug_excp_handler(env);
213 }
214
215 /* main execution loop */
216
217 volatile sig_atomic_t exit_request;
218
219 int cpu_exec(CPUState *env1)
220 {
221 volatile host_reg_t saved_env_reg;
222 int ret, interrupt_request;
223 TranslationBlock *tb;
224 uint8_t *tc_ptr;
225 unsigned long next_tb;
226
227 if (cpu_halted(env1) == EXCP_HALTED)
228 return EXCP_HALTED;
229
230 cpu_single_env = env1;
231
232 /* the access to env below is actually saving the global register's
233 value, so that files not including target-xyz/exec.h are free to
234 use it. */
235 QEMU_BUILD_BUG_ON (sizeof (saved_env_reg) != sizeof (env));
236 saved_env_reg = (host_reg_t) env;
237 barrier();
238 env = env1;
239
240 if (unlikely(exit_request)) {
241 env->exit_request = 1;
242 }
243
244 #if defined(TARGET_I386)
245 if (!kvm_enabled()) {
246 /* put eflags in CPU temporary format */
247 CC_SRC = env->eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
248 DF = 1 - (2 * ((env->eflags >> 10) & 1));
249 CC_OP = CC_OP_EFLAGS;
250 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
251 }
252 #elif defined(TARGET_SPARC)
253 #elif defined(TARGET_M68K)
254 env->cc_op = CC_OP_FLAGS;
255 env->cc_dest = env->sr & 0xf;
256 env->cc_x = (env->sr >> 4) & 1;
257 #elif defined(TARGET_ALPHA)
258 #elif defined(TARGET_ARM)
259 #elif defined(TARGET_PPC)
260 #elif defined(TARGET_MICROBLAZE)
261 #elif defined(TARGET_MIPS)
262 #elif defined(TARGET_SH4)
263 #elif defined(TARGET_CRIS)
264 #elif defined(TARGET_S390X)
265 /* XXXXX */
266 #else
267 #error unsupported target CPU
268 #endif
269 env->exception_index = -1;
270
271 /* prepare setjmp context for exception handling */
272 for(;;) {
273 if (setjmp(env->jmp_env) == 0) {
274 #if defined(__sparc__) && !defined(CONFIG_SOLARIS)
275 #undef env
276 env = cpu_single_env;
277 #define env cpu_single_env
278 #endif
279 /* if an exception is pending, we execute it here */
280 if (env->exception_index >= 0) {
281 if (env->exception_index >= EXCP_INTERRUPT) {
282 /* exit request from the cpu execution loop */
283 ret = env->exception_index;
284 if (ret == EXCP_DEBUG)
285 cpu_handle_debug_exception(env);
286 break;
287 } else {
288 #if defined(CONFIG_USER_ONLY)
289 /* if user mode only, we simulate a fake exception
290 which will be handled outside the cpu execution
291 loop */
292 #if defined(TARGET_I386)
293 do_interrupt_user(env->exception_index,
294 env->exception_is_int,
295 env->error_code,
296 env->exception_next_eip);
297 /* successfully delivered */
298 env->old_exception = -1;
299 #endif
300 ret = env->exception_index;
301 break;
302 #else
303 #if defined(TARGET_I386)
304 /* simulate a real cpu exception. On i386, it can
305 trigger new exceptions, but we do not handle
306 double or triple faults yet. */
307 do_interrupt(env->exception_index,
308 env->exception_is_int,
309 env->error_code,
310 env->exception_next_eip, 0);
311 /* successfully delivered */
312 env->old_exception = -1;
313 #elif defined(TARGET_PPC)
314 do_interrupt(env);
315 #elif defined(TARGET_MICROBLAZE)
316 do_interrupt(env);
317 #elif defined(TARGET_MIPS)
318 do_interrupt(env);
319 #elif defined(TARGET_SPARC)
320 do_interrupt(env);
321 #elif defined(TARGET_ARM)
322 do_interrupt(env);
323 #elif defined(TARGET_SH4)
324 do_interrupt(env);
325 #elif defined(TARGET_ALPHA)
326 do_interrupt(env);
327 #elif defined(TARGET_CRIS)
328 do_interrupt(env);
329 #elif defined(TARGET_M68K)
330 do_interrupt(0);
331 #endif
332 env->exception_index = -1;
333 #endif
334 }
335 }
336
337 if (kvm_enabled()) {
338 kvm_cpu_exec(env);
339 longjmp(env->jmp_env, 1);
340 }
341
342 next_tb = 0; /* force lookup of first TB */
343 for(;;) {
344 interrupt_request = env->interrupt_request;
345 if (unlikely(interrupt_request)) {
346 if (unlikely(env->singlestep_enabled & SSTEP_NOIRQ)) {
347 /* Mask out external interrupts for this step. */
348 interrupt_request &= ~(CPU_INTERRUPT_HARD |
349 CPU_INTERRUPT_FIQ |
350 CPU_INTERRUPT_SMI |
351 CPU_INTERRUPT_NMI);
352 }
353 if (interrupt_request & CPU_INTERRUPT_DEBUG) {
354 env->interrupt_request &= ~CPU_INTERRUPT_DEBUG;
355 env->exception_index = EXCP_DEBUG;
356 cpu_loop_exit();
357 }
358 #if defined(TARGET_ARM) || defined(TARGET_SPARC) || defined(TARGET_MIPS) || \
359 defined(TARGET_PPC) || defined(TARGET_ALPHA) || defined(TARGET_CRIS) || \
360 defined(TARGET_MICROBLAZE)
361 if (interrupt_request & CPU_INTERRUPT_HALT) {
362 env->interrupt_request &= ~CPU_INTERRUPT_HALT;
363 env->halted = 1;
364 env->exception_index = EXCP_HLT;
365 cpu_loop_exit();
366 }
367 #endif
368 #if defined(TARGET_I386)
369 if (interrupt_request & CPU_INTERRUPT_INIT) {
370 svm_check_intercept(SVM_EXIT_INIT);
371 do_cpu_init(env);
372 env->exception_index = EXCP_HALTED;
373 cpu_loop_exit();
374 } else if (interrupt_request & CPU_INTERRUPT_SIPI) {
375 do_cpu_sipi(env);
376 } else if (env->hflags2 & HF2_GIF_MASK) {
377 if ((interrupt_request & CPU_INTERRUPT_SMI) &&
378 !(env->hflags & HF_SMM_MASK)) {
379 svm_check_intercept(SVM_EXIT_SMI);
380 env->interrupt_request &= ~CPU_INTERRUPT_SMI;
381 do_smm_enter();
382 next_tb = 0;
383 } else if ((interrupt_request & CPU_INTERRUPT_NMI) &&
384 !(env->hflags2 & HF2_NMI_MASK)) {
385 env->interrupt_request &= ~CPU_INTERRUPT_NMI;
386 env->hflags2 |= HF2_NMI_MASK;
387 do_interrupt(EXCP02_NMI, 0, 0, 0, 1);
388 next_tb = 0;
389 } else if (interrupt_request & CPU_INTERRUPT_MCE) {
390 env->interrupt_request &= ~CPU_INTERRUPT_MCE;
391 do_interrupt(EXCP12_MCHK, 0, 0, 0, 0);
392 next_tb = 0;
393 } else if ((interrupt_request & CPU_INTERRUPT_HARD) &&
394 (((env->hflags2 & HF2_VINTR_MASK) &&
395 (env->hflags2 & HF2_HIF_MASK)) ||
396 (!(env->hflags2 & HF2_VINTR_MASK) &&
397 (env->eflags & IF_MASK &&
398 !(env->hflags & HF_INHIBIT_IRQ_MASK))))) {
399 int intno;
400 svm_check_intercept(SVM_EXIT_INTR);
401 env->interrupt_request &= ~(CPU_INTERRUPT_HARD | CPU_INTERRUPT_VIRQ);
402 intno = cpu_get_pic_interrupt(env);
403 qemu_log_mask(CPU_LOG_TB_IN_ASM, "Servicing hardware INT=0x%02x\n", intno);
404 #if defined(__sparc__) && !defined(CONFIG_SOLARIS)
405 #undef env
406 env = cpu_single_env;
407 #define env cpu_single_env
408 #endif
409 do_interrupt(intno, 0, 0, 0, 1);
410 /* ensure that no TB jump will be modified as
411 the program flow was changed */
412 next_tb = 0;
413 #if !defined(CONFIG_USER_ONLY)
414 } else if ((interrupt_request & CPU_INTERRUPT_VIRQ) &&
415 (env->eflags & IF_MASK) &&
416 !(env->hflags & HF_INHIBIT_IRQ_MASK)) {
417 int intno;
418 /* FIXME: this should respect TPR */
419 svm_check_intercept(SVM_EXIT_VINTR);
420 intno = ldl_phys(env->vm_vmcb + offsetof(struct vmcb, control.int_vector));
421 qemu_log_mask(CPU_LOG_TB_IN_ASM, "Servicing virtual hardware INT=0x%02x\n", intno);
422 do_interrupt(intno, 0, 0, 0, 1);
423 env->interrupt_request &= ~CPU_INTERRUPT_VIRQ;
424 next_tb = 0;
425 #endif
426 }
427 }
428 #elif defined(TARGET_PPC)
429 #if 0
430 if ((interrupt_request & CPU_INTERRUPT_RESET)) {
431 cpu_reset(env);
432 }
433 #endif
434 if (interrupt_request & CPU_INTERRUPT_HARD) {
435 ppc_hw_interrupt(env);
436 if (env->pending_interrupts == 0)
437 env->interrupt_request &= ~CPU_INTERRUPT_HARD;
438 next_tb = 0;
439 }
440 #elif defined(TARGET_MICROBLAZE)
441 if ((interrupt_request & CPU_INTERRUPT_HARD)
442 && (env->sregs[SR_MSR] & MSR_IE)
443 && !(env->sregs[SR_MSR] & (MSR_EIP | MSR_BIP))
444 && !(env->iflags & (D_FLAG | IMM_FLAG))) {
445 env->exception_index = EXCP_IRQ;
446 do_interrupt(env);
447 next_tb = 0;
448 }
449 #elif defined(TARGET_MIPS)
450 if ((interrupt_request & CPU_INTERRUPT_HARD) &&
451 cpu_mips_hw_interrupts_pending(env) &&
452 (env->CP0_Status & (1 << CP0St_IE)) &&
453 !(env->CP0_Status & (1 << CP0St_EXL)) &&
454 !(env->CP0_Status & (1 << CP0St_ERL)) &&
455 !(env->hflags & MIPS_HFLAG_DM)) {
456 /* Raise it */
457 env->exception_index = EXCP_EXT_INTERRUPT;
458 env->error_code = 0;
459 do_interrupt(env);
460 next_tb = 0;
461 }
462 #elif defined(TARGET_SPARC)
463 if (interrupt_request & CPU_INTERRUPT_HARD) {
464 if (cpu_interrupts_enabled(env) &&
465 env->interrupt_index > 0) {
466 int pil = env->interrupt_index & 0xf;
467 int type = env->interrupt_index & 0xf0;
468
469 if (((type == TT_EXTINT) &&
470 cpu_pil_allowed(env, pil)) ||
471 type != TT_EXTINT) {
472 env->exception_index = env->interrupt_index;
473 do_interrupt(env);
474 next_tb = 0;
475 }
476 }
477 } else if (interrupt_request & CPU_INTERRUPT_TIMER) {
478 //do_interrupt(0, 0, 0, 0, 0);
479 env->interrupt_request &= ~CPU_INTERRUPT_TIMER;
480 }
481 #elif defined(TARGET_ARM)
482 if (interrupt_request & CPU_INTERRUPT_FIQ
483 && !(env->uncached_cpsr & CPSR_F)) {
484 env->exception_index = EXCP_FIQ;
485 do_interrupt(env);
486 next_tb = 0;
487 }
488 /* ARMv7-M interrupt return works by loading a magic value
489 into the PC. On real hardware the load causes the
490 return to occur. The qemu implementation performs the
491 jump normally, then does the exception return when the
492 CPU tries to execute code at the magic address.
493 This will cause the magic PC value to be pushed to
494 the stack if an interrupt occured at the wrong time.
495 We avoid this by disabling interrupts when
496 pc contains a magic address. */
497 if (interrupt_request & CPU_INTERRUPT_HARD
498 && ((IS_M(env) && env->regs[15] < 0xfffffff0)
499 || !(env->uncached_cpsr & CPSR_I))) {
500 env->exception_index = EXCP_IRQ;
501 do_interrupt(env);
502 next_tb = 0;
503 }
504 #elif defined(TARGET_SH4)
505 if (interrupt_request & CPU_INTERRUPT_HARD) {
506 do_interrupt(env);
507 next_tb = 0;
508 }
509 #elif defined(TARGET_ALPHA)
510 if (interrupt_request & CPU_INTERRUPT_HARD) {
511 do_interrupt(env);
512 next_tb = 0;
513 }
514 #elif defined(TARGET_CRIS)
515 if (interrupt_request & CPU_INTERRUPT_HARD
516 && (env->pregs[PR_CCS] & I_FLAG)
517 && !env->locked_irq) {
518 env->exception_index = EXCP_IRQ;
519 do_interrupt(env);
520 next_tb = 0;
521 }
522 if (interrupt_request & CPU_INTERRUPT_NMI
523 && (env->pregs[PR_CCS] & M_FLAG)) {
524 env->exception_index = EXCP_NMI;
525 do_interrupt(env);
526 next_tb = 0;
527 }
528 #elif defined(TARGET_M68K)
529 if (interrupt_request & CPU_INTERRUPT_HARD
530 && ((env->sr & SR_I) >> SR_I_SHIFT)
531 < env->pending_level) {
532 /* Real hardware gets the interrupt vector via an
533 IACK cycle at this point. Current emulated
534 hardware doesn't rely on this, so we
535 provide/save the vector when the interrupt is
536 first signalled. */
537 env->exception_index = env->pending_vector;
538 do_interrupt(1);
539 next_tb = 0;
540 }
541 #endif
542 /* Don't use the cached interupt_request value,
543 do_interrupt may have updated the EXITTB flag. */
544 if (env->interrupt_request & CPU_INTERRUPT_EXITTB) {
545 env->interrupt_request &= ~CPU_INTERRUPT_EXITTB;
546 /* ensure that no TB jump will be modified as
547 the program flow was changed */
548 next_tb = 0;
549 }
550 }
551 if (unlikely(env->exit_request)) {
552 env->exit_request = 0;
553 env->exception_index = EXCP_INTERRUPT;
554 cpu_loop_exit();
555 }
556 #if defined(DEBUG_DISAS) || defined(CONFIG_DEBUG_EXEC)
557 if (qemu_loglevel_mask(CPU_LOG_TB_CPU)) {
558 /* restore flags in standard format */
559 #if defined(TARGET_I386)
560 env->eflags = env->eflags | helper_cc_compute_all(CC_OP) | (DF & DF_MASK);
561 log_cpu_state(env, X86_DUMP_CCOP);
562 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
563 #elif defined(TARGET_M68K)
564 cpu_m68k_flush_flags(env, env->cc_op);
565 env->cc_op = CC_OP_FLAGS;
566 env->sr = (env->sr & 0xffe0)
567 | env->cc_dest | (env->cc_x << 4);
568 log_cpu_state(env, 0);
569 #else
570 log_cpu_state(env, 0);
571 #endif
572 }
573 #endif /* DEBUG_DISAS || CONFIG_DEBUG_EXEC */
574 spin_lock(&tb_lock);
575 tb = tb_find_fast();
576 /* Note: we do it here to avoid a gcc bug on Mac OS X when
577 doing it in tb_find_slow */
578 if (tb_invalidated_flag) {
579 /* as some TB could have been invalidated because
580 of memory exceptions while generating the code, we
581 must recompute the hash index here */
582 next_tb = 0;
583 tb_invalidated_flag = 0;
584 }
585 #ifdef CONFIG_DEBUG_EXEC
586 qemu_log_mask(CPU_LOG_EXEC, "Trace 0x%08lx [" TARGET_FMT_lx "] %s\n",
587 (long)tb->tc_ptr, tb->pc,
588 lookup_symbol(tb->pc));
589 #endif
590 /* see if we can patch the calling TB. When the TB
591 spans two pages, we cannot safely do a direct
592 jump. */
593 if (next_tb != 0 && tb->page_addr[1] == -1) {
594 tb_add_jump((TranslationBlock *)(next_tb & ~3), next_tb & 3, tb);
595 }
596 spin_unlock(&tb_lock);
597
598 /* cpu_interrupt might be called while translating the
599 TB, but before it is linked into a potentially
600 infinite loop and becomes env->current_tb. Avoid
601 starting execution if there is a pending interrupt. */
602 env->current_tb = tb;
603 barrier();
604 if (likely(!env->exit_request)) {
605 tc_ptr = tb->tc_ptr;
606 /* execute the generated code */
607 #if defined(__sparc__) && !defined(CONFIG_SOLARIS)
608 #undef env
609 env = cpu_single_env;
610 #define env cpu_single_env
611 #endif
612 next_tb = tcg_qemu_tb_exec(tc_ptr);
613 if ((next_tb & 3) == 2) {
614 /* Instruction counter expired. */
615 int insns_left;
616 tb = (TranslationBlock *)(long)(next_tb & ~3);
617 /* Restore PC. */
618 cpu_pc_from_tb(env, tb);
619 insns_left = env->icount_decr.u32;
620 if (env->icount_extra && insns_left >= 0) {
621 /* Refill decrementer and continue execution. */
622 env->icount_extra += insns_left;
623 if (env->icount_extra > 0xffff) {
624 insns_left = 0xffff;
625 } else {
626 insns_left = env->icount_extra;
627 }
628 env->icount_extra -= insns_left;
629 env->icount_decr.u16.low = insns_left;
630 } else {
631 if (insns_left > 0) {
632 /* Execute remaining instructions. */
633 cpu_exec_nocache(insns_left, tb);
634 }
635 env->exception_index = EXCP_INTERRUPT;
636 next_tb = 0;
637 cpu_loop_exit();
638 }
639 }
640 }
641 env->current_tb = NULL;
642 /* reset soft MMU for next block (it can currently
643 only be set by a memory fault) */
644 } /* for(;;) */
645 }
646 } /* for(;;) */
647
648
649 #if defined(TARGET_I386)
650 /* restore flags in standard format */
651 env->eflags = env->eflags | helper_cc_compute_all(CC_OP) | (DF & DF_MASK);
652 #elif defined(TARGET_ARM)
653 /* XXX: Save/restore host fpu exception state?. */
654 #elif defined(TARGET_SPARC)
655 #elif defined(TARGET_PPC)
656 #elif defined(TARGET_M68K)
657 cpu_m68k_flush_flags(env, env->cc_op);
658 env->cc_op = CC_OP_FLAGS;
659 env->sr = (env->sr & 0xffe0)
660 | env->cc_dest | (env->cc_x << 4);
661 #elif defined(TARGET_MICROBLAZE)
662 #elif defined(TARGET_MIPS)
663 #elif defined(TARGET_SH4)
664 #elif defined(TARGET_ALPHA)
665 #elif defined(TARGET_CRIS)
666 #elif defined(TARGET_S390X)
667 /* XXXXX */
668 #else
669 #error unsupported target CPU
670 #endif
671
672 /* restore global registers */
673 barrier();
674 env = (void *) saved_env_reg;
675
676 /* fail safe : never use cpu_single_env outside cpu_exec() */
677 cpu_single_env = NULL;
678 return ret;
679 }
680
681 /* must only be called from the generated code as an exception can be
682 generated */
683 void tb_invalidate_page_range(target_ulong start, target_ulong end)
684 {
685 /* XXX: cannot enable it yet because it yields to MMU exception
686 where NIP != read address on PowerPC */
687 #if 0
688 target_ulong phys_addr;
689 phys_addr = get_phys_addr_code(env, start);
690 tb_invalidate_phys_page_range(phys_addr, phys_addr + end - start, 0);
691 #endif
692 }
693
694 #if defined(TARGET_I386) && defined(CONFIG_USER_ONLY)
695
696 void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector)
697 {
698 CPUX86State *saved_env;
699
700 saved_env = env;
701 env = s;
702 if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK)) {
703 selector &= 0xffff;
704 cpu_x86_load_seg_cache(env, seg_reg, selector,
705 (selector << 4), 0xffff, 0);
706 } else {
707 helper_load_seg(seg_reg, selector);
708 }
709 env = saved_env;
710 }
711
712 void cpu_x86_fsave(CPUX86State *s, target_ulong ptr, int data32)
713 {
714 CPUX86State *saved_env;
715
716 saved_env = env;
717 env = s;
718
719 helper_fsave(ptr, data32);
720
721 env = saved_env;
722 }
723
724 void cpu_x86_frstor(CPUX86State *s, target_ulong ptr, int data32)
725 {
726 CPUX86State *saved_env;
727
728 saved_env = env;
729 env = s;
730
731 helper_frstor(ptr, data32);
732
733 env = saved_env;
734 }
735
736 #endif /* TARGET_I386 */
737
738 #if !defined(CONFIG_SOFTMMU)
739
740 #if defined(TARGET_I386)
741 #define EXCEPTION_ACTION raise_exception_err(env->exception_index, env->error_code)
742 #else
743 #define EXCEPTION_ACTION cpu_loop_exit()
744 #endif
745
746 /* 'pc' is the host PC at which the exception was raised. 'address' is
747 the effective address of the memory exception. 'is_write' is 1 if a
748 write caused the exception and otherwise 0'. 'old_set' is the
749 signal set which should be restored */
750 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
751 int is_write, sigset_t *old_set,
752 void *puc)
753 {
754 TranslationBlock *tb;
755 int ret;
756
757 if (cpu_single_env)
758 env = cpu_single_env; /* XXX: find a correct solution for multithread */
759 #if defined(DEBUG_SIGNAL)
760 qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
761 pc, address, is_write, *(unsigned long *)old_set);
762 #endif
763 /* XXX: locking issue */
764 if (is_write && page_unprotect(h2g(address), pc, puc)) {
765 return 1;
766 }
767
768 /* see if it is an MMU fault */
769 ret = cpu_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
770 if (ret < 0)
771 return 0; /* not an MMU fault */
772 if (ret == 0)
773 return 1; /* the MMU fault was handled without causing real CPU fault */
774 /* now we have a real cpu fault */
775 tb = tb_find_pc(pc);
776 if (tb) {
777 /* the PC is inside the translated code. It means that we have
778 a virtual CPU fault */
779 cpu_restore_state(tb, env, pc, puc);
780 }
781
782 /* we restore the process signal mask as the sigreturn should
783 do it (XXX: use sigsetjmp) */
784 sigprocmask(SIG_SETMASK, old_set, NULL);
785 EXCEPTION_ACTION;
786
787 /* never comes here */
788 return 1;
789 }
790
791 #if defined(__i386__)
792
793 #if defined(__APPLE__)
794 # include <sys/ucontext.h>
795
796 # define EIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->ss.eip))
797 # define TRAP_sig(context) ((context)->uc_mcontext->es.trapno)
798 # define ERROR_sig(context) ((context)->uc_mcontext->es.err)
799 # define MASK_sig(context) ((context)->uc_sigmask)
800 #elif defined (__NetBSD__)
801 # include <ucontext.h>
802
803 # define EIP_sig(context) ((context)->uc_mcontext.__gregs[_REG_EIP])
804 # define TRAP_sig(context) ((context)->uc_mcontext.__gregs[_REG_TRAPNO])
805 # define ERROR_sig(context) ((context)->uc_mcontext.__gregs[_REG_ERR])
806 # define MASK_sig(context) ((context)->uc_sigmask)
807 #elif defined (__FreeBSD__) || defined(__DragonFly__)
808 # include <ucontext.h>
809
810 # define EIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext.mc_eip))
811 # define TRAP_sig(context) ((context)->uc_mcontext.mc_trapno)
812 # define ERROR_sig(context) ((context)->uc_mcontext.mc_err)
813 # define MASK_sig(context) ((context)->uc_sigmask)
814 #elif defined(__OpenBSD__)
815 # define EIP_sig(context) ((context)->sc_eip)
816 # define TRAP_sig(context) ((context)->sc_trapno)
817 # define ERROR_sig(context) ((context)->sc_err)
818 # define MASK_sig(context) ((context)->sc_mask)
819 #else
820 # define EIP_sig(context) ((context)->uc_mcontext.gregs[REG_EIP])
821 # define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
822 # define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
823 # define MASK_sig(context) ((context)->uc_sigmask)
824 #endif
825
826 int cpu_signal_handler(int host_signum, void *pinfo,
827 void *puc)
828 {
829 siginfo_t *info = pinfo;
830 #if defined(__NetBSD__) || defined (__FreeBSD__) || defined(__DragonFly__)
831 ucontext_t *uc = puc;
832 #elif defined(__OpenBSD__)
833 struct sigcontext *uc = puc;
834 #else
835 struct ucontext *uc = puc;
836 #endif
837 unsigned long pc;
838 int trapno;
839
840 #ifndef REG_EIP
841 /* for glibc 2.1 */
842 #define REG_EIP EIP
843 #define REG_ERR ERR
844 #define REG_TRAPNO TRAPNO
845 #endif
846 pc = EIP_sig(uc);
847 trapno = TRAP_sig(uc);
848 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
849 trapno == 0xe ?
850 (ERROR_sig(uc) >> 1) & 1 : 0,
851 &MASK_sig(uc), puc);
852 }
853
854 #elif defined(__x86_64__)
855
856 #ifdef __NetBSD__
857 #define PC_sig(context) _UC_MACHINE_PC(context)
858 #define TRAP_sig(context) ((context)->uc_mcontext.__gregs[_REG_TRAPNO])
859 #define ERROR_sig(context) ((context)->uc_mcontext.__gregs[_REG_ERR])
860 #define MASK_sig(context) ((context)->uc_sigmask)
861 #elif defined(__OpenBSD__)
862 #define PC_sig(context) ((context)->sc_rip)
863 #define TRAP_sig(context) ((context)->sc_trapno)
864 #define ERROR_sig(context) ((context)->sc_err)
865 #define MASK_sig(context) ((context)->sc_mask)
866 #elif defined (__FreeBSD__) || defined(__DragonFly__)
867 #include <ucontext.h>
868
869 #define PC_sig(context) (*((unsigned long*)&(context)->uc_mcontext.mc_rip))
870 #define TRAP_sig(context) ((context)->uc_mcontext.mc_trapno)
871 #define ERROR_sig(context) ((context)->uc_mcontext.mc_err)
872 #define MASK_sig(context) ((context)->uc_sigmask)
873 #else
874 #define PC_sig(context) ((context)->uc_mcontext.gregs[REG_RIP])
875 #define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
876 #define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
877 #define MASK_sig(context) ((context)->uc_sigmask)
878 #endif
879
880 int cpu_signal_handler(int host_signum, void *pinfo,
881 void *puc)
882 {
883 siginfo_t *info = pinfo;
884 unsigned long pc;
885 #if defined(__NetBSD__) || defined (__FreeBSD__) || defined(__DragonFly__)
886 ucontext_t *uc = puc;
887 #elif defined(__OpenBSD__)
888 struct sigcontext *uc = puc;
889 #else
890 struct ucontext *uc = puc;
891 #endif
892
893 pc = PC_sig(uc);
894 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
895 TRAP_sig(uc) == 0xe ?
896 (ERROR_sig(uc) >> 1) & 1 : 0,
897 &MASK_sig(uc), puc);
898 }
899
900 #elif defined(_ARCH_PPC)
901
902 /***********************************************************************
903 * signal context platform-specific definitions
904 * From Wine
905 */
906 #ifdef linux
907 /* All Registers access - only for local access */
908 # define REG_sig(reg_name, context) ((context)->uc_mcontext.regs->reg_name)
909 /* Gpr Registers access */
910 # define GPR_sig(reg_num, context) REG_sig(gpr[reg_num], context)
911 # define IAR_sig(context) REG_sig(nip, context) /* Program counter */
912 # define MSR_sig(context) REG_sig(msr, context) /* Machine State Register (Supervisor) */
913 # define CTR_sig(context) REG_sig(ctr, context) /* Count register */
914 # define XER_sig(context) REG_sig(xer, context) /* User's integer exception register */
915 # define LR_sig(context) REG_sig(link, context) /* Link register */
916 # define CR_sig(context) REG_sig(ccr, context) /* Condition register */
917 /* Float Registers access */
918 # define FLOAT_sig(reg_num, context) (((double*)((char*)((context)->uc_mcontext.regs+48*4)))[reg_num])
919 # define FPSCR_sig(context) (*(int*)((char*)((context)->uc_mcontext.regs+(48+32*2)*4)))
920 /* Exception Registers access */
921 # define DAR_sig(context) REG_sig(dar, context)
922 # define DSISR_sig(context) REG_sig(dsisr, context)
923 # define TRAP_sig(context) REG_sig(trap, context)
924 #endif /* linux */
925
926 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
927 #include <ucontext.h>
928 # define IAR_sig(context) ((context)->uc_mcontext.mc_srr0)
929 # define MSR_sig(context) ((context)->uc_mcontext.mc_srr1)
930 # define CTR_sig(context) ((context)->uc_mcontext.mc_ctr)
931 # define XER_sig(context) ((context)->uc_mcontext.mc_xer)
932 # define LR_sig(context) ((context)->uc_mcontext.mc_lr)
933 # define CR_sig(context) ((context)->uc_mcontext.mc_cr)
934 /* Exception Registers access */
935 # define DAR_sig(context) ((context)->uc_mcontext.mc_dar)
936 # define DSISR_sig(context) ((context)->uc_mcontext.mc_dsisr)
937 # define TRAP_sig(context) ((context)->uc_mcontext.mc_exc)
938 #endif /* __FreeBSD__|| __FreeBSD_kernel__ */
939
940 #ifdef __APPLE__
941 # include <sys/ucontext.h>
942 typedef struct ucontext SIGCONTEXT;
943 /* All Registers access - only for local access */
944 # define REG_sig(reg_name, context) ((context)->uc_mcontext->ss.reg_name)
945 # define FLOATREG_sig(reg_name, context) ((context)->uc_mcontext->fs.reg_name)
946 # define EXCEPREG_sig(reg_name, context) ((context)->uc_mcontext->es.reg_name)
947 # define VECREG_sig(reg_name, context) ((context)->uc_mcontext->vs.reg_name)
948 /* Gpr Registers access */
949 # define GPR_sig(reg_num, context) REG_sig(r##reg_num, context)
950 # define IAR_sig(context) REG_sig(srr0, context) /* Program counter */
951 # define MSR_sig(context) REG_sig(srr1, context) /* Machine State Register (Supervisor) */
952 # define CTR_sig(context) REG_sig(ctr, context)
953 # define XER_sig(context) REG_sig(xer, context) /* Link register */
954 # define LR_sig(context) REG_sig(lr, context) /* User's integer exception register */
955 # define CR_sig(context) REG_sig(cr, context) /* Condition register */
956 /* Float Registers access */
957 # define FLOAT_sig(reg_num, context) FLOATREG_sig(fpregs[reg_num], context)
958 # define FPSCR_sig(context) ((double)FLOATREG_sig(fpscr, context))
959 /* Exception Registers access */
960 # define DAR_sig(context) EXCEPREG_sig(dar, context) /* Fault registers for coredump */
961 # define DSISR_sig(context) EXCEPREG_sig(dsisr, context)
962 # define TRAP_sig(context) EXCEPREG_sig(exception, context) /* number of powerpc exception taken */
963 #endif /* __APPLE__ */
964
965 int cpu_signal_handler(int host_signum, void *pinfo,
966 void *puc)
967 {
968 siginfo_t *info = pinfo;
969 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
970 ucontext_t *uc = puc;
971 #else
972 struct ucontext *uc = puc;
973 #endif
974 unsigned long pc;
975 int is_write;
976
977 pc = IAR_sig(uc);
978 is_write = 0;
979 #if 0
980 /* ppc 4xx case */
981 if (DSISR_sig(uc) & 0x00800000)
982 is_write = 1;
983 #else
984 if (TRAP_sig(uc) != 0x400 && (DSISR_sig(uc) & 0x02000000))
985 is_write = 1;
986 #endif
987 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
988 is_write, &uc->uc_sigmask, puc);
989 }
990
991 #elif defined(__alpha__)
992
993 int cpu_signal_handler(int host_signum, void *pinfo,
994 void *puc)
995 {
996 siginfo_t *info = pinfo;
997 struct ucontext *uc = puc;
998 uint32_t *pc = uc->uc_mcontext.sc_pc;
999 uint32_t insn = *pc;
1000 int is_write = 0;
1001
1002 /* XXX: need kernel patch to get write flag faster */
1003 switch (insn >> 26) {
1004 case 0x0d: // stw
1005 case 0x0e: // stb
1006 case 0x0f: // stq_u
1007 case 0x24: // stf
1008 case 0x25: // stg
1009 case 0x26: // sts
1010 case 0x27: // stt
1011 case 0x2c: // stl
1012 case 0x2d: // stq
1013 case 0x2e: // stl_c
1014 case 0x2f: // stq_c
1015 is_write = 1;
1016 }
1017
1018 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1019 is_write, &uc->uc_sigmask, puc);
1020 }
1021 #elif defined(__sparc__)
1022
1023 int cpu_signal_handler(int host_signum, void *pinfo,
1024 void *puc)
1025 {
1026 siginfo_t *info = pinfo;
1027 int is_write;
1028 uint32_t insn;
1029 #if !defined(__arch64__) || defined(CONFIG_SOLARIS)
1030 uint32_t *regs = (uint32_t *)(info + 1);
1031 void *sigmask = (regs + 20);
1032 /* XXX: is there a standard glibc define ? */
1033 unsigned long pc = regs[1];
1034 #else
1035 #ifdef __linux__
1036 struct sigcontext *sc = puc;
1037 unsigned long pc = sc->sigc_regs.tpc;
1038 void *sigmask = (void *)sc->sigc_mask;
1039 #elif defined(__OpenBSD__)
1040 struct sigcontext *uc = puc;
1041 unsigned long pc = uc->sc_pc;
1042 void *sigmask = (void *)(long)uc->sc_mask;
1043 #endif
1044 #endif
1045
1046 /* XXX: need kernel patch to get write flag faster */
1047 is_write = 0;
1048 insn = *(uint32_t *)pc;
1049 if ((insn >> 30) == 3) {
1050 switch((insn >> 19) & 0x3f) {
1051 case 0x05: // stb
1052 case 0x15: // stba
1053 case 0x06: // sth
1054 case 0x16: // stha
1055 case 0x04: // st
1056 case 0x14: // sta
1057 case 0x07: // std
1058 case 0x17: // stda
1059 case 0x0e: // stx
1060 case 0x1e: // stxa
1061 case 0x24: // stf
1062 case 0x34: // stfa
1063 case 0x27: // stdf
1064 case 0x37: // stdfa
1065 case 0x26: // stqf
1066 case 0x36: // stqfa
1067 case 0x25: // stfsr
1068 case 0x3c: // casa
1069 case 0x3e: // casxa
1070 is_write = 1;
1071 break;
1072 }
1073 }
1074 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1075 is_write, sigmask, NULL);
1076 }
1077
1078 #elif defined(__arm__)
1079
1080 int cpu_signal_handler(int host_signum, void *pinfo,
1081 void *puc)
1082 {
1083 siginfo_t *info = pinfo;
1084 struct ucontext *uc = puc;
1085 unsigned long pc;
1086 int is_write;
1087
1088 #if (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
1089 pc = uc->uc_mcontext.gregs[R15];
1090 #else
1091 pc = uc->uc_mcontext.arm_pc;
1092 #endif
1093 /* XXX: compute is_write */
1094 is_write = 0;
1095 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1096 is_write,
1097 &uc->uc_sigmask, puc);
1098 }
1099
1100 #elif defined(__mc68000)
1101
1102 int cpu_signal_handler(int host_signum, void *pinfo,
1103 void *puc)
1104 {
1105 siginfo_t *info = pinfo;
1106 struct ucontext *uc = puc;
1107 unsigned long pc;
1108 int is_write;
1109
1110 pc = uc->uc_mcontext.gregs[16];
1111 /* XXX: compute is_write */
1112 is_write = 0;
1113 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1114 is_write,
1115 &uc->uc_sigmask, puc);
1116 }
1117
1118 #elif defined(__ia64)
1119
1120 #ifndef __ISR_VALID
1121 /* This ought to be in <bits/siginfo.h>... */
1122 # define __ISR_VALID 1
1123 #endif
1124
1125 int cpu_signal_handler(int host_signum, void *pinfo, void *puc)
1126 {
1127 siginfo_t *info = pinfo;
1128 struct ucontext *uc = puc;
1129 unsigned long ip;
1130 int is_write = 0;
1131
1132 ip = uc->uc_mcontext.sc_ip;
1133 switch (host_signum) {
1134 case SIGILL:
1135 case SIGFPE:
1136 case SIGSEGV:
1137 case SIGBUS:
1138 case SIGTRAP:
1139 if (info->si_code && (info->si_segvflags & __ISR_VALID))
1140 /* ISR.W (write-access) is bit 33: */
1141 is_write = (info->si_isr >> 33) & 1;
1142 break;
1143
1144 default:
1145 break;
1146 }
1147 return handle_cpu_signal(ip, (unsigned long)info->si_addr,
1148 is_write,
1149 (sigset_t *)&uc->uc_sigmask, puc);
1150 }
1151
1152 #elif defined(__s390__)
1153
1154 int cpu_signal_handler(int host_signum, void *pinfo,
1155 void *puc)
1156 {
1157 siginfo_t *info = pinfo;
1158 struct ucontext *uc = puc;
1159 unsigned long pc;
1160 uint16_t *pinsn;
1161 int is_write = 0;
1162
1163 pc = uc->uc_mcontext.psw.addr;
1164
1165 /* ??? On linux, the non-rt signal handler has 4 (!) arguments instead
1166 of the normal 2 arguments. The 3rd argument contains the "int_code"
1167 from the hardware which does in fact contain the is_write value.
1168 The rt signal handler, as far as I can tell, does not give this value
1169 at all. Not that we could get to it from here even if it were. */
1170 /* ??? This is not even close to complete, since it ignores all
1171 of the read-modify-write instructions. */
1172 pinsn = (uint16_t *)pc;
1173 switch (pinsn[0] >> 8) {
1174 case 0x50: /* ST */
1175 case 0x42: /* STC */
1176 case 0x40: /* STH */
1177 is_write = 1;
1178 break;
1179 case 0xc4: /* RIL format insns */
1180 switch (pinsn[0] & 0xf) {
1181 case 0xf: /* STRL */
1182 case 0xb: /* STGRL */
1183 case 0x7: /* STHRL */
1184 is_write = 1;
1185 }
1186 break;
1187 case 0xe3: /* RXY format insns */
1188 switch (pinsn[2] & 0xff) {
1189 case 0x50: /* STY */
1190 case 0x24: /* STG */
1191 case 0x72: /* STCY */
1192 case 0x70: /* STHY */
1193 case 0x8e: /* STPQ */
1194 case 0x3f: /* STRVH */
1195 case 0x3e: /* STRV */
1196 case 0x2f: /* STRVG */
1197 is_write = 1;
1198 }
1199 break;
1200 }
1201 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1202 is_write, &uc->uc_sigmask, puc);
1203 }
1204
1205 #elif defined(__mips__)
1206
1207 int cpu_signal_handler(int host_signum, void *pinfo,
1208 void *puc)
1209 {
1210 siginfo_t *info = pinfo;
1211 struct ucontext *uc = puc;
1212 greg_t pc = uc->uc_mcontext.pc;
1213 int is_write;
1214
1215 /* XXX: compute is_write */
1216 is_write = 0;
1217 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1218 is_write, &uc->uc_sigmask, puc);
1219 }
1220
1221 #elif defined(__hppa__)
1222
1223 int cpu_signal_handler(int host_signum, void *pinfo,
1224 void *puc)
1225 {
1226 struct siginfo *info = pinfo;
1227 struct ucontext *uc = puc;
1228 unsigned long pc = uc->uc_mcontext.sc_iaoq[0];
1229 uint32_t insn = *(uint32_t *)pc;
1230 int is_write = 0;
1231
1232 /* XXX: need kernel patch to get write flag faster. */
1233 switch (insn >> 26) {
1234 case 0x1a: /* STW */
1235 case 0x19: /* STH */
1236 case 0x18: /* STB */
1237 case 0x1b: /* STWM */
1238 is_write = 1;
1239 break;
1240
1241 case 0x09: /* CSTWX, FSTWX, FSTWS */
1242 case 0x0b: /* CSTDX, FSTDX, FSTDS */
1243 /* Distinguish from coprocessor load ... */
1244 is_write = (insn >> 9) & 1;
1245 break;
1246
1247 case 0x03:
1248 switch ((insn >> 6) & 15) {
1249 case 0xa: /* STWS */
1250 case 0x9: /* STHS */
1251 case 0x8: /* STBS */
1252 case 0xe: /* STWAS */
1253 case 0xc: /* STBYS */
1254 is_write = 1;
1255 }
1256 break;
1257 }
1258
1259 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1260 is_write, &uc->uc_sigmask, puc);
1261 }
1262
1263 #else
1264
1265 #error host CPU specific signal handler needed
1266
1267 #endif
1268
1269 #endif /* !defined(CONFIG_SOFTMMU) */
QEmu