#include "interrupt.h"
#include "interr.h"
#include "breakpoint.h"
+#include "monitor.h"
#define BREAKPOINT_INST 0xcc /* INT3 */
int vlen;
int code;
- FSHOW((stderr, "[arch_skip_inst at %x]\n", *os_context_pc_addr(context)));
+ FSHOW((stderr, "/[arch_skip_inst at %x]\n", *os_context_pc_addr(context)));
/* Get and skip the Lisp interrupt code. */
code = *(char*)(*os_context_pc_addr(context))++;
break;
case trap_Breakpoint: /* not tested */
- case trap_FunctionEndBreakpoint: /* not tested */
+ case trap_FunEndBreakpoint: /* not tested */
break;
case trap_PendingInterrupt:
}
FSHOW((stderr,
- "[arch_skip_inst resuming at %x]\n",
+ "/[arch_skip_inst resuming at %x]\n",
*os_context_pc_addr(context)));
}
#endif
void
-arch_do_displaced_inst(os_context_t *context, unsigned long orig_inst)
+arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst)
{
unsigned int *pc = (unsigned int*)(*os_context_pc_addr(context));
switch (trap) {
case trap_PendingInterrupt:
- FSHOW((stderr, "<trap pending interrupt>\n"));
+ FSHOW((stderr, "/<trap pending interrupt>\n"));
arch_skip_instruction(context);
interrupt_handle_pending(context);
break;
handle_breakpoint(signal, info, context);
break;
- case trap_FunctionEndBreakpoint:
+ case trap_FunEndBreakpoint:
(char*)(*os_context_pc_addr(context)) -= 1;
*os_context_pc_addr(context) =
- (int)handle_function_end_breakpoint(signal, info, context);
+ (int)handle_fun_end_breakpoint(signal, info, context);
break;
default:
- FSHOW((stderr,"[C--trap default %d %d %x]\n",
+ FSHOW((stderr,"/[C--trap default %d %d %x]\n",
signal, code, context));
interrupt_handle_now(signal, info, context);
break;
}
}
+static void
+sigill_handler(int signal, siginfo_t *siginfo, void *void_context) {
+ os_context_t *context = (os_context_t*)void_context;
+ fake_foreign_function_call(context);
+ monitor_or_something();
+}
+
void
arch_install_interrupt_handlers()
{
- interrupt_install_low_level_handler(SIGILL , sigtrap_handler);
- interrupt_install_low_level_handler(SIGTRAP, sigtrap_handler);
+ SHOW("entering arch_install_interrupt_handlers()");
+
+ /* Note: The old CMU CL code here used sigtrap_handler() to handle
+ * SIGILL as well as SIGTRAP. I couldn't see any reason to do
+ * things that way. So, I changed to separate handlers when
+ * debugging a problem on OpenBSD, where SBCL wasn't catching
+ * SIGILL properly, but was instead letting the process be
+ * terminated with an "Illegal instruction" output. If this change
+ * turns out to break something (maybe breakpoint handling on some
+ * 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 */
+ undoably_install_low_level_interrupt_handler(SIGILL , sigill_handler);
+ undoably_install_low_level_interrupt_handler(SIGTRAP, sigtrap_handler);
+
+ SHOW("returning from arch_install_interrupt_handlers()");
}
\f
/* This is implemented in assembly language and called from C: */
{
lispobj *args = NULL;
+ FSHOW((stderr, "/entering funcall0(0x%lx)\n", (long)function));
return call_into_lisp(function, args, 0);
}
lispobj