os_vm_address_t arch_get_bad_addr(int sig, siginfo_t *code, os_context_t *context)
{
+#if 1 /* New way. */
+ return (os_vm_address_t)code->si_addr;
+#else /* Old way, almost certainly predates sigaction(2)-style handlers */
unsigned int badinst;
unsigned int *pc;
int rs1;
(*os_context_register_addr(context, rs1) +
*os_context_register_addr(context, rs2));
}
+#endif
}
void arch_skip_instruction(os_context_t *context)
boolean arch_pseudo_atomic_atomic(os_context_t *context)
{
- return ((*os_context_register_addr(context,reg_ALLOC)) & 4);
+ /* FIXME: this foreign_function_call_active test is dubious at
+ * best. If a foreign call is made in a pseudo atomic section
+ * (?) or more likely a pseudo atomic section is in a foreign
+ * call then an interrupt is executed immediately. Maybe it
+ * has to do with C code not maintaining pseudo atomic
+ * properly. MG - 2005-08-10
+ *
+ * The foreign_function_call_active used to live at each call-site
+ * to arch_pseudo_atomic_atomic, but this seems clearer.
+ * --NS 2007-05-15 */
+ return (!foreign_function_call_active)
+ && ((*os_context_register_addr(context,reg_ALLOC)) & 4);
}
void arch_set_pseudo_atomic_interrupted(os_context_t *context)
os_flush_icache((os_vm_address_t) os_context_pc_addr(context), sizeof(unsigned int));
}
-static void sigill_handler(int signal, siginfo_t *siginfo, void *void_context)
+void
+arch_handle_single_step_trap(os_context_t *context, int trap)
{
- os_context_t *context = arch_os_get_context(&void_context);
-#ifdef LISP_FEATURE_LINUX
- /* FIXME: Check that this is necessary -- CSR, 2002-07-15 */
- os_restore_fp_control(context);
+ unsigned int code = *((u32 *)(*os_context_pc_addr(context)));
+ int register_offset = code >> 5 & 0x1f;
+ handle_single_step_trap(context, trap, register_offset);
+ arch_skip_instruction(context);
+}
+
+#ifdef LISP_FEATURE_GENCGC
+void
+arch_handle_allocation_trap(os_context_t *context)
+{
+ unsigned int* pc;
+ unsigned int or_inst;
+ int rs1;
+ int size;
+ int immed;
+ int context_index;
+ boolean were_in_lisp;
+ char* memory;
+
+ pc = (unsigned int*) *os_context_pc_addr(context);
+ or_inst = pc[-1];
+
+ /*
+ * The instruction before this trap instruction had better be an OR
+ * instruction!
+ */
+ if (!(((or_inst >> 30) == 2) && (((or_inst >> 19) & 0x1f) == 2)))
+ lose(stderr, "Whoa!!! Got an allocation trap not preceeded by an OR inst: 0x%08x!\n",
+ or_inst);
+
+ /*
+ * An OR instruction. RS1 is the register we want to allocate to.
+ * RS2 (or an immediate) is the size.
+ */
+ rs1 = (or_inst >> 14) & 0x1f;
+ immed = (or_inst >> 13) & 1;
+
+ if (immed == 1)
+ size = or_inst & 0x1fff;
+ else {
+ size = or_inst & 0x1f;
+ size = *os_context_register_addr(context, size);
+ }
+
+ if (foreign_function_call_active)
+ lose(stderr, "Whoa! allocation trap and we weren't in lisp!\n");
+ fake_foreign_function_call(context);
+
+ /*
+ * Allocate some memory, store the memory address in rs1.
+ */
+ {
+ struct interrupt_data *data =
+ arch_os_get_current_thread()->interrupt_data;
+ data->allocation_trap_context = context;
+ memory = alloc(size);
+ data->allocation_trap_context = 0;
+ }
+ *os_context_register_addr(context, rs1) = memory;
+
+ undo_fake_foreign_function_call(context);
+}
#endif
+static void sigill_handler(int signal, siginfo_t *siginfo,
+ os_context_t *context)
+{
if ((siginfo->si_code) == ILL_ILLOPC
#ifdef LISP_FEATURE_LINUX
|| (linux_sparc_siginfo_bug && (siginfo->si_code == 2))
unsigned int* pc = (unsigned int*) siginfo->si_addr;
inst = *pc;
- trap = inst & 0x3fffff;
+ trap = inst & 0x1f;
handle_trap(context,trap);
}
else if ((siginfo->si_code) == ILL_ILLTRP
}
}
-static void sigemt_handler(int signal, siginfo_t *siginfo, void *void_context)
+static void sigemt_handler(int signal, siginfo_t *siginfo,
+ os_context_t *context)
{
unsigned int badinst;
boolean subtract, immed;
int rd, rs1, op1, rs2, op2, result;
- os_context_t *context = arch_os_get_context(&void_context);
-#ifdef LISP_FEATURE_LINUX
- os_restore_fp_control(context);
-#endif
badinst = *(unsigned int *)os_context_pc_addr(context);
if ((badinst >> 30) != 2 || ((badinst >> 20) & 0x1f) != 0x11) {
}
\f
-extern lispobj call_into_lisp(lispobj fun, lispobj *args, int nargs);
-
-lispobj funcall0(lispobj function)
-{
- lispobj *args = current_control_stack_pointer;
-
- return call_into_lisp(function, args, 0);
-}
-
-lispobj funcall1(lispobj function, lispobj arg0)
-{
- lispobj *args = current_control_stack_pointer;
-
- current_control_stack_pointer += 1;
- args[0] = arg0;
-
- return call_into_lisp(function, args, 1);
-}
-
-lispobj funcall2(lispobj function, lispobj arg0, lispobj arg1)
-{
- lispobj *args = current_control_stack_pointer;
-
- current_control_stack_pointer += 2;
- args[0] = arg0;
- args[1] = arg1;
-
- return call_into_lisp(function, args, 2);
-}
-
-lispobj funcall3(lispobj function, lispobj arg0, lispobj arg1, lispobj arg2)
-{
- lispobj *args = current_control_stack_pointer;
-
- current_control_stack_pointer += 3;
- args[0] = arg0;
- args[1] = arg1;
- args[2] = arg2;
-
- return call_into_lisp(function, args, 3);
-}
-
#ifdef LISP_FEATURE_LINKAGE_TABLE
/* This a naive port from CMUCL/sparc, which was mostly stolen from the