#include <stdlib.h>
#include <stdio.h>
+#if __DARWIN_UNIX03
+#include <sys/_structs.h>
+#endif
+
+#if __DARWIN_UNIX03
+
+typedef struct __darwin_ucontext darwin_ucontext;
+typedef struct __darwin_mcontext64 darwin_mcontext;
+
+#define rip __rip
+#define rsp __rsp
+#define rbp __rbp
+#define rax __rax
+#define rbx __rbx
+#define rcx __rcx
+#define rdx __rdx
+#define rsi __rsi
+#define rdi __rdi
+#define r8 __r8
+#define r9 __r9
+#define faultvaddr __faultvaddr
+#define ss __ss
+#define es __es
+#define fs __fs
+
+#else
+
+typedef struct ucontext darwin_ucontext;
+typedef struct mcontext darwin_mcontext;
+
+#endif
+
#ifdef LISP_FEATURE_SB_THREAD
pthread_mutex_t mach_exception_lock = PTHREAD_MUTEX_INITIALIZER;
#endif
/* This executes in the faulting thread as part of the signal
* emulation. It is passed a context with the uc_mcontext field
* pointing to a valid block of memory. */
-void build_fake_signal_context(struct ucontext *context,
+void build_fake_signal_context(darwin_ucontext *context,
x86_thread_state64_t *thread_state,
x86_float_state64_t *float_state) {
pthread_sigmask(0, NULL, &context->uc_sigmask);
* emulation. It is effectively the inverse operation from above. */
void update_thread_state_from_context(x86_thread_state64_t *thread_state,
x86_float_state64_t *float_state,
- struct ucontext *context) {
+ darwin_ucontext *context) {
*thread_state = context->uc_mcontext->ss;
*float_state = context->uc_mcontext->fs;
pthread_sigmask(SIG_SETMASK, &context->uc_sigmask, NULL);
* context (and regs just for symmetry).
*/
- struct ucontext *context;
- struct mcontext *regs;
+ darwin_ucontext *context;
+ darwin_mcontext *regs;
- context = (struct ucontext*) os_validate(0, sizeof(struct ucontext));
- regs = (struct mcontext*) os_validate(0, sizeof(struct mcontext));
+ context = (darwin_ucontext *) os_validate(0, sizeof(darwin_ucontext));
+ regs = (darwin_mcontext*) os_validate(0, sizeof(darwin_mcontext));
context->uc_mcontext = regs;
/* when BSD signals are fired, they mask they signals in sa_mask
update_thread_state_from_context(thread_state, float_state, context);
- os_invalidate((os_vm_address_t)context, sizeof(struct ucontext));
- os_invalidate((os_vm_address_t)regs, sizeof(struct mcontext));
+ os_invalidate((os_vm_address_t)context, sizeof(darwin_ucontext));
+ os_invalidate((os_vm_address_t)regs, sizeof(darwin_mcontext));
/* Trap to restore the signal context. */
asm volatile ("mov %0, %%rax; mov %1, %%rbx; .quad 0xffffffffffff0b0f"
os_context_t *context = arch_os_get_context(&void_context);
arrange_return_to_lisp_function
- (context, SymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
+ (context, StaticSymbolFunction(CONTROL_STACK_EXHAUSTED_ERROR));
}
void
os_context_t *context = arch_os_get_context(&void_context);
arrange_return_to_lisp_function
- (context, SymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
+ (context, StaticSymbolFunction(UNDEFINED_ALIEN_VARIABLE_ERROR));
}
kern_return_t
backup_thread_state = thread_state;
open_stack_allocation(&thread_state);
+ /* Reserve a 256 byte zone for signal handlers
+ * to use on the interrupted thread stack.
+ */
+ stack_allocate(&thread_state, 256);
/* Save thread state */
target_thread_state =
addr < undefined_alien_address + os_vm_page_size) {
backup_thread_state = thread_state;
open_stack_allocation(&thread_state);
+ stack_allocate(&thread_state, 256);
/* Save thread state */
target_thread_state =
backup_thread_state = thread_state;
open_stack_allocation(&thread_state);
+ stack_allocate(&thread_state, 256);
/* Save thread state */
target_thread_state =
backup_thread_state = thread_state;
open_stack_allocation(&thread_state);
+ stack_allocate(&thread_state, 256);
/* Save thread state */
target_thread_state =