#include <glib.h>
#include <signal.h>
#include <string.h>
-#include <ucontext.h>
#include <mono/arch/mips/mips-codegen.h>
#include <mono/metadata/appdomain.h>
#define GENERIC_EXCEPTION_SIZE 256
-/* XXX */
-#if 1
-#define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do { \
- } while (0)
-#else
-#define restore_regs_from_context(ctx_reg,pc,tmp_reg) do { \
- int reg; \
- ppc_lwz (code, pc, G_STRUCT_OFFSET (MonoContext, sc_pc), ctx_reg); \
- ppc_lmw (code, ppc_r13, ctx_reg, G_STRUCT_OFFSET (MonoContext, sc_regs)); \
- for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) { \
- ppc_lfd (code, (14 + reg), G_STRUCT_OFFSET(MonoLMF, sc_fpregs) + reg * sizeof (gdouble), ctx_reg); \
- } \
- } while (0)
-#endif
-
-/* nothing to do */
-#define setup_context(ctx) do { \
- memset ((ctx), 0, sizeof(*(ctx))); \
- } while (0);
-
/*
* mono_arch_get_restore_context:
*
{
int i;
guint8 *code;
- static guint8 start [128];
+ static guint8 start [512];
static int inited = 0;
guint32 iregs_to_restore;
inited = 1;
code = start;
+ mips_move (code, mips_at, mips_a0);
+
iregs_to_restore = (MONO_ARCH_CALLEE_SAVED_REGS \
| (1 << mips_sp) | (1 << mips_ra));
for (i = 0; i < MONO_SAVED_GREGS; ++i) {
- if (iregs_to_restore & (1 << i)) {
- MIPS_LW (code, i, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[i]));
+ //if (iregs_to_restore & (1 << i)) {
+ if (i != mips_zero && i != mips_at) {
+ MIPS_LW (code, i, mips_at, G_STRUCT_OFFSET (MonoContext, sc_regs[i]));
}
}
/* Get the address to return to */
- mips_lw (code, mips_t9, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_pc));
+ mips_lw (code, mips_t9, mips_at, G_STRUCT_OFFSET (MonoContext, sc_pc));
/* jump to the saved IP */
mips_jr (code, mips_t9);
g_assert ((code - start) < sizeof(start));
mono_arch_flush_icache (start, code - start);
+ mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
return start;
}
g_assert ((code - start) < sizeof(start));
mono_arch_flush_icache (start, code - start);
+ mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
return start;
}
static void
throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gboolean rethrow)
{
- static void (*restore_context) (MonoContext *);
MonoContext ctx;
#ifdef DEBUG_EXCEPTIONS
exc, (void *)eip, (void *) esp, rethrow);
#endif
- if (!restore_context)
- restore_context = mono_get_restore_context ();
-
/* adjust eip so that it point into the call instruction */
eip -= 8;
- setup_context (&ctx);
+ memset (&ctx, 0, sizeof (MonoContext));
/*g_print ("stack in throw: %p\n", esp);*/
memcpy (&ctx.sc_regs, (void *)(esp + MIPS_STACK_PARAM_OFFSET),
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
- if (!rethrow)
+ if (!rethrow) {
mono_ex->stack_trace = NULL;
+ mono_ex->trace_ips = NULL;
+ }
}
- mono_handle_exception (&ctx, exc, (void *)eip, FALSE);
+ mono_handle_exception (&ctx, exc);
#ifdef DEBUG_EXCEPTIONS
g_print ("throw_exception: restore to pc=%p sp=%p fp=%p ctx=%p\n",
(void *) ctx.sc_pc, (void *) ctx.sc_regs[mips_sp],
(void *) ctx.sc_regs[mips_fp], &ctx);
#endif
- restore_context (&ctx);
+ mono_restore_context (&ctx);
g_assert_not_reached ();
}
g_assert ((code - start) < size);
mono_arch_flush_icache (start, code - start);
+ mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
return start;
}
start = code = mono_global_codeman_reserve (size);
mips_break (code, 0xfd);
mono_arch_flush_icache (start, code - start);
+ mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
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)
-{
- 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);
-
- for (i = 0; list; list = list->next, i++)
- mono_array_set (res, gpointer, i, list->data);
-
- return res;
}
/*
mgreg_t **save_locations,
StackFrameInfo *frame)
{
- gpointer ip = MONO_CONTEXT_GET_IP (ctx);
- gpointer fp = MONO_CONTEXT_GET_BP (ctx);
- guint32 sp;
-
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
if (ji != NULL) {
int i;
- gint32 address;
- int offset = 0;
+ gpointer ip = MONO_CONTEXT_GET_IP (ctx);
+ mgreg_t regs [MONO_MAX_IREGS + 1];
+ guint8 *cfa;
+ guint32 unwind_info_len;
+ guint8 *unwind_info;
frame->type = FRAME_TYPE_MANAGED;
- if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
- /* remove any unused lmf */
- *lmf = (*lmf)->previous_lmf;
- }
+ unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
- address = (char *)ip - (char *)ji->code_start;
+ for (i = 0; i < MONO_MAX_IREGS; ++i)
+ regs [i] = new_ctx->sc_regs [i];
- /* My stack frame */
- fp = MONO_CONTEXT_GET_BP (ctx);
+ mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
+ (guint8*)ji->code_start + ji->code_size,
+ ip, NULL, regs, MONO_MAX_IREGS,
+ save_locations, MONO_MAX_IREGS, &cfa);
- /* Compute the previous stack frame */
- sp = (guint32)(fp) - (short)(*(guint32 *)(ji->code_start));
+ for (i = 0; i < MONO_MAX_IREGS; ++i)
+ new_ctx->sc_regs [i] = regs [i];
+ new_ctx->sc_pc = regs [mips_ra];
+ new_ctx->sc_regs [mips_sp] = (mgreg_t)cfa;
- /* Sanity check the frame */
- if (!sp || (sp == 0xffffffff)
- || (sp & 0x07) || (sp < 64*1024)) {
-#ifdef DEBUG_EXCEPTIONS
- g_print ("mono_arch_find_jit_info: bad stack sp=%p\n", (void *) sp);
-#endif
- return FALSE;
- }
-
- if (ji->method->save_lmf && 0) {
- /* only enable this when prologue stops emitting
- * normal save of s-regs when save_lmf is true.
- * Will have to sync with prologue code at that point.
- */
- memcpy (&new_ctx->sc_fpregs,
- (char*)sp - sizeof (float) * MONO_SAVED_FREGS,
- sizeof (float) * MONO_SAVED_FREGS);
- memcpy (&new_ctx->sc_regs,
- (char*)sp - sizeof (float) * MONO_SAVED_FREGS - sizeof (gulong) * MONO_SAVED_GREGS,
- sizeof (gulong) * MONO_SAVED_GREGS);
- } else if (ji->used_regs) {
- guint32 *insn;
- guint32 mask = ji->used_regs;
-
- /* these all happen before adjustment of fp */
- /* Look for sw ??, ????(sp) */
- insn = ((guint32 *)ji->code_start) + 1;
- while (!*insn || ((*insn & 0xffe00000) == 0xafa00000) || ((*insn & 0xffe00000) == 0xffa00000)) {
- int reg = (*insn >> 16) & 0x1f;
- guint32 addr = (((guint32)fp) + (short)(*insn & 0x0000ffff));
-
- mask &= ~(1 << reg);
- if ((*insn & 0xffe00000) == 0xafa00000)
- new_ctx->sc_regs [reg] = *(guint32 *)addr;
- else
- new_ctx->sc_regs [reg] = *(guint64 *)addr;
- insn++;
- }
- MONO_CONTEXT_SET_SP (new_ctx, sp);
- MONO_CONTEXT_SET_BP (new_ctx, sp);
- /* assert that we found all registers we were supposed to */
- g_assert (!mask);
- }
/* we substract 8, so that the IP points into the call instruction */
- MONO_CONTEXT_SET_IP (new_ctx, new_ctx->sc_regs[mips_ra] - 8);
+ MONO_CONTEXT_SET_IP (new_ctx, new_ctx->sc_pc - 8);
/* Sanity check -- we should have made progress here */
- g_assert (new_ctx->sc_pc != ctx->sc_pc);
+ g_assert (MONO_CONTEXT_GET_SP (new_ctx) != MONO_CONTEXT_GET_SP (ctx));
return TRUE;
} else if (*lmf) {
+
+ if (((mgreg_t)(*lmf)->previous_lmf) & 2) {
+ /*
+ * This LMF entry is created by the soft debug code to mark transitions to
+ * managed code done during invokes.
+ */
+ MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
+
+ g_assert (ext->debugger_invoke);
+
+ memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
+
+ *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
+
+ frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
+
+ return TRUE;
+ }
+
if (!(*lmf)->method) {
#ifdef DEBUG_EXCEPTIONS
g_print ("mono_arch_find_jit_info: bad lmf @ %p\n", (void *) *lmf);
MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
/* ensure that we've made progress */
g_assert (new_ctx->sc_pc != ctx->sc_pc);
- *lmf = (*lmf)->previous_lmf;
+
+ *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
-void
-mono_arch_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
+gpointer
+mono_arch_ip_from_context (void *sigctx)
{
- int i;
- struct sigcontext *ctx = (struct sigcontext *)sigctx;
-
- mctx->sc_pc = ctx->sc_pc;
- for (i = 0; i < 32; ++i) {
- mctx->sc_regs[i] = ctx->sc_regs[i];
- mctx->sc_fpregs[i] = ctx->sc_fpregs[i];
- }
+ return (gpointer)(gsize)UCONTEXT_REG_PC (sigctx);
}
-void
-mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
+/*
+ * handle_exception:
+ *
+ * Called by resuming from a signal handler.
+ */
+static void
+handle_signal_exception (gpointer obj)
{
- int i;
- struct sigcontext *ctx = (struct sigcontext *)sigctx;
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ MonoContext ctx;
- ctx->sc_pc = mctx->sc_pc;
- for (i = 0; i < 32; ++i) {
- ctx->sc_regs[i] = mctx->sc_regs[i];
- ctx->sc_fpregs[i] = mctx->sc_fpregs[i];
- }
-}
+ memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
-gpointer
-mono_arch_ip_from_context (void *sigctx)
-{
- struct sigcontext *ctx = (struct sigcontext *)sigctx;
- return (gpointer)(guint32)ctx->sc_pc;
+ mono_handle_exception (&ctx, obj);
+
+ mono_restore_context (&ctx);
}
/*
* This is the function called from the signal handler
*/
gboolean
-mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+mono_arch_handle_exception (void *ctx, gpointer obj)
{
+#if defined(MONO_CROSS_COMPILE)
+ g_assert_not_reached ();
+#elif defined(MONO_ARCH_USE_SIGACTION)
+ void *sigctx = ctx;
+
+ /*
+ * 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);
+ guint64 sp = UCONTEXT_GREGS (sigctx) [mips_sp];
+
+ /* Pass the ctx parameter in TLS */
+ mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
+ /* The others in registers */
+ UCONTEXT_GREGS (sigctx)[mips_a0] = (gsize)obj;
+
+ /* Allocate a stack frame */
+ sp -= 256;
+ UCONTEXT_GREGS (sigctx)[mips_sp] = sp;
+
+ UCONTEXT_REG_PC (sigctx) = (gsize)handle_signal_exception;
+
+ return TRUE;
+#else
MonoContext mctx;
gboolean result;
-
- mono_arch_sigctx_to_monoctx (ctx, &mctx);
-#ifdef DEBUG_EXCEPTIONS
- g_print ("mono_arch_handle_exception: pc=%p\n", (void *) mctx.sc_pc);
-#endif
- mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_pc, test_only);
- result = TRUE;
-#ifdef DEBUG_EXCEPTIONS
- g_print ("mono_arch_handle_exception: restore pc=%p\n", (void *)mctx.sc_pc);
-#endif
- /* restore the context so that returning from the signal handler
- * will invoke the catch clause
- */
- mono_arch_monoctx_to_sigctx (&mctx, ctx);
+ mono_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
+ */
+ mono_monoctx_to_sigctx (&mctx, ctx);
return result;
+#endif
}
-
-gboolean
-mono_arch_has_unwind_info (gconstpointer addr)
+/*
+ * mono_arch_setup_resume_sighandler_ctx:
+ *
+ * Setup CTX so execution continues at FUNC.
+ */
+void
+mono_arch_setup_resume_sighandler_ctx (MonoContext *ctx, gpointer func)
{
- return FALSE;
+ MONO_CONTEXT_SET_IP (ctx,func);
}
-
projects / mono.git / blobdiff