#define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do { \
int reg; \
- ppc_load_reg (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg); \
+ 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), \
* 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 *start, *code;
int size = MONO_PPC_32_64_CASE (128, 172) + PPC_FTNPTR_SIZE;
code = start = mono_global_codeman_reserve (size);
- code = mono_ppc_create_pre_code_ftnptr (code);
+ *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_load_reg (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);
g_assert ((code - start) <= size);
mono_arch_flush_icache (start, code - start);
+
+ *code_size = code - start;
+
return start;
}
* @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)
{
guint8 *start, *code;
int alloc_size, pos, i;
int size = MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE;
+ *ji = NULL;
+
/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
code = start = mono_global_codeman_reserve (size);
- code = mono_ppc_create_pre_code_ftnptr (code);
+ if (!aot)
+ code = mono_ppc_create_pre_code_ftnptr (code);
/* store ret addr */
ppc_mflr (code, ppc_r0);
- ppc_store_reg (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;
/* allocate stack frame and set link from sp in ctx */
g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
- ppc_load_reg (code, ppc_r0, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
- ppc_load_reg_indexed (code, ppc_r0, ppc_r0, ppc_r0);
- ppc_store_reg_update (code, ppc_r0, -alloc_size, ppc_sp);
+ 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);
ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
/* epilog */
- ppc_load_reg (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);
/* restore all the regs from the stack */
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, mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
/*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)) {
* void (*func) (guint32 ex_token, gpointer ip)
*
*/
-static gpointer
-mono_arch_get_throw_exception_generic (int size, int corlib, gboolean rethrow)
+static gpointer
+mono_arch_get_throw_exception_generic (int size, guint32 *code_size, MonoJumpInfo **ji, int corlib, gboolean rethrow, gboolean aot)
{
guint8 *start, *code;
int alloc_size, pos;
- start = mono_global_codeman_reserve (size);
+ *ji = NULL;
- code = mono_ppc_create_pre_code_ftnptr (start);
+ 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_store_reg (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;
g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
- ppc_store_reg_update (code, ppc_sp, -alloc_size, ppc_sp);
+ ppc_stptr_update (code, ppc_sp, -alloc_size, ppc_sp);
code = emit_save_saved_regs (code, alloc_size);
//ppc_break (code);
if (corlib) {
ppc_mr (code, ppc_r4, ppc_r3);
- 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);
+
+ 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_load_reg (code, ppc_r5, 0, ppc_sp);
+ ppc_ldptr (code, ppc_r5, 0, ppc_sp);
/* exc is already in place in r3 */
if (corlib)
- ppc_load_reg (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
+ 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 */
ppc_addi (code, ppc_r6, ppc_sp, pos);
ppc_li (code, ppc_r8, rethrow);
- ppc_load_func (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);
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)
{
int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
- return mono_arch_get_throw_exception_generic (size, FALSE, TRUE);
+ 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)
{
int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
- return mono_arch_get_throw_exception_generic (size, FALSE, FALSE);
+ 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)
+gpointer
+mono_arch_get_throw_exception_by_name_full (guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
{
guint8 *start, *code;
int size = 64;
+ *ji = NULL;
+
/* 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;
}
* 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 (void)
+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 mono_arch_get_throw_exception_generic (size, TRUE, FALSE);
+ if (aot)
+ size += 64;
+ return mono_arch_get_throw_exception_generic (size, code_size, ji, TRUE, FALSE, aot);
}
-/* mono_arch_find_jit_info:
+/*
+ * mono_arch_find_jit_info_ext:
*
- * 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, MonoLMF **lmf, gboolean *managed)
+gboolean
+mono_arch_find_jit_info_ext (MonoDomain *domain, MonoJitTlsData *jit_tls,
+ MonoJitInfo *ji, MonoContext *ctx,
+ MonoContext *new_ctx, MonoLMF **lmf,
+ StackFrameInfo *frame)
{
- MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
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;
+ frame->managed = FALSE;
- if (managed)
- *managed = FALSE;
+ *new_ctx = *ctx;
+ setup_context (new_ctx);
if (ji != NULL) {
- gint32 address;
- int offset, i;
-
- *new_ctx = *ctx;
- setup_context (new_ctx);
+ int i;
+ gssize regs [ppc_lr + 1];
+ guint8 *cfa;
+ guint32 unwind_info_len;
+ guint8 *unwind_info;
- if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
- /* remove any unused lmf */
- *lmf = (*lmf)->previous_lmf;
- }
+ frame->type = FRAME_TYPE_MANAGED;
- address = (char *)ip - (char *)ji->code_start;
+ if (!ji->method->wrapper_type || ji->method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD)
+ frame->managed = TRUE;
- if (managed)
- if (!ji->method->wrapper_type)
- *managed = TRUE;
+ 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);
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, MONO_MAX_IREGS + 1, &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_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
+ /* remove any unused lmf */
+ *lmf = (*lmf)->previous_lmf;
}
- /* 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 ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
+ if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
} else {
if (!(*lmf)->method)
- return (gpointer)-1;
+ return FALSE;
- memset (res, 0, sizeof (MonoJitInfo));
- res->method = (*lmf)->method;
+ /* Trampoline lmf frame */
+ frame->method = (*lmf)->method;
}
/*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
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;
}
/*
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->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
}
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_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
}
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
}
static void
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 = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx));
+ MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx), NULL);
gpointer *sp;
int frame_size;
UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 1) = 0;
UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 2) = 0;
#endif
+
+#endif /* !MONO_CROSS_COMPILE */
}
gboolean
projects / mono.git / blobdiff