#include "interrupt.h"
#include "interr.h"
#include "breakpoint.h"
+#include "monitor.h"
+#include "thread.h"
+
+#include "genesis/static-symbols.h"
+#include "genesis/symbol.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)));
}
boolean
arch_pseudo_atomic_atomic(os_context_t *context)
{
- return SymbolValue(PSEUDO_ATOMIC_ATOMIC);
+ return SymbolValue(PSEUDO_ATOMIC_ATOMIC,arch_os_get_current_thread());
}
void
arch_set_pseudo_atomic_interrupted(os_context_t *context)
{
- SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, make_fixnum(1));
+ SetSymbolValue(PSEUDO_ATOMIC_INTERRUPTED, make_fixnum(1),
+ arch_os_get_current_thread());
}
\f
/*
return result;
}
+void
+get_spinlock(lispobj *word,int value)
+{
+ u32 eax=0;
+ do {
+ asm ("xor %0,%0;lock cmpxchg %1,%2"
+ : "=a" (eax)
+ : "r" (value), "m" (*word)
+ : "memory", "cc");
+ } while(eax!=0);
+}
+
void
arch_remove_breakpoint(void *pc, unsigned long orig_inst)
{
#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));
current_control_stack_pointer =
(lispobj *)*os_context_sp_addr(context);
+ /* FIXME: CMUCL puts the float control restoration code here.
+ Thus, it seems to me that single-stepping won't restore the
+ float control. Since SBCL currently doesn't support
+ 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
+ os_restore_fp_control(context);
+#endif
+
/* On entry %eip points just after the INT3 byte and aims at the
* 'kind' value (eg trap_Cerror). For error-trap and Cerror-trap a
* number of bytes will follow, the first is the length of the byte
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: */
* could be in registers depending on what the compiler likes. So we
* copy the args into a portable vector and let the assembly language
* call-in function figure it out. */
+
lispobj
funcall0(lispobj function)
{
lispobj *args = NULL;
+ FSHOW((stderr, "/entering funcall0(0x%lx)\n", (long)function));
return call_into_lisp(function, args, 0);
}
lispobj