X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Finterrupt.c;h=1e957413dba5827cec659b6e5518d77ca12de429;hb=7c406887c08477181e869b1b98142d99b52990ac;hp=78bafeb160ffb02f29a931d106952ec32da2b00a;hpb=b5c69cfe906a31ae57bb0f18c67af9d2eaa1dfef;p=sbcl.git

diff --git a/src/runtime/interrupt.c b/src/runtime/interrupt.c
index 78bafeb..1e95741 100644
--- a/src/runtime/interrupt.c
+++ b/src/runtime/interrupt.c
@@ -86,8 +86,10 @@ sigaddset_deferrable(sigset_t *s)
     sigaddset(s, SIGTSTP);
     sigaddset(s, SIGCHLD);
     sigaddset(s, SIGIO);
+#ifndef LISP_FEATURE_HPUX
     sigaddset(s, SIGXCPU);
     sigaddset(s, SIGXFSZ);
+#endif
     sigaddset(s, SIGVTALRM);
     sigaddset(s, SIGPROF);
     sigaddset(s, SIGWINCH);
@@ -276,11 +278,17 @@ fake_foreign_function_call(os_context_t *context)
         (lispobj *)(unsigned long)
             (*os_context_register_addr(context, reg_ALLOC));
     /* fprintf(stderr,"dynamic_space_free_pointer: %p\n", dynamic_space_free_pointer); */
-#if defined(LISP_FEATURE_ALPHA)
+#if defined(LISP_FEATURE_ALPHA) || defined(LISP_FEATURE_MIPS)
     if ((long)dynamic_space_free_pointer & 1) {
         lose("dead in fake_foreign_function_call, context = %x\n", context);
     }
 #endif
+/* why doesnt PPC and SPARC do something like this: */
+#if defined(LISP_FEATURE_HPPA)
+    if ((long)dynamic_space_free_pointer & 4) {
+        lose("dead in fake_foreign_function_call, context = %x, d_s_f_p = %x\n", context, dynamic_space_free_pointer);
+    }
+#endif
 #endif
 #ifdef reg_BSP
     current_binding_stack_pointer =
@@ -370,7 +378,7 @@ interrupt_internal_error(os_context_t *context, boolean continuable)
      * confused, we have a chance to determine what's going on. */
     describe_internal_error(context);
 #endif
-    funcall2(SymbolFunction(INTERNAL_ERROR), context_sap,
+    funcall2(StaticSymbolFunction(INTERNAL_ERROR), context_sap,
              continuable ? T : NIL);
 
     undo_fake_foreign_function_call(context); /* blocks signals again */
@@ -442,7 +450,7 @@ interrupt_handle_pending(os_context_t *context)
          * that had to be executed or because pseudo atomic triggered
          * twice for a single interrupt. For the interested reader,
          * that may happen if an interrupt hits after the interrupted
-         * flag is cleared but before pseduo-atomic is set and a
+         * flag is cleared but before pseudo-atomic is set and a
          * pseudo atomic is interrupted in that interrupt. */
         if (data->pending_handler) {
 
@@ -597,7 +605,8 @@ interrupt_handle_now(int signal, siginfo_t *info, os_context_t *context)
  * 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
@@ -692,10 +701,6 @@ maybe_now_maybe_later(int signal, siginfo_t *info, void *void_context)
 
     if(!maybe_defer_handler(interrupt_handle_now,data,signal,info,context))
         interrupt_handle_now(signal, info, context);
-
-#ifdef LISP_FEATURE_DARWIN
-    DARWIN_FIX_CONTEXT(context);
-#endif
 }
 
 static void
@@ -722,10 +727,6 @@ low_level_maybe_now_maybe_later(int signal, siginfo_t *info, void *void_context)
     if(!maybe_defer_handler(low_level_interrupt_handle_now,data,
                             signal,info,context))
         low_level_interrupt_handle_now(signal, info, context);
-
-#ifdef LISP_FEATURE_DARWIN
-    DARWIN_FIX_CONTEXT(context);
-#endif
 }
 #endif
 
@@ -775,10 +776,11 @@ sig_stop_for_gc_handler(int signal, siginfo_t *info, void *void_context)
     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
@@ -811,9 +813,6 @@ interrupt_handle_now_handler(int signal, siginfo_t *info, void *void_context)
     os_restore_fp_control(context);
 #endif
     interrupt_handle_now(signal, info, context);
