1 /*------------------------------------------------------------------*/
3 /* Name - exceptions-s390.c */
5 /* Function - Exception support for S/390. */
7 /* Name - Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com) */
9 /* Date - January, 2004 */
11 /* Derivation - From exceptions-x86 & exceptions-ppc */
12 /* Paolo Molaro (lupus@ximian.com) */
13 /* Dietmar Maurer (dietmar@ximian.com) */
15 /* Copyright - 2001 Ximian, Inc. */
17 /*------------------------------------------------------------------*/
19 /*------------------------------------------------------------------*/
21 /*------------------------------------------------------------------*/
23 #define S390_CALLFILTER_INTREGS S390_MINIMAL_STACK_SIZE
24 #define S390_CALLFILTER_FLTREGS S390_CALLFILTER_INTREGS+(16*sizeof(gulong))
25 #define S390_CALLFILTER_ACCREGS S390_CALLFILTER_FLTREGS+(16*sizeof(gdouble))
26 #define S390_CALLFILTER_SIZE (S390_CALLFILTER_ACCREGS+(16*sizeof(gulong)))
28 #define S390_THROWSTACK_ACCPRM S390_MINIMAL_STACK_SIZE
29 #define S390_THROWSTACK_FPCPRM S390_THROWSTACK_ACCPRM+sizeof(gpointer)
30 #define S390_THROWSTACK_RETHROW S390_THROWSTACK_FPCPRM+sizeof(gulong)
31 #define S390_THROWSTACK_INTREGS S390_THROWSTACK_RETHROW+sizeof(gboolean)
32 #define S390_THROWSTACK_FLTREGS S390_THROWSTACK_INTREGS+(16*sizeof(gulong))
33 #define S390_THROWSTACK_ACCREGS S390_THROWSTACK_FLTREGS+(16*sizeof(gdouble))
34 #define S390_THROWSTACK_SIZE (S390_THROWSTACK_ACCREGS+(16*sizeof(gulong)))
38 /*========================= End of Defines =========================*/
40 /*------------------------------------------------------------------*/
42 /*------------------------------------------------------------------*/
50 #include <mono/arch/s390/s390-codegen.h>
51 #include <mono/metadata/appdomain.h>
52 #include <mono/metadata/tabledefs.h>
53 #include <mono/metadata/threads.h>
54 #include <mono/metadata/debug-helpers.h>
55 #include <mono/metadata/exception.h>
56 #include <mono/metadata/mono-debug.h>
59 #include "mini-s390.h"
61 /*========================= End of Includes ========================*/
63 /*------------------------------------------------------------------*/
64 /* P r o t o t y p e s */
65 /*------------------------------------------------------------------*/
67 gboolean mono_arch_handle_exception (void *ctx,
71 /*========================= End of Prototypes ======================*/
73 /*------------------------------------------------------------------*/
74 /* G l o b a l V a r i a b l e s */
75 /*------------------------------------------------------------------*/
77 /*====================== End of Global Variables ===================*/
79 /*------------------------------------------------------------------*/
81 /* Name - mono_arch_has_unwind_info */
83 /* Function - Tests if a function has a DWARF exception table */
84 /* that is able to restore all caller saved registers*/
86 /*------------------------------------------------------------------*/
89 mono_arch_has_unwind_info (gconstpointer addr)
94 /*========================= End of Function ========================*/
96 /*------------------------------------------------------------------*/
98 /* Name - mono_arch_get_call_filter */
100 /* Function - Return a pointer to a method which calls an */
101 /* exception filter. We also use this function to */
102 /* call finally handlers (we pass NULL as @exc */
103 /* object in this case). */
105 /*------------------------------------------------------------------*/
108 mono_arch_get_call_filter (void)
110 static guint8 *start;
111 static int inited = 0;
113 int alloc_size, pos, i;
119 /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
120 code = start = mono_global_codeman_reserve (512);
122 s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
123 s390_lr (code, s390_r14, STK_BASE);
124 alloc_size = S390_ALIGN(S390_CALLFILTER_SIZE, S390_STACK_ALIGNMENT);
125 s390_ahi (code, STK_BASE, -alloc_size);
126 s390_st (code, s390_r14, 0, STK_BASE, 0);
128 /*------------------------------------------------------*/
129 /* save general registers on stack */
130 /*------------------------------------------------------*/
131 s390_stm (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
133 /*------------------------------------------------------*/
134 /* save floating point registers on stack */
135 /*------------------------------------------------------*/
136 // pos = S390_CALLFILTER_FLTREGS;
137 // for (i = 0; i < 16; ++i) {
138 // s390_std (code, i, 0, STK_BASE, pos);
139 // pos += sizeof (gdouble);
142 /*------------------------------------------------------*/
143 /* save access registers on stack */
144 /*------------------------------------------------------*/
145 // s390_stam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
147 /*------------------------------------------------------*/
149 /*------------------------------------------------------*/
150 s390_lr (code, s390_r13, s390_r2);
152 /*------------------------------------------------------*/
153 /* Get A(Handler Entry Point) */
154 /*------------------------------------------------------*/
155 s390_lr (code, s390_r0, s390_r3);
157 /*------------------------------------------------------*/
158 /* Set parameter register with Exception */
159 /*------------------------------------------------------*/
160 s390_lr (code, s390_r2, s390_r4);
162 /*------------------------------------------------------*/
163 /* Load all registers with values from the context */
164 /*------------------------------------------------------*/
165 s390_lm (code, s390_r3, s390_r12, s390_r13,
166 G_STRUCT_OFFSET(MonoContext, uc_mcontext.gregs[3]));
167 pos = G_STRUCT_OFFSET(MonoContext, uc_mcontext.fpregs.fprs[0]);
168 for (i = 0; i < 16; ++i) {
169 s390_ld (code, i, 0, s390_r13, pos);
170 pos += sizeof(gdouble);
173 /*------------------------------------------------------*/
174 /* Point at the copied stack frame and call the filter */
175 /*------------------------------------------------------*/
176 s390_lr (code, s390_r1, s390_r0);
177 s390_basr (code, s390_r14, s390_r1);
179 /*------------------------------------------------------*/
180 /* Save return value */
181 /*------------------------------------------------------*/
182 s390_lr (code, s390_r14, s390_r2);
184 /*------------------------------------------------------*/
185 /* Restore all the regs from the stack */
186 /*------------------------------------------------------*/
187 s390_lm (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
188 // pos = S390_CALLFILTER_FLTREGS;
189 // for (i = 0; i < 16; ++i) {
190 // s390_ld (code, i, 0, STK_BASE, pos);
191 // pos += sizeof (gdouble);
194 s390_lr (code, s390_r2, s390_r14);
195 // s390_lam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
196 s390_ahi (code, s390_r15, alloc_size);
197 s390_lm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
198 s390_br (code, s390_r14);
200 g_assert ((code - start) < SZ_THROW);
204 /*========================= End of Function ========================*/
206 /*------------------------------------------------------------------*/
208 /* Name - throw_exception. */
210 /* Function - Raise an exception based on the parameters passed.*/
212 /*------------------------------------------------------------------*/
215 throw_exception (MonoObject *exc, unsigned long ip, unsigned long sp,
216 gulong *int_regs, gdouble *fp_regs, gulong *acc_regs,
217 guint fpc, gboolean rethrow)
222 memset(&ctx, 0, sizeof(ctx));
226 /* adjust eip so that it point into the call instruction */
229 for (iReg = 0; iReg < 16; iReg++) {
230 ctx.uc_mcontext.gregs[iReg] = int_regs[iReg];
231 ctx.uc_mcontext.fpregs.fprs[iReg].d = fp_regs[iReg];
232 ctx.uc_mcontext.aregs[iReg] = acc_regs[iReg];
235 ctx.uc_mcontext.fpregs.fpc = fpc;
237 MONO_CONTEXT_SET_BP (&ctx, sp);
238 MONO_CONTEXT_SET_IP (&ctx, ip);
240 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
241 MonoException *mono_ex = (MonoException*)exc;
243 mono_ex->stack_trace = NULL;
245 mono_arch_handle_exception (&ctx, exc, FALSE);
248 g_assert_not_reached ();
251 /*========================= End of Function ========================*/
253 /*------------------------------------------------------------------*/
255 /* Name - get_throw_exception_generic */
257 /* Function - Return a function pointer which can be used to */
258 /* raise exceptions. The returned function has the */
259 /* following signature: */
260 /* void (*func) (MonoException *exc); or, */
261 /* void (*func) (char *exc_name); */
263 /*------------------------------------------------------------------*/
266 get_throw_exception_generic (guint8 *start, int size,
267 int by_name, gboolean rethrow)
270 int alloc_size, pos, i, offset;
274 s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
275 alloc_size = S390_ALIGN(S390_THROWSTACK_SIZE, S390_STACK_ALIGNMENT);
276 s390_lr (code, s390_r14, STK_BASE);
277 s390_ahi (code, STK_BASE, -alloc_size);
278 s390_st (code, s390_r14, 0, STK_BASE, 0);
280 s390_lr (code, s390_r4, s390_r2);
281 s390_bras (code, s390_r13, 6);
282 s390_word (code, mono_defaults.corlib);
283 s390_word (code, "System");
284 s390_l (code, s390_r2, 0, s390_r13, 0);
285 s390_l (code, s390_r3, 0, s390_r13, 4);
286 offset = (guint32) S390_RELATIVE(mono_exception_from_name, code);
287 s390_brasl(code, s390_r14, offset);
289 /*------------------------------------------------------*/
290 /* save the general registers on the stack */
291 /*------------------------------------------------------*/
292 s390_stm (code, s390_r0, s390_r13, STK_BASE, S390_THROWSTACK_INTREGS);
294 s390_lr (code, s390_r1, STK_BASE);
295 s390_ahi (code, s390_r1, alloc_size);
296 /*------------------------------------------------------*/
297 /* save the return address in the parameter register */
298 /*------------------------------------------------------*/
299 s390_l (code, s390_r3, 0, s390_r1, S390_RET_ADDR_OFFSET);
301 /*------------------------------------------------------*/
302 /* save the floating point registers */
303 /*------------------------------------------------------*/
304 pos = S390_THROWSTACK_FLTREGS;
305 for (i = 0; i < 16; ++i) {
306 s390_std (code, i, 0,STK_BASE, pos);
307 pos += sizeof (gdouble);
309 /*------------------------------------------------------*/
310 /* save the access registers */
311 /*------------------------------------------------------*/
312 s390_stam (code, s390_r0, s390_r15, STK_BASE, S390_THROWSTACK_ACCREGS);
314 /*------------------------------------------------------*/
315 /* call throw_exception (exc, ip, sp, gr, fr, ar) */
316 /* exc is already in place in r2 */
317 /*------------------------------------------------------*/
318 s390_lr (code, s390_r4, s390_r1); /* caller sp */
319 /*------------------------------------------------------*/
320 /* pointer to the saved int regs */
321 /*------------------------------------------------------*/
322 s390_la (code, s390_r5, 0, STK_BASE, S390_THROWSTACK_INTREGS);
323 s390_la (code, s390_r6, 0, STK_BASE, S390_THROWSTACK_FLTREGS);
324 s390_la (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCREGS);
325 s390_st (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCPRM);
326 s390_stfpc(code, STK_BASE, S390_THROWSTACK_FPCPRM);
327 s390_lhi (code, s390_r7, rethrow);
328 s390_st (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_RETHROW);
329 offset = (guint32) S390_RELATIVE(throw_exception, code);
330 s390_brasl(code, s390_r14, offset);
331 /* we should never reach this breakpoint */
333 g_assert ((code - start) < size);
337 /*========================= End of Function ========================*/
339 /*------------------------------------------------------------------*/
341 /* Name - arch_get_throw_exception */
343 /* Function - Return a function pointer which can be used to */
344 /* raise exceptions. The returned function has the */
345 /* following signature: */
346 /* void (*func) (MonoException *exc); */
348 /*------------------------------------------------------------------*/
351 mono_arch_get_throw_exception (void)
353 static guint8 *start;
354 static int inited = 0;
358 start = mono_global_codeman_reserve (SZ_THROW);
359 get_throw_exception_generic (start, SZ_THROW, FALSE, FALSE);
364 /*========================= End of Function ========================*/
366 /*------------------------------------------------------------------*/
368 /* Name - arch_get_rethrow_exception */
370 /* Function - Return a function pointer which can be used to */
371 /* raise exceptions. The returned function has the */
372 /* following signature: */
373 /* void (*func) (MonoException *exc); */
375 /*------------------------------------------------------------------*/
378 mono_arch_get_rethrow_exception (void)
380 static guint8 *start;
381 static int inited = 0;
385 start = mono_global_codeman_reserve (SZ_THROW);
386 get_throw_exception_generic (start, SZ_THROW, FALSE, TRUE);
391 /*========================= End of Function ========================*/
393 /*------------------------------------------------------------------*/
395 /* Name - arch_get_throw_exception_by_name */
397 /* Function - Return a function pointer which can be used to */
398 /* raise corlib exceptions. The return function has */
399 /* the following signature: */
400 /* void (*func) (char *exc_name); */
402 /*------------------------------------------------------------------*/
405 mono_arch_get_throw_exception_by_name (void)
407 static guint8 *start;
408 static int inited = 0;
412 start = mono_global_codeman_reserve (SZ_THROW);
413 get_throw_exception_generic (start, SZ_THROW, TRUE, FALSE);
418 /*========================= End of Function ========================*/
420 /*------------------------------------------------------------------*/
422 /* Name - mono_arch_find_jit_info */
424 /* Function - This function is used to gather informatoin from */
425 /* @ctx. It returns the MonoJitInfo of the corres- */
426 /* ponding function, unwinds one stack frame and */
427 /* stores the resulting context into @new_ctx. It */
428 /* also stores a string describing the stack location*/
429 /* into @trace (if not NULL), and modifies the @lmf */
430 /* if necessary. @native_offset returns the IP off- */
431 /* set from the start of the function or -1 if that */
432 /* informatoin is not available. */
434 /*------------------------------------------------------------------*/
437 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
438 MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
439 MonoContext *new_ctx, char **trace, MonoLMF **lmf,
440 int *native_offset, gboolean *managed)
443 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
444 MonoS390StackFrame *sframe;
447 (ip >= prev_ji->code_start &&
448 ((guint8 *) ip <= ((guint8 *) prev_ji->code_start) + prev_ji->code_size)))
451 ji = mono_jit_info_table_find (domain, ip);
463 char *source_location, *tmpaddr, *fname;
464 gint32 address, iloffset;
468 if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
469 /* remove any unused lmf */
470 *lmf = (*lmf)->previous_lmf;
473 address = (char *)ip - (char *)ji->code_start;
476 *native_offset = address;
479 if (!ji->method->wrapper_type)
483 source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain);
484 iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
487 tmpaddr = g_strdup_printf ("<0x%08x>", address);
489 tmpaddr = g_strdup_printf ("[0x%08x]", iloffset);
491 fname = mono_method_full_name (ji->method, TRUE);
494 *trace = g_strdup_printf ("in %s (at %s) %s", tmpaddr, source_location, fname);
496 *trace = g_strdup_printf ("in %s %s", tmpaddr, fname);
499 g_free (source_location);
502 sframe = (MonoS390StackFrame *) MONO_CONTEXT_GET_SP (ctx);
503 MONO_CONTEXT_SET_BP (new_ctx, sframe->prev);
504 sframe = (MonoS390StackFrame *) sframe->prev;
505 MONO_CONTEXT_SET_IP (new_ctx, sframe->return_address);
506 memcpy (&new_ctx->uc_mcontext.gregs[6], sframe->regs, (8*sizeof(gint32)));
516 *trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
518 if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
520 memset (res, 0, sizeof (MonoJitInfo));
521 res->method = (*lmf)->method;
524 memcpy(new_ctx->uc_mcontext.gregs, (*lmf)->gregs, sizeof((*lmf)->gregs));
525 memcpy(new_ctx->uc_mcontext.fpregs.fprs, (*lmf)->fregs, sizeof((*lmf)->fregs));
527 MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
528 MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
529 *lmf = (*lmf)->previous_lmf;
531 return ji ? ji : res;
537 /*========================= End of Function ========================*/
539 /*------------------------------------------------------------------*/
541 /* Name - mono_arch_handle_exception */
543 /* Function - Handle an exception raised by the JIT code. */
545 /* Parameters - ctx - Saved processor state */
546 /* obj - The exception object */
547 /* test_only - Only test if the exception is caught, */
548 /* but don't call handlers */
550 /*------------------------------------------------------------------*/
553 mono_arch_handle_exception (void *uc, gpointer obj, gboolean test_only)
555 return mono_handle_exception (uc, obj, mono_arch_ip_from_context(uc), test_only);
558 /*========================= End of Function ========================*/
560 /*------------------------------------------------------------------*/
562 /* Name - mono_arch_ip_from_context */
564 /* Function - Return the instruction pointer from the context. */
566 /* Parameters - sigctx - Saved processor state */
568 /*------------------------------------------------------------------*/
571 mono_arch_ip_from_context (void *sigctx)
573 return context_get_ip (sigctx);
577 /*========================= End of Function ========================*/
579 /*------------------------------------------------------------------*/
581 /* Name - mono_arch_get_restore_context */
583 /* Function - Return the address of the routine that will rest- */
584 /* ore the context. */
586 /*------------------------------------------------------------------*/
589 mono_arch_get_restore_context ()
595 /*========================= End of Function ========================*/
597 /*------------------------------------------------------------------*/
599 /* Name - mono_arch_is_int_overflow */
601 /* Function - Inspect the code that raised the SIGFPE signal */
602 /* to see if the DivideByZero or Arithmetic exception*/
603 /* should be raised. */
605 /*------------------------------------------------------------------*/
608 mono_arch_is_int_overflow (void *uc, void *info)
613 gboolean arithExc = TRUE;
617 ctx = (MonoContext *) uc;
618 code = (guint8 *) ((siginfo_t *)info)->si_addr;
619 /*----------------------------------------------------------*/
620 /* Divide operations are the only ones that will give the */
621 /* divide by zero exception so just check for these ops. */
622 /*----------------------------------------------------------*/
624 case 0x1d : /* Divide Register */
625 regNo = code[1] & 0x0f;
626 if (ctx->uc_mcontext.gregs[regNo] == 0)
629 case 0x5d : /* Divide */
630 regNo = (code[2] & 0xf0 >> 8);
631 offset = *((guint16 *) code+2) & 0x0fff;
632 operand = (guint32*)(ctx->uc_mcontext.gregs[regNo] + offset);
636 case 0xb9 : /* Divide logical Register? */
637 if (code[1] == 0x97) {
638 regNo = (code[2] & 0xf0 >> 8);
639 if (ctx->uc_mcontext.gregs[regNo] == 0)
643 case 0xe3 : /* Divide logical? */
644 if (code[1] == 0x97) {
645 regNo = (code[2] & 0xf0 >> 8);
646 offset = *((guint32 *) code+1) & 0x000fffff;
647 operand = (guint32*)(ctx->uc_mcontext.gregs[regNo] + offset);
655 ctx->uc_mcontext.psw.addr = (guint32)code;
659 /*========================= End of Function ========================*/