#include <glib.h>
#include <signal.h>
#include <string.h>
+#include <stddef.h>
#include <ucontext.h>
#include <mono/arch/ppc/ppc-codegen.h>
* Returns a pointer to a method which restores a previously saved sigcontext.
* The first argument in r3 is the pointer to the context.
*/
-static gpointer
-arch_get_restore_context (void)
+gpointer
+mono_arch_get_restore_context (void)
{
guint8 *code;
- static guint8 start [128];
- static int inited = 0;
+ static guint8 *start = NULL;
- if (inited)
+ if (start)
return start;
- inited = 1;
- code = start;
+ code = start = mono_global_codeman_reserve (128);
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);
/* never reached */
ppc_break (code);
- g_assert ((code - start) < sizeof(start));
+ g_assert ((code - start) < 128);
mono_arch_flush_icache (start, code - start);
return start;
}
static gpointer
arch_get_call_filter (void)
{
- static guint8 start [320];
- static int inited = 0;
+ static guint8 *start = NULL;
guint8 *code;
int alloc_size, pos, i;
- if (inited)
+ if (start)
return start;
- inited = 1;
/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
- code = start;
+ code = start = mono_global_codeman_reserve (320);
/* save all the regs on the stack */
pos = 0;
ppc_blr (code);
- g_assert ((code - start) < sizeof(start));
+ g_assert ((code - start) < 320);
mono_arch_flush_icache (start, code - start);
return start;
}
MonoContext ctx;
if (!restore_context)
- restore_context = arch_get_restore_context ();
+ restore_context = mono_arch_get_restore_context ();
/* adjust eip so that it point into the call instruction */
eip -= 4;
gpointer
mono_arch_get_rethrow_exception (void)
{
- static guint8 start [132];
+ static guint8 *start = NULL;
static int inited = 0;
if (inited)
return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, TRUE);
+ start = mono_global_codeman_reserve (132);
+ mono_arch_get_throw_exception_generic (start, 132, FALSE, TRUE);
inited = 1;
return start;
}
gpointer
mono_arch_get_throw_exception (void)
{
- static guint8 start [132];
+ static guint8 *start = NULL;
static int inited = 0;
if (inited)
return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, FALSE);
+ start = mono_global_codeman_reserve (132);
+ mono_arch_get_throw_exception_generic (start, 132, FALSE, FALSE);
inited = 1;
return start;
}
gpointer
mono_arch_get_throw_exception_by_name (void)
{
- static guint8 start [168];
+ static guint8 *start = NULL;
static int inited = 0;
if (inited)
return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE, FALSE);
+ start = mono_global_codeman_reserve (168);
+ mono_arch_get_throw_exception_generic (start, 168, TRUE, FALSE);
inited = 1;
return start;
}
{
MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
- unsigned long *ptr;
- char *p;
MonoPPCStackFrame *sframe;
/* Avoid costly table lookup during stack overflow */
if (ji != NULL) {
gint32 address;
int offset, i;
- gulong *ctx_regs;
*new_ctx = *ctx;
setup_context (new_ctx);
/*
* This is the function called from the signal handler
*/
-#ifdef __APPLE__
-gboolean
-mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+void
+mono_arch_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
{
- struct ucontext *uc = ctx;
- MonoContext mctx;
- gboolean result;
-
- mctx.sc_ir = uc->uc_mcontext->ss.srr0;
- mctx.sc_sp = uc->uc_mcontext->ss.r1;
- memcpy (&mctx.regs, &uc->uc_mcontext->ss.r13, sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&mctx.fregs, &uc->uc_mcontext->fs.fpregs [14], sizeof (double) * MONO_SAVED_FREGS);
+ os_ucontext *uc = ctx;
- result = arch_handle_exception (&mctx, obj, test_only);
- /* restore the context so that returning from the signal handler will invoke
- * the catch clause
- */
- uc->uc_mcontext->ss.srr0 = mctx.sc_ir;
- uc->uc_mcontext->ss.r1 = mctx.sc_sp;
- memcpy (&uc->uc_mcontext->ss.r13, &mctx.regs, sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&uc->uc_mcontext->fs.fpregs [14], &mctx.fregs, sizeof (double) * MONO_SAVED_FREGS);
- return result;
+ 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);
+}
+
+void
+mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
+{
+ 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);
}
gpointer
mono_arch_ip_from_context (void *sigctx)
{
- struct ucontext *uc = sigctx;
- return (gpointer)uc->uc_mcontext->ss.srr0;
+ os_ucontext *uc = sigctx;
+ return (gpointer)UCONTEXT_REG_NIP(uc);
}
-#else
-/* Linux */
+#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 ();
+ mono_arch_sigctx_to_monoctx (sigctx, &mctx);
+ arch_handle_exception (&mctx, obj, test_only);
+ restore_context (&mctx);
+}
+
+void
+mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf)
+{
+#ifdef MONO_ARCH_USE_SIGACTION
+ ucontext_t *uc = (ucontext_t*)sigctx;
+ ucontext_t *uc_copy;
+ MonoJitInfo *ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx));
+ gpointer *sp;
+ int frame_size;
+
+ if (stack_ovf) {
+ const char *method;
+ /* we don't do much now, but we can warn the user with a useful message */
+ fprintf (stderr, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx), (gpointer)UCONTEXT_REG_Rn(uc, 1));
+ if (ji && ji->method)
+ method = mono_method_full_name (ji->method, TRUE);
+ else
+ method = "Unmanaged";
+ fprintf (stderr, "At %s\n", method);
+ abort ();
+ }
+ if (!ji)
+ mono_handle_native_sigsegv (SIGSEGV, sigctx);
+ /* setup a call frame on the real stack so that control is returned there
+ * and exception handling can continue.
+ * The frame looks like:
+ * ucontext struct
+ * ...
+ * 224 is the size of the red zone
+ */
+ frame_size = sizeof (ucontext_t) + sizeof (gpointer) * 16 + 224;
+ frame_size += 15;
+ frame_size &= ~15;
+ sp = (gpointer)(UCONTEXT_REG_Rn(uc, 1) & ~15);
+ sp = (gpointer)((char*)sp - 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__
+ uc_copy->uc_mcontext.uc_regs = (char*)uc_copy + offsetof(ucontext_t, uc_mcontext.uc_regs);
+#endif
+ /* at the return form the signal handler execution starts in altstack_handle_and_restore() */
+ UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
+ UCONTEXT_REG_NIP(uc) = (unsigned long)altstack_handle_and_restore;
+ 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
+
gboolean
mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
{
- struct ucontext *uc = ctx;
MonoContext mctx;
gboolean result;
-
- mctx.sc_ir = uc->uc_mcontext.uc_regs->gregs [PT_NIP];
- mctx.sc_sp = uc->uc_mcontext.uc_regs->gregs [PT_R1];
- memcpy (&mctx.regs, &uc->uc_mcontext.uc_regs->gregs [PT_R13], sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&mctx.fregs, &uc->uc_mcontext.uc_regs->fpregs.fpregs [14], sizeof (double) * MONO_SAVED_FREGS);
+
+ mono_arch_sigctx_to_monoctx (ctx, &mctx);
result = arch_handle_exception (&mctx, obj, test_only);
/* restore the context so that returning from the signal handler will invoke
* the catch clause
*/
- uc->uc_mcontext.uc_regs->gregs [PT_NIP] = mctx.sc_ir;
- uc->uc_mcontext.uc_regs->gregs [PT_R1] = mctx.sc_sp;
- memcpy (&uc->uc_mcontext.uc_regs->gregs [PT_R13], &mctx.regs, sizeof (gulong) * MONO_SAVED_GREGS);
- memcpy (&uc->uc_mcontext.uc_regs->fpregs.fpregs [14], &mctx.fregs, sizeof (double) * MONO_SAVED_FREGS);
+ mono_arch_monoctx_to_sigctx (&mctx, ctx);
return result;
}
-gpointer
-mono_arch_ip_from_context (void *sigctx)
-{
- struct ucontext *uc = sigctx;
- return (gpointer)uc->uc_mcontext.uc_regs->gregs [PT_NIP];
-}
-
-#endif
-
/**
* arch_handle_exception:
* @ctx: saved processor state
}
if (!test_only && ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
MONO_CONTEXT_GET_IP (ctx) < ei->try_end &&
- (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
+ (ei->flags == MONO_EXCEPTION_CLAUSE_FAULT)) {
+ if (mono_jit_trace_calls != NULL)
+ g_print ("EXCEPTION: fault clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
+ call_filter (ctx, ei->handler_start, NULL);
+ }
+ if (!test_only && ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
+ MONO_CONTEXT_GET_IP (ctx) < ei->try_end &&
+ (ei->flags == MONO_EXCEPTION_CLAUSE_FINALLY)) {
if (mono_jit_trace_calls != NULL)
g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
call_filter (ctx, ei->handler_start, NULL);
projects / mono.git / blobdiff