* Authors:
* Dietmar Maurer (dietmar@ximian.com)
* Paolo Molaro (lupus@ximian.com)
+ * Andreas Faerber <andreas.faerber@web.de>
*
* (C) 2001 Ximian, Inc.
+ * (C) 2007-2008 Andreas Faerber
*/
#include <config.h>
#include <glib.h>
#include <signal.h>
#include <string.h>
+#include <stddef.h>
+#if HAVE_UCONTEXT_H
#include <ucontext.h>
+#endif
#include <mono/arch/ppc/ppc-codegen.h>
#include <mono/metadata/appdomain.h>
#include "mini.h"
#include "mini-ppc.h"
-static gboolean arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only);
-
/*
struct sigcontext {
#define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do { \
int reg; \
- ppc_lwz (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg); \
- ppc_lmw (code, ppc_r13, ctx_reg, G_STRUCT_OFFSET (MonoContext, regs)); \
+ ppc_ldptr (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg); \
+ ppc_load_multiple_regs (code, ppc_r13, G_STRUCT_OFFSET (MonoContext, regs), ctx_reg); \
for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) { \
- ppc_lfd (code, (14 + reg), G_STRUCT_OFFSET(MonoLMF, fregs) + reg * sizeof (gdouble), ctx_reg); \
+ ppc_lfd (code, (14 + reg), \
+ G_STRUCT_OFFSET(MonoContext, fregs) + reg * sizeof (gdouble), ctx_reg); \
} \
} while (0)
/* nothing to do */
#define setup_context(ctx)
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+guint8*
+mono_ppc_create_pre_code_ftnptr (guint8 *code)
+{
+ MonoPPCFunctionDescriptor *ftnptr = (MonoPPCFunctionDescriptor*)code;
+
+ code += sizeof (MonoPPCFunctionDescriptor);
+ ftnptr->code = code;
+ ftnptr->toc = NULL;
+ ftnptr->env = NULL;
+
+ return code;
+}
+#endif
+
/*
* arch_get_restore_context:
*
* Returns a pointer to a method which restores a previously saved sigcontext.
* The first argument in r3 is the pointer to the context.
*/
-static gpointer
-arch_get_restore_context (void)
+gpointer
+mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
{
- guint8 *code;
- static guint8 start [128];
- static int inited = 0;
-
- if (inited)
- return start;
- inited = 1;
-
- code = start;
+ 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);
+ if (!aot)
+ code = mono_ppc_create_pre_code_ftnptr (code);
restore_regs_from_context (ppc_r3, ppc_r4, ppc_r5);
/* restore also the stack pointer */
- ppc_lwz (code, ppc_sp, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
+ ppc_ldptr (code, ppc_sp, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
//ppc_break (code);
/* jump to the saved IP */
ppc_mtctr (code, ppc_r4);
/* never reached */
ppc_break (code);
- g_assert ((code - start) < sizeof(start));
+ g_assert ((code - start) <= size);
mono_arch_flush_icache (start, code - start);
+
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("restore_context"), start, code - start, ji, unwind_ops);
+
return start;
}
+#define SAVED_REGS_LENGTH (sizeof (gdouble) * MONO_SAVED_FREGS + sizeof (gpointer) * MONO_SAVED_GREGS)
+#define ALIGN_STACK_FRAME_SIZE(s) (((s) + MONO_ARCH_FRAME_ALIGNMENT - 1) & ~(MONO_ARCH_FRAME_ALIGNMENT - 1))
+/* The 64 bytes here are for outgoing arguments and a bit of spare.
+ We don't use it all, but it doesn't hurt. */
+#define REG_SAVE_STACK_FRAME_SIZE (ALIGN_STACK_FRAME_SIZE (SAVED_REGS_LENGTH + PPC_MINIMAL_STACK_SIZE + 64))
+
+static guint8*
+emit_save_saved_regs (guint8 *code, int pos)
+{
+ int i;
+
+ for (i = 31; i >= 14; --i) {
+ pos -= sizeof (gdouble);
+ ppc_stfd (code, i, pos, ppc_sp);
+ }
+ pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
+ ppc_store_multiple_regs (code, ppc_r13, pos, ppc_sp);
+
+ return code;
+}
+
/*
- * arch_get_call_filter:
+ * mono_arch_get_call_filter:
*
* Returns a pointer to a method which calls an exception filter. We
* also use this function to call finally handlers (we pass NULL as
* @exc object in this case).
*/
-static gpointer
-arch_get_call_filter (void)
+gpointer
+mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
{
- static guint8 start [320];
- static int inited = 0;
- guint8 *code;
+ guint8 *start, *code;
int alloc_size, pos, i;
+ int size = MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
- if (inited)
- return start;
-
- inited = 1;
/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
- code = start;
-
- /* save all the regs on the stack */
- pos = 0;
- for (i = 31; i >= 14; --i) {
- pos += sizeof (gdouble);
- ppc_stfd (code, i, -pos, ppc_sp);
- }
- pos += sizeof (gulong) * MONO_SAVED_GREGS;
- ppc_stmw (code, ppc_r13, ppc_sp, -pos);
+ code = start = mono_global_codeman_reserve (size);
+ if (!aot)
+ code = mono_ppc_create_pre_code_ftnptr (code);
+ /* store ret addr */
ppc_mflr (code, ppc_r0);
- ppc_stw (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+ ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+
+ alloc_size = REG_SAVE_STACK_FRAME_SIZE;
- alloc_size = PPC_MINIMAL_STACK_SIZE + pos + 64;
- // align to PPC_STACK_ALIGNMENT bytes
- alloc_size += PPC_STACK_ALIGNMENT - 1;
- alloc_size &= ~(PPC_STACK_ALIGNMENT - 1);
+ /* allocate stack frame and set link from sp in ctx */
+ g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
+ ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
+ ppc_ldptr_indexed (code, ppc_r0, ppc_r0, ppc_r0);
+ ppc_stptr_update (code, ppc_r0, -alloc_size, ppc_sp);
- g_assert ((alloc_size & (PPC_STACK_ALIGNMENT-1)) == 0);
- ppc_stwu (code, ppc_sp, -alloc_size, ppc_sp);
+ code = emit_save_saved_regs (code, alloc_size);
/* restore all the regs from ctx (in r3), but not r1, the stack pointer */
restore_regs_from_context (ppc_r3, ppc_r6, ppc_r7);
ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
/* epilog */
- ppc_lwz (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
+ ppc_ldptr (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
ppc_mtlr (code, ppc_r0);
- ppc_addic (code, ppc_sp, ppc_sp, alloc_size);
-
+
/* restore all the regs from the stack */
- pos = 0;
+ pos = alloc_size;
for (i = 31; i >= 14; --i) {
- pos += sizeof (double);
- ppc_lfd (code, i, -pos, ppc_sp);
+ pos -= sizeof (gdouble);
+ ppc_lfd (code, i, pos, ppc_sp);
}
- pos += sizeof (gulong) * MONO_SAVED_GREGS;
- ppc_lmw (code, ppc_r13, ppc_sp, -pos);
+ pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
+ ppc_load_multiple_regs (code, ppc_r13, pos, ppc_sp);
+ ppc_addic (code, ppc_sp, ppc_sp, alloc_size);
ppc_blr (code);
- g_assert ((code - start) < sizeof(start));
+ g_assert ((code - start) < size);
mono_arch_flush_icache (start, code - start);
+
+ if (info)
+ *info = mono_tramp_info_create (g_strdup_printf ("call_filter"), start, code - start, ji, unwind_ops);
+
return start;
}
-static void
-throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs, gboolean rethrow)
+void
+mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
if (!restore_context)
- restore_context = arch_get_restore_context ();
+ restore_context = mono_get_restore_context ();
/* adjust eip so that it point into the call instruction */
eip -= 4;
/*printf ("stack in throw: %p\n", esp);*/
MONO_CONTEXT_SET_BP (&ctx, esp);
MONO_CONTEXT_SET_IP (&ctx, eip);
- memcpy (&ctx.regs, int_regs, sizeof (gulong) * MONO_SAVED_GREGS);
+ memcpy (&ctx.regs, int_regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
memcpy (&ctx.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS);
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
if (!rethrow)
mono_ex->stack_trace = NULL;
}
- arch_handle_exception (&ctx, exc, FALSE);
+ mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
* Returns a function pointer which can be used to raise
* exceptions. The returned function has the following
* signature: void (*func) (MonoException *exc); or
- * void (*func) (char *exc_name);
+ * void (*func) (guint32 ex_token, gpointer ip)
*
*/
-static gpointer
-mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name, gboolean rethrow)
+static gpointer
+mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corlib, gboolean rethrow, gboolean aot)
{
- guint8 *code;
- int alloc_size, pos, i;
+ guint8 *start, *code;
+ int alloc_size, pos;
+ MonoJumpInfo *ji = NULL;
+ GSList *unwind_ops = NULL;
+
+ code = start = mono_global_codeman_reserve (size);
+ if (!aot)
+ code = mono_ppc_create_pre_code_ftnptr (code);
+
+ /* store ret addr */
+ if (corlib)
+ ppc_mr (code, ppc_r0, ppc_r4);
+ else
+ ppc_mflr (code, ppc_r0);
+ ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
- code = start;
+ alloc_size = REG_SAVE_STACK_FRAME_SIZE;
- /* save all the regs on the stack */
- pos = 0;
- for (i = 31; i >= 14; --i) {
- pos += sizeof (gdouble);
- ppc_stfd (code, i, -pos, ppc_sp);
- }
- pos += sizeof (gulong) * MONO_SAVED_GREGS;
- ppc_stmw (code, ppc_r13, ppc_sp, -pos);
-
- ppc_mflr (code, ppc_r0);
- ppc_stw (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+ g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
+ ppc_stptr_update (code, ppc_sp, -alloc_size, ppc_sp);
- alloc_size = PPC_MINIMAL_STACK_SIZE + pos + 64;
- // align to PPC_STACK_ALIGNMENT bytes
- alloc_size += PPC_STACK_ALIGNMENT - 1;
- alloc_size &= ~(PPC_STACK_ALIGNMENT - 1);
-
- g_assert ((alloc_size & (PPC_STACK_ALIGNMENT-1)) == 0);
- ppc_stwu (code, ppc_sp, -alloc_size, ppc_sp);
+ code = emit_save_saved_regs (code, alloc_size);
//ppc_break (code);
- if (by_name) {
- ppc_mr (code, ppc_r5, ppc_r3);
- ppc_load (code, ppc_r3, mono_defaults.corlib);
- ppc_load (code, ppc_r4, "System");
- ppc_load (code, ppc_r0, mono_exception_from_name);
- ppc_mtctr (code, ppc_r0);
- ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+ if (corlib) {
+ 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);
+ 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");
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+ ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
+ ppc_ldptr (code, ppc_r11, 0, ppc_r11);
+#endif
+ ppc_mtctr (code, ppc_r11);
+ ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+ } else {
+ ppc_load (code, ppc_r3, (gulong)mono_defaults.corlib);
+ ppc_load_func (code, ppc_r0, mono_exception_from_token);
+ ppc_mtctr (code, ppc_r0);
+ ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+ }
}
/* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
/* caller sp */
- ppc_lwz (code, ppc_r5, 0, ppc_sp);
+ ppc_ldptr (code, ppc_r5, 0, ppc_sp);
/* exc is already in place in r3 */
- if (by_name)
- ppc_lwz (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
+ if (corlib)
+ ppc_ldptr (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
else
ppc_mr (code, ppc_r4, ppc_r0); /* caller ip */
/* pointer to the saved fp regs */
- pos = alloc_size - sizeof (double) * MONO_SAVED_FREGS;
+ pos = alloc_size - sizeof (gdouble) * MONO_SAVED_FREGS;
ppc_addi (code, ppc_r7, ppc_sp, pos);
/* pointer to the saved int regs */
- pos -= sizeof (gulong) * MONO_SAVED_GREGS;
+ pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
ppc_addi (code, ppc_r6, ppc_sp, pos);
ppc_li (code, ppc_r8, rethrow);
- ppc_load (code, ppc_r0, throw_exception);
- ppc_mtctr (code, ppc_r0);
- ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+ if (aot) {
+ // 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");
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+ ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
+ ppc_ldptr (code, ppc_r11, 0, ppc_r11);
+#endif
+ ppc_mtctr (code, ppc_r11);
+ ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+ } else {
+ ppc_load_func (code, ppc_r0, mono_ppc_throw_exception);
+ ppc_mtctr (code, ppc_r0);
+ ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+ }
/* we should never reach this breakpoint */
ppc_break (code);
- g_assert ((code - start) < size);
+ g_assert ((code - start) <= size);
mono_arch_flush_icache (start, 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 (void)
+mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
{
- static guint8 start [132];
- static int inited = 0;
+ int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
- if (inited)
- return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, TRUE);
- inited = 1;
- return start;
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, info, FALSE, TRUE, aot);
}
+
/**
* arch_get_throw_exception:
*
* x86_call_code (code, arch_get_throw_exception ());
*
*/
-gpointer
-mono_arch_get_throw_exception (void)
+gpointer
+mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
{
- static guint8 start [132];
- static int inited = 0;
+ int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
- if (inited)
- return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, FALSE);
- inited = 1;
- return start;
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, info, FALSE, FALSE, aot);
}
/**
- * arch_get_throw_exception_by_name:
+ * mono_arch_get_throw_corlib_exception:
*
* 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 ());
- *
+ * signature: void (*func) (guint32 ex_token, guint32 offset);
+ * On PPC, we pass the ip instead of the offset
*/
-gpointer
-mono_arch_get_throw_exception_by_name (void)
-{
- static guint8 start [168];
- static int inited = 0;
-
- if (inited)
- return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE, FALSE);
- inited = 1;
- return start;
-}
-
-static MonoArray *
-glist_to_array (GList *list, MonoClass *eclass)
+gpointer
+mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
{
- MonoDomain *domain = mono_domain_get ();
- MonoArray *res;
- int len, i;
-
- if (!list)
- return NULL;
+ int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE;
- len = g_list_length (list);
- res = mono_array_new (domain, eclass, len);
-
- for (i = 0; list; list = list->next, i++)
- mono_array_set (res, gpointer, i, list->data);
-
- return res;
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, info, TRUE, FALSE, aot);
}
-/* mono_arch_find_jit_info:
+/*
+ * mono_arch_find_jit_info:
*
- * This function is used to gather information from @ctx. It return the
- * MonoJitInfo of the corresponding function, unwinds one stack frame and
- * stores the resulting context into @new_ctx. It also stores a string
- * describing the stack location into @trace (if not NULL), and modifies
- * the @lmf if necessary. @native_offset return the IP offset from the
- * start of the function or -1 if that info is not available.
+ * See exceptions-amd64.c for docs.
*/
-MonoJitInfo *
-mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji,
- MonoContext *ctx, MonoContext *new_ctx, char **trace, MonoLMF **lmf,
- int *native_offset, gboolean *managed)
+gboolean
+mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
+ MonoJitInfo *ji, MonoContext *ctx,
+ MonoContext *new_ctx, MonoLMF **lmf,
+ mgreg_t **save_locations,
+ StackFrameInfo *frame)
{
- MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
- unsigned long *ptr;
- char *p;
MonoPPCStackFrame *sframe;
- /* Avoid costly table lookup during stack overflow */
- if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
- ji = prev_ji;
- else
- ji = mono_jit_info_table_find (domain, ip);
-
- if (trace)
- *trace = NULL;
-
- if (native_offset)
- *native_offset = -1;
+ memset (frame, 0, sizeof (StackFrameInfo));
+ frame->ji = ji;
- if (managed)
- *managed = FALSE;
+ *new_ctx = *ctx;
+ setup_context (new_ctx);
if (ji != NULL) {
- gint32 address;
- int offset, i;
- gulong *ctx_regs;
+ int i;
+ mgreg_t regs [ppc_lr + 1];
+ guint8 *cfa;
+ guint32 unwind_info_len;
+ guint8 *unwind_info;
- *new_ctx = *ctx;
- setup_context (new_ctx);
+ frame->type = FRAME_TYPE_MANAGED;
- if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
- /* remove any unused lmf */
- *lmf = (*lmf)->previous_lmf;
- }
-
- address = (char *)ip - (char *)ji->code_start;
+ if (ji->from_aot)
+ unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
+ else
+ unwind_info = mono_get_cached_unwind_info (ji->used_regs, &unwind_info_len);
- if (native_offset)
- *native_offset = address;
-
- if (managed)
- if (!ji->method->wrapper_type)
- *managed = TRUE;
-
- if (trace) {
- *trace = mono_debug_print_stack_frame (ji->method, offset, domain);
- }
- sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_BP (ctx);
+ sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
if (ji->method->save_lmf) {
- memcpy (&new_ctx->fregs, (char*)sframe->sp - sizeof (double) * MONO_SAVED_FREGS, sizeof (double) * MONO_SAVED_FREGS);
- memcpy (&new_ctx->regs, (char*)sframe->sp - sizeof (double) * MONO_SAVED_FREGS - sizeof (gulong) * MONO_SAVED_GREGS, sizeof (gulong) * MONO_SAVED_GREGS);
- } else if (ji->used_regs) {
- /* keep updated with emit_prolog in mini-ppc.c */
- offset = 0;
- /* FIXME handle floating point args
- for (i = 31; i >= 14; --i) {
- if (ji->used_fregs & (1 << i)) {
- offset += sizeof (double);
- new_ctx->fregs [i - 14] = *(gulong*)((char*)sframe->sp - offset);
- }
- }*/
- for (i = 31; i >= 13; --i) {
- if (ji->used_regs & (1 << i)) {
- offset += sizeof (gulong);
- new_ctx->regs [i - 13] = *(gulong*)((char*)sframe->sp - offset);
- }
- }
+ /* sframe->sp points just past the end of the LMF */
+ guint8 *lmf_addr = (guint8*)sframe->sp - sizeof (MonoLMF);
+ memcpy (&new_ctx->fregs, lmf_addr + G_STRUCT_OFFSET (MonoLMF, fregs), sizeof (double) * MONO_SAVED_FREGS);
+ memcpy (&new_ctx->regs, lmf_addr + G_STRUCT_OFFSET (MonoLMF, iregs), sizeof (mgreg_t) * MONO_SAVED_GREGS);
+ /* the calling IP is in the parent frame */
+ sframe = (MonoPPCStackFrame*)sframe->sp;
+ /* we substract 4, so that the IP points into the call instruction */
+ MONO_CONTEXT_SET_IP (new_ctx, sframe->lr - 4);
+ } else {
+ regs [ppc_lr] = ctx->sc_ir;
+ regs [ppc_sp] = ctx->sc_sp;
+ for (i = 0; i < MONO_SAVED_GREGS; ++i)
+ regs [ppc_r13 + i] = ctx->regs [i];
+
+ mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
+ (guint8*)ji->code_start + ji->code_size,
+ 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);
+ MONO_CONTEXT_SET_BP (new_ctx, cfa);
+
+ for (i = 0; i < MONO_SAVED_GREGS; ++i)
+ new_ctx->regs [i] = regs [ppc_r13 + i];
}
- /* the calling IP is in the parent frame */
- sframe = (MonoPPCStackFrame*)sframe->sp;
- /* we substract 4, so that the IP points into the call instruction */
- MONO_CONTEXT_SET_IP (new_ctx, sframe->lr - 4);
-
- return ji;
- } else if (*lmf) {
-
- *new_ctx = *ctx;
- setup_context (new_ctx);
- if (!(*lmf)->method)
- return (gpointer)-1;
-
- if (trace) {
- char *fname = mono_method_full_name ((*lmf)->method, TRUE);
- *trace = g_strdup_printf ("in (unmanaged) %s", fname);
- g_free (fname);
+ if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
+ /* remove any unused lmf */
+ *lmf = (*lmf)->previous_lmf;
}
+
+ return TRUE;
+ } else if (*lmf) {
- if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
+ if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
} else {
- memset (res, 0, sizeof (MonoJitInfo));
- res->method = (*lmf)->method;
+ if (!(*lmf)->method)
+ return FALSE;
+
+ /* Trampoline lmf frame */
+ frame->method = (*lmf)->method;
}
- /*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_BP (ctx);
+ /*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);*/
MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
- memcpy (&new_ctx->regs, (*lmf)->iregs, sizeof (gulong) * MONO_SAVED_GREGS);
+ memcpy (&new_ctx->regs, (*lmf)->iregs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
memcpy (&new_ctx->fregs, (*lmf)->fregs, sizeof (double) * MONO_SAVED_FREGS);
+
+ frame->ji = ji;
+ frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
+
+ /* FIXME: what about trampoline LMF frames? see exceptions-x86.c */
+
*lmf = (*lmf)->previous_lmf;
- return ji ? ji : res;
+ return TRUE;
}
- return NULL;
+ return FALSE;
}
+/*
+ * This is the function called from the signal handler
+ */
void
-mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) {
- MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoLMF *lmf = jit_tls->lmf;
- MonoJitInfo *ji, rji;
- gint native_offset, il_offset;
- gboolean managed;
- MonoPPCStackFrame *sframe;
-
- MonoContext ctx, new_ctx;
-
- setup_context (&ctx);
- setup_context (&new_ctx);
-
-#ifdef __APPLE__
- __asm__ volatile("lwz %0,0(r1)" : "=r" (sframe));
+mono_arch_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
+{
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
#else
- __asm__ volatile("lwz %0,0(1)" : "=r" (sframe));
-#endif
- //MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
- MONO_CONTEXT_SET_BP (&ctx, sframe->sp);
- sframe = (MonoPPCStackFrame*)sframe->sp;
- MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
-
- while (MONO_CONTEXT_GET_BP (&ctx) < jit_tls->end_of_stack) {
-
- ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
- g_assert (ji);
-
- if (ji == (gpointer)-1)
- return;
+ os_ucontext *uc = ctx;
- if (do_il_offset) {
- MonoDebugSourceLocation *source;
+ mctx->sc_ir = UCONTEXT_REG_NIP(uc);
+ mctx->sc_sp = UCONTEXT_REG_Rn(uc, 1);
+ memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 13), sizeof (mgreg_t) * MONO_SAVED_GREGS);
+ memcpy (&mctx->fregs, &UCONTEXT_REG_FPRn(uc, 14), sizeof (double) * MONO_SAVED_FREGS);
+#endif
+}
- source = mono_debug_lookup_source_location (ji->method, native_offset, domain);
- il_offset = source ? source->il_offset : -1;
- mono_debug_free_source_location (source);
- } else
- il_offset = -1;
+void
+mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
+{
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
+#else
+ os_ucontext *uc = ctx;
- if (func (ji->method, native_offset, il_offset, managed, user_data))
- return;
-
- ctx = new_ctx;
- setup_context (&ctx);
- }
+ UCONTEXT_REG_NIP(uc) = mctx->sc_ir;
+ UCONTEXT_REG_Rn(uc, 1) = mctx->sc_sp;
+ memcpy (&UCONTEXT_REG_Rn(uc, 13), &mctx->regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
+ memcpy (&UCONTEXT_REG_FPRn(uc, 14), &mctx->fregs, sizeof (double) * MONO_SAVED_FREGS);
+#endif
}
-MonoBoolean
-ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
- MonoReflectionMethod **method,
- gint32 *iloffset, gint32 *native_offset,
- MonoString **file, gint32 *line, gint32 *column)
+gpointer
+mono_arch_ip_from_context (void *sigctx)
{
- MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoLMF *lmf = jit_tls->lmf;
- MonoJitInfo *ji, rji;
- MonoContext ctx, new_ctx;
- MonoPPCStackFrame *sframe;
- MonoDebugSourceLocation *location;
-
-#ifdef __APPLE__
- __asm__ volatile("lwz %0,0(r1)" : "=r" (sframe));
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
#else
- __asm__ volatile("lwz %0,0(1)" : "=r" (sframe));
+ os_ucontext *uc = sigctx;
+ return (gpointer)UCONTEXT_REG_NIP(uc);
#endif
- MONO_CONTEXT_SET_BP (&ctx, sframe->sp);
- sframe = (MonoPPCStackFrame*)sframe->sp;
- MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
- /*MONO_CONTEXT_SET_IP (&ctx, ves_icall_get_frame_info);
- MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (0));*/
-
- skip++;
-
- do {
- ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, native_offset, NULL);
-
- ctx = new_ctx;
-
- if (!ji || ji == (gpointer)-1 || MONO_CONTEXT_GET_BP (&ctx) >= jit_tls->end_of_stack)
- return FALSE;
-
- /* skip all wrappers ??*/
- if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
- ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
- ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
- ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
- ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE)
- continue;
-
- skip--;
-
- } while (skip >= 0);
-
- *method = mono_method_get_object (domain, ji->method, NULL);
-
- location = mono_debug_lookup_source_location (ji->method, *native_offset, domain);
- if (location)
- *iloffset = location->il_offset;
- else
- *iloffset = 0;
-
- if (need_file_info) {
- if (location) {
- *file = mono_string_new (domain, location->source_file);
- *line = location->row;
- *column = location->column;
- } else {
- *file = NULL;
- *line = *column = 0;
- }
- }
+}
- mono_debug_free_source_location (location);
+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;
- return TRUE;
+ UCONTEXT_REG_NIP(uc) = ((gsize*)func) [0];
+ UCONTEXT_REG_Rn (uc, 2) = ((gsize*)func)[1];
+#else
+ g_assert_not_reached ();
+#endif
}
-/*
- * This is the function called from the signal handler
- */
-#ifdef __APPLE__
-gboolean
-mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+static void
+altstack_handle_and_restore (void *sigctx, gpointer obj)
{
- struct ucontext *uc = ctx;
+ void (*restore_context) (MonoContext *);
MonoContext mctx;
- gboolean result;
-
- mctx.sc_ir = uc->uc_mcontext->ss.srr0;
- mctx.sc_sp = uc->uc_mcontext->ss.r1;
- memcpy (&mctx.regs, &uc->uc_mcontext->ss.r13, sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&mctx.fregs, &uc->uc_mcontext->fs.fpregs [14], sizeof (double) * MONO_SAVED_FREGS);
- result = arch_handle_exception (&mctx, obj, test_only);
- /* restore the context so that returning from the signal handler will invoke
- * the catch clause
- */
- uc->uc_mcontext->ss.srr0 = mctx.sc_ir;
- uc->uc_mcontext->ss.r1 = mctx.sc_sp;
- memcpy (&uc->uc_mcontext->ss.r13, &mctx.regs, sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&uc->uc_mcontext->fs.fpregs [14], &mctx.fregs, sizeof (double) * MONO_SAVED_FREGS);
- return result;
+ restore_context = mono_get_restore_context ();
+ mono_arch_sigctx_to_monoctx (sigctx, &mctx);
+ mono_handle_exception (&mctx, obj);
+ restore_context (&mctx);
}
-gpointer
-mono_arch_ip_from_context (void *sigctx)
+void
+mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf)
{
- struct ucontext *uc = sigctx;
- return (gpointer)uc->uc_mcontext->ss.srr0;
-}
-
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
#else
-/* Linux */
-gboolean
-mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
-{
- struct ucontext *uc = ctx;
- MonoContext mctx;
- gboolean result;
-
- mctx.sc_ir = uc->uc_mcontext.uc_regs->gregs [PT_NIP];
- mctx.sc_sp = uc->uc_mcontext.uc_regs->gregs [PT_R1];
- memcpy (&mctx.regs, &uc->uc_mcontext.uc_regs->gregs [PT_R13], sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&mctx.fregs, &uc->uc_mcontext.uc_regs->fpregs.fpregs [14], sizeof (double) * MONO_SAVED_FREGS);
-
- result = arch_handle_exception (&mctx, obj, test_only);
- /* restore the context so that returning from the signal handler will invoke
- * the catch clause
+#ifdef MONO_ARCH_USE_SIGACTION
+ os_ucontext *uc = (ucontext_t*)sigctx;
+ os_ucontext *uc_copy;
+ MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx), NULL);
+ gpointer *sp;
+ int frame_size;
+
+ if (stack_ovf) {
+ const char *method;
+ /* we don't do much now, but we can warn the user with a useful message */
+ fprintf (stderr, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx), (gpointer)UCONTEXT_REG_Rn(uc, 1));
+ if (ji && ji->method)
+ method = mono_method_full_name (ji->method, TRUE);
+ else
+ method = "Unmanaged";
+ fprintf (stderr, "At %s\n", method);
+ abort ();
+ }
+ if (!ji)
+ mono_handle_native_sigsegv (SIGSEGV, sigctx);
+ /* setup a call frame on the real stack so that control is returned there
+ * and exception handling can continue.
+ * The frame looks like:
+ * ucontext struct
+ * ...
+ * 224 is the size of the red zone
*/
- uc->uc_mcontext.uc_regs->gregs [PT_NIP] = mctx.sc_ir;
- uc->uc_mcontext.uc_regs->gregs [PT_R1] = mctx.sc_sp;
- memcpy (&uc->uc_mcontext.uc_regs->gregs [PT_R13], &mctx.regs, sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&uc->uc_mcontext.uc_regs->fpregs.fpregs [14], &mctx.fregs, sizeof (double) * MONO_SAVED_FREGS);
- return result;
-}
+ frame_size = sizeof (ucontext_t) + sizeof (gpointer) * 16 + 224;
+ frame_size += 15;
+ frame_size &= ~15;
+ sp = (gpointer)(UCONTEXT_REG_Rn(uc, 1) & ~15);
+ sp = (gpointer)((char*)sp - frame_size);
+ /* may need to adjust pointers in the new struct copy, depending on the OS */
+ uc_copy = (ucontext_t*)(sp + 16);
+ memcpy (uc_copy, uc, sizeof (os_ucontext));
+#if defined(__linux__) && !defined(__mono_ppc64__)
+ uc_copy->uc_mcontext.uc_regs = (gpointer)((char*)uc_copy + ((char*)uc->uc_mcontext.uc_regs - (char*)uc));
+#endif
+ g_assert (mono_arch_ip_from_context (uc) == mono_arch_ip_from_context (uc_copy));
+ /* at the return form the signal handler execution starts in altstack_handle_and_restore() */
+ UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+ {
+ MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)altstack_handle_and_restore;
+
+ UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
+ UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
+ }
+#else
+ UCONTEXT_REG_NIP(uc) = (unsigned long)altstack_handle_and_restore;
+#endif
+ UCONTEXT_REG_Rn(uc, 1) = (unsigned long)sp;
+ UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG) = (unsigned long)(sp + 16);
+ UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 1) = 0;
+ UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 2) = 0;
+#endif
-gpointer
-mono_arch_ip_from_context (void *sigctx)
-{
- struct ucontext *uc = sigctx;
- return (gpointer)uc->uc_mcontext.uc_regs->gregs [PT_NIP];
+#endif /* !MONO_CROSS_COMPILE */
}
-#endif
-
-/**
- * arch_handle_exception:
- * @ctx: saved processor state
- * @obj: the exception object
- * @test_only: only test if the exception is caught, but dont call handlers
- *
+/*
+ * handle_exception:
*
+ * Called by resuming from a signal handler.
*/
-static gboolean
-arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only)
+static void
+handle_signal_exception (gpointer obj)
{
- MonoDomain *domain = mono_domain_get ();
- MonoJitInfo *ji, rji;
- static int (*call_filter) (MonoContext *, gpointer, gpointer) = NULL;
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoLMF *lmf = jit_tls->lmf;
- GList *trace_ips = NULL;
- MonoException *mono_ex;
- MonoArray *initial_trace_ips = NULL;
- int frame_count = 0;
- gboolean has_dynamic_methods = FALSE;
-
- g_assert (ctx != NULL);
- if (!obj) {
- MonoException *ex = mono_get_exception_null_reference ();
- ex->message = mono_string_new (domain,
- "Object reference not set to an instance of an object");
- obj = (MonoObject *)ex;
- }
-
- if (mono_object_isinst (obj, mono_defaults.exception_class)) {
- mono_ex = (MonoException*)obj;
- initial_trace_ips = mono_ex->trace_ips;
- } else {
- mono_ex = NULL;
- }
-
-
- if (!call_filter)
- call_filter = arch_get_call_filter ();
-
- g_assert (jit_tls->end_of_stack);
- g_assert (jit_tls->abort_func);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoContext ctx;
+ static void (*restore_context) (MonoContext *);
- if (!test_only) {
- MonoContext ctx_cp = *ctx;
- setup_context (&ctx_cp);
- if (mono_jit_trace_calls != NULL)
- g_print ("EXCEPTION handling: %s\n", mono_object_class (obj)->name);
- if (!arch_handle_exception (&ctx_cp, obj, TRUE)) {
- if (mono_break_on_exc)
- G_BREAKPOINT ();
- mono_unhandled_exception (obj);
- }
- }
+ if (!restore_context)
+ restore_context = mono_get_restore_context ();
- memset (&rji, 0, sizeof (rji));
+ memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
- while (1) {
- MonoContext new_ctx;
+ mono_handle_exception (&ctx, obj);
- setup_context (&new_ctx);
- ji = mono_arch_find_jit_info (domain, jit_tls, &rji, &rji, ctx, &new_ctx,
- NULL, &lmf, NULL, NULL);
- if (!ji) {
- g_warning ("Exception inside function without unwind info");
- g_assert_not_reached ();
- }
-
- if (ji != (gpointer)-1) {
- frame_count ++;
-
- if (test_only && ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
- /*
- * Avoid overwriting the stack trace if the exception is
- * rethrown. Also avoid giant stack traces during a stack
- * overflow.
- */
- if (!initial_trace_ips && (frame_count < 1000)) {
- trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
-
- }
- }
-
- if (ji->method->dynamic)
- has_dynamic_methods = TRUE;
-
- if (ji->num_clauses) {
- int i;
-
- g_assert (ji->clauses);
-
- for (i = 0; i < ji->num_clauses; i++) {
- MonoJitExceptionInfo *ei = &ji->clauses [i];
- gboolean filtered = FALSE;
-
- if (ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
- MONO_CONTEXT_GET_IP (ctx) <= ei->try_end) {
- /* catch block */
-
- if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) || (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)) {
- /* store the exception object int cfg->excvar */
- g_assert (ei->exvar_offset);
- /* need to use the frame pointer (ppc_r31), not r1 (regs start from register r13): methods with clauses always have r31 */
- *((gpointer *)((char *)(ctx->regs [ppc_r31-13]) + ei->exvar_offset)) = obj;
- }
-
- if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)
- filtered = call_filter (ctx, ei->data.filter, mono_ex);
-
- if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
- mono_object_isinst (obj, ei->data.catch_class)) || filtered) {
- if (test_only) {
- if (mono_ex && !initial_trace_ips) {
- trace_ips = g_list_reverse (trace_ips);
- mono_ex->trace_ips = glist_to_array (trace_ips, mono_defaults.int_class);
- if (has_dynamic_methods)
- /* These methods could go away anytime, so compute the stack trace now */
- mono_ex->stack_trace = ves_icall_System_Exception_get_trace (mono_ex);
- }
- g_list_free (trace_ips);
- return TRUE;
- }
- if (mono_jit_trace_calls != NULL)
- g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
- /*printf ("stack for catch: %p\n", MONO_CONTEXT_GET_BP (ctx));*/
- MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
- jit_tls->lmf = lmf;
- return 0;
- }
- if (!test_only && ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
- MONO_CONTEXT_GET_IP (ctx) < ei->try_end &&
- (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
- if (mono_jit_trace_calls != NULL)
- g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
- call_filter (ctx, ei->handler_start, NULL);
- }
-
- }
- }
- }
- }
+ restore_context (&ctx);
+}
- *ctx = new_ctx;
- setup_context (ctx);
-
- if ((ji == (gpointer)-1) || MONO_CONTEXT_GET_BP (ctx) >= jit_tls->end_of_stack) {
- if (!test_only) {
- jit_tls->lmf = lmf;
- jit_tls->abort_func (obj);
- g_assert_not_reached ();
- } else {
- if (mono_ex && !initial_trace_ips) {
- trace_ips = g_list_reverse (trace_ips);
- mono_ex->trace_ips = glist_to_array (trace_ips, mono_defaults.int_class);
- if (has_dynamic_methods)
- /* These methods could go away anytime, so compute the stack trace now */
- mono_ex->stack_trace = ves_icall_System_Exception_get_trace (mono_ex);
- }
- g_list_free (trace_ips);
- return FALSE;
- }
- }
+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;
}
-
- g_assert_not_reached ();
+#else
+ UCONTEXT_REG_NIP(uc) = (unsigned long)func;
+#endif
+#endif
}
gboolean
-mono_arch_has_unwind_info (gconstpointer addr)
+mono_arch_handle_exception (void *ctx, gpointer obj)
{
- return FALSE;
-}
+#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);
+ /* 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
+}
projects / mono.git / blobdiff