X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fexceptions-ppc.c;h=80bbb3f9190d461b8503ca31569dd93d2ed5c9a6;hb=073752949f4e7846f3a9de365660077d44e22082;hp=043bae8dcbd34d44095faa6db68945e79b7daf92;hpb=d49951ccf584ba637afb1dab7fff714478e3174d;p=mono.git diff --git a/mono/mini/exceptions-ppc.c b/mono/mini/exceptions-ppc.c index 043bae8dcbd..80bbb3f9190 100644 --- a/mono/mini/exceptions-ppc.c +++ b/mono/mini/exceptions-ppc.c @@ -4,15 +4,20 @@ * Authors: * Dietmar Maurer (dietmar@ximian.com) * Paolo Molaro (lupus@ximian.com) + * Andreas Faerber * * (C) 2001 Ximian, Inc. + * (C) 2007-2008 Andreas Faerber */ #include #include #include #include +#include +#if HAVE_UCONTEXT_H #include +#endif #include #include @@ -25,8 +30,6 @@ #include "mini.h" #include "mini-ppc.h" -static gboolean arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only); - /* struct sigcontext { @@ -160,37 +163,52 @@ typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG]; #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); @@ -198,52 +216,70 @@ arch_get_restore_context (void) /* 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 ("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); @@ -253,35 +289,35 @@ arch_get_call_filter (void) 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 ("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 (); - /* adjust eip so that it point into the call instruction */ eip -= 4; @@ -290,7 +326,7 @@ throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong * /*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)) { @@ -298,8 +334,8 @@ throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong * if (!rethrow) mono_ex->stack_trace = NULL; } - arch_handle_exception (&ctx, exc, FALSE); - restore_context (&ctx); + mono_handle_exception (&ctx, exc); + mono_restore_context (&ctx); g_assert_not_reached (); } @@ -310,70 +346,98 @@ throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong * * 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; - - 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); + 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); - ppc_mflr (code, ppc_r0); - ppc_stw (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); + g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0); + ppc_stptr_update (code, ppc_sp, -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); //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 (corlib ? "throw_corlib_exception" : (rethrow ? "rethrow_exception" : "throw_exception"), start, code - start, ji, unwind_ops); + return start; } @@ -386,17 +450,15 @@ mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name, gbo * */ 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: * @@ -409,546 +471,351 @@ mono_arch_get_rethrow_exception (void) * 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; - - len = g_list_length (list); - res = mono_array_new (domain, eclass, len); + int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE; - 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); + memset (frame, 0, sizeof (StackFrameInfo)); + frame->ji = ji; - if (trace) - *trace = NULL; + *new_ctx = *ctx; + setup_context (new_ctx); - if (native_offset) - *native_offset = -1; + if (ji != NULL) { + int i; + mgreg_t regs [ppc_lr + 1]; + guint8 *cfa; + guint32 unwind_info_len; + guint8 *unwind_info; - if (managed) - *managed = FALSE; + frame->type = FRAME_TYPE_MANAGED; - if (ji != NULL) { - gint32 address; - int offset, i; - gulong *ctx_regs; + 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); - *new_ctx = *ctx; - setup_context (new_ctx); + sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx); + MONO_CONTEXT_SET_BP (new_ctx, sframe->sp); + if (jinfo_get_method (ji)->save_lmf) { + /* 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]; + } - if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) { + if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) { /* remove any unused lmf */ *lmf = (*lmf)->previous_lmf; } - address = (char *)ip - (char *)ji->code_start; - - 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); - 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); - } - } - } - /* 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; + return TRUE; } 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 ((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--; +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; - } while (skip >= 0); + UCONTEXT_REG_NIP(uc) = ((gsize*)func) [0]; + UCONTEXT_REG_Rn (uc, 2) = ((gsize*)func)[1]; +#else + g_assert_not_reached (); +#endif +} - *method = mono_method_get_object (domain, ji->method, NULL); +static void +altstack_handle_and_restore (void *sigctx, gpointer obj) +{ + MonoContext mctx; - location = mono_debug_lookup_source_location (ji->method, *native_offset, domain); - if (location) - *iloffset = location->il_offset; - else - *iloffset = 0; + mono_arch_sigctx_to_monoctx (sigctx, &mctx); + mono_handle_exception (&mctx, obj); + mono_restore_context (&mctx); +} - 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; - } +void +mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf) +{ +#ifdef MONO_CROSS_COMPILE + g_assert_not_reached (); +#else +#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 && jinfo_get_method (ji)) + method = mono_method_full_name (jinfo_get_method (ji), 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 + */ + 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 - mono_debug_free_source_location (location); - - return TRUE; +#endif /* !MONO_CROSS_COMPILE */ } /* - * This is the function called from the signal handler + * handle_exception: + * + * Called by resuming from a signal handler. */ -#ifdef __APPLE__ -gboolean -mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only) +static void +handle_signal_exception (gpointer obj) { - struct ucontext *uc = ctx; - 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); + MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id); + MonoContext ctx; - 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; + memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext)); + + mono_handle_exception (&ctx, obj); + + mono_restore_context (&ctx); } -gpointer -mono_arch_ip_from_context (void *sigctx) +static void +setup_ucontext_return (void *uc, gpointer func) { - struct ucontext *uc = sigctx; - return (gpointer)uc->uc_mcontext->ss.srr0; +#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 } -#else -/* Linux */ gboolean -mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only) +mono_arch_handle_exception (void *ctx, gpointer obj) { - struct ucontext *uc = ctx; +#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; - - 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); + 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 */ - 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); + mono_arch_monoctx_to_sigctx (&mctx, ctx); return result; -} - -gpointer -mono_arch_ip_from_context (void *sigctx) -{ - struct ucontext *uc = sigctx; - return (gpointer)uc->uc_mcontext.uc_regs->gregs [PT_NIP]; -} - #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 - * - * - */ -static gboolean -arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only) -{ - 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); - - 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); - } - } - - memset (&rji, 0, sizeof (rji)); - - while (1) { - MonoContext new_ctx; - - 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); - } - - } - } - } - } - - *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; - } - } - } - - g_assert_not_reached (); } - -gboolean -mono_arch_has_unwind_info (gconstpointer addr) -{ - return FALSE; -} -