-#ifdef LISP_FEATURE_DARWIN
-    DARWIN_FIX_CONTEXT(context);
-#endif
 }
 
 /* manipulate the signal context and stack such that when the handler
@@ -898,8 +897,10 @@ arrange_return_to_lisp_function(os_context_t *context, lispobj function)
     *(register_save_area + 7) = *os_context_register_addr(context,reg_EAX);
     *(register_save_area + 8) = *context_eflags_addr(context);
 
-    *os_context_pc_addr(context) = call_into_lisp_tramp;
-    *os_context_register_addr(context,reg_ECX) = register_save_area;
+    *os_context_pc_addr(context) =
+      (os_context_register_t) call_into_lisp_tramp;
+    *os_context_register_addr(context,reg_ECX) =
+      (os_context_register_t) register_save_area;
 #else
 
     /* return address for call_into_lisp: */
@@ -1009,7 +1010,7 @@ interrupt_thread_handler(int num, siginfo_t *info, void *v_context)
 
     /* let the handler enable interrupts again when it sees fit */
     sigaddset_deferrable(os_context_sigmask_addr(context));
-    arrange_return_to_lisp_function(context, SymbolFunction(RUN_INTERRUPTION));
+    arrange_return_to_lisp_function(context, StaticSymbolFunction(RUN_INTERRUPTION));
 }
 
 #endif
@@ -1021,8 +1022,9 @@ interrupt_thread_handler(int num, siginfo_t *info, void *v_context)
  * functions and variables.
  */
 void
-undefined_alien_function() {
-    funcall0(SymbolFunction(UNDEFINED_ALIEN_FUNCTION_ERROR));
+undefined_alien_function(void)
+{
+    funcall0(StaticSymbolFunction(UNDEFINED_ALIEN_FUNCTION_ERROR));
 }
 
 boolean
@@ -1042,7 +1044,7 @@ handle_guard_page_triggered(os_context_t *context,os_vm_address_t addr)
         protect_control_stack_return_guard_page(1);
 
         arrange_return_to_lisp_function
-            (context, SymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
+            (context, StaticSymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
         return 1;
     }
     else if(addr >= CONTROL_STACK_RETURN_GUARD_PAGE(th) &&
@@ -1058,7 +1060,7 @@ handle_guard_page_triggered(os_context_t *context,os_vm_address_t addr)
     else if (addr >= undefined_alien_address &&
              addr < undefined_alien_address + os_vm_page_size) {
         arrange_return_to_lisp_function
-          (context, SymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
+          (context, StaticSymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
         return 1;
     }
     else return 0;
@@ -1110,7 +1112,7 @@ sigaction_nodefer_test_handler(int signal, siginfo_t *info, void *void_context)
 }
 
 static void
-see_if_sigaction_nodefer_works()
+see_if_sigaction_nodefer_works(void)
 {
     struct sigaction sa, old_sa;
 
@@ -1158,9 +1160,7 @@ low_level_unblock_me_trampoline(int signal, siginfo_t *info, void *void_context)
 
 void
 undoably_install_low_level_interrupt_handler (int signal,
-                                              void handler(int,
-                                                           siginfo_t*,
-                                                           void*))
+                                              interrupt_handler_t handler)
 {
     struct sigaction sa;
 
@@ -1189,9 +1189,6 @@ undoably_install_low_level_interrupt_handler (int signal,
         | (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
@@ -1255,7 +1252,7 @@ install_handler(int signal, void handler(int, siginfo_t*, void*))
 }
 
 void
-interrupt_init()
+interrupt_init(void)
 {
 #ifndef LISP_FEATURE_WIN32
     int i;
@@ -1293,16 +1290,16 @@ void
 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.
     */
     current_memory_fault_address = addr;
-    arrange_return_to_lisp_function(context, SymbolFunction(MEMORY_FAULT_ERROR));
+    arrange_return_to_lisp_function(context, StaticSymbolFunction(MEMORY_FAULT_ERROR));
 }
 #endif
 
-void
+static void
 unhandled_trap_error(os_context_t *context)
 {
     lispobj context_sap;
@@ -1311,11 +1308,11 @@ unhandled_trap_error(os_context_t *context)
 #ifndef LISP_FEATURE_WIN32
     thread_sigmask(SIG_SETMASK, os_context_sigmask_addr(context), 0);
 #endif
-    funcall1(SymbolFunction(UNHANDLED_TRAP_ERROR), context_sap);
+    funcall1(StaticSymbolFunction(UNHANDLED_TRAP_ERROR), 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