?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Cleanup exception s390 handling; fix prolog length setting; correct test
[mono-project.git] / mono / mini / exceptions-s390.c
blob6b39cb2ceaa492104825f8ccf4c4ed970bab9d9d
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 MONO_CONTEXT_SET_IP(ctx,ip) \
24 do { \
25 (ctx)->uc_mcontext.gregs[14] = (unsigned long)ip; \
26 (ctx)->uc_mcontext.psw.addr = (unsigned long)ip; \
27 } while (0);
28
29 #define MONO_CONTEXT_SET_BP(ctx,bp) \
30 do { \
31 (ctx)->uc_mcontext.gregs[15] = (unsigned long)bp; \
32 (ctx)->uc_stack.ss_sp = (unsigned long)bp; \
33 } while (0);
34
35 #define MONO_CONTEXT_GET_IP(ctx) context_get_ip ((ctx))
36 #define MONO_CONTEXT_GET_BP(ctx) ((gpointer)((ctx)->uc_mcontext.gregs[15]))
37
38 #define S390_CALLFILTER_INTREGS S390_MINIMAL_STACK_SIZE
39 #define S390_CALLFILTER_FLTREGS S390_CALLFILTER_INTREGS+(16*sizeof(gulong))
40 #define S390_CALLFILTER_ACCREGS S390_CALLFILTER_FLTREGS+(16*sizeof(gdouble))
41 #define S390_CALLFILTER_SIZE (S390_CALLFILTER_ACCREGS+(16*sizeof(gulong)))
42
43 #define S390_THROWSTACK_ACCPRM S390_MINIMAL_STACK_SIZE
44 #define S390_THROWSTACK_FPCPRM S390_THROWSTACK_ACCPRM+sizeof(gpointer)
45 #define S390_THROWSTACK_INTREGS S390_THROWSTACK_FPCPRM+sizeof(gulong)
46 #define S390_THROWSTACK_FLTREGS S390_THROWSTACK_INTREGS+(16*sizeof(gulong))
47 #define S390_THROWSTACK_ACCREGS S390_THROWSTACK_FLTREGS+(16*sizeof(gdouble))
48 #define S390_THROWSTACK_SIZE (S390_THROWSTACK_ACCREGS+(16*sizeof(gulong)))
49
50 /*========================= End of Defines =========================*/
51
52 /*------------------------------------------------------------------*/
53 /* I n c l u d e s */
54 /*------------------------------------------------------------------*/
55
56 #include <config.h>
57 #include <glib.h>
58 #include <signal.h>
59 #include <string.h>
60 #include <ucontext.h>
61
62 #include <mono/arch/s390/s390-codegen.h>
63 #include <mono/metadata/appdomain.h>
64 #include <mono/metadata/tabledefs.h>
65 #include <mono/metadata/threads.h>
66 #include <mono/metadata/debug-helpers.h>
67 #include <mono/metadata/exception.h>
68 #include <mono/metadata/mono-debug.h>
69
70 #include "mini.h"
71 #include "mini-s390.h"
72
73 /*========================= End of Includes ========================*/
74
75 /*------------------------------------------------------------------*/
76 /* T y p e d e f s */
77 /*------------------------------------------------------------------*/
78
79 typedef struct
80 {
81 void *prev;
82 void *unused[5];
83 void *regs[8];
84 void *return_address;
85 } MonoS390StackFrame;
86
87 /*========================= End of Typedefs ========================*/
88
89 /*------------------------------------------------------------------*/
90 /* P r o t o t y p e s */
91 /*------------------------------------------------------------------*/
92
93 gboolean mono_arch_handle_exception (void *ctx,
94 gpointer obj,
95 gboolean test_only);
96
97 /*========================= End of Prototypes ======================*/
98
99 /*------------------------------------------------------------------*/
100 /* G l o b a l V a r i a b l e s */
101 /*------------------------------------------------------------------*/
102
103 /*====================== End of Global Variables ===================*/
104
105 /*------------------------------------------------------------------*/
106 /* */
107 /* Name - context_get_ip */
108 /* */
109 /* Function - Extract the current instruction address from the */
110 /* context. */
111 /* */
112 /*------------------------------------------------------------------*/
113
114 static inline gpointer
115 context_get_ip (MonoContext *ctx)
116 {
117 gpointer ip;
118
119 ip = (gpointer) ((gint32) (ctx->uc_mcontext.psw.addr) & 0x7fffffff);
120 return ip;
121 }
122
123 /*========================= End of Function ========================*/
124
125 /*------------------------------------------------------------------*/
126 /* */
127 /* Name - mono_arch_has_unwind_info */
128 /* */
129 /* Function - Tests if a function has a DWARF exception table */
130 /* that is able to restore all caller saved registers*/
131 /* */
132 /*------------------------------------------------------------------*/
133
134 gboolean
135 mono_arch_has_unwind_info (gconstpointer addr)
136 {
137 return FALSE;
138 }
139
140 /*========================= End of Function ========================*/
141
142 /*------------------------------------------------------------------*/
143 /* */
144 /* Name - arch_get_call_filter */
145 /* */
146 /* Function - Return a pointer to a method which calls an */
147 /* exception filter. We also use this function to */
148 /* call finally handlers (we pass NULL as @exc */
149 /* object in this case). */
150 /* */
151 /*------------------------------------------------------------------*/
152
153 static gpointer
154 arch_get_call_filter (void)
155 {
156 static guint8 start [512];
157 static int inited = 0;
158 guint8 *code;
159 int alloc_size, pos, i;
160
161 if (inited)
162 return start;
163
164 inited = 1;
165 /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
166 code = start;
167
168 s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
169 s390_lr (code, s390_r14, STK_BASE);
170 alloc_size = S390_ALIGN(S390_CALLFILTER_SIZE, S390_STACK_ALIGNMENT);
171 s390_ahi (code, STK_BASE, -alloc_size);
172 s390_st (code, s390_r14, 0, STK_BASE, 0);
173
174 /*------------------------------------------------------*/
175 /* save general registers on stack */
176 /*------------------------------------------------------*/
177 s390_stm (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
178
179 /*------------------------------------------------------*/
180 /* save floating point registers on stack */
181 /*------------------------------------------------------*/
182 // pos = S390_CALLFILTER_FLTREGS;
183 // for (i = 0; i < 16; ++i) {
184 // s390_std (code, i, 0, STK_BASE, pos);
185 // pos += sizeof (gdouble);
186 // }
187
188 /*------------------------------------------------------*/
189 /* save access registers on stack */
190 /*------------------------------------------------------*/
191 // s390_stam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
192
193 /*------------------------------------------------------*/
194 /* Get A(Context) */
195 /*------------------------------------------------------*/
196 s390_lr (code, s390_r13, s390_r2);
197
198 /*------------------------------------------------------*/
199 /* Get A(Handler Entry Point) */
200 /*------------------------------------------------------*/
201 s390_lr (code, s390_r0, s390_r3);
202
203 /*------------------------------------------------------*/
204 /* Set parameter register with Exception */
205 /*------------------------------------------------------*/
206 s390_lr (code, s390_r2, s390_r4);
207
208 /*------------------------------------------------------*/
209 /* Load all registers with values from the context */
210 /*------------------------------------------------------*/
211 s390_lm (code, s390_r3, s390_r12, s390_r13, G_STRUCT_OFFSET(MonoContext, uc_mcontext.gregs[3]));
212 pos = G_STRUCT_OFFSET(MonoContext, uc_mcontext.fpregs.fprs[0]);
213 for (i = 0; i < 16; ++i) {
214 s390_ld (code, i, 0, s390_r13, pos);
215 pos += sizeof(gdouble);
216 }
217
218 /*------------------------------------------------------*/
219 /* Point at the copied stack frame and call the filter */
220 /*------------------------------------------------------*/
221 s390_lr (code, s390_r1, s390_r0);
222 s390_basr (code, s390_r14, s390_r1);
223
224 /*------------------------------------------------------*/
225 /* Save return value */
226 /*------------------------------------------------------*/
227 s390_lr (code, s390_r14, s390_r2);
228
229 /*------------------------------------------------------*/
230 /* Restore all the regs from the stack */
231 /*------------------------------------------------------*/
232 s390_lm (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
233 // pos = S390_CALLFILTER_FLTREGS;
234 // for (i = 0; i < 16; ++i) {
235 // s390_ld (code, i, 0, STK_BASE, pos);
236 // pos += sizeof (gdouble);
237 // }
238
239 s390_lr (code, s390_r2, s390_r14);
240 // s390_lam (code, s390_a0, s390_a15, STK_BASE, S390_CALLFILTER_ACCREGS);
241 s390_ahi (code, s390_r15, alloc_size);
242 s390_lm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
243 s390_br (code, s390_r14);
244
245 g_assert ((code - start) < sizeof(start));
246 return start;
247 }
248
249 /*========================= End of Function ========================*/
250
251 /*------------------------------------------------------------------*/
252 /* */
253 /* Name - throw_exception. */
254 /* */
255 /* Function - Raise an exception based on the parameters passed.*/
256 /* */
257 /*------------------------------------------------------------------*/
258
259 static void
260 throw_exception (MonoObject *exc, unsigned long ip, unsigned long sp,
261 gulong *int_regs, gdouble *fp_regs, gulong *acc_regs, guint fpc)
262 {
263 static void (*restore_context) (MonoContext *);
264 MonoContext ctx;
265 int iReg;
266
267 memset(&ctx, 0, sizeof(ctx));
268
269 getcontext(&ctx);
270
271 /* adjust eip so that it point into the call instruction */
272 ip -= 6;
273
274 for (iReg = 0; iReg < 16; iReg++) {
275 ctx.uc_mcontext.gregs[iReg] = int_regs[iReg];
276 ctx.uc_mcontext.fpregs.fprs[iReg].d = fp_regs[iReg];
277 ctx.uc_mcontext.aregs[iReg] = acc_regs[iReg];
278 }
279
280 ctx.uc_mcontext.fpregs.fpc = fpc;
281
282 MONO_CONTEXT_SET_BP (&ctx, sp);
283 MONO_CONTEXT_SET_IP (&ctx, ip);
284
285 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
286 MonoException *mono_ex = (MonoException*)exc;
287 mono_ex->stack_trace = NULL;
288 }
289 mono_arch_handle_exception (&ctx, exc, FALSE);
290 setcontext(&ctx);
291
292 g_assert_not_reached ();
293 }
294
295 /*========================= End of Function ========================*/
296
297 /*------------------------------------------------------------------*/
298 /* */
299 /* Name - arch_get_throw_exception_generic */
300 /* */
301 /* Function - Return a function pointer which can be used to */
302 /* raise exceptions. The returned function has the */
303 /* following signature: */
304 /* void (*func) (MonoException *exc); or, */
305 /* void (*func) (char *exc_name); */
306 /* */
307 /*------------------------------------------------------------------*/
308
309 static gpointer
310 mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name)
311 {
312 guint8 *code;
313 int alloc_size, pos, i, offset;
314
315 code = start;
316
317 s390_stm (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
318 alloc_size = S390_ALIGN(S390_THROWSTACK_SIZE, S390_STACK_ALIGNMENT);
319 s390_lr (code, s390_r14, STK_BASE);
320 s390_ahi (code, STK_BASE, -alloc_size);
321 s390_st (code, s390_r14, 0, STK_BASE, 0);
322 if (by_name) {
323 s390_lr (code, s390_r4, s390_r2);
324 s390_bras (code, s390_r13, 6);
325 s390_word (code, mono_defaults.corlib);
326 s390_word (code, "System");
327 s390_l (code, s390_r2, 0, s390_r13, 0);
328 s390_l (code, s390_r3, 0, s390_r13, 4);
329 offset = (guint32) S390_RELATIVE(mono_exception_from_name, code);
330 s390_brasl(code, s390_r14, offset);
331 }
332 /*------------------------------------------------------*/
333 /* save the general registers on the stack */
334 /*------------------------------------------------------*/
335 s390_stm (code, s390_r0, s390_r13, STK_BASE, S390_THROWSTACK_INTREGS);
336
337 s390_lr (code, s390_r1, STK_BASE);
338 s390_ahi (code, s390_r1, alloc_size);
339 /*------------------------------------------------------*/
340 /* save the return address in the parameter register */
341 /*------------------------------------------------------*/
342 s390_l (code, s390_r3, 0, s390_r1, S390_RET_ADDR_OFFSET);
343
344 /*------------------------------------------------------*/
345 /* save the floating point registers */
346 /*------------------------------------------------------*/
347 pos = S390_THROWSTACK_FLTREGS;
348 for (i = 0; i < 16; ++i) {
349 s390_std (code, i, 0,STK_BASE, pos);
350 pos += sizeof (gdouble);
351 }
352 /*------------------------------------------------------*/
353 /* save the access registers */
354 /*------------------------------------------------------*/
355 s390_stam (code, s390_r0, s390_r15, STK_BASE, S390_THROWSTACK_ACCREGS);
356
357 /*------------------------------------------------------*/
358 /* call throw_exception (exc, ip, sp, gr, fr, ar) */
359 /* exc is already in place in r2 */
360 /*------------------------------------------------------*/
361 s390_lr (code, s390_r4, s390_r1); /* caller sp */
362 /*------------------------------------------------------*/
363 /* pointer to the saved int regs */
364 /*------------------------------------------------------*/
365 s390_la (code, s390_r5, 0, STK_BASE, S390_THROWSTACK_INTREGS);
366 s390_la (code, s390_r6, 0, STK_BASE, S390_THROWSTACK_FLTREGS);
367 s390_la (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCREGS);
368 s390_st (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCPRM);
369 s390_stfpc(code, STK_BASE, S390_THROWSTACK_FPCPRM);
370 offset = (guint32) S390_RELATIVE(throw_exception, code);
371 s390_brasl(code, s390_r14, offset);
372 /* we should never reach this breakpoint */
373 s390_break (code);
374 g_assert ((code - start) < size);
375 return start;
376 }
377
378 /*========================= End of Function ========================*/
379
380 /*------------------------------------------------------------------*/
381 /* */
382 /* Name - arch_get_throw_exception */
383 /* */
384 /* Function - Return a function pointer which can be used to */
385 /* raise exceptions. The returned function has the */
386 /* following signature: */
387 /* void (*func) (MonoException *exc); */
388 /* */
389 /*------------------------------------------------------------------*/
390
391 gpointer
392 mono_arch_get_throw_exception (void)
393 {
394 static guint8 start [256];
395 static int inited = 0;
396
397 if (inited)
398 return start;
399 mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE);
400 inited = 1;
401 return start;
402 }
403
404 /*========================= End of Function ========================*/
405
406 /*------------------------------------------------------------------*/
407 /* */
408 /* Name - arch_get_throw_exception_by_name */
409 /* */
410 /* Function - Return a function pointer which can be used to */
411 /* raise corlib exceptions. The return function has */
412 /* the following signature: */
413 /* void (*func) (char *exc_name); */
414 /* */
415 /*------------------------------------------------------------------*/
416
417 gpointer
418 mono_arch_get_throw_exception_by_name (void)
419 {
420 static guint8 start [160];
421 static int inited = 0;
422
423 if (inited)
424 return start;
425 mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE);
426 inited = 1;
427 return start;
428 }
429
430 /*========================= End of Function ========================*/
431
432 /*------------------------------------------------------------------*/
433 /* */
434 /* Name - glist_to_array */
435 /* */
436 /* Function - Convert a list to a mono array. */
437 /* */
438 /*------------------------------------------------------------------*/
439
440 static MonoArray *
441 glist_to_array (GList *list)
442 {
443 MonoDomain *domain = mono_domain_get ();
444 MonoArray *res;
445 int len, i;
446
447 if (!list)
448 return NULL;
449
450 len = g_list_length (list);
451 res = mono_array_new (domain, mono_defaults.int_class, len);
452
453 for (i = 0; list; list = list->next, i++)
454 mono_array_set (res, gpointer, i, list->data);
455
456 return res;
457 }
458
459 /*========================= End of Function ========================*/
460
461 /*------------------------------------------------------------------*/
462 /* */
463 /* Name - mono_arch_find_jit_info */
464 /* */
465 /* Function - This function is used to gather informatoin from */
466 /* @ctx. It returns the MonoJitInfo of the corres- */
467 /* ponding function, unwinds one stack frame and */
468 /* stores the resulting context into @new_ctx. It */
469 /* also stores a string describing the stack location*/
470 /* into @trace (if not NULL), and modifies the @lmf */
471 /* if necessary. @native_offset returns the IP off- */
472 /* set from the start of the function or -1 if that */
473 /* informatoin is not available. */
474 /* */
475 /*------------------------------------------------------------------*/
476
477 MonoJitInfo *
478 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
479 MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
480 MonoContext *new_ctx, char **trace, MonoLMF **lmf,
481 int *native_offset, gboolean *managed)
482 {
483 MonoJitInfo *ji;
484 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
485 unsigned long *ptr;
486 char *p;
487 MonoS390StackFrame *sframe;
488
489 if (prev_ji &&
490 (ip > prev_ji->code_start &&
491 ((guint8 *) ip < ((guint8 *) prev_ji->code_start) + prev_ji->code_size)))
492 ji = prev_ji;
493 else
494 ji = mono_jit_info_table_find (domain, ip);
495
496 if (trace)
497 *trace = NULL;
498
499 if (native_offset)
500 *native_offset = -1;
501
502 if (managed)
503 *managed = FALSE;
504
505 if (ji != NULL) {
506 char *source_location, *tmpaddr, *fname;
507 gint32 address, iloffset;
508 int offset;
509
510 *new_ctx = *ctx;
511
512 if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
513 /* remove any unused lmf */
514 *lmf = (*lmf)->previous_lmf;
515 }
516
517 address = (char *)ip - (char *)ji->code_start;
518
519 if (native_offset)
520 *native_offset = address;
521
522 if (managed)
523 if (!ji->method->wrapper_type)
524 *managed = TRUE;
525
526 if (trace) {
527 source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain);
528 iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
529
530 if (iloffset < 0)
531 tmpaddr = g_strdup_printf ("<0x%08x>", address);
532 else
533 tmpaddr = g_strdup_printf ("[0x%08x]", iloffset);
534
535 fname = mono_method_full_name (ji->method, TRUE);
536
537 if (source_location)
538 *trace = g_strdup_printf ("in %s (at %s) %s", tmpaddr, source_location, fname);
539 else
540 *trace = g_strdup_printf ("in %s %s", tmpaddr, fname);
541
542 g_free (fname);
543 g_free (source_location);
544 g_free (tmpaddr);
545 }
546 sframe = (MonoS390StackFrame *) MONO_CONTEXT_GET_BP (ctx);
547 MONO_CONTEXT_SET_BP (new_ctx, sframe->prev);
548 sframe = (MonoS390StackFrame *) sframe->prev;
549 MONO_CONTEXT_SET_IP (new_ctx, sframe->return_address);
550 memcpy (&new_ctx->uc_mcontext.gregs[6], sframe->regs, (8*sizeof(gint32)));
551 *res = *ji;
552 return res;
553 } else if (*lmf) {
554
555 *new_ctx = *ctx;
556
557 if (!(*lmf)->method)
558 return (gpointer)-1;
559
560 if (trace)
561 *trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
562
563 if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
564 *res = *ji;
565 } else {
566 memset (res, 0, sizeof (MonoJitInfo));
567 res->method = (*lmf)->method;
568 }
569
570 memcpy(new_ctx->uc_mcontext.gregs, (*lmf)->gregs, sizeof((*lmf)->gregs));
571 memcpy(new_ctx->uc_mcontext.fpregs.fprs, (*lmf)->fregs, sizeof((*lmf)->fregs));
572
573 MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
574 MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
575 *lmf = (*lmf)->previous_lmf;
576
577 return res;
578
579 }
580
581 return NULL;
582 }
583
584 /*========================= End of Function ========================*/
585
586 /*------------------------------------------------------------------*/
587 /* */
588 /* Name - ves_icall_get_trace */
589 /* */
590 /* Function - */
591 /* */
592 /*------------------------------------------------------------------*/
593
594 MonoArray *
595 ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
596 {
597 MonoDomain *domain = mono_domain_get ();
598 MonoArray *res;
599 MonoArray *ta = exc->trace_ips;
600 int i, len;
601
602 if (ta == NULL) {
603 return mono_array_new (domain, mono_defaults.stack_frame_class, 0);
604 }
605
606 len = mono_array_length (ta);
607
608 res = mono_array_new (domain, mono_defaults.stack_frame_class,
609 len > skip ? len - skip : 0);
610
611 for (i = skip; i < len; i++) {
612 MonoJitInfo *ji;
613 MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
614 gpointer ip = mono_array_get (ta, gpointer, i);
615
616 ji = mono_jit_info_table_find (domain, ip);
617 if (ji == NULL) {
618 mono_array_set (res, gpointer, i, sf);
619 continue;
620 }
621
622 sf->method = mono_method_get_object (domain, ji->method, NULL);
623 sf->native_offset = (char *)ip - (char *)ji->code_start;
624
625 sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset, domain);
626
627 if (need_file_info) {
628 gchar *filename;
629
630 filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line, domain);
631
632 sf->filename = filename? mono_string_new (domain, filename): NULL;
633 sf->column = 0;
634
635 g_free (filename);
636 }
637
638 mono_array_set (res, gpointer, i, sf);
639 }
640
641 return res;
642 }
643
644 /*========================= End of Function ========================*/
645
646 /*------------------------------------------------------------------*/
647 /* */
648 /* Name - mono_jit_walk_stack */
649 /* */
650 /* Function - */
651 /* */
652 /*------------------------------------------------------------------*/
653
654 void
655 mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) {
656 MonoDomain *domain = mono_domain_get ();
657 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
658 MonoLMF *lmf = jit_tls->lmf;
659 MonoJitInfo *ji, rji;
660 gint native_offset, il_offset;
661 gboolean managed;
662 MonoContext ctx, new_ctx;
663
664 MONO_CONTEXT_SET_IP (&ctx, __builtin_return_address (0));
665 MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (1));
666
667 while (MONO_CONTEXT_GET_BP (&ctx) < jit_tls->end_of_stack) {
668
669 ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL,
670 &ctx, &new_ctx, NULL, &lmf,
671 &native_offset, &managed);
672 g_assert (ji);
673
674 if (ji == (gpointer)-1)
675 return;
676
677 il_offset = do_il_offset ? mono_debug_il_offset_from_address (ji->method, native_offset, domain): -1;
678
679 if (func (ji->method, native_offset, il_offset, managed, user_data))
680 return;
681
682 ctx = new_ctx;
683 }
684 }
685
686 /*========================= End of Function ========================*/
687
688 /*------------------------------------------------------------------*/
689 /* */
690 /* Name - ves_icall_get_frame_info */
691 /* */
692 /* Function - */
693 /* */
694 /*------------------------------------------------------------------*/
695
696 MonoBoolean
697 ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
698 MonoReflectionMethod **method,
699 gint32 *iloffset, gint32 *native_offset,
700 MonoString **file, gint32 *line, gint32 *column)
701 {
702 MonoDomain *domain = mono_domain_get ();
703 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
704 MonoLMF *lmf = jit_tls->lmf;
705 MonoJitInfo *ji, rji;
706 MonoContext ctx, new_ctx;
707
708 MONO_CONTEXT_SET_IP (&ctx, ves_icall_get_frame_info);
709 MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (0));
710
711 skip++;
712
713 do {
714 ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL,
715 &ctx, &new_ctx, NULL, &lmf,
716 native_offset, NULL);
717
718 ctx = new_ctx;
719
720 if (!ji || ji == (gpointer)-1 || MONO_CONTEXT_GET_BP (&ctx) >= jit_tls->end_of_stack)
721 return FALSE;
722
723 /* skip all wrappers ??*/
724 if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
725 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
726 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE)
727 continue;
728
729 skip--;
730
731 } while (skip >= 0);
732
733 *method = mono_method_get_object (domain, ji->method, NULL);
734 *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain);
735
736 if (need_file_info) {
737 gchar *filename;
738
739 filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain);
740
741 *file = filename? mono_string_new (domain, filename): NULL;
742 *column = 0;
743
744 g_free (filename);
745 }
746
747 return TRUE;
748 }
749
750 /*========================= End of Function ========================*/
751
752 /*------------------------------------------------------------------*/
753 /* */
754 /* Name - mono_arch_handle_exception */
755 /* */
756 /* Function - Handle an exception raised by the JIT code. */
757 /* */
758 /* Parameters - ctx - Saved processor state */
759 /* obj - The exception object */
760 /* test_only - Only test if the exception is caught, */
761 /* but don't call handlers */
762 /* */
763 /*------------------------------------------------------------------*/
764
765 gboolean
766 mono_arch_handle_exception (void *uc, gpointer obj, gboolean test_only)
767 {
768 MonoContext *ctx = uc;
769 MonoDomain *domain = mono_domain_get ();
770 MonoJitInfo *ji, rji;
771 static int (*call_filter) (MonoContext *, gpointer, gpointer) = NULL;
772 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
773 MonoLMF *lmf = jit_tls->lmf;
774 GList *trace_ips = NULL;
775 GString *traceStr = NULL;
776 MonoException *mono_ex;
777 MonoString *initialStackTrace = NULL;
778 int frameCount = 0;
779
780 g_assert (ctx != NULL);
781 memset(&rji, 0, sizeof(rji));
782 if (!obj) {
783 MonoException *ex = mono_get_exception_null_reference ();
784 ex->message = mono_string_new (domain,
785 "Object reference not set to an instance of an object");
786 obj = (MonoObject *)ex;
787 }
788
789 if (mono_object_isinst (obj, mono_defaults.exception_class)) {
790 mono_ex = (MonoException*)obj;
791 mono_ex->stack_trace = NULL;
792 } else {
793 mono_ex = NULL;
794 }
795
796
797 if (!call_filter)
798 call_filter = arch_get_call_filter ();
799
800 g_assert (jit_tls->end_of_stack);
801 g_assert (jit_tls->abort_func);
802
803 if (!test_only) {
804 MonoContext ctx_cp = *ctx;
805 if (mono_jit_trace_calls != NULL)
806 g_print ("EXCEPTION handling: %s\n", mono_object_class (obj)->name);
807 if (!mono_arch_handle_exception (&ctx_cp, obj, TRUE)) {
808 if (mono_break_on_exc)
809 G_BREAKPOINT ();
810 mono_unhandled_exception (obj);
811 }
812 }
813
814 memset (&rji, 0, sizeof(rji));
815
816 while (1) {
817 MonoContext new_ctx;
818 char *trace = NULL;
819 gboolean needTrace = FALSE;
820
821 if (test_only && (frameCount < 1000)) {
822 needTrace = TRUE;
823 if (!traceStr)
824 traceStr = g_string_new ("");
825 }
826
827 ji = mono_arch_find_jit_info (domain, jit_tls, &rji, &rji, ctx, &new_ctx,
828 test_only ? &trace : NULL, &lmf, NULL, NULL);
829 if (!ji) {
830 g_warning ("Exception inside function without unwind info");
831 g_assert_not_reached ();
832 }
833
834 if (ji != (gpointer)-1) {
835 frameCount++;
836
837 if ((test_only) &&
838 (ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) &&
839 (mono_ex)) {
840 if (!initialStackTrace && (frameCount < 1000)) {
841 trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
842 g_string_append (traceStr, trace);
843 g_string_append_c (traceStr, '\n');
844 }
845 }
846
847 if (ji->num_clauses) {
848 int i;
849
850 g_assert (ji->clauses);
851
852 for (i = 0; i < ji->num_clauses; i++) {
853 MonoJitExceptionInfo *ei = &ji->clauses [i];
854 gboolean filtered = FALSE;
855
856 if (ei->try_start < MONO_CONTEXT_GET_IP (ctx) &&
857 MONO_CONTEXT_GET_IP (ctx) <= ei->try_end) {
858 /* catch block */
859 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) ||
860 (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)) {
861 g_assert (ji->exvar_offset);
862 *((gpointer *)((char *)MONO_CONTEXT_GET_BP (ctx) + ji->exvar_offset)) = obj;
863 if (!initialStackTrace &&
864 traceStr) {
865 mono_ex->stack_trace = mono_string_new (domain, traceStr->str);
866 }
867 }
868
869 if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)
870 filtered = call_filter (ctx, ei->data.filter, obj);
871
872 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) &&
873 (mono_object_isinst (obj, mono_class_get (ji->method->klass->image, ei->data.token))) ||
874 (filtered)) {
875 if (test_only) {
876 if (mono_ex) {
877 trace_ips = g_list_reverse (trace_ips);
878 mono_ex->trace_ips = glist_to_array (trace_ips);
879 }
880 g_list_free (trace_ips);
881 g_free (trace);
882 if (traceStr)
883 g_string_free (traceStr, TRUE);
884
885 return TRUE;
886 }
887
888 if (mono_jit_trace_calls != NULL)
889 g_print ("EXCEPTION: catch found at clause %d of %s - caught at %p with sp %p\n",
890 i, mono_method_full_name (ji->method, TRUE),
891 ei->handler_start,
892 MONO_CONTEXT_GET_BP(ctx));
893 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
894 jit_tls->lmf = lmf;
895 g_free (trace);
896 if (traceStr)
897 g_string_free (traceStr, TRUE);
898 return FALSE;
899 }
900
901 if (!test_only && ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
902 MONO_CONTEXT_GET_IP (ctx) < ei->try_end &&
903 (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
904 if (mono_jit_trace_calls != NULL)
905 g_print ("EXCEPTION: finally clause %d of %s handled at: %p using sp: %p\n",
906 i, mono_method_full_name (ji->method, TRUE),
907 ei->handler_start,
908 MONO_CONTEXT_GET_BP(ctx));
909 call_filter (ctx, ei->handler_start, NULL);
910 }
911
912 }
913 }
914 }
915 }
916
917 g_free (trace);
918
919 *ctx = new_ctx;
920
921 if ((ji == (gpointer)-1) ||
922 (MONO_CONTEXT_GET_BP (ctx) >= jit_tls->end_of_stack)) {
923 if (!test_only) {
924 jit_tls->lmf = lmf;
925 jit_tls->abort_func (obj);
926 g_assert_not_reached ();
927 } else {
928 if (mono_ex) {
929 trace_ips = g_list_reverse (trace_ips);
930 mono_ex->trace_ips = glist_to_array (trace_ips);
931 }
932 g_list_free (trace_ips);
933 if (traceStr)
934 g_string_free (traceStr, TRUE);
935 return FALSE;
936 }
937 }
938 }
939
940 g_assert_not_reached ();
941 }
942
943 /*========================= End of Function ========================*/
944
945 /*------------------------------------------------------------------*/
946 /* */
947 /* Name - mono_arch_ip_from_context */
948 /* */
949 /* Function - Return the instruction pointer from the context. */
950 /* */
951 /* Parameters - sigctx - Saved processor state */
952 /* */
953 /*------------------------------------------------------------------*/
954
955 gpointer
956 mono_arch_ip_from_context (void *sigctx)
957 {
958 return context_get_ip (sigctx);
959 }
960
Mirror of the official Mono project git repository