In mono/metadata:
[mono.git] / mono / mini / exceptions-ia64.c
blob414b61e3495853813f604d033affa12bfb38dd10
1 /*
2 * exceptions-ia64.c: exception support for IA64
4 * Authors:
5 * Zoltan Varga (vargaz@gmail.com)
7 * (C) 2001 Ximian, Inc.
8 */
11 * We implement exception handling with the help of the libuwind library:
13 * http://www.hpl.hp.com/research/linux/libunwind/
15 * Under IA64 all functions are assumed to have unwind info, we do not need to save
16 * the machine state in the LMF. But we have to generate unwind info for all
17 * dynamically generated code.
20 #include <config.h>
21 #include <glib.h>
22 #include <signal.h>
23 #include <string.h>
24 #include <sys/ucontext.h>
26 #include <mono/arch/ia64/ia64-codegen.h>
27 #include <mono/metadata/appdomain.h>
28 #include <mono/metadata/tabledefs.h>
29 #include <mono/metadata/threads.h>
30 #include <mono/metadata/debug-helpers.h>
31 #include <mono/metadata/exception.h>
32 #include <mono/metadata/gc-internal.h>
33 #include <mono/metadata/mono-debug.h>
35 #include "mini.h"
36 #include "mini-ia64.h"
38 #define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
40 #define GP_SCRATCH_REG 31
41 #define GP_SCRATCH_REG2 30
43 G_GNUC_UNUSED static void
44 print_ctx (MonoContext *ctx)
46 char name[256];
47 unw_word_t off, ip, sp;
48 unw_proc_info_t pi;
49 int res;
51 unw_get_proc_name (&ctx->cursor, name, 256, &off);
52 unw_get_proc_info(&ctx->cursor, &pi);
53 res = unw_get_reg (&ctx->cursor, UNW_IA64_IP, &ip);
54 g_assert (res == 0);
55 res = unw_get_reg (&ctx->cursor, UNW_IA64_SP, &sp);
56 g_assert (res == 0);
58 printf ("%s:%lx [%lx-%lx] SP: %lx\n", name, ip - pi.start_ip, pi.start_ip, pi.end_ip, sp);
61 static gpointer
62 ia64_create_ftnptr (gpointer ptr)
64 gpointer *desc = mono_global_codeman_reserve (2 * sizeof (gpointer));
65 desc [0] = ptr;
66 desc [1] = NULL;
68 return desc;
71 static void
72 restore_context (MonoContext *ctx)
74 int res;
75 unw_word_t ip;
77 res = unw_get_reg (&ctx->cursor, UNW_IA64_IP, &ip);
78 g_assert (res == 0);
80 /* Set this to 0 to tell OP_START_HANDLER that it doesn't have to set the frame pointer */
81 res = unw_set_reg (&ctx->cursor, UNW_IA64_GR + 15, 0);
82 g_assert (res == 0);
84 unw_resume (&ctx->cursor);
88 * mono_arch_get_restore_context:
90 * Returns a pointer to a method which restores a previously saved sigcontext.
92 gpointer
93 mono_arch_get_restore_context (void)
95 return restore_context;
98 static gpointer
99 get_real_call_filter (void)
101 static gpointer filter;
102 static gboolean inited = FALSE;
103 guint8 *start;
104 Ia64CodegenState code;
105 int in0, local0, out0, nout;
106 unw_dyn_info_t *di;
107 unw_dyn_region_info_t *r_pro, *r_body, *r_epilog;
109 if (inited)
110 return filter;
112 start = mono_global_codeman_reserve (1024);
114 /* int call_filter (guint64 fp, guint64 ip) */
117 * We have to create a register+stack frame similar to the frame which
118 * contains the filter.
119 * - setting fp
120 * - setting up a register stack frame
121 * These cannot be set up in this function, because the fp register is a
122 * stacked register which is different in each method. Also, the register
123 * stack frame is different in each method. So we pass the FP value in a a
124 * non-stacked register and the code generated by the OP_START_HANDLER
125 * opcode will copy it to the appropriate register after setting up the
126 * register stack frame.
127 * The stacked registers are not need to be set since variables used in
128 * handler regions are never allocated to registers.
131 in0 = 32;
132 local0 = in0 + 2;
133 out0 = local0 + 4;
134 nout = 0;
136 ia64_codegen_init (code, start);
138 ia64_codegen_set_one_ins_per_bundle (code, TRUE);
140 ia64_unw_save_reg (code, UNW_IA64_AR_PFS, UNW_IA64_GR + local0 + 0);
141 ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, nout, 0);
142 ia64_unw_save_reg (code, UNW_IA64_RP, UNW_IA64_GR + local0 + 1);
143 ia64_mov_from_br (code, local0 + 1, IA64_B0);
145 ia64_begin_bundle (code);
147 r_pro = mono_ia64_create_unwind_region (&code);
149 /* Frame pointer */
150 ia64_mov (code, IA64_R15, in0 + 0);
151 /* Target ip */
152 ia64_mov_to_br (code, IA64_B6, in0 + 1);
154 /* Call the filter */
155 ia64_br_call_reg (code, IA64_B0, IA64_B6);
157 /* R8 contains the result of the filter */
159 /* FIXME: Add unwind info for this */
161 ia64_begin_bundle (code);
163 r_body = mono_ia64_create_unwind_region (&code);
164 r_pro->next = r_body;
166 ia64_mov_to_ar_i (code, IA64_PFS, local0 + 0);
167 ia64_mov_ret_to_br (code, IA64_B0, local0 + 1);
168 ia64_br_ret_reg (code, IA64_B0);
170 ia64_begin_bundle (code);
172 r_epilog = mono_ia64_create_unwind_region (&code);
173 r_body->next = r_epilog;
175 ia64_codegen_set_one_ins_per_bundle (code, FALSE);
177 ia64_codegen_close (code);
179 g_assert ((code.buf - start) <= 256);
181 mono_arch_flush_icache (start, code.buf - start);
183 di = g_malloc0 (sizeof (unw_dyn_info_t));
184 di->start_ip = (unw_word_t) start;
185 di->end_ip = (unw_word_t) code.buf;
186 di->gp = 0;
187 di->format = UNW_INFO_FORMAT_DYNAMIC;
188 di->u.pi.name_ptr = (unw_word_t)"throw_trampoline";
189 di->u.pi.regions = r_body;
191 _U_dyn_register (di);
193 filter = ia64_create_ftnptr (start);
195 inited = TRUE;
197 return filter;
200 static int
201 call_filter (MonoContext *ctx, gpointer ip)
203 int (*filter) (MonoContext *, gpointer);
204 gpointer fp = MONO_CONTEXT_GET_BP (ctx);
206 filter = get_real_call_filter ();
208 return filter (fp, ip);
212 * mono_arch_get_call_filter:
214 * Returns a pointer to a method which calls an exception filter. We
215 * also use this function to call finally handlers (we pass NULL as
216 * @exc object in this case).
218 gpointer
219 mono_arch_get_call_filter (void)
221 /* Initialize the real filter non-lazily */
222 get_real_call_filter ();
224 return call_filter;
227 static void
228 throw_exception (MonoObject *exc, guint64 rethrow)
230 unw_context_t unw_ctx;
231 MonoContext ctx;
232 MonoJitInfo *ji;
233 unw_word_t ip, sp;
234 int res;
236 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
237 MonoException *mono_ex = (MonoException*)exc;
238 if (!rethrow)
239 mono_ex->stack_trace = NULL;
242 res = unw_getcontext (&unw_ctx);
243 g_assert (res == 0);
244 res = unw_init_local (&ctx.cursor, &unw_ctx);
245 g_assert (res == 0);
248 * Unwind until the first managed frame. This is needed since
249 * mono_handle_exception expects the variables in the original context to
250 * correspond to the method returned by mono_find_jit_info.
252 while (TRUE) {
253 res = unw_get_reg (&ctx.cursor, UNW_IA64_IP, &ip);
254 g_assert (res == 0);
256 res = unw_get_reg (&ctx.cursor, UNW_IA64_SP, &sp);
257 g_assert (res == 0);
259 ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)ip, NULL);
261 //printf ("UN: %s %lx %lx\n", ji ? ji->method->name : "", ip, sp);
263 if (ji)
264 break;
266 res = unw_step (&ctx.cursor);
268 if (res == 0) {
270 * This means an unhandled exception during the compilation of a
271 * topmost method like Main
273 break;
275 g_assert (res >= 0);
277 ctx.precise_ip = FALSE;
279 mono_handle_exception (&ctx, exc, (gpointer)(ip), FALSE);
280 restore_context (&ctx);
282 g_assert_not_reached ();
285 static gpointer
286 get_throw_trampoline (gboolean rethrow)
288 guint8* start;
289 Ia64CodegenState code;
290 gpointer ptr = throw_exception;
291 int i, in0, local0, out0;
292 unw_dyn_info_t *di;
293 unw_dyn_region_info_t *r_pro;
295 start = mono_global_codeman_reserve (256);
297 in0 = 32;
298 local0 = in0 + 1;
299 out0 = local0 + 2;
301 ia64_codegen_init (code, start);
302 ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, 3, 0);
303 ia64_mov_from_br (code, local0 + 1, IA64_B0);
305 /* FIXME: This depends on the current instruction emitter */
307 r_pro = g_malloc0 (_U_dyn_region_info_size (2));
308 r_pro->op_count = 2;
309 r_pro->insn_count = 6;
310 i = 0;
311 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 2,
312 /* reg=*/ UNW_IA64_AR_PFS, /* dst=*/ UNW_IA64_GR + local0 + 0);
313 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 5,
314 /* reg=*/ UNW_IA64_RP, /* dst=*/ UNW_IA64_GR + local0 + 1);
315 g_assert ((unsigned) i <= r_pro->op_count);
317 /* Set args */
318 ia64_mov (code, out0 + 0, in0 + 0);
319 ia64_adds_imm (code, out0 + 1, rethrow, IA64_R0);
321 /* Call throw_exception */
322 ia64_movl (code, GP_SCRATCH_REG, ptr);
323 ia64_ld8_inc_imm (code, GP_SCRATCH_REG2, GP_SCRATCH_REG, 8);
324 ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
325 ia64_ld8 (code, IA64_GP, GP_SCRATCH_REG);
326 ia64_br_call_reg (code, IA64_B0, IA64_B6);
328 /* Not reached */
329 ia64_break_i (code, 1000);
330 ia64_codegen_close (code);
332 g_assert ((code.buf - start) <= 256);
334 mono_arch_flush_icache (start, code.buf - start);
336 di = g_malloc0 (sizeof (unw_dyn_info_t));
337 di->start_ip = (unw_word_t) start;
338 di->end_ip = (unw_word_t) code.buf;
339 di->gp = 0;
340 di->format = UNW_INFO_FORMAT_DYNAMIC;
341 di->u.pi.name_ptr = (unw_word_t)"throw_trampoline";
342 di->u.pi.regions = r_pro;
344 _U_dyn_register (di);
346 return ia64_create_ftnptr (start);
350 * mono_arch_get_throw_exception:
352 * Returns a function pointer which can be used to raise
353 * exceptions. The returned function has the following
354 * signature: void (*func) (MonoException *exc);
357 gpointer
358 mono_arch_get_throw_exception (void)
360 static guint8* start;
361 static gboolean inited = FALSE;
363 if (inited)
364 return start;
366 start = get_throw_trampoline (FALSE);
368 inited = TRUE;
370 return start;
373 gpointer
374 mono_arch_get_rethrow_exception (void)
376 static guint8* start;
377 static gboolean inited = FALSE;
379 if (inited)
380 return start;
382 start = get_throw_trampoline (TRUE);
384 inited = TRUE;
386 return start;
389 gpointer
390 mono_arch_get_throw_exception_by_name (void)
392 guint8* start;
393 Ia64CodegenState code;
395 start = mono_global_codeman_reserve (64);
397 /* Not used on ia64 */
398 ia64_codegen_init (code, start);
399 ia64_break_i (code, 1001);
400 ia64_codegen_close (code);
402 g_assert ((code.buf - start) <= 256);
404 mono_arch_flush_icache (start, code.buf - start);
406 return start;
410 * mono_arch_get_throw_corlib_exception:
412 * Returns a function pointer which can be used to raise
413 * corlib exceptions. The returned function has the following
414 * signature: void (*func) (guint32 ex_token_index, guint32 offset);
415 * Here, offset is the offset which needs to be substracted from the caller IP
416 * to get the IP of the throw. Passing the offset has the advantage that it
417 * needs no relocations in the caller.
419 gpointer
420 mono_arch_get_throw_corlib_exception (void)
422 static guint8* res;
423 static gboolean inited = FALSE;
424 guint8 *start;
425 gpointer ptr;
426 int i, in0, local0, out0, nout;
427 Ia64CodegenState code;
428 unw_dyn_info_t *di;
429 unw_dyn_region_info_t *r_pro;
431 if (inited)
432 return res;
434 start = mono_global_codeman_reserve (1024);
436 in0 = 32;
437 local0 = in0 + 2;
438 out0 = local0 + 4;
439 nout = 3;
441 ia64_codegen_init (code, start);
442 ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, nout, 0);
443 ia64_mov_from_br (code, local0 + 1, IA64_RP);
445 r_pro = g_malloc0 (_U_dyn_region_info_size (2));
446 r_pro->op_count = 2;
447 r_pro->insn_count = 6;
448 i = 0;
449 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 2,
450 /* reg=*/ UNW_IA64_AR_PFS, /* dst=*/ UNW_IA64_GR + local0 + 0);
451 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 5,
452 /* reg=*/ UNW_IA64_RP, /* dst=*/ UNW_IA64_GR + local0 + 1);
453 g_assert ((unsigned) i <= r_pro->op_count);
455 /* Call exception_from_token */
456 ia64_movl (code, out0 + 0, mono_defaults.exception_class->image);
457 ia64_mov (code, out0 + 1, in0 + 0);
458 ia64_movl (code, GP_SCRATCH_REG, MONO_TOKEN_TYPE_DEF);
459 ia64_add (code, out0 + 1, in0 + 0, GP_SCRATCH_REG);
460 ptr = mono_exception_from_token;
461 ia64_movl (code, GP_SCRATCH_REG, ptr);
462 ia64_ld8_inc_imm (code, GP_SCRATCH_REG2, GP_SCRATCH_REG, 8);
463 ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
464 ia64_ld8 (code, IA64_GP, GP_SCRATCH_REG);
465 ia64_br_call_reg (code, IA64_B0, IA64_B6);
466 ia64_mov (code, local0 + 3, IA64_R8);
468 /* Compute throw ip */
469 ia64_mov (code, local0 + 2, local0 + 1);
470 ia64_sub (code, local0 + 2, local0 + 2, in0 + 1);
472 /* Trick the unwind library into using throw_ip as the IP in the caller frame */
473 ia64_mov (code, local0 + 1, local0 + 2);
475 /* Set args */
476 ia64_mov (code, out0 + 0, local0 + 3);
477 ia64_mov (code, out0 + 1, IA64_R0);
479 /* Call throw_exception */
480 ptr = throw_exception;
481 ia64_movl (code, GP_SCRATCH_REG, ptr);
482 ia64_ld8_inc_imm (code, GP_SCRATCH_REG2, GP_SCRATCH_REG, 8);
483 ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
484 ia64_ld8 (code, IA64_GP, GP_SCRATCH_REG);
485 ia64_br_call_reg (code, IA64_B0, IA64_B6);
487 ia64_break_i (code, 1002);
488 ia64_codegen_close (code);
490 g_assert ((code.buf - start) <= 1024);
492 di = g_malloc0 (sizeof (unw_dyn_info_t));
493 di->start_ip = (unw_word_t) start;
494 di->end_ip = (unw_word_t) code.buf;
495 di->gp = 0;
496 di->format = UNW_INFO_FORMAT_DYNAMIC;
497 di->u.pi.name_ptr = (unw_word_t)"throw_corlib_exception_trampoline";
498 di->u.pi.regions = r_pro;
500 _U_dyn_register (di);
502 mono_arch_flush_icache (start, code.buf - start);
504 res = ia64_create_ftnptr (start);
505 inited = TRUE;
507 return res;
510 /* mono_arch_find_jit_info:
512 * This function is used to gather information from @ctx. It return the
513 * MonoJitInfo of the corresponding function, unwinds one stack frame and
514 * stores the resulting context into @new_ctx. It also stores a string
515 * describing the stack location into @trace (if not NULL), and modifies
516 * the @lmf if necessary. @native_offset return the IP offset from the
517 * start of the function or -1 if that info is not available.
519 MonoJitInfo *
520 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
521 MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
523 MonoJitInfo *ji;
524 int err;
525 unw_word_t ip;
527 *new_ctx = *ctx;
528 new_ctx->precise_ip = FALSE;
530 while (TRUE) {
531 err = unw_get_reg (&new_ctx->cursor, UNW_IA64_IP, &ip);
532 g_assert (err == 0);
534 /* Avoid costly table lookup during stack overflow */
535 if (prev_ji && ((guint8*)ip > (guint8*)prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
536 ji = prev_ji;
537 else
538 ji = mini_jit_info_table_find (domain, (gpointer)ip, NULL);
540 if (managed)
541 *managed = FALSE;
545 char name[256];
546 unw_word_t off;
548 unw_get_proc_name (&new_ctx->cursor, name, 256, &off);
549 printf ("F: %s\n", name);
553 if (ji != NULL) {
554 if (managed)
555 if (!ji->method->wrapper_type)
556 *managed = TRUE;
558 break;
561 /* This is an unmanaged frame, so just unwind through it */
562 /* FIXME: This returns -3 for the __clone2 frame in libc */
563 err = unw_step (&new_ctx->cursor);
564 if (err < 0)
565 break;
567 if (err == 0)
568 break;
571 if (ji) {
572 //print_ctx (new_ctx);
574 err = unw_step (&new_ctx->cursor);
575 g_assert (err >= 0);
577 //print_ctx (new_ctx);
579 return ji;
581 else
582 return (gpointer)(gssize)-1;
586 * mono_arch_handle_exception:
588 * @ctx: saved processor state
589 * @obj: the exception object
591 gboolean
592 mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only)
594 /* libunwind takes care of this */
595 unw_context_t unw_ctx;
596 MonoContext ctx;
597 MonoJitInfo *ji;
598 unw_word_t ip;
599 int res;
601 res = unw_getcontext (&unw_ctx);
602 g_assert (res == 0);
603 res = unw_init_local (&ctx.cursor, &unw_ctx);
604 g_assert (res == 0);
607 * Unwind until the first managed frame. This skips the signal handler frames
608 * too.
610 while (TRUE) {
611 res = unw_get_reg (&ctx.cursor, UNW_IA64_IP, &ip);
612 g_assert (res == 0);
614 ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)ip, NULL);
616 if (ji)
617 break;
619 res = unw_step (&ctx.cursor);
620 g_assert (res >= 0);
622 ctx.precise_ip = TRUE;
624 mono_handle_exception (&ctx, obj, (gpointer)ip, test_only);
626 restore_context (&ctx);
628 g_assert_not_reached ();
631 gpointer
632 mono_arch_ip_from_context (void *sigctx)
634 ucontext_t *ctx = (ucontext_t*)sigctx;
636 return (gpointer)ctx->uc_mcontext.sc_ip;