* already; we're just doing the Lisp-level processing now that we
* put off then */
static void
-run_deferred_handler(struct interrupt_data *data, void *v_context) {
+run_deferred_handler(struct interrupt_data *data, void *v_context)
+{
/* The pending_handler may enable interrupts and then another
* interrupt may hit, overwrite interrupt_data, so reset the
* pending handler before calling it. Trust the handler to finish
thread->state=STATE_SUSPENDED;
FSHOW_SIGNAL((stderr,"thread=%lu suspended\n",thread->os_thread));
+ sigemptyset(&ss);
#if defined(SIG_RESUME_FROM_GC)
- sigemptyset(&ss); sigaddset(&ss,SIG_RESUME_FROM_GC);
+ sigaddset(&ss,SIG_RESUME_FROM_GC);
#else
- sigemptyset(&ss); sigaddset(&ss,SIG_STOP_FOR_GC);
+ sigaddset(&ss,SIG_STOP_FOR_GC);
#endif
/* It is possible to get SIGCONT (and probably other non-blockable
* functions and variables.
*/
void
-undefined_alien_function() {
+undefined_alien_function(void)
+{
funcall0(SymbolFunction(UNDEFINED_ALIEN_FUNCTION_ERROR));
}
}
static void
-see_if_sigaction_nodefer_works()
+see_if_sigaction_nodefer_works(void)
{
struct sigaction sa, old_sa;
| (sigaction_nodefer_works ? SA_NODEFER : 0);
#ifdef LISP_FEATURE_C_STACK_IS_CONTROL_STACK
if((signal==SIG_MEMORY_FAULT)
-#ifdef SIG_MEMORY_FAULT2
- || (signal==SIG_MEMORY_FAULT2)
-#endif
#ifdef SIG_INTERRUPT_THREAD
|| (signal==SIG_INTERRUPT_THREAD)
#endif
}
void
-interrupt_init()
+interrupt_init(void)
{
#ifndef LISP_FEATURE_WIN32
int i;
lisp_memory_fault_error(os_context_t *context, os_vm_address_t addr)
{
/* FIXME: This is lossy: if we get another memory fault (eg. from
- * another thread) before lisp has read this, we the information.
+ * another thread) before lisp has read this, we lose the information.
* However, since this is mostly informative, we'll live with that for
* now -- some address is better then no address in this case.
*/
}
#endif
-void
+static void
unhandled_trap_error(os_context_t *context)
{
lispobj context_sap;
lose("UNHANDLED-TRAP-ERROR fell through");
}
-/* Common logic far trapping instructions. How we actually handle each
+/* Common logic for trapping instructions. How we actually handle each
* case is highly architecture dependent, but the overall shape is
* this. */
void