- if (!foreign_function_call_active
-#ifndef INTERNAL_GC_TRIGGER
- && gc_trigger_hit(signal, info, context)
-#endif
- ) {
-#ifndef INTERNAL_GC_TRIGGER
- clear_auto_gc_trigger();
-#endif
-
- if (arch_pseudo_atomic_atomic(context)) {
- /* don't GC during an atomic operation. Instead, copy the
- * signal mask somewhere safe. interrupt_handle_pending
- * will detect pending_signal==0 and know to do a GC with the
- * signal context instead of calling a Lisp-level handler */
- maybe_gc_pending = 1;
- if (pending_signal == 0) {
- /* FIXME: This copy-pending_mask-then-sigaddset_blockable
- * idiom occurs over and over. It should be factored out
- * into a function with a descriptive name. */
- memcpy(&pending_mask,
- os_context_sigmask_addr(context),
- sizeof(sigset_t));
- sigaddset_blockable(os_context_sigmask_addr(context));
- }
- arch_set_pseudo_atomic_interrupted(context);
- }
- else {
- fake_foreign_function_call(context);
- funcall0(SymbolFunction(MAYBE_GC));
- undo_fake_foreign_function_call(context);
- }
+ u32 *sp=(u32 *)*os_context_register_addr(context,reg_ESP);
+
+ *(sp-15) = post_signal_tramp; /* return address for call_into_lisp */
+ *(sp-14) = function; /* args for call_into_lisp : function*/
+ *(sp-13) = 0; /* arg array */
+ *(sp-12) = 0; /* no. args */
+ /* this order matches that used in POPAD */
+ *(sp-11)=*os_context_register_addr(context,reg_EDI);
+ *(sp-10)=*os_context_register_addr(context,reg_ESI);
+
+ *(sp-9)=*os_context_register_addr(context,reg_ESP)-8;
+ /* POPAD ignores the value of ESP: */
+ *(sp-8)=0;
+ *(sp-7)=*os_context_register_addr(context,reg_EBX);
+
+ *(sp-6)=*os_context_register_addr(context,reg_EDX);
+ *(sp-5)=*os_context_register_addr(context,reg_ECX);
+ *(sp-4)=*os_context_register_addr(context,reg_EAX);
+ *(sp-3)=*context_eflags_addr(context);
+ *(sp-2)=*os_context_register_addr(context,reg_EBP);
+ *(sp-1)=*os_context_pc_addr(context);
+
+#elif defined(LISP_FEATURE_X86_64)
+ u64 *sp=(u64 *)*os_context_register_addr(context,reg_RSP);
+ *(sp-20) = post_signal_tramp; /* return address for call_into_lisp */
+
+ *(sp-19)=*os_context_register_addr(context,reg_R15);
+ *(sp-18)=*os_context_register_addr(context,reg_R14);
+ *(sp-17)=*os_context_register_addr(context,reg_R13);
+ *(sp-16)=*os_context_register_addr(context,reg_R12);
+ *(sp-15)=*os_context_register_addr(context,reg_R11);
+ *(sp-14)=*os_context_register_addr(context,reg_R10);
+ *(sp-13)=*os_context_register_addr(context,reg_R9);
+ *(sp-12)=*os_context_register_addr(context,reg_R8);
+ *(sp-11)=*os_context_register_addr(context,reg_RDI);
+ *(sp-10)=*os_context_register_addr(context,reg_RSI);
+ *(sp-9)=*os_context_register_addr(context,reg_RSP)-16;
+ *(sp-8)=0;
+ *(sp-7)=*os_context_register_addr(context,reg_RBX);
+ *(sp-6)=*os_context_register_addr(context,reg_RDX);
+ *(sp-5)=*os_context_register_addr(context,reg_RCX);
+ *(sp-4)=*os_context_register_addr(context,reg_RAX);
+ *(sp-3)=*context_eflags_addr(context);
+ *(sp-2)=*os_context_register_addr(context,reg_RBP);
+ *(sp-1)=*os_context_pc_addr(context);
+
+ *os_context_register_addr(context,reg_RDI) = function; /* function */
+ *os_context_register_addr(context,reg_RSI) = 0; /* arg. array */
+ *os_context_register_addr(context,reg_RDX) = 0; /* no. args */
+#else
+ struct thread *th=arch_os_get_current_thread();
+ build_fake_control_stack_frames(th,context);
+#endif
+
+#ifdef LISP_FEATURE_X86
+ *os_context_pc_addr(context) = call_into_lisp;
+ *os_context_register_addr(context,reg_ECX) = 0;
+ *os_context_register_addr(context,reg_EBP) = sp-2;
+#ifdef __NetBSD__
+ *os_context_register_addr(context,reg_UESP) = sp-15;
+#else
+ *os_context_register_addr(context,reg_ESP) = sp-15;
+#endif
+#elif defined(LISP_FEATURE_X86_64)
+ *os_context_pc_addr(context) = call_into_lisp;
+ *os_context_register_addr(context,reg_RCX) = 0;
+ *os_context_register_addr(context,reg_RBP) = sp-2;
+ *os_context_register_addr(context,reg_RSP) = sp-20;
+#else
+ /* this much of the calling convention is common to all
+ non-x86 ports */
+ *os_context_pc_addr(context) = code;
+ *os_context_register_addr(context,reg_NARGS) = 0;
+ *os_context_register_addr(context,reg_LIP) = code;
+ *os_context_register_addr(context,reg_CFP) =
+ current_control_frame_pointer;
+#endif
+#ifdef ARCH_HAS_NPC_REGISTER
+ *os_context_npc_addr(context) =
+ 4 + *os_context_pc_addr(context);
+#endif
+#ifdef LISP_FEATURE_SPARC
+ *os_context_register_addr(context,reg_CODE) =
+ fun + FUN_POINTER_LOWTAG;
+#endif
+}
+
+#ifdef LISP_FEATURE_SB_THREAD
+void interrupt_thread_handler(int num, siginfo_t *info, void *v_context)
+{
+ os_context_t *context = (os_context_t*)arch_os_get_context(&v_context);
+ /* The order of interrupt execution is peculiar. If thread A
+ * interrupts thread B with I1, I2 and B for some reason recieves
+ * I1 when FUN2 is already on the list, then it is FUN2 that gets
+ * to run first. But when FUN2 is run SIG_INTERRUPT_THREAD is
+ * enabled again and I2 hits pretty soon in FUN2 and run
+ * FUN1. This is of course just one scenario, and the order of
+ * thread interrupt execution is undefined. */
+ struct thread *th=arch_os_get_current_thread();
+ struct cons *c;
+ get_spinlock(&th->interrupt_fun_lock,(long)th);
+ c=((struct cons *)native_pointer(th->interrupt_fun));
+ arrange_return_to_lisp_function(context,c->car);
+ th->interrupt_fun=(lispobj *)(c->cdr);
+ release_spinlock(&th->interrupt_fun_lock);
+}
+
+#endif
+
+/* KLUDGE: Theoretically the approach we use for undefined alien
+ * variables should work for functions as well, but on PPC/Darwin
+ * we get bus error at bogus addresses instead, hence this workaround,
+ * that has the added benefit of automatically discriminating between
+ * functions and variables.
+ */
+void undefined_alien_function() {
+ funcall0(SymbolFunction(UNDEFINED_ALIEN_FUNCTION_ERROR));
+}