Use --relocation-model=pic for llvm on ios.

[mono.git] / mono / mini / exceptions-arm.c

diff --git a/mono/mini/exceptions-arm.c b/mono/mini/exceptions-arm.c
index 95a83109f1343ccd0ffff915e428b969c69c794f..575654b67e3ca63724d4f5f70b7201fd356a9277 100644 (file)
--- a/mono/mini/exceptions-arm.c
+++ b/mono/mini/exceptions-arm.c
@@ -24,6 +24,7 @@
 #endif  /* def HAVE_UCONTEXT_H */
 
 #include <mono/arch/arm/arm-codegen.h>
+#include <mono/arch/arm/arm-vfp-codegen.h>
 #include <mono/metadata/appdomain.h>
 #include <mono/metadata/tabledefs.h>
 #include <mono/metadata/threads.h>
@@ -59,6 +60,11 @@ mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
 
        ctx_reg = ARMREG_R0;
 
+#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)));
@@ -145,7 +151,7 @@ mono_arm_throw_exception (MonoObject *exc, mgreg_t pc, mgreg_t sp, mgreg_t *int_
        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;
@@ -199,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);
 
@@ -208,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 */
@@ -223,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;
@@ -472,6 +493,7 @@ 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)
 {
@@ -483,6 +505,7 @@ mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
 {
        mono_monoctx_to_sigctx (mctx, ctx);
 }
+#endif /* MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX */
 
 /*
  * handle_exception:
@@ -525,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;
@@ -577,6 +600,8 @@ mono_arch_ip_from_context (void *sigctx)
 {
 #ifdef MONO_CROSS_COMPILE
        g_assert_not_reached ();
+#elif defined(__native_client__)
+       g_assert_not_reached ();
 #else
        arm_ucontext *my_uc = sigctx;
        return (void*) UCONTEXT_REG_PC (my_uc);