* The first argument in r3 is the pointer to the context.
*/
gpointer
-mono_arch_get_restore_context_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
{
guint8 *start, *code;
int size = MONO_PPC_32_64_CASE (128, 172) + PPC_FTNPTR_SIZE;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
code = start = mono_global_codeman_reserve (size);
- *ji = NULL;
if (!aot)
code = mono_ppc_create_pre_code_ftnptr (code);
restore_regs_from_context (ppc_r3, ppc_r4, ppc_r5);
g_assert ((code - start) <= size);
mono_arch_flush_icache (start, code - start);
- *code_size = code - start;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("restore_context"), start, code - start, ji, unwind_ops);
return start;
}
* @exc object in this case).
*/
gpointer
-mono_arch_get_call_filter_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
{
guint8 *start, *code;
int alloc_size, pos, i;
int size = MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE;
-
- *ji = NULL;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
code = start = mono_global_codeman_reserve (size);
g_assert ((code - start) < size);
mono_arch_flush_icache (start, code - start);
- *code_size = code - start;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("call_filter"), start, code - start, ji, unwind_ops);
return start;
}
if (!rethrow)
mono_ex->stack_trace = NULL;
}
- mono_handle_exception (&ctx, exc, (gpointer)eip, FALSE);
+ mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
*
*/
static gpointer
-mono_arch_get_throw_exception_generic (int size, guint32 *code_size, MonoJumpInfo **ji, int corlib, gboolean rethrow, gboolean aot)
+mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corlib, gboolean rethrow, gboolean aot)
{
guint8 *start, *code;
int alloc_size, pos;
-
- *ji = NULL;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
code = start = mono_global_codeman_reserve (size);
if (!aot)
ppc_mr (code, ppc_r4, ppc_r3);
if (aot) {
- code = mono_arch_emit_load_aotconst (start, code, ji, MONO_PATCH_INFO_IMAGE, mono_defaults.corlib);
+ code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_IMAGE, mono_defaults.corlib);
ppc_mr (code, ppc_r3, ppc_r11);
- code = mono_arch_emit_load_aotconst (start, code, ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_exception_from_token");
+ code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_exception_from_token");
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
ppc_ldptr (code, ppc_r11, 0, ppc_r11);
// This can be called from runtime code, which can't guarantee that
// r30 contains the got address.
// So emit the got address loading code too
- code = mono_arch_emit_load_got_addr (start, code, NULL, ji);
- code = mono_arch_emit_load_aotconst (start, code, ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_ppc_throw_exception");
+ code = mono_arch_emit_load_got_addr (start, code, NULL, &ji);
+ code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_ppc_throw_exception");
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
ppc_ldptr (code, ppc_r11, 0, ppc_r11);
g_assert ((code - start) <= size);
mono_arch_flush_icache (start, code - start);
- *code_size = code - start;
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf (corlib ? "throw_corlib_exception" : (rethrow ? "rethrow_exception" : "throw_exception")), start, code - start, ji, unwind_ops);
return start;
}
*
*/
gpointer
-mono_arch_get_rethrow_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
{
int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
if (aot)
size += 64;
- return mono_arch_get_throw_exception_generic (size, code_size, ji, FALSE, TRUE, aot);
+ return mono_arch_get_throw_exception_generic (size, info, FALSE, TRUE, aot);
}
/**
*
*/
gpointer
-mono_arch_get_throw_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
{
int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
if (aot)
size += 64;
- return mono_arch_get_throw_exception_generic (size, code_size, ji, FALSE, FALSE, aot);
-}
-
-/**
- * arch_get_throw_exception_by_name:
- *
- * Returns a function pointer which can be used to raise
- * corlib exceptions. The returned function has the following
- * signature: void (*func) (char *exc_name);
- * For example to raise an arithmetic exception you can use:
- *
- * x86_push_imm (code, "ArithmeticException");
- * x86_call_code (code, arch_get_throw_exception_by_name ());
- *
- */
-gpointer
-mono_arch_get_throw_exception_by_name_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
-{
- guint8 *start, *code;
- int size = 64;
-
- *ji = NULL;
-
- /* Not used on PPC */
- start = code = mono_global_codeman_reserve (size);
- ppc_break (code);
- mono_arch_flush_icache (start, code - start);
- *code_size = code - start;
- return start;
+ return mono_arch_get_throw_exception_generic (size, info, FALSE, FALSE, aot);
}
/**
* On PPC, we pass the ip instead of the offset
*/
gpointer
-mono_arch_get_throw_corlib_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
{
int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE;
if (aot)
size += 64;
- return mono_arch_get_throw_exception_generic (size, code_size, ji, TRUE, FALSE, aot);
+ return mono_arch_get_throw_exception_generic (size, info, TRUE, FALSE, aot);
}
/*
- * mono_arch_find_jit_info_ext:
+ * mono_arch_find_jit_info:
*
* See exceptions-amd64.c for docs.
*/
gboolean
-mono_arch_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
+mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
- MonoContext *new_ctx, MonoLMF **lmf,
+ MonoContext *new_ctx, MonoLMF **lmf,
+ mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
- frame->managed = FALSE;
*new_ctx = *ctx;
setup_context (new_ctx);
frame->type = FRAME_TYPE_MANAGED;
- if (!ji->method->wrapper_type || ji->method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
- frame->managed = TRUE;
-
if (ji->from_aot)
unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
else
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
- ip, regs, ppc_lr + 1, &cfa);
+ ip, regs, ppc_lr + 1,
+ save_locations, MONO_MAX_IREGS, &cfa);
/* we substract 4, so that the IP points into the call instruction */
MONO_CONTEXT_SET_IP (new_ctx, regs [ppc_lr] - 4);
#endif
}
+void
+mono_ppc_set_func_into_sigctx (void *sigctx, void *func)
+{
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
+#elif defined(PPC_USES_FUNCTION_DESCRIPTOR)
+ /* Have to set both the ip and the TOC reg */
+ os_ucontext *uc = sigctx;
+
+ UCONTEXT_REG_NIP(uc) = ((gsize*)func) [0];
+ UCONTEXT_REG_Rn (uc, 2) = ((gsize*)func)[1];
+#else
+ g_assert_not_reached ();
+#endif
+}
+
static void
-altstack_handle_and_restore (void *sigctx, gpointer obj, gboolean test_only)
+altstack_handle_and_restore (void *sigctx, gpointer obj)
{
void (*restore_context) (MonoContext *);
MonoContext mctx;
restore_context = mono_get_restore_context ();
mono_arch_sigctx_to_monoctx (sigctx, &mctx);
- mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_ir, test_only);
+ mono_handle_exception (&mctx, obj);
restore_context (&mctx);
}
#endif /* !MONO_CROSS_COMPILE */
}
+/*
+ * handle_exception:
+ *
+ * Called by resuming from a signal handler.
+ */
+static void
+handle_signal_exception (gpointer obj)
+{
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoContext ctx;
+ static void (*restore_context) (MonoContext *);
+
+ if (!restore_context)
+ restore_context = mono_get_restore_context ();
+
+ memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
+
+ mono_handle_exception (&ctx, obj);
+
+ restore_context (&ctx);
+}
+
+static void
+setup_ucontext_return (void *uc, gpointer func)
+{
+#if !defined(MONO_CROSS_COMPILE)
+ UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+ {
+ MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)func;
+
+ UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
+ UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
+ }
+#else
+ UCONTEXT_REG_NIP(uc) = (unsigned long)func;
+#endif
+#endif
+}
+
gboolean
-mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+mono_arch_handle_exception (void *ctx, gpointer obj)
{
+#if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
+ /*
+ * Handling the exception in the signal handler is problematic, since the original
+ * 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 = mono_native_tls_get_value (mono_jit_tls_id);
+ mgreg_t sp;
+ void *sigctx = ctx;
+ int frame_size;
+ void *uc = sigctx;
+
+ /* Pass the ctx parameter in TLS */
+ mono_arch_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
+ /* The others in registers */
+ UCONTEXT_REG_Rn (sigctx, PPC_FIRST_ARG_REG) = (gsize)obj;
+
+ /* Allocate a stack frame below the red zone */
+ /* Similar to mono_arch_handle_altstack_exception () */
+ frame_size = 224;
+ frame_size += 15;
+ frame_size &= ~15;
+ sp = (mgreg_t)(UCONTEXT_REG_Rn(uc, 1) & ~15);
+ sp = (mgreg_t)(sp - frame_size);
+ UCONTEXT_REG_Rn(uc, 1) = (mgreg_t)sp;
+ setup_ucontext_return (uc, handle_signal_exception);
+
+ return TRUE;
+#else
MonoContext mctx;
gboolean result;
mono_arch_sigctx_to_monoctx (ctx, &mctx);
- result = mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_ir, test_only);
+ result = mono_handle_exception (&mctx, obj);
/* restore the context so that returning from the signal handler will invoke
* the catch clause
*/
mono_arch_monoctx_to_sigctx (&mctx, ctx);
return result;
+#endif
}
-
-gboolean
-mono_arch_has_unwind_info (gconstpointer addr)
-{
- return FALSE;
-}
-
projects / mono.git / blobdiff