-/*
- * exceptions-s390.c: exception support for S/390
- *
- * Authors:
- * Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com)
- * Dietmar Maurer (dietmar@ximian.com)
- * Paolo Molaro (lupus@ximian.com)
- *
- * (C) 2001 Ximian, Inc.
- */
+/*------------------------------------------------------------------*/
+/* */
+/* Name - exceptions-s390.c */
+/* */
+/* Function - Exception support for S/390. */
+/* */
+/* Name - Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com) */
+/* */
+/* Date - January, 2004 */
+/* */
+/* Derivation - From exceptions-x86 & exceptions-ppc */
+/* Paolo Molaro (lupus@ximian.com) */
+/* Dietmar Maurer (dietmar@ximian.com) */
+/* */
+/* Copyright - 2001 Ximian, Inc. */
+/* */
+/*------------------------------------------------------------------*/
+
+/*------------------------------------------------------------------*/
+/* D e f i n e s */
+/*------------------------------------------------------------------*/
+
+#define S390_CALLFILTER_INTREGS S390_MINIMAL_STACK_SIZE
+#define S390_CALLFILTER_FLTREGS S390_CALLFILTER_INTREGS+(16*sizeof(gulong))
+#define S390_CALLFILTER_ACCREGS S390_CALLFILTER_FLTREGS+(16*sizeof(gdouble))
+#define S390_CALLFILTER_SIZE (S390_CALLFILTER_ACCREGS+(16*sizeof(gulong)))
+
+#define S390_THROWSTACK_ACCPRM S390_MINIMAL_STACK_SIZE
+#define S390_THROWSTACK_FPCPRM S390_THROWSTACK_ACCPRM+sizeof(gpointer)
+#define S390_THROWSTACK_RETHROW S390_THROWSTACK_FPCPRM+sizeof(gulong)
+#define S390_THROWSTACK_INTREGS S390_THROWSTACK_RETHROW+sizeof(gboolean)
+#define S390_THROWSTACK_FLTREGS S390_THROWSTACK_INTREGS+(16*sizeof(gulong))
+#define S390_THROWSTACK_ACCREGS S390_THROWSTACK_FLTREGS+(16*sizeof(gdouble))
+#define S390_THROWSTACK_SIZE (S390_THROWSTACK_ACCREGS+(16*sizeof(gulong)))
+
+#define SZ_THROW 384
+
+/*========================= End of Defines =========================*/
+
+/*------------------------------------------------------------------*/
+/* I n c l u d e s */
+/*------------------------------------------------------------------*/
#include <config.h>
#include <glib.h>
#include <signal.h>
#include <string.h>
+#include <ucontext.h>
#include <mono/arch/s390/s390-codegen.h>
#include <mono/metadata/appdomain.h>
#include "mini.h"
#include "mini-s390.h"
-typedef struct sigcontext MonoContext;
+/*========================= End of Includes ========================*/
-/*
+/*------------------------------------------------------------------*/
+/* P r o t o t y p e s */
+/*------------------------------------------------------------------*/
-struct sigcontext {
- int sc_onstack; // sigstack state to restore
- int sc_mask; // signal mask to restore
- int sc_ir; // pc
- int sc_psw; // processor status word
- int sc_sp; // stack pointer if sc_regs == NULL
- void *sc_regs; // (kernel private) saved state
-};
+gboolean mono_arch_handle_exception (void *ctx,
+ gpointer obj,
+ gboolean test_only);
-struct ucontext {
- int uc_onstack;
- sigset_t uc_sigmask; // signal mask used by this context
- stack_t uc_stack; // stack used by this context
- struct ucontext *uc_link; // pointer to resuming context
- size_t uc_mcsize; // size of the machine context passed in
- mcontext_t uc_mcontext; // machine specific context
-};
+/*========================= End of Prototypes ======================*/
-typedef struct s390_exception_state {
- unsigned long dar; // Fault registers for coredump
- unsigned long dsisr;
- unsigned long exception;// number of s390 exception taken
- unsigned long pad0; // align to 16 bytes
+/*------------------------------------------------------------------*/
+/* G l o b a l V a r i a b l e s */
+/*------------------------------------------------------------------*/
- unsigned long pad1[4]; // space in PCB "just in case"
-} s390_exception_state_t;
+/*====================== End of Global Variables ===================*/
-typedef struct s390_float_state {
- double fpregs[16];
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_has_unwind_info */
+/* */
+/* Function - Tests if a function has a DWARF exception table */
+/* that is able to restore all caller saved registers*/
+/* */
+/*------------------------------------------------------------------*/
- unsigned int fpc; // floating point status register
-} s390_float_state_t;
-
-typedef struct s390_thread_state {
- unsigned int ip; // Instruction address register (PC)
- unsigned int reg[16];
-} s390_thread_state_t;
-
-struct mcontext {
- s390_exception_state_t es;
- s390_thread_state_t ss;
- s390_float_state_t fs;
-};
-
-typedef struct mcontext * mcontext_t;
-
-*/
-
-#define MONO_CONTEXT_SET_IP(ctx,ip) do { \
- (ctx)->sregs->regs.psw.addr = (unsigned long)ip;\
- } while (0);
-#define MONO_CONTEXT_SET_BP(ctx,bp) do { (ctx)->sregs->regs.gprs[15] = (unsigned long)bp; } while (0);
-
-#define MONO_CONTEXT_GET_IP(ctx) ((gpointer)((ctx)->sregs->regs.psw.addr))
-#define MONO_CONTEXT_GET_BP(ctx) ((gpointer)((ctx)->sregs->regs.gprs[15]))
-
-typedef struct {
- unsigned long sp;
- unsigned long lr;
-} MonoS390StackFrame;
-
-/* disbale this for now */
-#undef MONO_USE_EXC_TABLES
-
-#ifdef MONO_USE_EXC_TABLES
-
-/*************************************/
-/* STACK UNWINDING STUFF */
-/*************************************/
-
-/* These definitions are from unwind-dw2.c in glibc 2.2.5 */
-
-/* For x86 */
-#define DWARF_FRAME_REGISTERS 17
-
-typedef struct frame_state
-{
- void *cfa;
- void *eh_ptr;
- long cfa_offset;
- long args_size;
- long reg_or_offset[DWARF_FRAME_REGISTERS+1];
- unsigned short cfa_reg;
- unsigned short retaddr_column;
- char saved[DWARF_FRAME_REGISTERS+1];
-} frame_state;
-
-#if 0
-
-static long
-get_sigcontext_reg (struct sigcontext *ctx, int dwarf_regnum)
-{
- switch (dwarf_regnum) {
- case X86_EAX:
- return ctx->SC_EAX;
- case X86_EBX:
- return ctx->SC_EBX;
- case X86_ECX:
- return ctx->SC_ECX;
- case X86_EDX:
- return ctx->SC_EDX;
- case X86_ESI:
- return ctx->SC_ESI;
- case X86_EDI:
- return ctx->SC_EDI;
- case X86_EBP:
- return ctx->SC_EBP;
- case X86_ESP:
- return ctx->SC_ESP;
- default:
- g_assert_not_reached ();
- }
-
- return 0;
-}
-
-static void
-set_sigcontext_reg (struct sigcontext *ctx, int dwarf_regnum, long value)
-{
- switch (dwarf_regnum) {
- case X86_EAX:
- ctx->SC_EAX = value;
- break;
- case X86_EBX:
- ctx->SC_EBX = value;
- break;
- case X86_ECX:
- ctx->SC_ECX = value;
- break;
- case X86_EDX:
- ctx->SC_EDX = value;
- break;
- case X86_ESI:
- ctx->SC_ESI = value;
- break;
- case X86_EDI:
- ctx->SC_EDI = value;
- break;
- case X86_EBP:
- ctx->SC_EBP = value;
- break;
- case X86_ESP:
- ctx->SC_ESP = value;
- break;
- case 8:
- ctx->SC_EIP = value;
- break;
- default:
- g_assert_not_reached ();
- }
-}
-
-typedef struct frame_state * (*framesf) (void *, struct frame_state *);
-
-static framesf frame_state_for = NULL;
-
-static gboolean inited = FALSE;
-
-typedef char ** (*get_backtrace_symbols_type) (void *__const *__array, int __size);
-
-static get_backtrace_symbols_type get_backtrace_symbols = NULL;
-
-static void
-init_frame_state_for (void)
-{
- GModule *module;
-
- /*
- * There are two versions of __frame_state_for: one in libgcc.a and the
- * other in glibc.so. We need the version from glibc.
- * For more info, see this:
- * http://gcc.gnu.org/ml/gcc/2002-08/msg00192.html
- */
- if ((module = g_module_open ("libc.so.6", G_MODULE_BIND_LAZY))) {
-
- if (!g_module_symbol (module, "__frame_state_for", (gpointer*)&frame_state_for))
- frame_state_for = NULL;
-
- if (!g_module_symbol (module, "backtrace_symbols", (gpointer*)&get_backtrace_symbols)) {
- get_backtrace_symbols = NULL;
- frame_state_for = NULL;
- }
-
- g_module_close (module);
- }
-
- inited = TRUE;
-}
-
-#endif
-
-gboolean mono_arch_handle_exception (struct sigcontext *ctx, gpointer obj, gboolean test_only);
-
-/* mono_arch_has_unwind_info:
- *
- * Tests if a function has an DWARF exception table able to restore
- * all caller saved registers.
- */
gboolean
-mono_arch_has_unwind_info (MonoMethod *method)
+mono_arch_has_unwind_info (gconstpointer addr)
{
-#if 0
- struct frame_state state_in;
- struct frame_state *res;
-
- if (!inited)
- init_frame_state_for ();
-
- if (!frame_state_for)
- return FALSE;
-
- g_assert (method->addr);
-
- memset (&state_in, 0, sizeof (state_in));
-
- /* offset 10 is just a guess, but it works for all methods tested */
- if ((res = frame_state_for ((char *)method->addr + 10, &state_in))) {
-
- if (res->saved [X86_EBX] != 1 ||
- res->saved [X86_EDI] != 1 ||
- res->saved [X86_EBP] != 1 ||
- res->saved [X86_ESI] != 1) {
- return FALSE;
- }
- return TRUE;
- } else {
- return FALSE;
- }
-#else
return FALSE;
-#endif
-}
-
-struct stack_frame
-{
- void *next;
- void *return_address;
-};
-
-static MonoJitInfo *
-s390_unwind_native_frame (MonoDomain *domain, MonoJitTlsData *jit_tls, struct sigcontext *ctx,
- struct sigcontext *new_ctx, MonoLMF *lmf, char **trace)
-{
-#if 0
- struct stack_frame *frame;
- gpointer max_stack;
- MonoJitInfo *ji;
- struct frame_state state_in;
- struct frame_state *res;
-
- if (trace)
- *trace = NULL;
-
- if (!inited)
- init_frame_state_for ();
-
- if (!frame_state_for)
- return FALSE;
-
- frame = MONO_CONTEXT_GET_BP (ctx);
-
- max_stack = lmf && lmf->method ? lmf : jit_tls->end_of_stack;
-
- *new_ctx = *ctx;
-
- memset (&state_in, 0, sizeof (state_in));
-
- while ((gpointer)frame->next < (gpointer)max_stack) {
- gpointer ip, addr = frame->return_address;
- void *cfa;
- char *tmp, **symbols;
-
- if (trace) {
- ip = MONO_CONTEXT_GET_IP (new_ctx);
- symbols = get_backtrace_symbols (&ip, 1);
- if (*trace)
- tmp = g_strdup_printf ("%s\nin (unmanaged) %s", *trace, symbols [0]);
- else
- tmp = g_strdup_printf ("in (unmanaged) %s", symbols [0]);
-
- free (symbols);
- g_free (*trace);
- *trace = tmp;
- }
-
- if ((res = frame_state_for (addr, &state_in))) {
- int i;
-
- cfa = (gint8*) (get_sigcontext_reg (new_ctx, res->cfa_reg) + res->cfa_offset);
- frame = (struct stack_frame *)((gint8*)cfa - 8);
- for (i = 0; i < DWARF_FRAME_REGISTERS + 1; i++) {
- int how = res->saved[i];
- long val;
- g_assert ((how == 0) || (how == 1));
-
- if (how == 1) {
- val = * (long*) ((gint8*)cfa + res->reg_or_offset[i]);
- set_sigcontext_reg (new_ctx, i, val);
- }
- }
- new_ctx->SC_ESP = (long)cfa;
-
- if (res->saved [X86_EBX] == 1 &&
- res->saved [X86_EDI] == 1 &&
- res->saved [X86_EBP] == 1 &&
- res->saved [X86_ESI] == 1 &&
- (ji = mono_jit_info_table_find (domain, frame->return_address))) {
- //printf ("FRAME CFA %s\n", mono_method_full_name (ji->method, TRUE));
- return ji;
- }
-
- } else {
- //printf ("FRAME %p %p %p\n", frame, MONO_CONTEXT_GET_IP (new_ctx), mono_jit_info_table_find (domain, MONO_CONTEXT_GET_IP (new_ctx)));
-
- MONO_CONTEXT_SET_IP (new_ctx, frame->return_address);
- frame = frame->next;
- MONO_CONTEXT_SET_BP (new_ctx, frame);
-
- /* stop if !frame or when we detect an unexpected managed frame */
- if (!frame || mono_jit_info_table_find (domain, frame->return_address)) {
- if (trace) {
- g_free (*trace);
- *trace = NULL;
- }
- return NULL;
- }
- }
- }
-
- //if (!lmf)
- //g_assert_not_reached ();
-
- if (trace) {
- g_free (*trace);
- *trace = NULL;
- }
-#endif
- return NULL;
}
-#endif
-
-/*
- * arch_get_restore_context:
- *
- * Returns a pointer to a method which restores a previously saved sigcontext.
- */
-static gpointer
-arch_get_restore_context (void)
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_get_call_filter */
+/* */
+/* Function - Return a pointer to a method which calls an */
+/* exception filter. We also use this function to */
+/* call finally handlers (we pass NULL as @exc */
+/* object in this case). */
+/* */
+/*------------------------------------------------------------------*/
+
+gpointer
+mono_arch_get_call_filter (void)
{
- static guint8 *start = NULL;
- guint8 *code;
-
- if (start)
- return start;
-
-#if 0
- /* restore_contect (struct sigcontext *ctx) */
- /* we do not restore X86_EAX, X86_EDX */
-
- start = code = g_malloc (1024);
-
- /* load ctx */
- x86_mov_reg_membase (code, X86_EAX, X86_ESP, 4, 4);
-
- /* get return address, stored in EDX */
- x86_mov_reg_membase (code, X86_EDX, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EIP), 4);
- /* restore EBX */
- x86_mov_reg_membase (code, X86_EBX, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EBX), 4);
- /* restore EDI */
- x86_mov_reg_membase (code, X86_EDI, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EDI), 4);
- /* restore ESI */
- x86_mov_reg_membase (code, X86_ESI, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_ESI), 4);
- /* restore ESP */
- x86_mov_reg_membase (code, X86_ESP, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_ESP), 4);
- /* restore EBP */
- x86_mov_reg_membase (code, X86_EBP, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EBP), 4);
-
- /* jump to the saved IP */
- x86_jump_reg (code, X86_EDX);
-
-#endif
- return start;
-}
-
-/*
- * arch_get_call_filter:
- *
- * Returns a pointer to a method which calls an exception filter. We
- * also use this function to call finally handlers (we pass NULL as
- * @exc object in this case).
- */
-static gpointer
-arch_get_call_filter (void)
-{
- static guint8 start [196];
+ static guint8 *start;
static int inited = 0;
guint8 *code;
int alloc_size, pos, i;
return start;
inited = 1;
- /* call_filter (struct sigcontext *ctx, unsigned long eip, gpointer exc) */
- code = start;
+ /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
+ code = start = mono_global_codeman_reserve (512);
- s390_lr (code, s390_r0, s390_r14);
- s390_st (code, s390_r0, 0, STK_BASE, S390_RET_ADDR_OFFSET);
- alloc_size = S390_MINIMAL_STACK_SIZE + (sizeof (gulong) * 16 + sizeof (gdouble) * 14);
- // align to S390_STACK_ALIGNMENT bytes
- if (alloc_size & (S390_STACK_ALIGNMENT - 1))
- alloc_size += S390_STACK_ALIGNMENT - (alloc_size & (S390_STACK_ALIGNMENT - 1));
- s390_st (code, STK_BASE, 0, STK_BASE, 0);
- s390_ahi (code, STK_BASE, -alloc_size);
- /* save all the regs on the stack */
- pos = S390_MINIMAL_STACK_SIZE;
- s390_stm (code, s390_r6, s390_r14, STK_BASE, pos);
- pos += sizeof (gulong) * 9;
- for (i = 0; i < 16; ++i) {
- s390_std (code, i, 0, STK_BASE, pos);
- pos += sizeof (gdouble);
- }
- /* FIXME: restore all the regs from ctx (in r3) */
- /* call handler at eip (r4) and set the first arg with the exception (r5) */
-
- /* restore all the regs from the stack */
- pos = S390_MINIMAL_STACK_SIZE;
- s390_lm (code, s390_r6, s390_r14, STK_BASE, pos);
- pos += sizeof (gulong) * 9;
+ s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
+ s390_lr (code, s390_r14, STK_BASE);
+ alloc_size = S390_ALIGN(S390_CALLFILTER_SIZE, S390_STACK_ALIGNMENT);
+ s390_ahi (code, STK_BASE, -alloc_size);
+ s390_st (code, s390_r14, 0, STK_BASE, 0);
+
+ /*------------------------------------------------------*/
+ /* save general registers on stack */
+ /*------------------------------------------------------*/
+ s390_stm (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
+
+ /*------------------------------------------------------*/
+ /* save floating point registers on stack */
+ /*------------------------------------------------------*/
+// pos = S390_CALLFILTER_FLTREGS;
+// for (i = 0; i < 16; ++i) {
+// s390_std (code, i, 0, STK_BASE, pos);
+// pos += sizeof (gdouble);
+// }
+
+ /*------------------------------------------------------*/
+ /* save access registers on stack */
+ /*------------------------------------------------------*/
+// s390_stam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
+
+ /*------------------------------------------------------*/
+ /* Get A(Context) */
+ /*------------------------------------------------------*/
+ s390_lr (code, s390_r13, s390_r2);
+
+ /*------------------------------------------------------*/
+ /* Get A(Handler Entry Point) */
+ /*------------------------------------------------------*/
+ s390_lr (code, s390_r0, s390_r3);
+
+ /*------------------------------------------------------*/
+ /* Set parameter register with Exception */
+ /*------------------------------------------------------*/
+ s390_lr (code, s390_r2, s390_r4);
+
+ /*------------------------------------------------------*/
+ /* Load all registers with values from the context */
+ /*------------------------------------------------------*/
+ s390_lm (code, s390_r3, s390_r12, s390_r13,
+ G_STRUCT_OFFSET(MonoContext, uc_mcontext.gregs[3]));
+ pos = G_STRUCT_OFFSET(MonoContext, uc_mcontext.fpregs.fprs[0]);
for (i = 0; i < 16; ++i) {
- s390_ld (code, i, 0,STK_BASE, pos);
- pos += sizeof (gdouble);
+ s390_ld (code, i, 0, s390_r13, pos);
+ pos += sizeof(gdouble);
}
- s390_l (code, s390_r14, 0, STK_BASE, alloc_size + S390_RET_ADDR_OFFSET);
- s390_ahi (code, STK_BASE, alloc_size);
-
- g_assert ((code - start) < sizeof(start));
+
+ /*------------------------------------------------------*/
+ /* Point at the copied stack frame and call the filter */
+ /*------------------------------------------------------*/
+ s390_lr (code, s390_r1, s390_r0);
+ s390_basr (code, s390_r14, s390_r1);
+
+ /*------------------------------------------------------*/
+ /* Save return value */
+ /*------------------------------------------------------*/
+ s390_lr (code, s390_r14, s390_r2);
+
+ /*------------------------------------------------------*/
+ /* Restore all the regs from the stack */
+ /*------------------------------------------------------*/
+ s390_lm (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
+// pos = S390_CALLFILTER_FLTREGS;
+// for (i = 0; i < 16; ++i) {
+// s390_ld (code, i, 0, STK_BASE, pos);
+// pos += sizeof (gdouble);
+// }
+
+ s390_lr (code, s390_r2, s390_r14);
+// s390_lam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
+ s390_ahi (code, s390_r15, alloc_size);
+ s390_lm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
+ s390_br (code, s390_r14);
+
+ g_assert ((code - start) < SZ_THROW);
return start;
}
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - throw_exception. */
+/* */
+/* Function - Raise an exception based on the parameters passed.*/
+/* */
+/*------------------------------------------------------------------*/
+
static void
-throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs)
+throw_exception (MonoObject *exc, unsigned long ip, unsigned long sp,
+ gulong *int_regs, gdouble *fp_regs, gulong *acc_regs,
+ guint fpc, gboolean rethrow)
{
- static void (*restore_context) (struct sigcontext *);
- struct sigcontext ctx;
- _sigregs ctxRegs;
+ MonoContext ctx;
int iReg;
- ctx.sregs = &ctxRegs;
+ memset(&ctx, 0, sizeof(ctx));
- if (!restore_context)
- restore_context = arch_get_restore_context ();
+ getcontext(&ctx);
/* adjust eip so that it point into the call instruction */
- eip -= 4;
+ ip -= 6;
for (iReg = 0; iReg < 16; iReg++) {
- ctx.sregs->regs.gprs[iReg] = int_regs[iReg];
- ctx.sregs->fpregs.fprs[iReg] = fp_regs[iReg];
- ctx.sregs->regs.acrs[iReg] = 0;
+ ctx.uc_mcontext.gregs[iReg] = int_regs[iReg];
+ ctx.uc_mcontext.fpregs.fprs[iReg].d = fp_regs[iReg];
+ ctx.uc_mcontext.aregs[iReg] = acc_regs[iReg];
}
- MONO_CONTEXT_SET_BP (&ctx, esp);
- MONO_CONTEXT_SET_IP (&ctx, eip);
+ ctx.uc_mcontext.fpregs.fpc = fpc;
+
+ MONO_CONTEXT_SET_BP (&ctx, sp);
+ MONO_CONTEXT_SET_IP (&ctx, ip);
+ if (mono_object_isinst (exc, mono_defaults.exception_class)) {
+ MonoException *mono_ex = (MonoException*)exc;
+ if (!rethrow)
+ mono_ex->stack_trace = NULL;
+ }
mono_arch_handle_exception (&ctx, exc, FALSE);
- restore_context (&ctx);
+ setcontext(&ctx);
g_assert_not_reached ();
}
-/**
- * arch_get_throw_exception_generic:
- *
- * 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);
- *
- */
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - get_throw_exception_generic */
+/* */
+/* Function - Return 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); */
+/* */
+/*------------------------------------------------------------------*/
+
static gpointer
-mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name)
+get_throw_exception_generic (guint8 *start, int size,
+ int by_name, gboolean rethrow)
{
guint8 *code;
int alloc_size, pos, i, offset;
code = start;
s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
- alloc_size = S390_MINIMAL_STACK_SIZE + (sizeof (gulong) * 16 + sizeof (gdouble) * 16);
- // align to S390_STACK_ALIGNMENT bytes
- if (alloc_size & (S390_STACK_ALIGNMENT - 1))
- alloc_size += S390_STACK_ALIGNMENT - (alloc_size & (S390_STACK_ALIGNMENT - 1));
+ alloc_size = S390_ALIGN(S390_THROWSTACK_SIZE, S390_STACK_ALIGNMENT);
s390_lr (code, s390_r14, STK_BASE);
s390_ahi (code, STK_BASE, -alloc_size);
s390_st (code, s390_r14, 0, STK_BASE, 0);
- //s390_break (code);
if (by_name) {
s390_lr (code, s390_r4, s390_r2);
s390_bras (code, s390_r13, 6);
offset = (guint32) S390_RELATIVE(mono_exception_from_name, code);
s390_brasl(code, s390_r14, offset);
}
- /* save the general registers on the stack */
- pos = S390_MINIMAL_STACK_SIZE;
- s390_stm (code, s390_r0, s390_r13, STK_BASE, pos);
- s390_l (code, s390_r1, 0, STK_BASE, 0);
- s390_lm (code, s390_r6, s390_r7, s390_r1, S390_RET_ADDR_OFFSET);
- s390_stm (code, s390_r6, s390_r7, STK_BASE, pos+(14*sizeof(gulong)));
- /* save the floating point registers */
- pos += sizeof (gulong) * 9;
+ /*------------------------------------------------------*/
+ /* save the general registers on the stack */
+ /*------------------------------------------------------*/
+ s390_stm (code, s390_r0, s390_r13, STK_BASE, S390_THROWSTACK_INTREGS);
+
+ s390_lr (code, s390_r1, STK_BASE);
+ s390_ahi (code, s390_r1, alloc_size);
+ /*------------------------------------------------------*/
+ /* save the return address in the parameter register */
+ /*------------------------------------------------------*/
+ s390_l (code, s390_r3, 0, s390_r1, S390_RET_ADDR_OFFSET);
+
+ /*------------------------------------------------------*/
+ /* save the floating point registers */
+ /*------------------------------------------------------*/
+ pos = S390_THROWSTACK_FLTREGS;
for (i = 0; i < 16; ++i) {
s390_std (code, i, 0,STK_BASE, pos);
pos += sizeof (gdouble);
}
- /* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
- /* exc is already in place in r2 */
- s390_lr (code, s390_r3, s390_r6); /* caller ip */
- s390_lr (code, s390_r4, s390_r1); /* caller sp */
- /* pointer to the saved int regs */
- pos = S390_MINIMAL_STACK_SIZE;
- s390_la (code, s390_r5, 0, STK_BASE, S390_MINIMAL_STACK_SIZE);
- s390_la (code, s390_r6, 0, s390_r5, (sizeof(gulong) * 14));
+ /*------------------------------------------------------*/
+ /* save the access registers */
+ /*------------------------------------------------------*/
+ s390_stam (code, s390_r0, s390_r15, STK_BASE, S390_THROWSTACK_ACCREGS);
+
+ /*------------------------------------------------------*/
+ /* call throw_exception (exc, ip, sp, gr, fr, ar) */
+ /* exc is already in place in r2 */
+ /*------------------------------------------------------*/
+ s390_lr (code, s390_r4, s390_r1); /* caller sp */
+ /*------------------------------------------------------*/
+ /* pointer to the saved int regs */
+ /*------------------------------------------------------*/
+ s390_la (code, s390_r5, 0, STK_BASE, S390_THROWSTACK_INTREGS);
+ s390_la (code, s390_r6, 0, STK_BASE, S390_THROWSTACK_FLTREGS);
+ s390_la (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCREGS);
+ s390_st (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCPRM);
+ s390_stfpc(code, STK_BASE, S390_THROWSTACK_FPCPRM);
+ s390_lhi (code, s390_r7, rethrow);
+ s390_st (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_RETHROW);
offset = (guint32) S390_RELATIVE(throw_exception, code);
s390_brasl(code, s390_r14, offset);
/* we should never reach this breakpoint */
return start;
}
-/**
- * arch_get_throw_exception:
- *
- * Returns a function pointer which can be used to raise
- * exceptions. The returned function has the following
- * signature: void (*func) (MonoException *exc);
- * For example to raise an arithmetic exception you can use:
- *
- * x86_push_imm (code, mono_get_exception_arithmetic ());
- * x86_call_code (code, arch_get_throw_exception ());
- *
- */
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - arch_get_throw_exception */
+/* */
+/* Function - Return a function pointer which can be used to */
+/* raise exceptions. The returned function has the */
+/* following signature: */
+/* void (*func) (MonoException *exc); */
+/* */
+/*------------------------------------------------------------------*/
+
gpointer
mono_arch_get_throw_exception (void)
{
- static guint8 start [128];
+ static guint8 *start;
static int inited = 0;
if (inited)
return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE);
+ start = mono_global_codeman_reserve (SZ_THROW);
+ get_throw_exception_generic (start, SZ_THROW, FALSE, FALSE);
inited = 1;
return start;
}
-/**
- * arch_get_throw_exception_by_name:
- *
- * Returns a function pointer which can be used to raise
- * corlib exceptions. The returned function has the following
- * signature: void (*func) (char *exc_name);
- * For example to raise an arithmetic exception you can use:
- *
- * x86_push_imm (code, "ArithmeticException");
- * x86_call_code (code, arch_get_throw_exception_by_name ());
- *
- */
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - arch_get_rethrow_exception */
+/* */
+/* Function - Return a function pointer which can be used to */
+/* raise exceptions. The returned function has the */
+/* following signature: */
+/* void (*func) (MonoException *exc); */
+/* */
+/*------------------------------------------------------------------*/
+
gpointer
-mono_arch_get_throw_exception_by_name (void)
+mono_arch_get_rethrow_exception (void)
{
- static guint8 start [160];
+ static guint8 *start;
static int inited = 0;
if (inited)
return start;
- mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE);
+ start = mono_global_codeman_reserve (SZ_THROW);
+ get_throw_exception_generic (start, SZ_THROW, FALSE, TRUE);
inited = 1;
return start;
-}
-
-static MonoArray *
-glist_to_array (GList *list)
-{
- MonoDomain *domain = mono_domain_get ();
- MonoArray *res;
- int len, i;
+}
- if (!list)
- return NULL;
+/*========================= End of Function ========================*/
- len = g_list_length (list);
- res = mono_array_new (domain, mono_defaults.int_class, len);
+/*------------------------------------------------------------------*/
+/* */
+/* Name - arch_get_throw_exception_by_name */
+/* */
+/* Function - Return a function pointer which can be used to */
+/* raise corlib exceptions. The return function has */
+/* the following signature: */
+/* void (*func) (char *exc_name); */
+/* */
+/*------------------------------------------------------------------*/
- for (i = 0; list; list = list->next, i++)
- mono_array_set (res, gpointer, i, list->data);
+gpointer
+mono_arch_get_throw_exception_by_name (void)
+{
+ static guint8 *start;
+ static int inited = 0;
- return res;
-}
+ if (inited)
+ return start;
+ start = mono_global_codeman_reserve (SZ_THROW);
+ get_throw_exception_generic (start, SZ_THROW, TRUE, FALSE);
+ inited = 1;
+ return start;
+}
-/* mono_arch_find_jit_info:
- *
- * 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.
- */
-static MonoJitInfo *
-mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoContext *ctx,
- MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset,
- gboolean *managed)
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_find_jit_info */
+/* */
+/* Function - This function is used to gather informatoin from */
+/* @ctx. It returns the MonoJitInfo of the corres- */
+/* ponding 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 returns the IP off- */
+/* set from the start of the function or -1 if that */
+/* informatoin is not available. */
+/* */
+/*------------------------------------------------------------------*/
+
+MonoJitInfo *
+mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
+ MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
+ MonoContext *new_ctx, char **trace, MonoLMF **lmf,
+ int *native_offset, gboolean *managed)
{
MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
- unsigned long *ptr;
- char *p;
MonoS390StackFrame *sframe;
- ji = mono_jit_info_table_find (domain, ip);
+ 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);
if (trace)
*trace = NULL;
if (ji != NULL) {
char *source_location, *tmpaddr, *fname;
gint32 address, iloffset;
- int offset;
*new_ctx = *ctx;
- if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
+ if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*lmf = (*lmf)->previous_lmf;
}
iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
if (iloffset < 0)
- tmpaddr = g_strdup_printf ("<0x%05x>", address);
+ tmpaddr = g_strdup_printf ("<0x%08x>", address);
else
- tmpaddr = g_strdup_printf ("[0x%05x]", iloffset);
+ tmpaddr = g_strdup_printf ("[0x%08x]", iloffset);
fname = mono_method_full_name (ji->method, TRUE);
g_free (source_location);
g_free (tmpaddr);
}
-#if 0
- offset = -1;
- /* restore caller saved registers */
- if (ji->used_regs & X86_EBX_MASK) {
- new_ctx->SC_EBX = *((int *)ctx->SC_EBP + offset);
- offset--;
- }
- if (ji->used_regs & X86_EDI_MASK) {
- new_ctx->SC_EDI = *((int *)ctx->SC_EBP + offset);
- offset--;
- }
- if (ji->used_regs & X86_ESI_MASK) {
- new_ctx->SC_ESI = *((int *)ctx->SC_EBP + offset);
- }
-
- new_ctx->SC_ESP = ctx->SC_EBP;
- /* we substract 1, so that the IP points into the call instruction */
- new_ctx->SC_EIP = *((int *)ctx->SC_EBP + 1) - 1;
- new_ctx->SC_EBP = *((int *)ctx->SC_EBP);
-#endif
- sframe = (MonoS390StackFrame*)MONO_CONTEXT_GET_BP (ctx);
- MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
- MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);
- *res = *ji;
- return res;
-#ifdef MONO_USE_EXC_TABLES
- } else if ((ji = s390_unwind_native_frame (domain, jit_tls, ctx, new_ctx, *lmf, trace))) {
- *res = *ji;
- return res;
-#endif
+ sframe = (MonoS390StackFrame *) MONO_CONTEXT_GET_SP (ctx);
+ MONO_CONTEXT_SET_BP (new_ctx, sframe->prev);
+ sframe = (MonoS390StackFrame *) sframe->prev;
+ MONO_CONTEXT_SET_IP (new_ctx, sframe->return_address);
+ memcpy (&new_ctx->uc_mcontext.gregs[6], sframe->regs, (8*sizeof(gint32)));
+ return ji;
} else if (*lmf) {
*new_ctx = *ctx;
*trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
- *res = *ji;
} else {
memset (res, 0, sizeof (MonoJitInfo));
res->method = (*lmf)->method;
}
-#if 0
- new_ctx->SC_ESI = (*lmf)->esi;
- new_ctx->SC_EDI = (*lmf)->edi;
- new_ctx->SC_EBX = (*lmf)->ebx;
- new_ctx->SC_EBP = (*lmf)->ebp;
- new_ctx->SC_EIP = (*lmf)->eip;
- /* the lmf is always stored on the stack, so the following
- * expression points to a stack location which can be used as ESP */
- new_ctx->SC_ESP = (unsigned long)&((*lmf)->eip);
-#endif
- sframe = (MonoS390StackFrame*)MONO_CONTEXT_GET_BP (ctx);
- MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
- MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);
+ memcpy(new_ctx->uc_mcontext.gregs, (*lmf)->gregs, sizeof((*lmf)->gregs));
+ memcpy(new_ctx->uc_mcontext.fpregs.fprs, (*lmf)->fregs, sizeof((*lmf)->fregs));
+
+ MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
+ MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
*lmf = (*lmf)->previous_lmf;
- return res;
-
+ return ji ? ji : res;
}
return NULL;
}
-MonoArray *
-ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
-{
- MonoDomain *domain = mono_domain_get ();
- MonoArray *res;
- MonoArray *ta = exc->trace_ips;
- int i, len;
-
- len = mono_array_length (ta);
-
- res = mono_array_new (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0);
-
- for (i = skip; i < len; i++) {
- MonoJitInfo *ji;
- MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
- gpointer ip = mono_array_get (ta, gpointer, i);
+/*========================= End of Function ========================*/
+
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_handle_exception */
+/* */
+/* Function - Handle an exception raised by the JIT code. */
+/* */
+/* Parameters - ctx - Saved processor state */
+/* obj - The exception object */
+/* test_only - Only test if the exception is caught, */
+/* but don't call handlers */
+/* */
+/*------------------------------------------------------------------*/
- ji = mono_jit_info_table_find (domain, ip);
- g_assert (ji != NULL);
-
- sf->method = mono_method_get_object (domain, ji->method, NULL);
- sf->native_offset = (char *)ip - (char *)ji->code_start;
-
- sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset, domain);
-
- if (need_file_info) {
- gchar *filename;
-
- filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line, domain);
-
- sf->filename = filename? mono_string_new (domain, filename): NULL;
- sf->column = 0;
-
- g_free (filename);
- }
-
- mono_array_set (res, gpointer, i, sf);
- }
-
- return res;
+gboolean
+mono_arch_handle_exception (void *uc, gpointer obj, gboolean test_only)
+{
+ return mono_handle_exception (uc, obj, mono_arch_ip_from_context(uc), test_only);
}
-void
-mono_jit_walk_stack (MonoStackWalk func, gpointer user_data) {
- MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoLMF *lmf = jit_tls->lmf;
- MonoJitInfo *ji, rji;
- gint native_offset, il_offset;
- gboolean managed;
- MonoS390StackFrame *sframe;
-
- MonoContext ctx, new_ctx;
-
- __asm__ volatile("l %0,0(15)" : "=r" (sframe));
-
- MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
- MONO_CONTEXT_SET_BP (&ctx, sframe->sp);
-
- while (MONO_CONTEXT_GET_BP (&ctx) < jit_tls->end_of_stack) {
-
- ji = mono_arch_find_jit_info (domain, jit_tls, &rji, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
- g_assert (ji);
-
- if (ji == (gpointer)-1)
- return;
-
- il_offset = mono_debug_il_offset_from_address (ji->method, native_offset, domain);
+/*========================= End of Function ========================*/
- if (func (ji->method, native_offset, il_offset, managed, user_data))
- return;
-
- ctx = new_ctx;
- }
-}
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_ip_from_context */
+/* */
+/* Function - Return the instruction pointer from the context. */
+/* */
+/* Parameters - sigctx - Saved processor state */
+/* */
+/*------------------------------------------------------------------*/
-MonoBoolean
-ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
- MonoReflectionMethod **method,
- gint32 *iloffset, gint32 *native_offset,
- MonoString **file, gint32 *line, gint32 *column)
+gpointer
+mono_arch_ip_from_context (void *sigctx)
{
- MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoLMF *lmf = jit_tls->lmf;
- MonoJitInfo *ji, rji;
- MonoContext ctx, new_ctx;
-
- MONO_CONTEXT_SET_IP (&ctx, ves_icall_get_frame_info);
- MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (0));
-
- skip++;
-
- do {
- ji = mono_arch_find_jit_info (domain, jit_tls, &rji, &ctx, &new_ctx, NULL, &lmf, native_offset, NULL);
-
- ctx = new_ctx;
-
- if (!ji || ji == (gpointer)-1 || MONO_CONTEXT_GET_BP (&ctx) >= jit_tls->end_of_stack)
- return FALSE;
-
- /* skip all wrappers ??*/
- if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
- ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
- ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE)
- continue;
+ return context_get_ip (sigctx);
+}
- skip--;
- } while (skip >= 0);
+/*========================= End of Function ========================*/
- *method = mono_method_get_object (domain, ji->method, NULL);
- *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain);
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_get_restore_context */
+/* */
+/* Function - Return the address of the routine that will rest- */
+/* ore the context. */
+/* */
+/*------------------------------------------------------------------*/
- if (need_file_info) {
- gchar *filename;
+gpointer
+mono_arch_get_restore_context ()
+{
+ return setcontext;
+}
- filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain);
- *file = filename? mono_string_new (domain, filename): NULL;
- *column = 0;
+/*========================= End of Function ========================*/
- g_free (filename);
- }
+/*------------------------------------------------------------------*/
+/* */
+/* Name - mono_arch_is_int_overflow */
+/* */
+/* Function - Inspect the code that raised the SIGFPE signal */
+/* to see if the DivideByZero or Arithmetic exception*/
+/* should be raised. */
+/* */
+/*------------------------------------------------------------------*/
- return TRUE;
-}
-
-/**
- * arch_handle_exception:
- * @ctx: saved processor state
- * @obj: the exception object
- * @test_only: only test if the exception is caught, but dont call handlers
- *
- *
- */
gboolean
-mono_arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only)
+mono_arch_is_int_overflow (void *uc, void *info)
{
- MonoDomain *domain = mono_domain_get ();
- MonoJitInfo *ji, rji;
- static int (*call_filter) (MonoContext *, gpointer, gpointer) = NULL;
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoLMF *lmf = jit_tls->lmf;
- GList *trace_ips = NULL;
- MonoException *mono_ex;
- MonoString *initial_stack_trace;
-
- g_assert (ctx != NULL);
- if (!obj) {
- MonoException *ex = mono_get_exception_null_reference ();
- ex->message = mono_string_new (domain,
- "Object reference not set to an instance of an object");
- obj = (MonoObject *)ex;
- }
-
- if (mono_object_isinst (obj, mono_defaults.exception_class)) {
- mono_ex = (MonoException*)obj;
- initial_stack_trace = mono_ex->stack_trace;
- } else {
- mono_ex = NULL;
- }
-
-
- if (!call_filter)
- call_filter = arch_get_call_filter ();
-
- g_assert (jit_tls->end_of_stack);
- g_assert (jit_tls->abort_func);
-
- if (!test_only) {
- MonoContext ctx_cp = *ctx;
- if (mono_jit_trace_calls != NULL)
- g_print ("EXCEPTION handling: %s\n", mono_object_class (obj)->name);
- if (!mono_arch_handle_exception (&ctx_cp, obj, TRUE)) {
- if (mono_break_on_exc)
- G_BREAKPOINT ();
- mono_unhandled_exception (obj);
- }
- }
-
- while (1) {
- MonoContext new_ctx;
- char *trace = NULL;
-
- ji = mono_arch_find_jit_info (domain, jit_tls, &rji, ctx, &new_ctx,
- test_only ? &trace : NULL, &lmf, NULL, NULL);
- if (!ji) {
- g_warning ("Exception inside function without unwind info");
- g_assert_not_reached ();
- }
-
- if (ji != (gpointer)-1) {
-
- if (test_only && ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
- char *tmp, *strace;
-
- if (!initial_stack_trace) {
- trace_ips = g_list_append (trace_ips, MONO_CONTEXT_GET_IP (ctx));
-
- if (!mono_ex->stack_trace)
- strace = g_strdup ("");
- else
- strace = mono_string_to_utf8 (mono_ex->stack_trace);
-
- tmp = g_strdup_printf ("%s%s\n", strace, trace);
- g_free (strace);
-
- mono_ex->stack_trace = mono_string_new (domain, tmp);
-
- g_free (tmp);
- }
- }
-
- if (ji->num_clauses) {
- int i;
-
- g_assert (ji->clauses);
-
- for (i = 0; i < ji->num_clauses; i++) {
- MonoJitExceptionInfo *ei = &ji->clauses [i];
-
- if (ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
- MONO_CONTEXT_GET_IP (ctx) <= ei->try_end) {
- /* catch block */
- if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
- mono_object_isinst (obj, mono_class_get (ji->method->klass->image, ei->data.token))) ||
- ((ei->flags == MONO_EXCEPTION_CLAUSE_FILTER &&
- call_filter (ctx, ei->data.filter, obj)))) {
- if (test_only) {
- if (mono_ex)
- mono_ex->trace_ips = glist_to_array (trace_ips);
- g_list_free (trace_ips);
- g_free (trace);
- return TRUE;
- }
- if (mono_jit_trace_calls != NULL)
- g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
- MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
- *((gpointer *)((char *)MONO_CONTEXT_GET_BP (ctx) + ji->exvar_offset)) = obj;
- jit_tls->lmf = lmf;
- g_free (trace);
- return 0;
- }
- 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);
- }
-
- }
- }
+ MonoContext *ctx;
+ guint8 *code;
+ guint32 *operand;
+ gboolean arithExc = TRUE;
+ gint regNo,
+ offset;
+
+ ctx = (MonoContext *) uc;
+ code = (guint8 *) ((siginfo_t *)info)->si_addr;
+ /*----------------------------------------------------------*/
+ /* Divide operations are the only ones that will give the */
+ /* divide by zero exception so just check for these ops. */
+ /*----------------------------------------------------------*/
+ switch (code[0]) {
+ case 0x1d : /* Divide Register */
+ regNo = code[1] & 0x0f;
+ if (ctx->uc_mcontext.gregs[regNo] == 0)
+ arithExc = FALSE;
+ break;
+ case 0x5d : /* Divide */
+ regNo = (code[2] & 0xf0 >> 8);
+ offset = *((guint16 *) code+2) & 0x0fff;
+ operand = ctx->uc_mcontext.gregs[regNo] + offset;
+ if (*operand == 0)
+ arithExc = FALSE;
+ break;
+ case 0xb9 : /* Divide logical Register? */
+ if (code[1] == 0x97) {
+ regNo = (code[2] & 0xf0 >> 8);
+ if (ctx->uc_mcontext.gregs[regNo] == 0)
+ arithExc = FALSE;
}
- }
-
- g_free (trace);
-
- *ctx = new_ctx;
-
- if ((ji == (gpointer)-1) || MONO_CONTEXT_GET_BP (ctx) >= jit_tls->end_of_stack) {
- if (!test_only) {
- jit_tls->lmf = lmf;
- jit_tls->abort_func (obj);
- g_assert_not_reached ();
- } else {
- if (mono_ex)
- mono_ex->trace_ips = glist_to_array (trace_ips);
- g_list_free (trace_ips);
- return FALSE;
+ break;
+ case 0xe3 : /* Divide logical? */
+ if (code[1] == 0x97) {
+ regNo = (code[2] & 0xf0 >> 8);
+ offset = *((guint32 *) code+1) & 0x000fffff;
+ operand = ctx->uc_mcontext.gregs[regNo] + offset;
+ if (*operand == 0)
+ arithExc = FALSE;
}
- }
+ break;
+ default:
+ arithExc = TRUE;
}
-
- g_assert_not_reached ();
-}
-
-gboolean
-mono_arch_has_unwind_info (gconstpointer addr)
-{
- return FALSE;
+ ctx->uc_mcontext.psw.addr = code;
+ return (arithExc);
}
+/*========================= End of Function ========================*/
projects / mono.git / blobdiff