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 MONO_CONTEXT_SET_IP(ctx,ip) \
25 (ctx)->uc_mcontext.gregs[14] = (unsigned long)ip; \
26 (ctx)->uc_mcontext.psw.addr = (unsigned long)ip; \
29 #define MONO_CONTEXT_SET_BP(ctx,bp) \
31 (ctx)->uc_mcontext.gregs[15] = (unsigned long)bp; \
32 (ctx)->uc_stack.ss_sp = (unsigned long)bp; \
35 #define MONO_CONTEXT_GET_IP(ctx) context_get_ip ((ctx))
36 #define MONO_CONTEXT_GET_BP(ctx) ((gpointer)((ctx)->uc_mcontext.gregs[15]))
38 /* disable this for now */
39 #undef MONO_USE_EXC_TABLES
41 #define S390_CALLFILTER_INTREGS S390_MINIMAL_STACK_SIZE
42 #define S390_CALLFILTER_FLTREGS S390_CALLFILTER_INTREGS+(16*sizeof(gulong))
43 #define S390_CALLFILTER_ACCREGS S390_CALLFILTER_FLTREGS+(16*sizeof(gdouble))
44 #define S390_CALLFILTER_SIZE (S390_CALLFILTER_ACCREGS+(16*sizeof(gulong)))
46 #define S390_THROWSTACK_ACCPRM S390_MINIMAL_STACK_SIZE
47 #define S390_THROWSTACK_FPCPRM S390_THROWSTACK_ACCPRM+sizeof(gpointer)
48 #define S390_THROWSTACK_INTREGS S390_THROWSTACK_FPCPRM+sizeof(gulong)
49 #define S390_THROWSTACK_FLTREGS S390_THROWSTACK_INTREGS+(16*sizeof(gulong))
50 #define S390_THROWSTACK_ACCREGS S390_THROWSTACK_FLTREGS+(16*sizeof(gdouble))
51 #define S390_THROWSTACK_SIZE (S390_THROWSTACK_ACCREGS+(16*sizeof(gulong)))
53 /*========================= End of Defines =========================*/
55 /*------------------------------------------------------------------*/
57 /*------------------------------------------------------------------*/
65 #include <mono/arch/s390x/s390x-codegen.h>
66 #include <mono/metadata/appdomain.h>
67 #include <mono/metadata/tabledefs.h>
68 #include <mono/metadata/threads.h>
69 #include <mono/metadata/debug-helpers.h>
70 #include <mono/metadata/exception.h>
71 #include <mono/metadata/mono-debug.h>
74 #include "mini-s390x.h"
76 /*========================= End of Includes ========================*/
78 /*------------------------------------------------------------------*/
80 /*------------------------------------------------------------------*/
90 #ifdef MONO_USE_EXC_TABLES
92 /*************************************/
93 /* STACK UNWINDING STUFF */
94 /*************************************/
96 /* These definitions are from unwind-dw2.c in glibc 2.2.5 */
99 #define DWARF_FRAME_REGISTERS 17
101 typedef struct frame_state
107 long reg_or_offset[DWARF_FRAME_REGISTERS+1];
108 unsigned short cfa_reg;
109 unsigned short retaddr_column;
110 char saved[DWARF_FRAME_REGISTERS+1];
113 typedef struct frame_state * (*framesf) (void *, struct frame_state *);
117 /*========================= End of Typedefs ========================*/
119 /*------------------------------------------------------------------*/
120 /* P r o t o t y p e s */
121 /*------------------------------------------------------------------*/
123 gboolean mono_arch_handle_exception (void *ctx,
127 /*========================= End of Prototypes ======================*/
129 /*------------------------------------------------------------------*/
130 /* G l o b a l V a r i a b l e s */
131 /*------------------------------------------------------------------*/
133 #ifdef MONO_USE_EXC_TABLES
135 static framesf frame_state_for = NULL;
137 static gboolean inited = FALSE;
139 typedef char ** (*get_backtrace_symbols_type) (void *__const *__array, int __size);
141 static get_backtrace_symbols_type get_backtrace_symbols = NULL;
145 /*====================== End of Global Variables ===================*/
147 /*------------------------------------------------------------------*/
149 /* Name - context_get_ip */
151 /* Function - Extract the current instruction address from the */
154 /*------------------------------------------------------------------*/
156 static inline gpointer
157 context_get_ip (MonoContext *ctx)
161 ip = (gpointer) ((gint32) (ctx->uc_mcontext.psw.addr) & 0x7fffffff);
165 /*========================= End of Function ========================*/
167 #ifdef MONO_USE_EXC_TABLES
169 /*------------------------------------------------------------------*/
171 /* Name - init_frame_state_for */
173 /* Function - Load the __frame_state_for from libc. */
174 /* There are two versions of __frame_state_for: one */
175 /* in libgcc.a and the other in glibc.so. We need */
176 /* the version from glibc. For more information, see:*/
177 /* http://gcc.gnu.org/ml/gcc/2002-08/msg00192.html */
179 /*------------------------------------------------------------------*/
182 init_frame_state_for (void)
186 if ((module = g_module_open ("libc.so.6", G_MODULE_BIND_LAZY))) {
188 if (!g_module_symbol (module, "__frame_state_for", (gpointer*)&frame_state_for))
189 frame_state_for = NULL;
191 if (!g_module_symbol (module, "backtrace_symbols", (gpointer*)&get_backtrace_symbols)) {
192 get_backtrace_symbols = NULL;
193 frame_state_for = NULL;
196 g_module_close (module);
202 /*========================= End of Function ========================*/
206 /*------------------------------------------------------------------*/
208 /* Name - mono_arch_has_unwind_info */
210 /* Function - Tests if a function has a DWARF exception table */
211 /* that is able to restore all caller saved registers*/
213 /*------------------------------------------------------------------*/
216 mono_arch_has_unwind_info (gconstpointer addr)
221 /*========================= End of Function ========================*/
223 /*------------------------------------------------------------------*/
225 /* Name - s390_unwind_native_frame */
227 /* Function - Use the context to unwind a stack frame. */
229 /*------------------------------------------------------------------*/
232 s390_unwind_native_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
233 struct sigcontext *ctx, struct sigcontext *new_ctx,
234 MonoLMF *lmf, char **trace)
237 struct stack_frame *frame;
240 struct frame_state state_in;
241 struct frame_state *res;
247 init_frame_state_for ();
249 if (!frame_state_for)
252 frame = MONO_CONTEXT_GET_BP (ctx);
254 max_stack = lmf && lmf->method ? lmf : jit_tls->end_of_stack;
258 memset (&state_in, 0, sizeof (state_in));
260 while ((gpointer)frame->next < (gpointer)max_stack) {
261 gpointer ip, addr = frame->return_address;
263 char *tmp, **symbols;
266 ip = MONO_CONTEXT_GET_IP (new_ctx);
267 symbols = get_backtrace_symbols (&ip, 1);
269 tmp = g_strdup_printf ("%s\nin (unmanaged) %s", *trace, symbols [0]);
271 tmp = g_strdup_printf ("in (unmanaged) %s", symbols [0]);
278 if ((res = frame_state_for (addr, &state_in))) {
281 cfa = (gint8*) (get_sigcontext_reg (new_ctx, res->cfa_reg) + res->cfa_offset);
282 frame = (struct stack_frame *)((gint8*)cfa - 8);
283 for (i = 0; i < DWARF_FRAME_REGISTERS + 1; i++) {
284 int how = res->saved[i];
286 g_assert ((how == 0) || (how == 1));
289 val = * (long*) ((gint8*)cfa + res->reg_or_offset[i]);
290 set_sigcontext_reg (new_ctx, i, val);
293 new_ctx->SC_ESP = (long)cfa;
295 if (res->saved [X86_EBX] == 1 &&
296 res->saved [X86_EDI] == 1 &&
297 res->saved [X86_EBP] == 1 &&
298 res->saved [X86_ESI] == 1 &&
299 (ji = mono_jit_info_table_find (domain, frame->return_address))) {
300 //printf ("FRAME CFA %s\n", mono_method_full_name (ji->method, TRUE));
306 MONO_CONTEXT_SET_IP (new_ctx, frame->return_address);
308 MONO_CONTEXT_SET_BP (new_ctx, frame);
310 /* stop if !frame or when we detect an unexpected managed frame */
311 if (!frame || mono_jit_info_table_find (domain, frame->return_address)) {
329 /*========================= End of Function ========================*/
331 /*------------------------------------------------------------------*/
333 /* Name - arch_get_call_filter */
335 /* Function - Return a pointer to a method which calls an */
336 /* exception filter. We also use this function to */
337 /* call finally handlers (we pass NULL as @exc */
338 /* object in this case). */
340 /*------------------------------------------------------------------*/
343 arch_get_call_filter (void)
345 static guint8 start [512];
346 static int inited = 0;
348 int alloc_size, pos, i;
354 /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
357 s390_stmg(code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
358 s390_lgr (code, s390_r14, STK_BASE);
359 alloc_size = S390_ALIGN(S390_CALLFILTER_SIZE, S390_STACK_ALIGNMENT);
360 s390_aghi(code, STK_BASE, -alloc_size);
361 s390_stg (code, s390_r14, 0, STK_BASE, 0);
363 /*------------------------------------------------------*/
364 /* save general registers on stack */
365 /*------------------------------------------------------*/
366 s390_stmg(code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
368 /*------------------------------------------------------*/
370 /*------------------------------------------------------*/
371 s390_lgr (code, s390_r13, s390_r2);
373 /*------------------------------------------------------*/
374 /* Get A(Handler Entry Point) */
375 /*------------------------------------------------------*/
376 s390_lgr (code, s390_r0, s390_r3);
378 /*------------------------------------------------------*/
379 /* Set parameter register with Exception */
380 /*------------------------------------------------------*/
381 s390_lgr (code, s390_r2, s390_r4);
383 /*------------------------------------------------------*/
384 /* Load all registers with values from the context */
385 /*------------------------------------------------------*/
386 s390_lmg (code, s390_r3, s390_r12, s390_r13, G_STRUCT_OFFSET(MonoContext, uc_mcontext.gregs[3]));
387 pos = G_STRUCT_OFFSET(MonoContext, uc_mcontext.fpregs.fprs[0]);
388 for (i = 0; i < 16; ++i) {
389 s390_ld (code, i, 0, s390_r13, pos);
390 pos += sizeof(gdouble);
393 /*------------------------------------------------------*/
394 /* Point at the copied stack frame and call the filter */
395 /*------------------------------------------------------*/
396 s390_lgr (code, s390_r1, s390_r0);
397 s390_basr (code, s390_r14, s390_r1);
399 /*------------------------------------------------------*/
400 /* Save return value */
401 /*------------------------------------------------------*/
402 s390_lgr (code, s390_r14, s390_r2);
404 /*------------------------------------------------------*/
405 /* Restore all the regs from the stack */
406 /*------------------------------------------------------*/
407 s390_lmg (code, s390_r0, s390_r13, STK_BASE, S390_CALLFILTER_INTREGS);
409 s390_lgr (code, s390_r2, s390_r14);
410 s390_aghi (code, s390_r15, alloc_size);
411 s390_lmg (code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
412 s390_br (code, s390_r14);
414 g_assert ((code - start) < sizeof(start));
418 /*========================= End of Function ========================*/
420 /*------------------------------------------------------------------*/
422 /* Name - throw_exception. */
424 /* Function - Raise an exception based on the parameters passed.*/
426 /*------------------------------------------------------------------*/
429 throw_exception (MonoObject *exc, unsigned long ip, unsigned long sp,
430 gulong *int_regs, gdouble *fp_regs, gulong *acc_regs, guint fpc)
432 static void (*restore_context) (MonoContext *);
436 memset(&ctx, 0, sizeof(ctx));
440 /* adjust eip so that it point into the call instruction */
443 for (iReg = 0; iReg < 16; iReg++) {
444 ctx.uc_mcontext.gregs[iReg] = int_regs[iReg];
445 ctx.uc_mcontext.fpregs.fprs[iReg].d = fp_regs[iReg];
446 ctx.uc_mcontext.aregs[iReg] = acc_regs[iReg];
449 ctx.uc_mcontext.fpregs.fpc = fpc;
451 MONO_CONTEXT_SET_BP (&ctx, sp);
452 MONO_CONTEXT_SET_IP (&ctx, ip);
454 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
455 MonoException *mono_ex = (MonoException*)exc;
456 mono_ex->stack_trace = NULL;
458 mono_arch_handle_exception (&ctx, exc, FALSE);
461 g_assert_not_reached ();
464 /*========================= End of Function ========================*/
466 /*------------------------------------------------------------------*/
468 /* Name - arch_get_throw_exception_generic */
470 /* Function - Return a function pointer which can be used to */
471 /* raise exceptions. The returned function has the */
472 /* following signature: */
473 /* void (*func) (MonoException *exc); or, */
474 /* void (*func) (char *exc_name); */
476 /*------------------------------------------------------------------*/
479 mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name)
482 int alloc_size, pos, i, offset;
486 s390_stmg(code, s390_r6, s390_r14, STK_BASE, S390_REG_SAVE_OFFSET);
487 alloc_size = S390_ALIGN(S390_THROWSTACK_SIZE, S390_STACK_ALIGNMENT);
488 s390_lgr (code, s390_r14, STK_BASE);
489 s390_aghi (code, STK_BASE, -alloc_size);
490 s390_stg (code, s390_r14, 0, STK_BASE, 0);
492 s390_lgr (code, s390_r4, s390_r2);
493 s390_bras (code, s390_r13, 6);
494 s390_llong(code, mono_defaults.corlib);
495 s390_llong(code, "System");
496 s390_lg (code, s390_r2, 0, s390_r13, 0);
497 s390_lg (code, s390_r3, 0, s390_r13, 4);
498 offset = (guint32) S390_RELATIVE(mono_exception_from_name, code);
499 s390_brasl(code, s390_r14, offset);
501 /*------------------------------------------------------*/
502 /* save the general registers on the stack */
503 /*------------------------------------------------------*/
504 s390_stmg(code, s390_r0, s390_r13, STK_BASE, S390_THROWSTACK_INTREGS);
506 s390_lgr (code, s390_r1, STK_BASE);
507 s390_aghi(code, s390_r1, alloc_size);
508 /*------------------------------------------------------*/
509 /* save the return address in the parameter register */
510 /*------------------------------------------------------*/
511 s390_lg (code, s390_r3, 0, s390_r1, S390_RET_ADDR_OFFSET);
513 /*------------------------------------------------------*/
514 /* save the floating point registers */
515 /*------------------------------------------------------*/
516 pos = S390_THROWSTACK_FLTREGS;
517 for (i = 0; i < 16; ++i) {
518 s390_std (code, i, 0,STK_BASE, pos);
519 pos += sizeof (gdouble);
521 /*------------------------------------------------------*/
522 /* save the access registers */
523 /*------------------------------------------------------*/
524 s390_stam (code, s390_r0, s390_r15, STK_BASE, S390_THROWSTACK_ACCREGS);
526 /*------------------------------------------------------*/
527 /* call throw_exception (exc, ip, sp, gr, fr, ar) */
528 /* exc is already in place in r2 */
529 /*------------------------------------------------------*/
530 s390_lgr (code, s390_r4, s390_r1); /* caller sp */
531 /*------------------------------------------------------*/
532 /* pointer to the saved int regs */
533 /*------------------------------------------------------*/
534 s390_la (code, s390_r5, 0, STK_BASE, S390_THROWSTACK_INTREGS);
535 s390_la (code, s390_r6, 0, STK_BASE, S390_THROWSTACK_FLTREGS);
536 s390_la (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCREGS);
537 s390_stg (code, s390_r7, 0, STK_BASE, S390_THROWSTACK_ACCPRM);
538 s390_stfpc(code, STK_BASE, S390_THROWSTACK_FPCPRM);
539 offset = (guint32) S390_RELATIVE(throw_exception, code);
540 s390_brasl(code, s390_r14, offset);
541 /* we should never reach this breakpoint */
543 g_assert ((code - start) < size);
547 /*========================= End of Function ========================*/
549 /*------------------------------------------------------------------*/
551 /* Name - arch_get_throw_exception */
553 /* Function - Return a function pointer which can be used to */
554 /* raise exceptions. The returned function has the */
555 /* following signature: */
556 /* void (*func) (MonoException *exc); */
558 /*------------------------------------------------------------------*/
561 mono_arch_get_throw_exception (void)
563 static guint8 start [384];
564 static int inited = 0;
568 mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE);
573 /*========================= End of Function ========================*/
575 /*------------------------------------------------------------------*/
577 /* Name - arch_get_throw_exception_by_name */
579 /* Function - Return a function pointer which can be used to */
580 /* raise corlib exceptions. The return function has */
581 /* the following signature: */
582 /* void (*func) (char *exc_name); */
584 /*------------------------------------------------------------------*/
587 mono_arch_get_throw_exception_by_name (void)
589 static guint8 start [384];
590 static int inited = 0;
594 mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE);
599 /*========================= End of Function ========================*/
601 /*------------------------------------------------------------------*/
603 /* Name - glist_to_array */
605 /* Function - Convert a list to a mono array. */
607 /*------------------------------------------------------------------*/
610 glist_to_array (GList *list)
612 MonoDomain *domain = mono_domain_get ();
619 len = g_list_length (list);
620 res = mono_array_new (domain, mono_defaults.int_class, len);
622 for (i = 0; list; list = list->next, i++)
623 mono_array_set (res, gpointer, i, list->data);
628 /*========================= End of Function ========================*/
630 /*------------------------------------------------------------------*/
632 /* Name - mono_arch_find_jit_info */
634 /* Function - This function is used to gather informatoin from */
635 /* @ctx. It returns the MonoJitInfo of the corres- */
636 /* ponding function, unwinds one stack frame and */
637 /* stores the resulting context into @new_ctx. It */
638 /* also stores a string describing the stack location*/
639 /* into @trace (if not NULL), and modifies the @lmf */
640 /* if necessary. @native_offset returns the IP off- */
641 /* set from the start of the function or -1 if that */
642 /* informatoin is not available. */
644 /*------------------------------------------------------------------*/
647 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
648 MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
649 MonoContext *new_ctx, char **trace, MonoLMF **lmf,
650 int *native_offset, gboolean *managed)
653 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
656 MonoS390StackFrame *sframe;
659 (ip > prev_ji->code_start &&
660 ((guint8 *) ip < ((guint8 *) prev_ji->code_start) + prev_ji->code_size)))
663 ji = mono_jit_info_table_find (domain, ip);
675 char *source_location, *tmpaddr, *fname;
676 gint32 address, iloffset;
680 // memcpy(new_ctx, ctx, sizeof(*new_ctx));
682 if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
683 /* remove any unused lmf */
684 *lmf = (*lmf)->previous_lmf;
687 address = (char *)ip - (char *)ji->code_start;
690 *native_offset = address;
693 if (!ji->method->wrapper_type)
697 source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain);
698 iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
701 tmpaddr = g_strdup_printf ("<0x%08x>", address);
703 tmpaddr = g_strdup_printf ("[0x%08x]", iloffset);
705 fname = mono_method_full_name (ji->method, TRUE);
708 *trace = g_strdup_printf ("in %s (at %s) %s", tmpaddr, source_location, fname);
710 *trace = g_strdup_printf ("in %s %s", tmpaddr, fname);
713 g_free (source_location);
716 sframe = (MonoS390StackFrame *) MONO_CONTEXT_GET_BP (ctx);
717 MONO_CONTEXT_SET_BP (new_ctx, sframe->prev);
718 sframe = (MonoS390StackFrame *) sframe->prev;
719 MONO_CONTEXT_SET_IP (new_ctx, sframe->return_address);
720 memcpy (&new_ctx->uc_mcontext.gregs[6], sframe->regs, (8*sizeof(gint32)));
730 *trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
732 if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
734 memset (res, 0, sizeof (MonoJitInfo));
735 res->method = (*lmf)->method;
739 MONO_CONTEXT_SET_BP (ctx, (*lmf)->ebp);
740 MONO_CONTEXT_SET_IP (ctx, (*lmf)->eip);
742 memcpy(new_ctx->uc_mcontext.gregs, (*lmf)->gregs, sizeof((*lmf)->gregs));
743 memcpy(new_ctx->uc_mcontext.fpregs.fprs, (*lmf)->fregs, sizeof((*lmf)->fregs));
745 MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
746 MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
747 *lmf = (*lmf)->previous_lmf;
749 return ji ? ji : res;
755 /*========================= End of Function ========================*/
757 /*------------------------------------------------------------------*/
759 /* Name - ves_icall_get_trace */
763 /*------------------------------------------------------------------*/
766 ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
768 MonoDomain *domain = mono_domain_get ();
770 MonoArray *ta = exc->trace_ips;
774 return mono_array_new (domain, mono_defaults.stack_frame_class, 0);
777 len = mono_array_length (ta);
779 res = mono_array_new (domain, mono_defaults.stack_frame_class,
780 len > skip ? len - skip : 0);
782 for (i = skip; i < len; i++) {
784 MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
785 gpointer ip = mono_array_get (ta, gpointer, i);
787 ji = mono_jit_info_table_find (domain, ip);
789 mono_array_set (res, gpointer, i, sf);
793 sf->method = mono_method_get_object (domain, ji->method, NULL);
794 sf->native_offset = (char *)ip - (char *)ji->code_start;
796 sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset, domain);
798 if (need_file_info) {
801 filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line, domain);
803 sf->filename = filename? mono_string_new (domain, filename): NULL;
809 mono_array_set (res, gpointer, i, sf);
815 /*========================= End of Function ========================*/
817 /*------------------------------------------------------------------*/
819 /* Name - mono_jit_walk_stack */
823 /*------------------------------------------------------------------*/
826 mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) {
827 MonoDomain *domain = mono_domain_get ();
828 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
829 MonoLMF *lmf = jit_tls->lmf;
830 MonoJitInfo *ji, rji;
831 gint native_offset, il_offset;
833 MonoContext ctx, new_ctx;
835 MONO_CONTEXT_SET_IP (&ctx, __builtin_return_address (0));
836 MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (1));
838 while (MONO_CONTEXT_GET_BP (&ctx) < jit_tls->end_of_stack) {
840 ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL,
841 &ctx, &new_ctx, NULL, &lmf,
842 &native_offset, &managed);
845 if (ji == (gpointer)-1)
848 il_offset = do_il_offset ? mono_debug_il_offset_from_address (ji->method, native_offset, domain): -1;
850 if (func (ji->method, native_offset, il_offset, managed, user_data))
857 /*========================= End of Function ========================*/
859 /*------------------------------------------------------------------*/
861 /* Name - ves_icall_get_frame_info */
865 /*------------------------------------------------------------------*/
868 ves_icall_get_frame_info (gint32 skip, MonoBoolean need_file_info,
869 MonoReflectionMethod **method,
870 gint32 *iloffset, gint32 *native_offset,
871 MonoString **file, gint32 *line, gint32 *column)
873 MonoDomain *domain = mono_domain_get ();
874 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
875 MonoLMF *lmf = jit_tls->lmf;
876 MonoJitInfo *ji, rji;
877 MonoContext ctx, new_ctx;
879 MONO_CONTEXT_SET_IP (&ctx, ves_icall_get_frame_info);
880 MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (0));
885 ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL,
886 &ctx, &new_ctx, NULL, &lmf,
887 native_offset, NULL);
891 if (!ji || ji == (gpointer)-1 || MONO_CONTEXT_GET_BP (&ctx) >= jit_tls->end_of_stack)
894 /* skip all wrappers ??*/
895 if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
896 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
897 ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
898 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
899 ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE)
906 *method = mono_method_get_object (domain, ji->method, NULL);
907 *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain);
909 if (need_file_info) {
912 filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain);
914 *file = filename? mono_string_new (domain, filename): NULL;
923 /*========================= End of Function ========================*/
925 /*------------------------------------------------------------------*/
927 /* Name - mono_arch_handle_exception */
929 /* Function - Handle an exception raised by the JIT code. */
931 /* Parameters - ctx - Saved processor state */
932 /* obj - The exception object */
933 /* test_only - Only test if the exception is caught, */
934 /* but don't call handlers */
936 /*------------------------------------------------------------------*/
939 mono_arch_handle_exception (void *uc, gpointer obj, gboolean test_only)
941 MonoContext *ctx = uc;
942 MonoDomain *domain = mono_domain_get ();
943 MonoJitInfo *ji, rji;
944 static int (*call_filter) (MonoContext *, gpointer, gpointer) = NULL;
945 MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
946 MonoLMF *lmf = jit_tls->lmf;
947 GList *trace_ips = NULL;
948 MonoException *mono_ex;
950 g_assert (ctx != NULL);
951 memset(&rji, 0, sizeof(rji));
953 MonoException *ex = mono_get_exception_null_reference ();
954 ex->message = mono_string_new (domain,
955 "Object reference not set to an instance of an object");
956 obj = (MonoObject *)ex;
959 if (mono_object_isinst (obj, mono_defaults.exception_class)) {
960 mono_ex = (MonoException*)obj;
961 mono_ex->stack_trace = NULL;
968 call_filter = arch_get_call_filter ();
970 g_assert (jit_tls->end_of_stack);
971 g_assert (jit_tls->abort_func);
974 MonoContext ctx_cp = *ctx;
975 if (mono_jit_trace_calls != NULL)
976 g_print ("EXCEPTION handling: %s\n", mono_object_class (obj)->name);
977 if (!mono_arch_handle_exception (&ctx_cp, obj, TRUE)) {
978 if (mono_break_on_exc)
980 mono_unhandled_exception (obj);
988 ji = mono_arch_find_jit_info (domain, jit_tls, &rji, &rji, ctx, &new_ctx,
989 test_only ? &trace : NULL, &lmf, NULL, NULL);
991 g_warning ("Exception inside function without unwind info");
992 g_assert_not_reached ();
995 if (ji != (gpointer)-1) {
997 if (test_only && ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
1000 trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
1002 if (!mono_ex->stack_trace)
1003 strace = g_strdup ("");
1005 strace = mono_string_to_utf8 (mono_ex->stack_trace);
1007 tmp = g_strdup_printf ("%s%s\n", strace, trace);
1010 mono_ex->stack_trace = mono_string_new (domain, tmp);
1015 if (ji->num_clauses) {
1018 g_assert (ji->clauses);
1020 for (i = 0; i < ji->num_clauses; i++) {
1021 MonoJitExceptionInfo *ei = &ji->clauses [i];
1023 if (ei->try_start < MONO_CONTEXT_GET_IP (ctx) &&
1024 MONO_CONTEXT_GET_IP (ctx) <= ei->try_end) {
1026 if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
1027 mono_object_isinst (obj, ei->data.catch_class)) ||
1028 ((ei->flags == MONO_EXCEPTION_CLAUSE_FILTER &&
1029 call_filter (ctx, ei->data.filter, obj)))) {
1032 trace_ips = g_list_reverse (trace_ips);
1033 mono_ex->trace_ips = glist_to_array (trace_ips);
1035 g_list_free (trace_ips);
1039 // memcpy(ctx, &new_ctx, sizeof(new_ctx));
1040 if (mono_jit_trace_calls != NULL)
1041 g_print ("EXCEPTION: catch found at clause %d of %s - caught at %p with sp %p\n",
1042 i, mono_method_full_name (ji->method, TRUE),
1044 MONO_CONTEXT_GET_BP(ctx));
1045 MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
1046 *((gpointer *)((char *)MONO_CONTEXT_GET_BP (ctx) + ji->exvar_offset)) = obj;
1051 if (!test_only && ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
1052 MONO_CONTEXT_GET_IP (ctx) < ei->try_end &&
1053 (ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
1054 if (mono_jit_trace_calls != NULL)
1055 g_print ("EXCEPTION: finally clause %d of %s handled at: %p using sp: %p\n",
1056 i, mono_method_full_name (ji->method, TRUE),
1058 MONO_CONTEXT_GET_BP(ctx));
1059 call_filter (ctx, ei->handler_start, NULL);
1071 if ((ji == (gpointer)-1) || MONO_CONTEXT_GET_BP (ctx) >= jit_tls->end_of_stack) {
1074 jit_tls->abort_func (obj);
1075 g_assert_not_reached ();
1078 trace_ips = g_list_reverse (trace_ips);
1079 mono_ex->trace_ips = glist_to_array (trace_ips);
1081 g_list_free (trace_ips);
1087 g_assert_not_reached ();
1090 /*========================= End of Function ========================*/
1092 /*------------------------------------------------------------------*/
1094 /* Name - mono_arch_ip_from_context */
1096 /* Function - Return the instruction pointer from the context. */
1098 /* Parameters - sigctx - Saved processor state */
1100 /*------------------------------------------------------------------*/
1103 mono_arch_ip_from_context (void *sigctx)
1105 return context_get_ip (sigctx);