* want to get to, and on OS, which determines how we get to it.)
*/
-int *
+os_context_register_t *
context_eflags_addr(os_context_t *context)
{
#if defined __linux__
* instead. */
return &context->uc_mcontext.gregs[17];
#elif defined __FreeBSD__
- return &context->uc_mcontext.mc_eflags;
+ return &context->uc_mcontext.mc_rflags;
+#elif defined LISP_FEATURE_DARWIN
+ return &context->uc_mcontext->ss.rflags;
#elif defined __OpenBSD__
return &context->sc_eflags;
#else
break;
default:
- fprintf(stderr,"[arch_skip_inst invalid code %d\n]\n",code);
+ fprintf(stderr,"[arch_skip_inst invalid code %ld\n]\n",code);
break;
}
/* When single stepping, single_stepping holds the original instruction
* PC location. */
unsigned int *single_stepping = NULL;
+#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
+unsigned int single_step_save1;
+unsigned int single_step_save2;
+unsigned int single_step_save3;
+#endif
void
arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst)
*((char *)pc) = orig_inst & 0xff;
*((char *)pc + 1) = (orig_inst & 0xff00) >> 8;
+#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
+ /* Install helper instructions for the single step:
+ * pushf; or [esp],0x100; popf. */
+ single_step_save1 = *(pc-3);
+ single_step_save2 = *(pc-2);
+ single_step_save3 = *(pc-1);
+ *(pc-3) = 0x9c909090;
+ *(pc-2) = 0x00240c81;
+ *(pc-1) = 0x9d000001;
+#else
*context_eflags_addr(context) |= 0x100;
+#endif
single_stepping = pc;
+
+#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
+ *os_context_pc_addr(context) = (os_context_register_t)((char *)pc - 9);
+#endif
}
\f
if (single_stepping && (signal==SIGTRAP))
{
+#ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
+ /* Un-install single step helper instructions. */
+ *(single_stepping-3) = single_step_save1;
+ *(single_stepping-2) = single_step_save2;
+ *(single_stepping-1) = single_step_save3;
+#else
*context_eflags_addr(context) ^= 0x100;
-
+#endif
/* Re-install the breakpoint if possible. */
- if (*os_context_pc_addr(context) == (int)single_stepping + 1) {
+ if ((char *)*os_context_pc_addr(context) ==
+ (char *)single_stepping + 1) {
fprintf(stderr, "warning: couldn't reinstall breakpoint\n");
} else {
*((char *)single_stepping) = BREAKPOINT_INST; /* x86 INT3 */
single-stepping (as far as I can tell) this is somewhat moot,
but it might be worth either moving this code up or deleting
the single-stepping code entirely. -- CSR, 2002-07-15 */
-#ifdef LISP_FEATURE_LINUX
+#if defined(LISP_FEATURE_LINUX) || defined(RESTORE_FP_CONTROL_FROM_CONTEXT)
os_restore_fp_control(context);
#endif
case trap_Error:
case trap_Cerror:
- FSHOW((stderr, "<trap error/cerror %d>\n", code));
- interrupt_internal_error(signal, info, context, code==trap_Cerror);
+ FSHOW((stderr, "<trap error/cerror %d>\n", trap));
+ interrupt_internal_error(signal, info, context, trap==trap_Cerror);
break;
case trap_Breakpoint:
}
}
-static void
+void
sigill_handler(int signal, siginfo_t *siginfo, void *void_context) {
os_context_t *context = (os_context_t*)void_context;
+
+ /* Triggering SIGTRAP using int3 is unreliable on OS X/x86, so
+ * we need to use illegal instructions for traps.
+ */
+#if defined(LISP_FEATURE_DARWIN) && !defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER)
+ if (*((unsigned short *)*os_context_pc_addr(context)) == 0x0b0f) {
+ *os_context_pc_addr(context) += 2;
+ return sigtrap_handler(signal, siginfo, void_context);
+ }
+#endif
+
fake_foreign_function_call(context);
lose("fake_foreign_function_call fell through");
}
+#ifdef X86_64_SIGFPE_FIXUP
+#define MXCSR_IE (0x01) /* Invalid Operation */
+#define MXCSR_DE (0x02) /* Denormal */
+#define MXCSR_ZE (0x04) /* Devide-by-Zero */
+#define MXCSR_OE (0x08) /* Overflow */
+#define MXCSR_UE (0x10) /* Underflow */
+#define MXCSR_PE (0x20) /* Precision */
+
+static inline int
+mxcsr_to_code(unsigned int mxcsr)
+{
+ /* Extract unmasked exception bits. */
+ mxcsr &= ~(mxcsr >> 7) & 0x3F;
+
+ /* This order is defined at "Intel 64 and IA-32 Architectures
+ * Software Developerfs Manual" Volume 1: "Basic Architecture",
+ * 4.9.2 "Floating-Point Exception Priority". */
+ if (mxcsr & MXCSR_IE)
+ return FPE_FLTINV;
+ else if (mxcsr & MXCSR_ZE)
+ return FPE_FLTDIV;
+ else if (mxcsr & MXCSR_DE)
+ return FPE_FLTUND;
+ else if (mxcsr & MXCSR_OE)
+ return FPE_FLTOVF;
+ else if (mxcsr & MXCSR_UE)
+ return FPE_FLTUND;
+ else if (mxcsr & MXCSR_PE)
+ return FPE_FLTRES;
+
+ return 0;
+}
+
+static void
+sigfpe_handler(int signal, siginfo_t *siginfo, void *void_context)
+{
+ os_context_t *context = arch_os_get_context(&void_context);
+ unsigned int *mxcsr = arch_os_context_mxcsr_addr(context);
+
+ if (siginfo->si_code == 0) { /* XMM exception */
+ siginfo->si_code = mxcsr_to_code(*mxcsr);
+
+ /* Clear sticky exception flag. */
+ *mxcsr &= ~0x3F;
+ }
+
+ interrupt_handle_now(signal, siginfo, context);
+}
+#endif
+
void
arch_install_interrupt_handlers()
{
* OS I haven't tested on?) and we have to go back to the old CMU
* CL way, I hope there will at least be a comment to explain
* why.. -- WHN 2001-06-07 */
+#if !defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER)
undoably_install_low_level_interrupt_handler(SIGILL , sigill_handler);
undoably_install_low_level_interrupt_handler(SIGTRAP, sigtrap_handler);
+#endif
+
+#ifdef X86_64_SIGFPE_FIXUP
+ undoably_install_low_level_interrupt_handler(SIGFPE, sigfpe_handler);
+#endif
SHOW("returning from arch_install_interrupt_handlers()");
}