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