X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fexceptions-arm.c;h=575654b67e3ca63724d4f5f70b7201fd356a9277;hb=d0771cfe0d6f833be7bdcc4f19369f38dba89a6a;hp=c7d6d36559d52494daec019b1170c26529235eba;hpb=4a59ac0f37672014e01619f0a06cafeb8de89ed1;p=mono.git diff --git a/mono/mini/exceptions-arm.c b/mono/mini/exceptions-arm.c index c7d6d36559d..575654b67e3 100644 --- a/mono/mini/exceptions-arm.c +++ b/mono/mini/exceptions-arm.c @@ -24,6 +24,7 @@ #endif /* def HAVE_UCONTEXT_H */ #include +#include #include #include #include @@ -59,12 +60,14 @@ mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot) ctx_reg = ARMREG_R0; - /* move eip to PC */ - ARM_LDR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, eip)); +#if defined(ARM_FPU_VFP) + ARM_ADD_REG_IMM8 (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, fregs)); + ARM_FLDMD (code, ARM_VFP_D0, 16, ARMREG_IP); +#endif + + /* move pc to PC */ + ARM_LDR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, pc)); ARM_STR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, regs) + (ARMREG_PC * sizeof (mgreg_t))); - /* move sp to SP */ - ARM_LDR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, esp)); - ARM_STR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, regs) + (ARMREG_SP * sizeof (mgreg_t))); /* restore everything */ ARM_ADD_REG_IMM8 (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET(MonoContext, regs)); @@ -108,7 +111,7 @@ mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) /* restore all the regs from ctx (in r0), but not sp, the stack pointer */ ctx_reg = ARMREG_R0; - ARM_LDR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, eip)); + ARM_LDR_IMM (code, ARMREG_IP, ctx_reg, G_STRUCT_OFFSET (MonoContext, pc)); ARM_ADD_REG_IMM8 (code, ARMREG_LR, ctx_reg, G_STRUCT_OFFSET(MonoContext, regs) + (MONO_ARM_FIRST_SAVED_REG * sizeof (mgreg_t))); ARM_LDM (code, ARMREG_LR, MONO_ARM_REGSAVE_MASK); /* call handler at eip (r1) and set the first arg with the exception (r2) */ @@ -130,25 +133,25 @@ mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot) } void -mono_arm_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs) +mono_arm_throw_exception (MonoObject *exc, mgreg_t pc, mgreg_t sp, mgreg_t *int_regs, gdouble *fp_regs) { static void (*restore_context) (MonoContext *); MonoContext ctx; - gboolean rethrow = eip & 1; + gboolean rethrow = pc & 1; if (!restore_context) restore_context = mono_get_restore_context (); - eip &= ~1; /* clear the optional rethrow bit */ + pc &= ~1; /* clear the optional rethrow bit */ /* adjust eip so that it point into the call instruction */ - eip -= 4; + pc -= 4; /*printf ("stack in throw: %p\n", esp);*/ MONO_CONTEXT_SET_BP (&ctx, int_regs [ARMREG_FP - 4]); - MONO_CONTEXT_SET_SP (&ctx, esp); - MONO_CONTEXT_SET_IP (&ctx, eip); + MONO_CONTEXT_SET_SP (&ctx, sp); + MONO_CONTEXT_SET_IP (&ctx, pc); memcpy (((guint8*)&ctx.regs) + (ARMREG_R4 * sizeof (mgreg_t)), int_regs, 8 * sizeof (mgreg_t)); - /* memcpy (&ctx.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS); */ + memcpy (&ctx.fregs, fp_regs, sizeof (double) * 16); if (mono_object_isinst (exc, mono_defaults.exception_class)) { MonoException *mono_ex = (MonoException*)exc; @@ -161,26 +164,26 @@ mono_arm_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, } void -mono_arm_throw_exception_by_token (guint32 type_token, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs) +mono_arm_throw_exception_by_token (guint32 type_token, mgreg_t pc, mgreg_t sp, mgreg_t *int_regs, gdouble *fp_regs) { /* Clear thumb bit */ - eip &= ~1; + pc &= ~1; - mono_arm_throw_exception ((MonoObject*)mono_exception_from_token (mono_defaults.corlib, type_token), eip, esp, int_regs, fp_regs); + mono_arm_throw_exception ((MonoObject*)mono_exception_from_token (mono_defaults.corlib, type_token), pc, sp, int_regs, fp_regs); } void -mono_arm_resume_unwind (guint32 dummy1, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs) +mono_arm_resume_unwind (guint32 dummy1, mgreg_t pc, mgreg_t sp, mgreg_t *int_regs, gdouble *fp_regs) { MonoContext ctx; - eip &= ~1; /* clear the optional rethrow bit */ + pc &= ~1; /* clear the optional rethrow bit */ /* adjust eip so that it point into the call instruction */ - eip -= 4; + pc -= 4; MONO_CONTEXT_SET_BP (&ctx, int_regs [ARMREG_FP - 4]); - MONO_CONTEXT_SET_SP (&ctx, esp); - MONO_CONTEXT_SET_IP (&ctx, eip); + MONO_CONTEXT_SET_SP (&ctx, sp); + MONO_CONTEXT_SET_IP (&ctx, pc); memcpy (((guint8*)&ctx.regs) + (ARMREG_R4 * sizeof (mgreg_t)), int_regs, 8 * sizeof (mgreg_t)); mono_resume_unwind (&ctx); @@ -202,6 +205,7 @@ get_throw_trampoline (int size, gboolean corlib, gboolean rethrow, gboolean llvm guint8 *code; MonoJumpInfo *ji = NULL; GSList *unwind_ops = NULL; + int cfa_offset; code = start = mono_global_codeman_reserve (size); @@ -211,12 +215,26 @@ get_throw_trampoline (int size, gboolean corlib, gboolean rethrow, gboolean llvm ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_SP); ARM_PUSH (code, MONO_ARM_REGSAVE_MASK); - mono_add_unwind_op_def_cfa (unwind_ops, code, start, ARMREG_SP, MONO_ARM_NUM_SAVED_REGS * sizeof (mgreg_t)); + cfa_offset = MONO_ARM_NUM_SAVED_REGS * sizeof (mgreg_t); + mono_add_unwind_op_def_cfa (unwind_ops, code, start, ARMREG_SP, cfa_offset); mono_add_unwind_op_offset (unwind_ops, code, start, ARMREG_LR, - sizeof (mgreg_t)); + /* Save fp regs */ + ARM_SUB_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, sizeof (double) * 16); + cfa_offset += sizeof (double) * 16; + mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, cfa_offset); +#if defined(ARM_FPU_VFP) + ARM_FSTMD (code, ARM_VFP_D0, 16, ARMREG_SP); +#endif + + /* Param area */ + ARM_SUB_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, 8); + cfa_offset += 8; + mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, cfa_offset); + /* call throw_exception (exc, ip, sp, int_regs, fp_regs) */ /* caller sp */ - ARM_ADD_REG_IMM8 (code, ARMREG_R2, ARMREG_SP, MONO_ARM_NUM_SAVED_REGS * sizeof (mgreg_t)); + ARM_ADD_REG_IMM8 (code, ARMREG_R2, ARMREG_SP, cfa_offset); /* exc is already in place in r0 */ if (corlib) { /* The caller ip is already in R1 */ @@ -226,13 +244,13 @@ get_throw_trampoline (int size, gboolean corlib, gboolean rethrow, gboolean llvm } else { ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_LR); /* caller ip */ } - /* FIXME: pointer to the saved fp regs */ - /*pos = alloc_size - sizeof (double) * MONO_SAVED_FREGS; - ppc_addi (code, ppc_r7, ppc_sp, pos);*/ - /* pointer to the saved int regs */ - ARM_MOV_REG_REG (code, ARMREG_R3, ARMREG_SP); /* the pushed regs */ - /* we encode rethrow in the ip, so we avoid args on the stack */ + /* int regs */ + ARM_ADD_REG_IMM8 (code, ARMREG_R3, ARMREG_SP, (cfa_offset - (MONO_ARM_NUM_SAVED_REGS * sizeof (mgreg_t)))); + /* we encode rethrow in the ip */ ARM_ORR_REG_IMM8 (code, ARMREG_R1, ARMREG_R1, rethrow); + /* fp regs */ + ARM_ADD_REG_IMM8 (code, ARMREG_LR, ARMREG_SP, 8); + ARM_STR_IMM (code, ARMREG_LR, ARMREG_SP, 0); if (aot) { const char *icall_name; @@ -395,7 +413,6 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, for (i = 0; i < 16; ++i) regs [i] = new_ctx->regs [i]; - regs [ARMREG_SP] = new_ctx->esp; mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start, (guint8*)ji->code_start + ji->code_size, @@ -404,8 +421,8 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, for (i = 0; i < 16; ++i) new_ctx->regs [i] = regs [i]; - new_ctx->eip = regs [ARMREG_LR]; - new_ctx->esp = (gsize)cfa; + new_ctx->pc = regs [ARMREG_LR]; + new_ctx->regs [ARMREG_SP] = (gsize)cfa; if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->sp)) { /* remove any unused lmf */ @@ -413,10 +430,10 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, } /* Clear thumb bit */ - new_ctx->eip &= ~1; + new_ctx->pc &= ~1; /* we substract 1, so that the IP points into the call instruction */ - new_ctx->eip--; + new_ctx->pc--; return TRUE; } else if (*lmf) { @@ -458,15 +475,15 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, * transitioned to native call, so we save the sp/fp/ip in the LMF. */ memcpy (&new_ctx->regs [0], &(*lmf)->iregs [0], sizeof (mgreg_t) * 13); - new_ctx->esp = (*lmf)->sp; - new_ctx->eip = (*lmf)->ip; + new_ctx->pc = (*lmf)->ip; + new_ctx->regs [ARMREG_SP] = (*lmf)->sp; new_ctx->regs [ARMREG_FP] = (*lmf)->fp; /* Clear thumb bit */ - new_ctx->eip &= ~1; + new_ctx->pc &= ~1; /* we substract 1, so that the IP points into the call instruction */ - new_ctx->eip--; + new_ctx->pc--; *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3); @@ -476,40 +493,19 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, return FALSE; } +#if MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX void mono_arch_sigctx_to_monoctx (void *sigctx, MonoContext *mctx) { -#ifdef MONO_CROSS_COMPILE - g_assert_not_reached (); -#elif BROKEN_LINUX - g_assert_not_reached (); -#else - arm_ucontext *my_uc = sigctx; - - mctx->eip = UCONTEXT_REG_PC (my_uc); - mctx->esp = UCONTEXT_REG_SP (my_uc); - mctx->cpsr = UCONTEXT_REG_CPSR (my_uc); - memcpy (&mctx->regs, &UCONTEXT_REG_R0 (my_uc), sizeof (mgreg_t) * 16); -#endif + mono_sigctx_to_monoctx (sigctx, mctx); } void mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx) { -#ifdef MONO_CROSS_COMPILE - g_assert_not_reached (); -#elif BROKEN_LINUX - g_assert_not_reached (); -#else - arm_ucontext *my_uc = ctx; - - UCONTEXT_REG_PC (my_uc) = mctx->eip; - UCONTEXT_REG_SP (my_uc) = mctx->regs [ARMREG_FP]; - UCONTEXT_REG_CPSR (my_uc) = mctx->cpsr; - /* The upper registers are not guaranteed to be valid */ - memcpy (&UCONTEXT_REG_R0 (my_uc), &mctx->regs, sizeof (mgreg_t) * 12); -#endif + mono_monoctx_to_sigctx (mctx, ctx); } +#endif /* MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX */ /* * handle_exception: @@ -552,7 +548,7 @@ get_handle_signal_exception_addr (void) gboolean mono_arch_handle_exception (void *ctx, gpointer obj) { -#if defined(MONO_CROSS_COMPILE) +#if defined(MONO_CROSS_COMPILE) || !defined(MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX) g_assert_not_reached (); #elif defined(MONO_ARCH_USE_SIGACTION) arm_ucontext *sigctx = ctx; @@ -604,7 +600,7 @@ mono_arch_ip_from_context (void *sigctx) { #ifdef MONO_CROSS_COMPILE g_assert_not_reached (); -#elif BROKEN_LINUX +#elif defined(__native_client__) g_assert_not_reached (); #else arm_ucontext *my_uc = sigctx; @@ -615,7 +611,7 @@ mono_arch_ip_from_context (void *sigctx) void mono_arch_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data) { - guint64 sp = ctx->esp; + mgreg_t sp = (mgreg_t)MONO_CONTEXT_GET_SP (ctx); // FIXME: g_assert (!user_data); @@ -627,3 +623,20 @@ mono_arch_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), g // FIXME: thumb/arm } + +/* + * mono_arch_setup_resume_sighandler_ctx: + * + * Setup CTX so execution continues at FUNC. + */ +void +mono_arch_setup_resume_sighandler_ctx (MonoContext *ctx, gpointer func) +{ + MONO_CONTEXT_SET_IP (ctx,func); + if ((mgreg_t)MONO_CONTEXT_GET_IP (ctx) & 1) + /* Transition to thumb */ + ctx->cpsr |= (1 << 5); + else + /* Transition to ARM */ + ctx->cpsr &= ~(1 << 5); +}