?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qdev/prop: convert syborg_pointer.c to helper macros.
[qemu/scottt.git] / cpu-exec.c
blob1718dc4ebf979a88c53005313f8a81722cc3b9f3
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 #if !defined(CONFIG_USER_ONLY)
489 cpu_check_irqs(env);
490 #endif
491 next_tb = 0;
492 }
493 } else if (interrupt_request & CPU_INTERRUPT_TIMER) {
494 //do_interrupt(0, 0, 0, 0, 0);
495 env->interrupt_request &= ~CPU_INTERRUPT_TIMER;
496 }
497 #elif defined(TARGET_ARM)
498 if (interrupt_request & CPU_INTERRUPT_FIQ
499 && !(env->uncached_cpsr & CPSR_F)) {
500 env->exception_index = EXCP_FIQ;
501 do_interrupt(env);
502 next_tb = 0;
503 }
504 /* ARMv7-M interrupt return works by loading a magic value
505 into the PC. On real hardware the load causes the
506 return to occur. The qemu implementation performs the
507 jump normally, then does the exception return when the
508 CPU tries to execute code at the magic address.
509 This will cause the magic PC value to be pushed to
510 the stack if an interrupt occured at the wrong time.
511 We avoid this by disabling interrupts when
512 pc contains a magic address. */
513 if (interrupt_request & CPU_INTERRUPT_HARD
514 && ((IS_M(env) && env->regs[15] < 0xfffffff0)
515 || !(env->uncached_cpsr & CPSR_I))) {
516 env->exception_index = EXCP_IRQ;
517 do_interrupt(env);
518 next_tb = 0;
519 }
520 #elif defined(TARGET_SH4)
521 if (interrupt_request & CPU_INTERRUPT_HARD) {
522 do_interrupt(env);
523 next_tb = 0;
524 }
525 #elif defined(TARGET_ALPHA)
526 if (interrupt_request & CPU_INTERRUPT_HARD) {
527 do_interrupt(env);
528 next_tb = 0;
529 }
530 #elif defined(TARGET_CRIS)
531 if (interrupt_request & CPU_INTERRUPT_HARD
532 && (env->pregs[PR_CCS] & I_FLAG)) {
533 env->exception_index = EXCP_IRQ;
534 do_interrupt(env);
535 next_tb = 0;
536 }
537 if (interrupt_request & CPU_INTERRUPT_NMI
538 && (env->pregs[PR_CCS] & M_FLAG)) {
539 env->exception_index = EXCP_NMI;
540 do_interrupt(env);
541 next_tb = 0;
542 }
543 #elif defined(TARGET_M68K)
544 if (interrupt_request & CPU_INTERRUPT_HARD
545 && ((env->sr & SR_I) >> SR_I_SHIFT)
546 < env->pending_level) {
547 /* Real hardware gets the interrupt vector via an
548 IACK cycle at this point. Current emulated
549 hardware doesn't rely on this, so we
550 provide/save the vector when the interrupt is
551 first signalled. */
552 env->exception_index = env->pending_vector;
553 do_interrupt(1);
554 next_tb = 0;
555 }
556 #endif
557 /* Don't use the cached interupt_request value,
558 do_interrupt may have updated the EXITTB flag. */
559 if (env->interrupt_request & CPU_INTERRUPT_EXITTB) {
560 env->interrupt_request &= ~CPU_INTERRUPT_EXITTB;
561 /* ensure that no TB jump will be modified as
562 the program flow was changed */
563 next_tb = 0;
564 }
565 }
566 if (unlikely(env->exit_request)) {
567 env->exit_request = 0;
568 env->exception_index = EXCP_INTERRUPT;
569 cpu_loop_exit();
570 }
571 #ifdef CONFIG_DEBUG_EXEC
572 if (qemu_loglevel_mask(CPU_LOG_TB_CPU)) {
573 /* restore flags in standard format */
574 regs_to_env();
575 #if defined(TARGET_I386)
576 env->eflags = env->eflags | helper_cc_compute_all(CC_OP) | (DF & DF_MASK);
577 log_cpu_state(env, X86_DUMP_CCOP);
578 env->eflags &= ~(DF_MASK | CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
579 #elif defined(TARGET_ARM)
580 log_cpu_state(env, 0);
581 #elif defined(TARGET_SPARC)
582 log_cpu_state(env, 0);
583 #elif defined(TARGET_PPC)
584 log_cpu_state(env, 0);
585 #elif defined(TARGET_M68K)
586 cpu_m68k_flush_flags(env, env->cc_op);
587 env->cc_op = CC_OP_FLAGS;
588 env->sr = (env->sr & 0xffe0)
589 | env->cc_dest | (env->cc_x << 4);
590 log_cpu_state(env, 0);
591 #elif defined(TARGET_MICROBLAZE)
592 log_cpu_state(env, 0);
593 #elif defined(TARGET_MIPS)
594 log_cpu_state(env, 0);
595 #elif defined(TARGET_SH4)
596 log_cpu_state(env, 0);
597 #elif defined(TARGET_ALPHA)
598 log_cpu_state(env, 0);
599 #elif defined(TARGET_CRIS)
600 log_cpu_state(env, 0);
601 #else
602 #error unsupported target CPU
603 #endif
604 }
605 #endif
606 spin_lock(&tb_lock);
607 tb = tb_find_fast();
608 /* Note: we do it here to avoid a gcc bug on Mac OS X when
609 doing it in tb_find_slow */
610 if (tb_invalidated_flag) {
611 /* as some TB could have been invalidated because
612 of memory exceptions while generating the code, we
613 must recompute the hash index here */
614 next_tb = 0;
615 tb_invalidated_flag = 0;
616 }
617 #ifdef CONFIG_DEBUG_EXEC
618 qemu_log_mask(CPU_LOG_EXEC, "Trace 0x%08lx [" TARGET_FMT_lx "] %s\n",
619 (long)tb->tc_ptr, tb->pc,
620 lookup_symbol(tb->pc));
621 #endif
622 /* see if we can patch the calling TB. When the TB
623 spans two pages, we cannot safely do a direct
624 jump. */
625 {
626 if (next_tb != 0 &&
627 #ifdef CONFIG_KQEMU
628 (env->kqemu_enabled != 2) &&
629 #endif
630 tb->page_addr[1] == -1) {
631 tb_add_jump((TranslationBlock *)(next_tb & ~3), next_tb & 3, tb);
632 }
633 }
634 spin_unlock(&tb_lock);
635 env->current_tb = tb;
636
637 /* cpu_interrupt might be called while translating the
638 TB, but before it is linked into a potentially
639 infinite loop and becomes env->current_tb. Avoid
640 starting execution if there is a pending interrupt. */
641 if (unlikely (env->exit_request))
642 env->current_tb = NULL;
643
644 while (env->current_tb) {
645 tc_ptr = tb->tc_ptr;
646 /* execute the generated code */
647 #if defined(__sparc__) && !defined(CONFIG_SOLARIS)
648 #undef env
649 env = cpu_single_env;
650 #define env cpu_single_env
651 #endif
652 next_tb = tcg_qemu_tb_exec(tc_ptr);
653 env->current_tb = NULL;
654 if ((next_tb & 3) == 2) {
655 /* Instruction counter expired. */
656 int insns_left;
657 tb = (TranslationBlock *)(long)(next_tb & ~3);
658 /* Restore PC. */
659 cpu_pc_from_tb(env, tb);
660 insns_left = env->icount_decr.u32;
661 if (env->icount_extra && insns_left >= 0) {
662 /* Refill decrementer and continue execution. */
663 env->icount_extra += insns_left;
664 if (env->icount_extra > 0xffff) {
665 insns_left = 0xffff;
666 } else {
667 insns_left = env->icount_extra;
668 }
669 env->icount_extra -= insns_left;
670 env->icount_decr.u16.low = insns_left;
671 } else {
672 if (insns_left > 0) {
673 /* Execute remaining instructions. */
674 cpu_exec_nocache(insns_left, tb);
675 }
676 env->exception_index = EXCP_INTERRUPT;
677 next_tb = 0;
678 cpu_loop_exit();
679 }
680 }
681 }
682 /* reset soft MMU for next block (it can currently
683 only be set by a memory fault) */
684 #if defined(CONFIG_KQEMU)
685 #define MIN_CYCLE_BEFORE_SWITCH (100 * 1000)
686 if (kqemu_is_ok(env) &&
687 (cpu_get_time_fast() - env->last_io_time) >= MIN_CYCLE_BEFORE_SWITCH) {
688 cpu_loop_exit();
689 }
690 #endif
691 } /* for(;;) */
692 } else {
693 env_to_regs();
694 }
695 } /* for(;;) */
696
697
698 #if defined(TARGET_I386)
699 /* restore flags in standard format */
700 env->eflags = env->eflags | helper_cc_compute_all(CC_OP) | (DF & DF_MASK);
701 #elif defined(TARGET_ARM)
702 /* XXX: Save/restore host fpu exception state?. */
703 #elif defined(TARGET_SPARC)
704 #elif defined(TARGET_PPC)
705 #elif defined(TARGET_M68K)
706 cpu_m68k_flush_flags(env, env->cc_op);
707 env->cc_op = CC_OP_FLAGS;
708 env->sr = (env->sr & 0xffe0)
709 | env->cc_dest | (env->cc_x << 4);
710 #elif defined(TARGET_MICROBLAZE)
711 #elif defined(TARGET_MIPS)
712 #elif defined(TARGET_SH4)
713 #elif defined(TARGET_ALPHA)
714 #elif defined(TARGET_CRIS)
715 /* XXXXX */
716 #else
717 #error unsupported target CPU
718 #endif
719
720 /* restore global registers */
721 #include "hostregs_helper.h"
722
723 /* fail safe : never use cpu_single_env outside cpu_exec() */
724 cpu_single_env = NULL;
725 return ret;
726 }
727
728 /* must only be called from the generated code as an exception can be
729 generated */
730 void tb_invalidate_page_range(target_ulong start, target_ulong end)
731 {
732 /* XXX: cannot enable it yet because it yields to MMU exception
733 where NIP != read address on PowerPC */
734 #if 0
735 target_ulong phys_addr;
736 phys_addr = get_phys_addr_code(env, start);
737 tb_invalidate_phys_page_range(phys_addr, phys_addr + end - start, 0);
738 #endif
739 }
740
741 #if defined(TARGET_I386) && defined(CONFIG_USER_ONLY)
742
743 void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector)
744 {
745 CPUX86State *saved_env;
746
747 saved_env = env;
748 env = s;
749 if (!(env->cr[0] & CR0_PE_MASK) || (env->eflags & VM_MASK)) {
750 selector &= 0xffff;
751 cpu_x86_load_seg_cache(env, seg_reg, selector,
752 (selector << 4), 0xffff, 0);
753 } else {
754 helper_load_seg(seg_reg, selector);
755 }
756 env = saved_env;
757 }
758
759 void cpu_x86_fsave(CPUX86State *s, target_ulong ptr, int data32)
760 {
761 CPUX86State *saved_env;
762
763 saved_env = env;
764 env = s;
765
766 helper_fsave(ptr, data32);
767
768 env = saved_env;
769 }
770
771 void cpu_x86_frstor(CPUX86State *s, target_ulong ptr, int data32)
772 {
773 CPUX86State *saved_env;
774
775 saved_env = env;
776 env = s;
777
778 helper_frstor(ptr, data32);
779
780 env = saved_env;
781 }
782
783 #endif /* TARGET_I386 */
784
785 #if !defined(CONFIG_SOFTMMU)
786
787 #if defined(TARGET_I386)
788
789 /* 'pc' is the host PC at which the exception was raised. 'address' is
790 the effective address of the memory exception. 'is_write' is 1 if a
791 write caused the exception and otherwise 0'. 'old_set' is the
792 signal set which should be restored */
793 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
794 int is_write, sigset_t *old_set,
795 void *puc)
796 {
797 TranslationBlock *tb;
798 int ret;
799
800 if (cpu_single_env)
801 env = cpu_single_env; /* XXX: find a correct solution for multithread */
802 #if defined(DEBUG_SIGNAL)
803 qemu_printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
804 pc, address, is_write, *(unsigned long *)old_set);
805 #endif
806 /* XXX: locking issue */
807 if (is_write && page_unprotect(h2g(address), pc, puc)) {
808 return 1;
809 }
810
811 /* see if it is an MMU fault */
812 ret = cpu_x86_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
813 if (ret < 0)
814 return 0; /* not an MMU fault */
815 if (ret == 0)
816 return 1; /* the MMU fault was handled without causing real CPU fault */
817 /* now we have a real cpu fault */
818 tb = tb_find_pc(pc);
819 if (tb) {
820 /* the PC is inside the translated code. It means that we have
821 a virtual CPU fault */
822 cpu_restore_state(tb, env, pc, puc);
823 }
824 if (ret == 1) {
825 #if 0
826 printf("PF exception: EIP=0x%08x CR2=0x%08x error=0x%x\n",
827 env->eip, env->cr[2], env->error_code);
828 #endif
829 /* we restore the process signal mask as the sigreturn should
830 do it (XXX: use sigsetjmp) */
831 sigprocmask(SIG_SETMASK, old_set, NULL);
832 raise_exception_err(env->exception_index, env->error_code);
833 } else {
834 /* activate soft MMU for this block */
835 env->hflags |= HF_SOFTMMU_MASK;
836 cpu_resume_from_signal(env, puc);
837 }
838 /* never comes here */
839 return 1;
840 }
841
842 #elif defined(TARGET_ARM)
843 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
844 int is_write, sigset_t *old_set,
845 void *puc)
846 {
847 TranslationBlock *tb;
848 int ret;
849
850 if (cpu_single_env)
851 env = cpu_single_env; /* XXX: find a correct solution for multithread */
852 #if defined(DEBUG_SIGNAL)
853 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
854 pc, address, is_write, *(unsigned long *)old_set);
855 #endif
856 /* XXX: locking issue */
857 if (is_write && page_unprotect(h2g(address), pc, puc)) {
858 return 1;
859 }
860 /* see if it is an MMU fault */
861 ret = cpu_arm_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
862 if (ret < 0)
863 return 0; /* not an MMU fault */
864 if (ret == 0)
865 return 1; /* the MMU fault was handled without causing real CPU fault */
866 /* now we have a real cpu fault */
867 tb = tb_find_pc(pc);
868 if (tb) {
869 /* the PC is inside the translated code. It means that we have
870 a virtual CPU fault */
871 cpu_restore_state(tb, env, pc, puc);
872 }
873 /* we restore the process signal mask as the sigreturn should
874 do it (XXX: use sigsetjmp) */
875 sigprocmask(SIG_SETMASK, old_set, NULL);
876 cpu_loop_exit();
877 /* never comes here */
878 return 1;
879 }
880 #elif defined(TARGET_SPARC)
881 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
882 int is_write, sigset_t *old_set,
883 void *puc)
884 {
885 TranslationBlock *tb;
886 int ret;
887
888 if (cpu_single_env)
889 env = cpu_single_env; /* XXX: find a correct solution for multithread */
890 #if defined(DEBUG_SIGNAL)
891 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
892 pc, address, is_write, *(unsigned long *)old_set);
893 #endif
894 /* XXX: locking issue */
895 if (is_write && page_unprotect(h2g(address), pc, puc)) {
896 return 1;
897 }
898 /* see if it is an MMU fault */
899 ret = cpu_sparc_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
900 if (ret < 0)
901 return 0; /* not an MMU fault */
902 if (ret == 0)
903 return 1; /* the MMU fault was handled without causing real CPU fault */
904 /* now we have a real cpu fault */
905 tb = tb_find_pc(pc);
906 if (tb) {
907 /* the PC is inside the translated code. It means that we have
908 a virtual CPU fault */
909 cpu_restore_state(tb, env, pc, puc);
910 }
911 /* we restore the process signal mask as the sigreturn should
912 do it (XXX: use sigsetjmp) */
913 sigprocmask(SIG_SETMASK, old_set, NULL);
914 cpu_loop_exit();
915 /* never comes here */
916 return 1;
917 }
918 #elif defined (TARGET_PPC)
919 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
920 int is_write, sigset_t *old_set,
921 void *puc)
922 {
923 TranslationBlock *tb;
924 int ret;
925
926 if (cpu_single_env)
927 env = cpu_single_env; /* XXX: find a correct solution for multithread */
928 #if defined(DEBUG_SIGNAL)
929 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
930 pc, address, is_write, *(unsigned long *)old_set);
931 #endif
932 /* XXX: locking issue */
933 if (is_write && page_unprotect(h2g(address), pc, puc)) {
934 return 1;
935 }
936
937 /* see if it is an MMU fault */
938 ret = cpu_ppc_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
939 if (ret < 0)
940 return 0; /* not an MMU fault */
941 if (ret == 0)
942 return 1; /* the MMU fault was handled without causing real CPU fault */
943
944 /* now we have a real cpu fault */
945 tb = tb_find_pc(pc);
946 if (tb) {
947 /* the PC is inside the translated code. It means that we have
948 a virtual CPU fault */
949 cpu_restore_state(tb, env, pc, puc);
950 }
951 if (ret == 1) {
952 #if 0
953 printf("PF exception: NIP=0x%08x error=0x%x %p\n",
954 env->nip, env->error_code, tb);
955 #endif
956 /* we restore the process signal mask as the sigreturn should
957 do it (XXX: use sigsetjmp) */
958 sigprocmask(SIG_SETMASK, old_set, NULL);
959 cpu_loop_exit();
960 } else {
961 /* activate soft MMU for this block */
962 cpu_resume_from_signal(env, puc);
963 }
964 /* never comes here */
965 return 1;
966 }
967
968 #elif defined(TARGET_M68K)
969 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
970 int is_write, sigset_t *old_set,
971 void *puc)
972 {
973 TranslationBlock *tb;
974 int ret;
975
976 if (cpu_single_env)
977 env = cpu_single_env; /* XXX: find a correct solution for multithread */
978 #if defined(DEBUG_SIGNAL)
979 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
980 pc, address, is_write, *(unsigned long *)old_set);
981 #endif
982 /* XXX: locking issue */
983 if (is_write && page_unprotect(address, pc, puc)) {
984 return 1;
985 }
986 /* see if it is an MMU fault */
987 ret = cpu_m68k_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
988 if (ret < 0)
989 return 0; /* not an MMU fault */
990 if (ret == 0)
991 return 1; /* the MMU fault was handled without causing real CPU fault */
992 /* now we have a real cpu fault */
993 tb = tb_find_pc(pc);
994 if (tb) {
995 /* the PC is inside the translated code. It means that we have
996 a virtual CPU fault */
997 cpu_restore_state(tb, env, pc, puc);
998 }
999 /* we restore the process signal mask as the sigreturn should
1000 do it (XXX: use sigsetjmp) */
1001 sigprocmask(SIG_SETMASK, old_set, NULL);
1002 cpu_loop_exit();
1003 /* never comes here */
1004 return 1;
1005 }
1006
1007 #elif defined (TARGET_MIPS)
1008 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1009 int is_write, sigset_t *old_set,
1010 void *puc)
1011 {
1012 TranslationBlock *tb;
1013 int ret;
1014
1015 if (cpu_single_env)
1016 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1017 #if defined(DEBUG_SIGNAL)
1018 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1019 pc, address, is_write, *(unsigned long *)old_set);
1020 #endif
1021 /* XXX: locking issue */
1022 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1023 return 1;
1024 }
1025
1026 /* see if it is an MMU fault */
1027 ret = cpu_mips_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1028 if (ret < 0)
1029 return 0; /* not an MMU fault */
1030 if (ret == 0)
1031 return 1; /* the MMU fault was handled without causing real CPU fault */
1032
1033 /* now we have a real cpu fault */
1034 tb = tb_find_pc(pc);
1035 if (tb) {
1036 /* the PC is inside the translated code. It means that we have
1037 a virtual CPU fault */
1038 cpu_restore_state(tb, env, pc, puc);
1039 }
1040 if (ret == 1) {
1041 #if 0
1042 printf("PF exception: PC=0x" TARGET_FMT_lx " error=0x%x %p\n",
1043 env->PC, env->error_code, tb);
1044 #endif
1045 /* we restore the process signal mask as the sigreturn should
1046 do it (XXX: use sigsetjmp) */
1047 sigprocmask(SIG_SETMASK, old_set, NULL);
1048 cpu_loop_exit();
1049 } else {
1050 /* activate soft MMU for this block */
1051 cpu_resume_from_signal(env, puc);
1052 }
1053 /* never comes here */
1054 return 1;
1055 }
1056
1057 #elif defined (TARGET_MICROBLAZE)
1058 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1059 int is_write, sigset_t *old_set,
1060 void *puc)
1061 {
1062 TranslationBlock *tb;
1063 int ret;
1064
1065 if (cpu_single_env)
1066 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1067 #if defined(DEBUG_SIGNAL)
1068 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1069 pc, address, is_write, *(unsigned long *)old_set);
1070 #endif
1071 /* XXX: locking issue */
1072 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1073 return 1;
1074 }
1075
1076 /* see if it is an MMU fault */
1077 ret = cpu_mb_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1078 if (ret < 0)
1079 return 0; /* not an MMU fault */
1080 if (ret == 0)
1081 return 1; /* the MMU fault was handled without causing real CPU fault */
1082
1083 /* now we have a real cpu fault */
1084 tb = tb_find_pc(pc);
1085 if (tb) {
1086 /* the PC is inside the translated code. It means that we have
1087 a virtual CPU fault */
1088 cpu_restore_state(tb, env, pc, puc);
1089 }
1090 if (ret == 1) {
1091 #if 0
1092 printf("PF exception: PC=0x" TARGET_FMT_lx " error=0x%x %p\n",
1093 env->PC, env->error_code, tb);
1094 #endif
1095 /* we restore the process signal mask as the sigreturn should
1096 do it (XXX: use sigsetjmp) */
1097 sigprocmask(SIG_SETMASK, old_set, NULL);
1098 cpu_loop_exit();
1099 } else {
1100 /* activate soft MMU for this block */
1101 cpu_resume_from_signal(env, puc);
1102 }
1103 /* never comes here */
1104 return 1;
1105 }
1106
1107 #elif defined (TARGET_SH4)
1108 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1109 int is_write, sigset_t *old_set,
1110 void *puc)
1111 {
1112 TranslationBlock *tb;
1113 int ret;
1114
1115 if (cpu_single_env)
1116 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1117 #if defined(DEBUG_SIGNAL)
1118 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1119 pc, address, is_write, *(unsigned long *)old_set);
1120 #endif
1121 /* XXX: locking issue */
1122 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1123 return 1;
1124 }
1125
1126 /* see if it is an MMU fault */
1127 ret = cpu_sh4_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1128 if (ret < 0)
1129 return 0; /* not an MMU fault */
1130 if (ret == 0)
1131 return 1; /* the MMU fault was handled without causing real CPU fault */
1132
1133 /* now we have a real cpu fault */
1134 tb = tb_find_pc(pc);
1135 if (tb) {
1136 /* the PC is inside the translated code. It means that we have
1137 a virtual CPU fault */
1138 cpu_restore_state(tb, env, pc, puc);
1139 }
1140 #if 0
1141 printf("PF exception: NIP=0x%08x error=0x%x %p\n",
1142 env->nip, env->error_code, tb);
1143 #endif
1144 /* we restore the process signal mask as the sigreturn should
1145 do it (XXX: use sigsetjmp) */
1146 sigprocmask(SIG_SETMASK, old_set, NULL);
1147 cpu_loop_exit();
1148 /* never comes here */
1149 return 1;
1150 }
1151
1152 #elif defined (TARGET_ALPHA)
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_alpha_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 #elif defined (TARGET_CRIS)
1197 static inline int handle_cpu_signal(unsigned long pc, unsigned long address,
1198 int is_write, sigset_t *old_set,
1199 void *puc)
1200 {
1201 TranslationBlock *tb;
1202 int ret;
1203
1204 if (cpu_single_env)
1205 env = cpu_single_env; /* XXX: find a correct solution for multithread */
1206 #if defined(DEBUG_SIGNAL)
1207 printf("qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n",
1208 pc, address, is_write, *(unsigned long *)old_set);
1209 #endif
1210 /* XXX: locking issue */
1211 if (is_write && page_unprotect(h2g(address), pc, puc)) {
1212 return 1;
1213 }
1214
1215 /* see if it is an MMU fault */
1216 ret = cpu_cris_handle_mmu_fault(env, address, is_write, MMU_USER_IDX, 0);
1217 if (ret < 0)
1218 return 0; /* not an MMU fault */
1219 if (ret == 0)
1220 return 1; /* the MMU fault was handled without causing real CPU fault */
1221
1222 /* now we have a real cpu fault */
1223 tb = tb_find_pc(pc);
1224 if (tb) {
1225 /* the PC is inside the translated code. It means that we have
1226 a virtual CPU fault */
1227 cpu_restore_state(tb, env, pc, puc);
1228 }
1229 /* we restore the process signal mask as the sigreturn should
1230 do it (XXX: use sigsetjmp) */
1231 sigprocmask(SIG_SETMASK, old_set, NULL);
1232 cpu_loop_exit();
1233 /* never comes here */
1234 return 1;
1235 }
1236
1237 #else
1238 #error unsupported target CPU
1239 #endif
1240
1241 #if defined(__i386__)
1242
1243 #if defined(__APPLE__)
1244 # include <sys/ucontext.h>
1245
1246 # define EIP_sig(context) (*((unsigned long*)&(context)->uc_mcontext->ss.eip))
1247 # define TRAP_sig(context) ((context)->uc_mcontext->es.trapno)
1248 # define ERROR_sig(context) ((context)->uc_mcontext->es.err)
1249 # define MASK_sig(context) ((context)->uc_sigmask)
1250 #elif defined(__OpenBSD__)
1251 # define EIP_sig(context) ((context)->sc_eip)
1252 # define TRAP_sig(context) ((context)->sc_trapno)
1253 # define ERROR_sig(context) ((context)->sc_err)
1254 # define MASK_sig(context) ((context)->sc_mask)
1255 #else
1256 # define EIP_sig(context) ((context)->uc_mcontext.gregs[REG_EIP])
1257 # define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
1258 # define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
1259 # define MASK_sig(context) ((context)->uc_sigmask)
1260 #endif
1261
1262 int cpu_signal_handler(int host_signum, void *pinfo,
1263 void *puc)
1264 {
1265 siginfo_t *info = pinfo;
1266 #if defined(__OpenBSD__)
1267 struct sigcontext *uc = puc;
1268 #else
1269 struct ucontext *uc = puc;
1270 #endif
1271 unsigned long pc;
1272 int trapno;
1273
1274 #ifndef REG_EIP
1275 /* for glibc 2.1 */
1276 #define REG_EIP EIP
1277 #define REG_ERR ERR
1278 #define REG_TRAPNO TRAPNO
1279 #endif
1280 pc = EIP_sig(uc);
1281 trapno = TRAP_sig(uc);
1282 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1283 trapno == 0xe ?
1284 (ERROR_sig(uc) >> 1) & 1 : 0,
1285 &MASK_sig(uc), puc);
1286 }
1287
1288 #elif defined(__x86_64__)
1289
1290 #ifdef __NetBSD__
1291 #define PC_sig(context) _UC_MACHINE_PC(context)
1292 #define TRAP_sig(context) ((context)->uc_mcontext.__gregs[_REG_TRAPNO])
1293 #define ERROR_sig(context) ((context)->uc_mcontext.__gregs[_REG_ERR])
1294 #define MASK_sig(context) ((context)->uc_sigmask)
1295 #elif defined(__OpenBSD__)
1296 #define PC_sig(context) ((context)->sc_rip)
1297 #define TRAP_sig(context) ((context)->sc_trapno)
1298 #define ERROR_sig(context) ((context)->sc_err)
1299 #define MASK_sig(context) ((context)->sc_mask)
1300 #else
1301 #define PC_sig(context) ((context)->uc_mcontext.gregs[REG_RIP])
1302 #define TRAP_sig(context) ((context)->uc_mcontext.gregs[REG_TRAPNO])
1303 #define ERROR_sig(context) ((context)->uc_mcontext.gregs[REG_ERR])
1304 #define MASK_sig(context) ((context)->uc_sigmask)
1305 #endif
1306
1307 int cpu_signal_handler(int host_signum, void *pinfo,
1308 void *puc)
1309 {
1310 siginfo_t *info = pinfo;
1311 unsigned long pc;
1312 #ifdef __NetBSD__
1313 ucontext_t *uc = puc;
1314 #elif defined(__OpenBSD__)
1315 struct sigcontext *uc = puc;
1316 #else
1317 struct ucontext *uc = puc;
1318 #endif
1319
1320 pc = PC_sig(uc);
1321 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1322 TRAP_sig(uc) == 0xe ?
1323 (ERROR_sig(uc) >> 1) & 1 : 0,
1324 &MASK_sig(uc), puc);
1325 }
1326
1327 #elif defined(_ARCH_PPC)
1328
1329 /***********************************************************************
1330 * signal context platform-specific definitions
1331 * From Wine
1332 */
1333 #ifdef linux
1334 /* All Registers access - only for local access */
1335 # define REG_sig(reg_name, context) ((context)->uc_mcontext.regs->reg_name)
1336 /* Gpr Registers access */
1337 # define GPR_sig(reg_num, context) REG_sig(gpr[reg_num], context)
1338 # define IAR_sig(context) REG_sig(nip, context) /* Program counter */
1339 # define MSR_sig(context) REG_sig(msr, context) /* Machine State Register (Supervisor) */
1340 # define CTR_sig(context) REG_sig(ctr, context) /* Count register */
1341 # define XER_sig(context) REG_sig(xer, context) /* User's integer exception register */
1342 # define LR_sig(context) REG_sig(link, context) /* Link register */
1343 # define CR_sig(context) REG_sig(ccr, context) /* Condition register */
1344 /* Float Registers access */
1345 # define FLOAT_sig(reg_num, context) (((double*)((char*)((context)->uc_mcontext.regs+48*4)))[reg_num])
1346 # define FPSCR_sig(context) (*(int*)((char*)((context)->uc_mcontext.regs+(48+32*2)*4)))
1347 /* Exception Registers access */
1348 # define DAR_sig(context) REG_sig(dar, context)
1349 # define DSISR_sig(context) REG_sig(dsisr, context)
1350 # define TRAP_sig(context) REG_sig(trap, context)
1351 #endif /* linux */
1352
1353 #ifdef __APPLE__
1354 # include <sys/ucontext.h>
1355 typedef struct ucontext SIGCONTEXT;
1356 /* All Registers access - only for local access */
1357 # define REG_sig(reg_name, context) ((context)->uc_mcontext->ss.reg_name)
1358 # define FLOATREG_sig(reg_name, context) ((context)->uc_mcontext->fs.reg_name)
1359 # define EXCEPREG_sig(reg_name, context) ((context)->uc_mcontext->es.reg_name)
1360 # define VECREG_sig(reg_name, context) ((context)->uc_mcontext->vs.reg_name)
1361 /* Gpr Registers access */
1362 # define GPR_sig(reg_num, context) REG_sig(r##reg_num, context)
1363 # define IAR_sig(context) REG_sig(srr0, context) /* Program counter */
1364 # define MSR_sig(context) REG_sig(srr1, context) /* Machine State Register (Supervisor) */
1365 # define CTR_sig(context) REG_sig(ctr, context)
1366 # define XER_sig(context) REG_sig(xer, context) /* Link register */
1367 # define LR_sig(context) REG_sig(lr, context) /* User's integer exception register */
1368 # define CR_sig(context) REG_sig(cr, context) /* Condition register */
1369 /* Float Registers access */
1370 # define FLOAT_sig(reg_num, context) FLOATREG_sig(fpregs[reg_num], context)
1371 # define FPSCR_sig(context) ((double)FLOATREG_sig(fpscr, context))
1372 /* Exception Registers access */
1373 # define DAR_sig(context) EXCEPREG_sig(dar, context) /* Fault registers for coredump */
1374 # define DSISR_sig(context) EXCEPREG_sig(dsisr, context)
1375 # define TRAP_sig(context) EXCEPREG_sig(exception, context) /* number of powerpc exception taken */
1376 #endif /* __APPLE__ */
1377
1378 int cpu_signal_handler(int host_signum, void *pinfo,
1379 void *puc)
1380 {
1381 siginfo_t *info = pinfo;
1382 struct ucontext *uc = puc;
1383 unsigned long pc;
1384 int is_write;
1385
1386 pc = IAR_sig(uc);
1387 is_write = 0;
1388 #if 0
1389 /* ppc 4xx case */
1390 if (DSISR_sig(uc) & 0x00800000)
1391 is_write = 1;
1392 #else
1393 if (TRAP_sig(uc) != 0x400 && (DSISR_sig(uc) & 0x02000000))
1394 is_write = 1;
1395 #endif
1396 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1397 is_write, &uc->uc_sigmask, puc);
1398 }
1399
1400 #elif defined(__alpha__)
1401
1402 int cpu_signal_handler(int host_signum, void *pinfo,
1403 void *puc)
1404 {
1405 siginfo_t *info = pinfo;
1406 struct ucontext *uc = puc;
1407 uint32_t *pc = uc->uc_mcontext.sc_pc;
1408 uint32_t insn = *pc;
1409 int is_write = 0;
1410
1411 /* XXX: need kernel patch to get write flag faster */
1412 switch (insn >> 26) {
1413 case 0x0d: // stw
1414 case 0x0e: // stb
1415 case 0x0f: // stq_u
1416 case 0x24: // stf
1417 case 0x25: // stg
1418 case 0x26: // sts
1419 case 0x27: // stt
1420 case 0x2c: // stl
1421 case 0x2d: // stq
1422 case 0x2e: // stl_c
1423 case 0x2f: // stq_c
1424 is_write = 1;
1425 }
1426
1427 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1428 is_write, &uc->uc_sigmask, puc);
1429 }
1430 #elif defined(__sparc__)
1431
1432 int cpu_signal_handler(int host_signum, void *pinfo,
1433 void *puc)
1434 {
1435 siginfo_t *info = pinfo;
1436 int is_write;
1437 uint32_t insn;
1438 #if !defined(__arch64__) || defined(CONFIG_SOLARIS)
1439 uint32_t *regs = (uint32_t *)(info + 1);
1440 void *sigmask = (regs + 20);
1441 /* XXX: is there a standard glibc define ? */
1442 unsigned long pc = regs[1];
1443 #else
1444 #ifdef __linux__
1445 struct sigcontext *sc = puc;
1446 unsigned long pc = sc->sigc_regs.tpc;
1447 void *sigmask = (void *)sc->sigc_mask;
1448 #elif defined(__OpenBSD__)
1449 struct sigcontext *uc = puc;
1450 unsigned long pc = uc->sc_pc;
1451 void *sigmask = (void *)(long)uc->sc_mask;
1452 #endif
1453 #endif
1454
1455 /* XXX: need kernel patch to get write flag faster */
1456 is_write = 0;
1457 insn = *(uint32_t *)pc;
1458 if ((insn >> 30) == 3) {
1459 switch((insn >> 19) & 0x3f) {
1460 case 0x05: // stb
1461 case 0x15: // stba
1462 case 0x06: // sth
1463 case 0x16: // stha
1464 case 0x04: // st
1465 case 0x14: // sta
1466 case 0x07: // std
1467 case 0x17: // stda
1468 case 0x0e: // stx
1469 case 0x1e: // stxa
1470 case 0x24: // stf
1471 case 0x34: // stfa
1472 case 0x27: // stdf
1473 case 0x37: // stdfa
1474 case 0x26: // stqf
1475 case 0x36: // stqfa
1476 case 0x25: // stfsr
1477 case 0x3c: // casa
1478 case 0x3e: // casxa
1479 is_write = 1;
1480 break;
1481 }
1482 }
1483 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1484 is_write, sigmask, NULL);
1485 }
1486
1487 #elif defined(__arm__)
1488
1489 int cpu_signal_handler(int host_signum, void *pinfo,
1490 void *puc)
1491 {
1492 siginfo_t *info = pinfo;
1493 struct ucontext *uc = puc;
1494 unsigned long pc;
1495 int is_write;
1496
1497 #if (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
1498 pc = uc->uc_mcontext.gregs[R15];
1499 #else
1500 pc = uc->uc_mcontext.arm_pc;
1501 #endif
1502 /* XXX: compute is_write */
1503 is_write = 0;
1504 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1505 is_write,
1506 &uc->uc_sigmask, puc);
1507 }
1508
1509 #elif defined(__mc68000)
1510
1511 int cpu_signal_handler(int host_signum, void *pinfo,
1512 void *puc)
1513 {
1514 siginfo_t *info = pinfo;
1515 struct ucontext *uc = puc;
1516 unsigned long pc;
1517 int is_write;
1518
1519 pc = uc->uc_mcontext.gregs[16];
1520 /* XXX: compute is_write */
1521 is_write = 0;
1522 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1523 is_write,
1524 &uc->uc_sigmask, puc);
1525 }
1526
1527 #elif defined(__ia64)
1528
1529 #ifndef __ISR_VALID
1530 /* This ought to be in <bits/siginfo.h>... */
1531 # define __ISR_VALID 1
1532 #endif
1533
1534 int cpu_signal_handler(int host_signum, void *pinfo, void *puc)
1535 {
1536 siginfo_t *info = pinfo;
1537 struct ucontext *uc = puc;
1538 unsigned long ip;
1539 int is_write = 0;
1540
1541 ip = uc->uc_mcontext.sc_ip;
1542 switch (host_signum) {
1543 case SIGILL:
1544 case SIGFPE:
1545 case SIGSEGV:
1546 case SIGBUS:
1547 case SIGTRAP:
1548 if (info->si_code && (info->si_segvflags & __ISR_VALID))
1549 /* ISR.W (write-access) is bit 33: */
1550 is_write = (info->si_isr >> 33) & 1;
1551 break;
1552
1553 default:
1554 break;
1555 }
1556 return handle_cpu_signal(ip, (unsigned long)info->si_addr,
1557 is_write,
1558 &uc->uc_sigmask, puc);
1559 }
1560
1561 #elif defined(__s390__)
1562
1563 int cpu_signal_handler(int host_signum, void *pinfo,
1564 void *puc)
1565 {
1566 siginfo_t *info = pinfo;
1567 struct ucontext *uc = puc;
1568 unsigned long pc;
1569 int is_write;
1570
1571 pc = uc->uc_mcontext.psw.addr;
1572 /* XXX: compute is_write */
1573 is_write = 0;
1574 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1575 is_write, &uc->uc_sigmask, puc);
1576 }
1577
1578 #elif defined(__mips__)
1579
1580 int cpu_signal_handler(int host_signum, void *pinfo,
1581 void *puc)
1582 {
1583 siginfo_t *info = pinfo;
1584 struct ucontext *uc = puc;
1585 greg_t pc = uc->uc_mcontext.pc;
1586 int is_write;
1587
1588 /* XXX: compute is_write */
1589 is_write = 0;
1590 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1591 is_write, &uc->uc_sigmask, puc);
1592 }
1593
1594 #elif defined(__hppa__)
1595
1596 int cpu_signal_handler(int host_signum, void *pinfo,
1597 void *puc)
1598 {
1599 struct siginfo *info = pinfo;
1600 struct ucontext *uc = puc;
1601 unsigned long pc;
1602 int is_write;
1603
1604 pc = uc->uc_mcontext.sc_iaoq[0];
1605 /* FIXME: compute is_write */
1606 is_write = 0;
1607 return handle_cpu_signal(pc, (unsigned long)info->si_addr,
1608 is_write,
1609 &uc->uc_sigmask, puc);
1610 }
1611
1612 #else
1613
1614 #error host CPU specific signal handler needed
1615
1616 #endif
1617
1618 #endif /* !defined(CONFIG_SOFTMMU) */
Scott Tsai's queue for QEMU