* 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 <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>
#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:
*
* The first argument in r3 is the pointer to the context.
*/
gpointer
-mono_arch_get_restore_context (void)
+mono_arch_get_restore_context_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
{
- guint8 *code;
- static guint8 *start = NULL;
-
- if (start)
- return start;
+ guint8 *start, *code;
+ int size = MONO_PPC_32_64_CASE (128, 172) + PPC_FTNPTR_SIZE;
- code = start = mono_global_codeman_reserve (128);
+ code = start = mono_global_codeman_reserve (size);
+ *ji = NULL;
+ if (!aot)
+ code = mono_ppc_create_pre_code_ftnptr (code);
restore_regs_from_context (ppc_r3, ppc_r4, ppc_r5);
/* 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) < 128);
+ g_assert ((code - start) <= size);
mono_arch_flush_icache (start, code - start);
+
+ *code_size = code - start;
+
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;
+}
+
/*
* mono_arch_get_call_filter:
*
* @exc object in this case).
*/
gpointer
-mono_arch_get_call_filter (void)
+mono_arch_get_call_filter_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
{
- static guint8 *start = NULL;
- guint8 *code;
+ guint8 *start, *code;
int alloc_size, pos, i;
+ int size = MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE;
- if (start)
- return start;
+ *ji = NULL;
/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
- code = start = mono_global_codeman_reserve (320);
-
- /* 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 = PPC_MINIMAL_STACK_SIZE + pos + 64;
- // align to PPC_STACK_ALIGNMENT bytes
- alloc_size += PPC_STACK_ALIGNMENT - 1;
- alloc_size &= ~(PPC_STACK_ALIGNMENT - 1);
+ alloc_size = REG_SAVE_STACK_FRAME_SIZE;
/* allocate stack frame and set link from sp in ctx */
- g_assert ((alloc_size & (PPC_STACK_ALIGNMENT-1)) == 0);
- ppc_lwz (code, ppc_r0, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
- ppc_lwzx (code, ppc_r0, ppc_r0, ppc_r0);
- ppc_stwu (code, ppc_r0, -alloc_size, ppc_sp);
+ 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);
+
+ 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) < 320);
+ g_assert ((code - start) < size);
mono_arch_flush_icache (start, code - start);
+
+ *code_size = code - start;
+
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, gulong *int_regs, gdouble *fp_regs, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
if (!restore_context)
- restore_context = mono_arch_get_restore_context ();
+ restore_context = mono_get_restore_context ();
/* adjust eip so that it point into the call instruction */
eip -= 4;
* 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, guint32 *code_size, MonoJumpInfo **ji, int corlib, gboolean rethrow, gboolean aot)
{
- guint8 *code;
- int alloc_size, pos, i;
+ guint8 *start, *code;
+ int alloc_size, pos;
- code = start;
+ *ji = NULL;
- /* 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);
- ppc_mflr (code, ppc_r0);
- ppc_stw (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+ /* 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);
- 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);
+ alloc_size = REG_SAVE_STACK_FRAME_SIZE;
- g_assert ((alloc_size & (PPC_STACK_ALIGNMENT-1)) == 0);
- ppc_stwu (code, ppc_sp, -alloc_size, ppc_sp);
+ g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
+ ppc_stptr_update (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, (guint32)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);
+
+ *code_size = code - start;
+
return start;
}
*
*/
gpointer
-mono_arch_get_rethrow_exception (void)
+mono_arch_get_rethrow_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
{
- static guint8 *start = NULL;
- static int inited = 0;
-
- if (inited)
- return start;
- start = mono_global_codeman_reserve (132);
- mono_arch_get_throw_exception_generic (start, 132, FALSE, TRUE);
- inited = 1;
- return start;
+ int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
+
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, code_size, ji, FALSE, TRUE, aot);
}
+
/**
* 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_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
{
- static guint8 *start = NULL;
- static int inited = 0;
-
- if (inited)
- return start;
- start = mono_global_codeman_reserve (132);
- mono_arch_get_throw_exception_generic (start, 132, FALSE, FALSE);
- inited = 1;
- return start;
+ int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
+
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, code_size, ji, FALSE, FALSE, aot);
}
/**
* x86_call_code (code, arch_get_throw_exception_by_name ());
*
*/
-gpointer
-mono_arch_get_throw_exception_by_name (void)
-{
- static guint8 *start = NULL;
- static int inited = 0;
-
- if (inited)
- return start;
- start = mono_global_codeman_reserve (168);
- mono_arch_get_throw_exception_generic (start, 168, TRUE, FALSE);
- inited = 1;
- return start;
-}
-
-static MonoArray *
-glist_to_array (GList *list, MonoClass *eclass)
+gpointer
+mono_arch_get_throw_exception_by_name_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
{
- MonoDomain *domain = mono_domain_get ();
- MonoArray *res;
- int len, i;
+ guint8 *start, *code;
+ int size = 64;
- if (!list)
- return NULL;
+ *ji = NULL;
- len = g_list_length (list);
- res = mono_array_new (domain, eclass, len);
+ /* Not used on PPC */
+ start = code = mono_global_codeman_reserve (size);
+ ppc_break (code);
+ mono_arch_flush_icache (start, code - start);
+ *code_size = code - start;
+ return start;
+}
- for (i = 0; list; list = list->next, i++)
- mono_array_set (res, gpointer, i, list->data);
+/**
+ * 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) (guint32 ex_token, guint32 offset);
+ * On PPC, we pass the ip instead of the offset
+ */
+gpointer
+mono_arch_get_throw_corlib_exception_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
+{
+ int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE;
- return res;
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, code_size, ji, TRUE, FALSE, aot);
}
/* mono_arch_find_jit_info:
if (!(*lmf)->method)
return (gpointer)-1;
- memset (res, 0, sizeof (MonoJitInfo));
+ memset (res, 0, MONO_SIZEOF_JIT_INFO);
res->method = (*lmf)->method;
}
void
mono_arch_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
{
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
+#else
os_ucontext *uc = ctx;
mctx->sc_ir = UCONTEXT_REG_NIP(uc);
mctx->sc_sp = UCONTEXT_REG_Rn(uc, 1);
memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 13), sizeof (gulong) * MONO_SAVED_GREGS);
memcpy (&mctx->fregs, &UCONTEXT_REG_FPRn(uc, 14), sizeof (double) * MONO_SAVED_FREGS);
+#endif
}
void
mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
{
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
+#else
os_ucontext *uc = 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 (gulong) * MONO_SAVED_GREGS);
memcpy (&UCONTEXT_REG_FPRn(uc, 14), &mctx->fregs, sizeof (double) * MONO_SAVED_FREGS);
+#endif
}
gpointer
mono_arch_ip_from_context (void *sigctx)
{
+#ifdef MONO_CROSS_COMPILE
+ g_assert_not_reached ();
+#else
os_ucontext *uc = sigctx;
return (gpointer)UCONTEXT_REG_NIP(uc);
+#endif
}
-#ifndef __APPLE__
static void
altstack_handle_and_restore (void *sigctx, gpointer obj, gboolean test_only)
{
void (*restore_context) (MonoContext *);
MonoContext mctx;
- restore_context = mono_arch_get_restore_context ();
+ restore_context = mono_get_restore_context ();
mono_arch_sigctx_to_monoctx (sigctx, &mctx);
mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_ir, test_only);
restore_context (&mctx);
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
- ucontext_t *uc = (ucontext_t*)sigctx;
- ucontext_t *uc_copy;
+ os_ucontext *uc = (ucontext_t*)sigctx;
+ os_ucontext *uc_copy;
MonoJitInfo *ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx));
gpointer *sp;
int 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));
-#ifdef __linux__
+#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
-}
-#endif
+#endif /* !MONO_CROSS_COMPILE */
+}
gboolean
mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
projects / mono.git / blobdiff