?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #444 from knocte/xbuild_improvements
[mono-project.git] / mono / mini / exceptions-s390x.c
blobc46265b7fe45818adcf2a739abf8958b35d5ea70
1 /*------------------------------------------------------------------*/
2 /* */
3 /* Name - exceptions-s390.c */
4 /* */
5 /* Function - Exception support for S/390. */
6 /* */
7 /* Name - Neale Ferguson (Neale.Ferguson@SoftwareAG-usa.com) */
8 /* */
9 /* Date - January, 2004 */
10 /* */
11 /* Derivation - From exceptions-x86 & exceptions-ppc */
12 /* Paolo Molaro (lupus@ximian.com) */
13 /* Dietmar Maurer (dietmar@ximian.com) */
14 /* */
15 /* Copyright - 2001 Ximian, Inc. */
16 /* */
17 /*------------------------------------------------------------------*/
18
19 /*------------------------------------------------------------------*/
20 /* D e f i n e s */
21 /*------------------------------------------------------------------*/
22
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(gint32)))
27
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(gint32)))
35
36 #define S390_REG_SAVE_R13 (S390_REG_SAVE_OFFSET+(7*sizeof(gulong)))
37
38 #define SZ_THROW 384
39
40 #define setup_context(ctx)
41
42 /*========================= End of Defines =========================*/
43
44 /*------------------------------------------------------------------*/
45 /* I n c l u d e s */
46 /*------------------------------------------------------------------*/
47
48 #include <config.h>
49 #include <glib.h>
50 #include <signal.h>
51 #include <string.h>
52 #include <ucontext.h>
53
54 #include <mono/arch/s390x/s390x-codegen.h>
55 #include <mono/metadata/appdomain.h>
56 #include <mono/metadata/tabledefs.h>
57 #include <mono/metadata/threads.h>
58 #include <mono/metadata/debug-helpers.h>
59 #include <mono/metadata/exception.h>
60 #include <mono/metadata/mono-debug.h>
61
62 #include "mini.h"
63 #include "mini-s390x.h"
64
65 /*========================= End of Includes ========================*/
66
67 /*------------------------------------------------------------------*/
68 /* P r o t o t y p e s */
69 /*------------------------------------------------------------------*/
70
71 gboolean mono_arch_handle_exception (void *ctx,
72 gpointer obj);
73
74 /*========================= End of Prototypes ======================*/
75
76 /*------------------------------------------------------------------*/
77 /* G l o b a l V a r i a b l e s */
78 /*------------------------------------------------------------------*/
79
80 typedef enum {
81 by_none,
82 by_token
83 } throwType;
84
85 /*====================== End of Global Variables ===================*/
86
87 /*------------------------------------------------------------------*/
88 /* */
89 /* Name - mono_arch_get_call_filter */
90 /* */
91 /* Function - Return a pointer to a method which calls an */
92 /* exception filter. We also use this function to */
93 /* call finally handlers (we pass NULL as @exc */
94 /* object in this case). */
95 /* */
96 /*------------------------------------------------------------------*/
97
98 gpointer
99 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
100 {
101 static guint8 *start;
102 static int inited = 0;
103 guint8 *code;
104 int alloc_size, pos, i;
105 GSList *unwind_ops = NULL;
106 MonoJumpInfo *ji = NULL;
107
108 g_assert (!aot);
109
110 if (inited)
111 return start;
112
113 inited = 1;
114 /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
115 code = start = mono_global_codeman_reserve (512);
116
117 s390_stmg (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
118 s390_lgr (code, s390_r14, STK_BASE);
119 alloc_size = S390_ALIGN(S390_CALLFILTER_SIZE, S390_STACK_ALIGNMENT);
120 s390_aghi (code, STK_BASE, -alloc_size);
121 s390_stg (code, s390_r14, 0, STK_BASE, 0);
122
123 /*------------------------------------------------------*/
124 /* save general registers on stack */
125 /*------------------------------------------------------*/
126 s390_stmg (code, s390_r0, STK_BASE, STK_BASE, S390_CALLFILTER_INTREGS);
127
128 /*------------------------------------------------------*/
129 /* save floating point registers on stack */
130 /*------------------------------------------------------*/
131 pos = S390_CALLFILTER_FLTREGS;
132 for (i = 0; i < 16; ++i) {
133 s390_std (code, i, 0, STK_BASE, pos);
134 pos += sizeof (gdouble);
135 }
136
137 /*------------------------------------------------------*/
138 /* save access registers on stack */
139 /*------------------------------------------------------*/
140 s390_stam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
141
142 /*------------------------------------------------------*/
143 /* Get A(Context) */
144 /*------------------------------------------------------*/
145 s390_lgr (code, s390_r13, s390_r2);
146
147 /*------------------------------------------------------*/
148 /* Get A(Handler Entry Point) */
149 /*------------------------------------------------------*/
150 s390_lgr (code, s390_r0, s390_r3);
151
152 /*------------------------------------------------------*/
153 /* Set parameter register with Exception */
154 /*------------------------------------------------------*/
155 s390_lgr (code, s390_r2, s390_r4);
156
157 /*------------------------------------------------------*/
158 /* Load all registers with values from the context */
159 /*------------------------------------------------------*/
160 s390_lmg (code, s390_r3, s390_r12, s390_r13,
161 G_STRUCT_OFFSET(MonoContext, uc_mcontext.gregs[3]));
162 pos = G_STRUCT_OFFSET(MonoContext, uc_mcontext.fpregs.fprs[0]);
163 for (i = 0; i < 16; ++i) {
164 s390_ld (code, i, 0, s390_r13, pos);
165 pos += sizeof(gdouble);
166 }
167
168 #if 0
169 /*------------------------------------------------------*/
170 /* We need to preserve current SP before calling filter */
171 /* with SP from the context */
172 /*------------------------------------------------------*/
173 s390_lgr (code, s390_r14, STK_BASE);
174 s390_lg (code, STK_BASE, 0, s390_r13,
175 G_STRUCT_OFFSET(MonoContext, uc_mcontext.gregs[15]));
176 s390_lgr (code, s390_r13, s390_r14);
177 #endif
178
179 /*------------------------------------------------------*/
180 /* Go call filter */
181 /*------------------------------------------------------*/
182 s390_lgr (code, s390_r1, s390_r0);
183 s390_basr (code, s390_r14, s390_r1);
184
185 /*------------------------------------------------------*/
186 /* Save return value */
187 /*------------------------------------------------------*/
188 s390_lgr (code, s390_r14, s390_r2);
189
190 #if 0
191 /*------------------------------------------------------*/
192 /* Reload our stack register with value saved in context*/
193 /*------------------------------------------------------*/
194 s390_lgr (code, STK_BASE, s390_r13);
195 #endif
196
197 /*------------------------------------------------------*/
198 /* Restore all the regs from the stack */
199 /*------------------------------------------------------*/
200 s390_lmg (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
201 pos = S390_CALLFILTER_FLTREGS;
202 for (i = 0; i < 16; ++i) {
203 s390_ld (code, i, 0, STK_BASE, pos);
204 pos += sizeof (gdouble);
205 }
206
207 s390_lgr (code, s390_r2, s390_r14);
208 s390_lam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
209 s390_aghi (code, s390_r15, alloc_size);
210 s390_lmg (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
211 s390_br (code, s390_r14);
212
213 g_assert ((code - start) < SZ_THROW);
214
215 if (info)
216 *info = mono_tramp_info_create (g_strdup_printf("call_filter"),
217 start, code - start, ji,
218 unwind_ops);
219
220 return start;
221 }
222
223 /*========================= End of Function ========================*/
224
225 /*------------------------------------------------------------------*/
226 /* */
227 /* Name - throw_exception. */
228 /* */
229 /* Function - Raise an exception based on the parameters passed.*/
230 /* */
231 /*------------------------------------------------------------------*/
232
233 static void
234 throw_exception (MonoObject *exc, unsigned long ip, unsigned long sp,
235 gulong *int_regs, gdouble *fp_regs, gint32 *acc_regs,
236 guint fpc, gboolean rethrow)
237 {
238 MonoContext ctx;
239 int iReg;
240 static void (*restore_context) (MonoContext *);
241
242 if (!restore_context)
243 restore_context = mono_get_restore_context();
244
245 memset(&ctx, 0, sizeof(ctx));
246
247 setup_context(&ctx);
248
249 /* adjust eip so that it point into the call instruction */
250 ip -= 2;
251
252 for (iReg = 0; iReg < 16; iReg++) {
253 ctx.uc_mcontext.gregs[iReg] = int_regs[iReg];
254 ctx.uc_mcontext.fpregs.fprs[iReg].d = fp_regs[iReg];
255 ctx.uc_mcontext.aregs[iReg] = acc_regs[iReg];
256 }
257
258 ctx.uc_mcontext.fpregs.fpc = fpc;
259
260 MONO_CONTEXT_SET_BP (&ctx, sp);
261 MONO_CONTEXT_SET_IP (&ctx, ip);
262
263 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
264 MonoException *mono_ex = (MonoException*)exc;
265 if (!rethrow)
266 mono_ex->stack_trace = NULL;
267 }
268 // mono_arch_handle_exception (&ctx, exc, FALSE);
269 mono_handle_exception (&ctx, exc);
270 restore_context(&ctx);
271
272 g_assert_not_reached ();
273 }
274
275 /*========================= End of Function ========================*/
276
277 /*------------------------------------------------------------------*/
278 /* */
279 /* Name - get_throw_exception_generic */
280 /* */
281 /* Function - Return a function pointer which can be used to */
282 /* raise exceptions. The returned function has the */
283 /* following signature: */
284 /* void (*func) (MonoException *exc); or, */
285 /* void (*func) (char *exc_name); */
286 /* */
287 /*------------------------------------------------------------------*/
288
289 static gpointer
290 mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info,
291 int corlib, gboolean rethrow, gboolean aot)
292 {
293 guint8 *code, *start;
294 int alloc_size, pos, i;
295 MonoJumpInfo *ji = NULL;
296 GSList *unwind_ops = NULL;
297
298 code = start = mono_global_codeman_reserve(size);
299
300 s390_stmg (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
301 alloc_size = S390_ALIGN(S390_THROWSTACK_SIZE, S390_STACK_ALIGNMENT);
302 s390_lgr (code, s390_r14, STK_BASE);
303 s390_aghi (code, STK_BASE, -alloc_size);
304 s390_stg (code, s390_r14, 0, STK_BASE, 0);
305 s390_lgr (code, s390_r3, s390_r2);
306 if (corlib) {
307 s390_basr (code, s390_r13, 0);
308 s390_j (code, 10);
309 s390_llong(code, mono_defaults.exception_class->image);
310 s390_llong(code, mono_exception_from_token);
311 s390_lg (code, s390_r2, 0, s390_r13, 4);
312 s390_lg (code, s390_r1, 0, s390_r13, 12);
313 s390_basr (code, s390_r14, s390_r1);
314 }
315
316 /*------------------------------------------------------*/
317 /* save the general registers on the stack */
318 /*------------------------------------------------------*/
319 s390_stmg (code, s390_r0, s390_r13, STK_BASE, S390_THROWSTACK_INTREGS);
320
321 s390_lgr (code, s390_r1, STK_BASE);
322 s390_aghi (code, s390_r1, alloc_size);
323 /*------------------------------------------------------*/
324 /* save the return address in the parameter register */
325 /*------------------------------------------------------*/
326 s390_lg (code, s390_r3, 0, s390_r1, S390_RET_ADDR_OFFSET);
327
328 /*------------------------------------------------------*/
329 /* save the floating point registers */
330 /*------------------------------------------------------*/
331 pos = S390_THROWSTACK_FLTREGS;
332 for (i = 0; i < 16; ++i) {
333 s390_std (code, i, 0, STK_BASE, pos);
334 pos += sizeof (gdouble);
335 }
336 /*------------------------------------------------------*/
337 /* save the access registers */
338 /*------------------------------------------------------*/
339 s390_stam (code, s390_r0, s390_r15, STK_BASE, S390_THROWSTACK_ACCREGS);
340
341 /*------------------------------------------------------*/
342 /* call throw_exception (tkn, ip, sp, gr, fr, ar, re) */
343 /* - r2 already contains *exc */
344 /*------------------------------------------------------*/
345 s390_lgr (code, s390_r4, s390_r1); /* caller sp */
346
347 /*------------------------------------------------------*/
348 /* pointer to the saved int regs */
349 /*------------------------------------------------------*/
350 s390_la (code, s390_r5, 0, STK_BASE, S390_THROWSTACK_INTREGS);
351 s390_la (code, s390_r6, 0, STK_BASE, S390_THROWSTACK_FLTREGS);
352 s390_la (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCREGS);
353 s390_stg (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCPRM);
354 s390_stfpc(code, STK_BASE, S390_THROWSTACK_FPCPRM+4);
355 s390_lghi (code, s390_r7, rethrow);
356 s390_stg (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_RETHROW);
357 s390_basr (code, s390_r13, 0);
358 s390_j (code, 6);
359 s390_llong(code, throw_exception);
360 s390_lg (code, s390_r1, 0, s390_r13, 4);
361 s390_basr (code, s390_r14, s390_r1);
362 /* we should never reach this breakpoint */
363 s390_break (code);
364 g_assert ((code - start) < size);
365
366 if (info)
367 *info = mono_tramp_info_create (g_strdup_printf(corlib ? "throw_corlib_exception"
368 : (rethrow ? "rethrow_exception"
369 : "throw_exception")),
370 start, code - start, ji, unwind_ops);
371
372 return start;
373 }
374
375 /*========================= End of Function ========================*/
376
377 /*------------------------------------------------------------------*/
378 /* */
379 /* Name - arch_get_throw_exception */
380 /* */
381 /* Function - Return a function pointer which can be used to */
382 /* raise exceptions. The returned function has the */
383 /* following signature: */
384 /* void (*func) (MonoException *exc); */
385 /* */
386 /*------------------------------------------------------------------*/
387
388 gpointer
389 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
390 {
391
392 g_assert (!aot);
393 if (info)
394 *info = NULL;
395
396 return (mono_arch_get_throw_exception_generic (SZ_THROW, info, FALSE, FALSE, aot));
397 }
398
399 /*========================= End of Function ========================*/
400
401 /*------------------------------------------------------------------*/
402 /* */
403 /* Name - arch_get_rethrow_exception */
404 /* */
405 /* Function - Return a function pointer which can be used to */
406 /* raise exceptions. The returned function has the */
407 /* following signature: */
408 /* void (*func) (MonoException *exc); */
409 /* */
410 /*------------------------------------------------------------------*/
411
412 gpointer
413 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
414 {
415 g_assert (!aot);
416 if (info)
417 *info = NULL;
418
419 return (mono_arch_get_throw_exception_generic (SZ_THROW, info, FALSE, FALSE, aot));
420 }
421
422 /*========================= End of Function ========================*/
423
424 /*------------------------------------------------------------------*/
425 /* */
426 /* Name - arch_get_corlib_exception */
427 /* */
428 /* Function - Return a function pointer which can be used to */
429 /* raise corlib exceptions. The return function has */
430 /* the following signature: */
431 /* void (*func) (guint32 token, guint32 offset) */
432 /* */
433 /*------------------------------------------------------------------*/
434
435 gpointer
436 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
437 {
438 g_assert (!aot);
439 if (info)
440 *info = NULL;
441
442 return (mono_arch_get_throw_exception_generic (SZ_THROW, info, TRUE, FALSE, aot));
443 }
444
445 /*========================= End of Function ========================*/
446
447 /*------------------------------------------------------------------*/
448 /* */
449 /* Name - mono_arch_find_jit_info */
450 /* */
451 /* Function - See exceptions-amd64.c for docs. */
452 /* */
453 /*------------------------------------------------------------------*/
454
455 gboolean
456 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
457 MonoJitInfo *ji, MonoContext *ctx,
458 MonoContext *new_ctx, MonoLMF **lmf,
459 mgreg_t **save_locations,
460 StackFrameInfo *frame)
461 {
462 gpointer ip = (gpointer) MONO_CONTEXT_GET_IP (ctx);
463 MonoS390StackFrame *sframe;
464
465 memset (frame, 0, sizeof (StackFrameInfo));
466 frame->ji = ji;
467
468 *new_ctx = *ctx;
469
470 if (ji != NULL) {
471 gint64 address;
472 guint8 *cfa;
473 guint32 unwind_info_len;
474 guint8 *unwind_info;
475 mgreg_t regs[16];
476
477 frame->type = FRAME_TYPE_MANAGED;
478
479 if (ji->from_aot)
480 unwind_info = mono_aot_get_unwind_info(ji, &unwind_info_len);
481 else
482 unwind_info = mono_get_cached_unwind_info(ji->used_regs, &unwind_info_len);
483
484 if (*lmf && ((*lmf) != jit_tls->first_lmf) &&
485 (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
486 /* remove any unused lmf */
487 *lmf = (*lmf)->previous_lmf;
488 }
489
490 address = (char *)ip - (char *)ji->code_start;
491
492 memcpy(&regs, &ctx->uc_mcontext.gregs, sizeof(regs));
493 mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
494 (guint8 *) ji->code_start + ji->code_size,
495 ip, regs, 16, save_locations,
496 MONO_MAX_IREGS, &cfa);
497 memcpy (&new_ctx->uc_mcontext.gregs, &regs, sizeof(regs));
498 MONO_CONTEXT_SET_IP(new_ctx, regs[14] - 2);
499 MONO_CONTEXT_SET_BP(new_ctx, cfa);
500
501 if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
502 /* remove any unused lmf */
503 *lmf = (*lmf)->previous_lmf;
504 }
505 return TRUE;
506 } else if (*lmf) {
507
508 ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL);
509 if (!ji) {
510 if (!(*lmf)->method)
511 return FALSE;
512
513 frame->method = (*lmf)->method;
514 }
515
516 frame->ji = ji;
517 frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
518
519 memcpy(new_ctx->uc_mcontext.gregs, (*lmf)->gregs, sizeof((*lmf)->gregs));
520 memcpy(new_ctx->uc_mcontext.fpregs.fprs, (*lmf)->fregs, sizeof((*lmf)->fregs));
521 MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
522 MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip - 2);
523 *lmf = (*lmf)->previous_lmf;
524
525 return TRUE;
526 }
527
528 return FALSE;
529 }
530
531 /*========================= End of Function ========================*/
532
533 /*------------------------------------------------------------------*/
534 /* */
535 /* Name - mono_arch_handle_exception */
536 /* */
537 /* Function - Handle an exception raised by the JIT code. */
538 /* */
539 /* Parameters - ctx - Saved processor state */
540 /* obj - The exception object */
541 /* */
542 /*------------------------------------------------------------------*/
543
544 gboolean
545 mono_arch_handle_exception (void *uc, gpointer obj)
546 {
547 return mono_handle_exception (uc, obj);
548 }
549
550 /*========================= End of Function ========================*/
551
552 /*------------------------------------------------------------------*/
553 /* */
554 /* Name - mono_arch_sigctx_to_monoctx. */
555 /* */
556 /* Function - Called from the signal handler to convert signal */
557 /* context to MonoContext. */
558 /* */
559 /*------------------------------------------------------------------*/
560
561 void
562 mono_arch_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
563 {
564 mono_sigctx_to_monoctx(ctx, mctx);
565 }
566
567 /*========================= End of Function ========================*/
568
569 /*------------------------------------------------------------------*/
570 /* */
571 /* Name - mono_arch_monoctx_to_sigctx. */
572 /* */
573 /* Function - Convert MonoContext structure to signal context. */
574 /* */
575 /*------------------------------------------------------------------*/
576
577 void
578 mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
579 {
580 mono_monoctx_to_sigctx(mctx, ctx);
581 }
582
583 /*========================= End of Function ========================*/
584
585 /*------------------------------------------------------------------*/
586 /* */
587 /* Name - mono_arch_ip_from_context */
588 /* */
589 /* Function - Return the instruction pointer from the context. */
590 /* */
591 /* Parameters - sigctx - Saved processor state */
592 /* */
593 /*------------------------------------------------------------------*/
594
595 gpointer
596 mono_arch_ip_from_context (void *sigctx)
597 {
598 return ((gpointer) MONO_CONTEXT_GET_IP(((MonoContext *) sigctx)));
599 }
600
601
602 /*========================= End of Function ========================*/
603
604 /*------------------------------------------------------------------*/
605 /* */
606 /* Name - mono_arch_get_restore_context */
607 /* */
608 /* Function - Return the address of the routine that will rest- */
609 /* ore the context. */
610 /* */
611 /*------------------------------------------------------------------*/
612
613 gpointer
614 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
615 {
616 g_assert (!aot);
617 if (info)
618 *info = NULL;
619
620 return setcontext;
621 }
622
623 /*========================= End of Function ========================*/
624
625 /*------------------------------------------------------------------*/
626 /* */
627 /* Name - mono_arch_is_int_overflow */
628 /* */
629 /* Function - Inspect the code that raised the SIGFPE signal */
630 /* to see if the DivideByZero or Arithmetic exception*/
631 /* should be raised. */
632 /* */
633 /*------------------------------------------------------------------*/
634
635 gboolean
636 mono_arch_is_int_overflow (void *uc, void *info)
637 {
638 MonoContext *ctx;
639 guint8 *code;
640 guint64 *operand;
641 gboolean arithExc = TRUE;
642 gint regNo,
643 idxNo,
644 offset;
645
646 ctx = (MonoContext *) uc;
647 code = (guint8 *) ((siginfo_t *)info)->si_addr;
648 /*----------------------------------------------------------*/
649 /* Divide operations are the only ones that will give the */
650 /* divide by zero exception so just check for these ops. */
651 /*----------------------------------------------------------*/
652 switch (code[0]) {
653 case 0x1d : /* Divide Register */
654 regNo = code[1] & 0x0f;
655 if (ctx->uc_mcontext.gregs[regNo] == 0)
656 arithExc = FALSE;
657 break;
658 case 0x5d : /* Divide */
659 regNo = (code[2] & 0xf0 >> 8);
660 idxNo = (code[1] & 0x0f);
661 offset = *((guint16 *) code+2) & 0x0fff;
662 operand = (guint64*)(ctx->uc_mcontext.gregs[regNo] + offset);
663 if (idxNo != 0)
664 operand += ctx->uc_mcontext.gregs[idxNo];
665 if (*operand == 0)
666 arithExc = FALSE;
667 break;
668 case 0xb9 : /* DL[GR] or DS[GR] */
669 if ((code[1] == 0x97) || (code[1] == 0x87) ||
670 (code[1] == 0x0d) || (code[1] == 0x1d)) {
671 regNo = (code[3] & 0x0f);
672 if (ctx->uc_mcontext.gregs[regNo] == 0)
673 arithExc = FALSE;
674 }
675 break;
676 case 0xe3 : /* DL[G] | DS[G] */
677 if ((code[5] == 0x97) || (code[5] == 0x87) ||
678 (code[5] == 0x0d) || (code[5] == 0x1d)) {
679 regNo = (code[2] & 0xf0 >> 8);
680 idxNo = (code[1] & 0x0f);
681 offset = (code[2] & 0x0f << 8) +
682 code[3] + (code[4] << 12);
683 operand = (guint64*)(ctx->uc_mcontext.gregs[regNo] + offset);
684 if (idxNo != 0)
685 operand += ctx->uc_mcontext.gregs[idxNo];
686 if (*operand == 0)
687 arithExc = FALSE;
688 }
689 break;
690 default:
691 arithExc = TRUE;
692 }
693 ctx->uc_mcontext.psw.addr = (guint64)code;
694 return (arithExc);
695 }
696
697 /*========================= End of Function ========================*/
Mirror of the official Mono project git repository