/* get stack overflow exception from domain object */
x86_mov_reg_membase (code, X86_EAX, X86_EAX, G_STRUCT_OFFSET (MonoDomain, stack_overflow_ex), 4);
- /* call mono_arch_handle_exception (sctx, stack_overflow_exception_obj, FALSE) */
- x86_push_imm (code, 0);
+ /* call mono_arch_handle_exception (sctx, stack_overflow_exception_obj) */
x86_push_reg (code, X86_EAX);
x86_push_reg (code, X86_EBX);
x86_call_code (code, mono_arch_handle_exception);
DWORD page_size;
MonoDomain *domain = mono_domain_get ();
MonoJitInfo rji;
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = jit_tls->lmf;
MonoContext initial_ctx;
MonoContext ctx;
/* adjust eip so that it point into the call instruction */
ctx.eip -= 1;
- mono_handle_exception (&ctx, exc, (gpointer)eip, FALSE);
+ mono_handle_exception (&ctx, exc);
restore_context (&ctx);
/* Pop arguments off the stack */
/*
* FIXME: LLVM doesn't push these, we can't use ji->from_llvm as it describes
- * the caller.
+ * the callee.
*/
#ifndef ENABLE_LLVM
- {
- MonoJitArgumentInfo *arg_info = g_newa (MonoJitArgumentInfo, mono_method_signature (ji->method)->param_count + 1);
-
- guint32 stack_to_pop = mono_arch_get_argument_info (mono_method_signature (ji->method), mono_method_signature (ji->method)->param_count, arg_info);
- new_ctx->esp += stack_to_pop;
- }
+ if (ji->has_arch_eh_info)
+ new_ctx->esp += mono_jit_info_get_arch_eh_info (ji)->stack_size;
#endif
return TRUE;
MonoMethod *method = (*lmf)->method;
MonoJitArgumentInfo *arg_info = g_newa (MonoJitArgumentInfo, mono_method_signature (method)->param_count + 1);
- guint32 stack_to_pop = mono_arch_get_argument_info (mono_method_signature (method), mono_method_signature (method)->param_count, arg_info);
+ guint32 stack_to_pop = mono_arch_get_argument_info (NULL, mono_method_signature (method), mono_method_signature (method)->param_count, arg_info);
new_ctx->esp += stack_to_pop;
}
#endif
static void
handle_signal_exception (gpointer obj)
{
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoContext ctx;
static void (*restore_context) (MonoContext *);
if (mono_debugger_handle_exception (&ctx, (MonoObject *)obj))
return;
- mono_handle_exception (&ctx, obj, MONO_CONTEXT_GET_IP (&ctx), FALSE);
+ mono_handle_exception (&ctx, obj);
restore_context (&ctx);
}
return start;
}
+
+void
+mono_arch_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
+{
+ /*
+ * Can't pass the obj on the stack, since we are executing on the
+ * same stack. Can't save it into MonoJitTlsData, since it needs GC tracking.
+ * So put it into a register, and branch to a trampoline which
+ * pushes it.
+ */
+ ctx->eax = (mgreg_t)user_data;
+ ctx->ecx = ctx->eip;
+ ctx->edx = (mgreg_t)async_cb;
+
+ /*align the stack*/
+ ctx->esp = (ctx->esp - 16) & ~15;
+ ctx->eip = (mgreg_t)signal_exception_trampoline;
+}
+
gboolean
-mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only)
+mono_arch_handle_exception (void *sigctx, gpointer obj)
{
#if defined(MONO_ARCH_USE_SIGACTION)
+ MonoContext mctx;
ucontext_t *ctx = (ucontext_t*)sigctx;
/*
* signal is disabled, and we could run arbitrary code though the debugger. So
* resume into the normal stack and do most work there if possible.
*/
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- guint64 sp = UCONTEXT_REG_ESP (ctx);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
/* Pass the ctx parameter in TLS */
mono_arch_sigctx_to_monoctx (ctx, &jit_tls->ex_ctx);
- /*
- * Can't pass the obj on the stack, since we are executing on the
- * same stack. Can't save it into MonoJitTlsData, since it needs GC tracking.
- * So put it into a register, and branch to a trampoline which
- * pushes it.
- */
- g_assert (!test_only);
- UCONTEXT_REG_EAX (ctx) = (gsize)obj;
- UCONTEXT_REG_ECX (ctx) = UCONTEXT_REG_EIP (ctx);
- UCONTEXT_REG_EDX (ctx) = (gsize)handle_signal_exception;
- /* Allocate a stack frame, align it to 16 bytes which is needed on apple */
- sp -= 16;
- sp &= ~15;
- UCONTEXT_REG_ESP (ctx) = sp;
-
- UCONTEXT_REG_EIP (ctx) = (gsize)signal_exception_trampoline;
+ mctx = jit_tls->ex_ctx;
+ mono_setup_async_callback (&mctx, handle_signal_exception, obj);
+ mono_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#elif defined (TARGET_WIN32)
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoContext mctx;
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
struct sigcontext *ctx = (struct sigcontext *)sigctx;
- guint64 sp = ctx->SC_ESP;
mono_arch_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
- /*
- * Can't pass the obj on the stack, since we are executing on the
- * same stack. Can't save it into MonoJitTlsData, since it needs GC tracking.
- * So put it into a register, and branch to a trampoline which
- * pushes it.
- */
- g_assert (!test_only);
- ctx->SC_EAX = (gsize)obj;
- ctx->SC_ECX = ctx->SC_EIP;
- ctx->SC_EDX = (gsize)handle_signal_exception;
-
- /* Allocate a stack frame, align it to 16 bytes which is needed on apple */
- sp -= 16;
- sp &= ~15;
- ctx->SC_ESP = sp;
-
- ctx->SC_EIP = (gsize)signal_exception_trampoline;
+ mctx = jit_tls->ex_ctx;
+ mono_setup_async_callback (&mctx, handle_signal_exception, obj);
+ mono_monoctx_to_sigctx (&mctx, sigctx);
return TRUE;
#else
if (mono_debugger_handle_exception (&mctx, (MonoObject *)obj))
return TRUE;
- mono_handle_exception (&mctx, obj, (gpointer)mctx.eip, test_only);
+ mono_handle_exception (&mctx, obj);
mono_arch_monoctx_to_sigctx (&mctx, sigctx);
static void
restore_soft_guard_pages (void)
{
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
if (jit_tls->stack_ovf_guard_base)
mono_mprotect (jit_tls->stack_ovf_guard_base, jit_tls->stack_ovf_guard_size, MONO_MMAP_NONE);
}
}
static void
-altstack_handle_and_restore (void *sigctx, gpointer obj, gboolean stack_ovf)
+altstack_handle_and_restore (MonoContext *ctx, gpointer obj, gboolean stack_ovf)
{
void (*restore_context) (MonoContext *);
MonoContext mctx;
restore_context = mono_get_restore_context ();
- mono_arch_sigctx_to_monoctx (sigctx, &mctx);
+ mctx = *ctx;
if (mono_debugger_handle_exception (&mctx, (MonoObject *)obj)) {
if (stack_ovf)
restore_context (&mctx);
}
- mono_handle_exception (&mctx, obj, (gpointer)mctx.eip, FALSE);
+ mono_handle_exception (&mctx, obj);
if (stack_ovf)
prepare_for_guard_pages (&mctx);
restore_context (&mctx);
* ctx arg
* return ip
*/
- frame_size = sizeof (ucontext_t) + sizeof (gpointer) * 4;
+ // FIXME: test_only is no more.
+ frame_size = sizeof (MonoContext) + sizeof (gpointer) * 4;
frame_size += 15;
frame_size &= ~15;
sp = (gpointer)(UCONTEXT_REG_ESP (ctx) & ~15);
sp [0] = sp + 4;
sp [1] = exc;
sp [2] = (gpointer)stack_ovf;
- /* may need to adjust pointers in the new struct copy, depending on the OS */
- memcpy (sp + 4, ctx, sizeof (ucontext_t));
+ mono_sigctx_to_monoctx (sigctx, (MonoContext*)(sp + 4));
/* at the return form the signal handler execution starts in altstack_handle_and_restore() */
UCONTEXT_REG_EIP (ctx) = (unsigned long)altstack_handle_and_restore;
UCONTEXT_REG_ESP (ctx) = (unsigned long)(sp - 1);
/* the signature is: restore (MonoContinuation *cont, int state, MonoLMF **lmf_addr) */
/* put cont in edx */
x86_mov_reg_membase (code, X86_EDX, X86_ESP, 4, 4);
+ /* state in eax, so it's setup as the return value */
+ x86_mov_reg_membase (code, X86_EAX, X86_ESP, 8, 4);
+
/* setup the copy of the stack */
x86_mov_reg_membase (code, X86_ECX, X86_EDX, G_STRUCT_OFFSET (MonoContinuation, stack_used_size), 4);
x86_shift_reg_imm (code, X86_SHR, X86_ECX, 2);
/*x86_mov_reg_membase (code, X86_ECX, X86_ESP, 12, 4);
x86_mov_membase_reg (code, X86_ECX, 0, X86_EDX, 4);*/
- /* state in eax, so it's setup as the return value */
- x86_mov_reg_membase (code, X86_EAX, X86_ESP, 8, 4);
x86_jump_membase (code, X86_EDX, G_STRUCT_OFFSET (MonoContinuation, return_ip));
g_assert ((code - start) <= 48);
saved = start;
projects / mono.git / blobdiff