X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fexceptions-s390.c;h=1aad39a1b33a70247bf2eb456682d3e336cc4cb0;hb=6644c191b8292d9a07227f182be9ce689c1848e2;hp=bbd328e4d9fb6187b83edfb35dee8f5c69383a7b;hpb=bd13a9521bd74949d45fdfe98b1c02e8d73e1ceb;p=mono.git diff --git a/mono/mini/exceptions-s390.c b/mono/mini/exceptions-s390.c index bbd328e4d9f..1aad39a1b33 100644 --- a/mono/mini/exceptions-s390.c +++ b/mono/mini/exceptions-s390.c @@ -1,18 +1,51 @@ -/* - * 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 #include #include #include +#include #include #include @@ -25,406 +58,56 @@ #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 +/*========================= 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) { - 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) -{ - 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; @@ -433,85 +116,155 @@ arch_get_call_filter (void) 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; @@ -519,14 +272,10 @@ mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name) 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); @@ -537,26 +286,46 @@ mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name) 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 */ @@ -565,96 +334,121 @@ mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name) 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; @@ -666,13 +460,11 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf *managed = FALSE; if (ji != NULL) { - char *source_location, *tmpaddr, *fname; - gint32 address, iloffset; - int offset; + gint32 address; *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; } @@ -686,56 +478,12 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf if (!ji->method->wrapper_type) *managed = TRUE; - if (trace) { - source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain); - iloffset = mono_debug_il_offset_from_address (ji->method, address, domain); - - if (iloffset < 0) - tmpaddr = g_strdup_printf ("<0x%05x>", address); - else - tmpaddr = g_strdup_printf ("[0x%05x]", iloffset); - - fname = mono_method_full_name (ji->method, TRUE); - - if (source_location) - *trace = g_strdup_printf ("in %s (at %s) %s", tmpaddr, source_location, fname); - else - *trace = g_strdup_printf ("in %s %s", tmpaddr, fname); - - g_free (fname); - 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; @@ -743,316 +491,145 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf if (!(*lmf)->method) return (gpointer)-1; - if (trace) - *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); +/*========================= 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 */ +/* */ +/*------------------------------------------------------------------*/ - 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); - - 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; +/*========================= End of Function ========================*/ - il_offset = mono_debug_il_offset_from_address (ji->method, native_offset, domain); +/*------------------------------------------------------------------*/ +/* */ +/* Name - mono_arch_ip_from_context */ +/* */ +/* Function - Return the instruction pointer from the context. */ +/* */ +/* Parameters - sigctx - Saved processor state */ +/* */ +/*------------------------------------------------------------------*/ - if (func (ji->method, native_offset, il_offset, managed, user_data)) - return; - - ctx = new_ctx; - } -} - -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; - - skip--; + return context_get_ip (sigctx); +} - } while (skip >= 0); - *method = mono_method_get_object (domain, ji->method, NULL); - *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain); +/*========================= End of Function ========================*/ - if (need_file_info) { - gchar *filename; +/*------------------------------------------------------------------*/ +/* */ +/* Name - mono_arch_get_restore_context */ +/* */ +/* Function - Return the address of the routine that will rest- */ +/* ore the context. */ +/* */ +/*------------------------------------------------------------------*/ - filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain); +gpointer +mono_arch_get_restore_context () +{ + return setcontext; +} - *file = filename? mono_string_new (domain, filename): NULL; - *column = 0; - g_free (filename); - } +/*========================= End of Function ========================*/ - return TRUE; -} +/*------------------------------------------------------------------*/ +/* */ +/* 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. */ +/* */ +/*------------------------------------------------------------------*/ -/** - * 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; - - 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; - mono_ex->stack_trace = NULL; - } 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; - - 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 = (guint32*)(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 = (guint32*)(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 = (guint32)code; + return (arithExc); } +/*========================= End of Function ========================*/