2 * exceptions-ia64.c: exception support for IA64
5 * Zoltan Varga (vargaz@gmail.com)
7 * (C) 2001 Ximian, Inc.
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.
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>
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)
47 unw_word_t off, ip, sp;
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);
55 res = unw_get_reg (&ctx->cursor, UNW_IA64_SP, &sp);
58 printf ("%s:%lx [%lx-%lx] SP: %lx\n", name, ip - pi.start_ip, pi.start_ip, pi.end_ip, sp);
62 ia64_create_ftnptr (gpointer ptr)
64 gpointer *desc = mono_global_codeman_reserve (2 * sizeof (gpointer));
72 restore_context (MonoContext *ctx)
77 res = unw_get_reg (&ctx->cursor, UNW_IA64_IP, &ip);
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);
84 unw_resume (&ctx->cursor);
88 * mono_arch_get_restore_context:
90 * Returns a pointer to a method which restores a previously saved sigcontext.
93 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
99 return restore_context;
103 get_real_call_filter (void)
105 static gpointer filter;
106 static gboolean inited = FALSE;
108 Ia64CodegenState code;
109 int in0, local0, out0, nout;
111 unw_dyn_region_info_t *r_pro, *r_body, *r_epilog;
116 start = mono_global_codeman_reserve (1024);
118 /* int call_filter (guint64 fp, guint64 ip) */
121 * We have to create a register+stack frame similar to the frame which
122 * contains the filter.
124 * - setting up a register stack frame
125 * These cannot be set up in this function, because the fp register is a
126 * stacked register which is different in each method. Also, the register
127 * stack frame is different in each method. So we pass the FP value in a a
128 * non-stacked register and the code generated by the OP_START_HANDLER
129 * opcode will copy it to the appropriate register after setting up the
130 * register stack frame.
131 * The stacked registers are not need to be set since variables used in
132 * handler regions are never allocated to registers.
140 ia64_codegen_init (code, start);
142 ia64_codegen_set_one_ins_per_bundle (code, TRUE);
144 ia64_unw_save_reg (code, UNW_IA64_AR_PFS, UNW_IA64_GR + local0 + 0);
145 ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, nout, 0);
146 ia64_unw_save_reg (code, UNW_IA64_RP, UNW_IA64_GR + local0 + 1);
147 ia64_mov_from_br (code, local0 + 1, IA64_B0);
149 ia64_begin_bundle (code);
151 r_pro = mono_ia64_create_unwind_region (&code);
154 ia64_mov (code, IA64_R15, in0 + 0);
156 ia64_mov_to_br (code, IA64_B6, in0 + 1);
158 /* Call the filter */
159 ia64_br_call_reg (code, IA64_B0, IA64_B6);
161 /* R8 contains the result of the filter */
163 /* FIXME: Add unwind info for this */
165 ia64_begin_bundle (code);
167 r_body = mono_ia64_create_unwind_region (&code);
168 r_pro->next = r_body;
170 ia64_mov_to_ar_i (code, IA64_PFS, local0 + 0);
171 ia64_mov_ret_to_br (code, IA64_B0, local0 + 1);
172 ia64_br_ret_reg (code, IA64_B0);
174 ia64_begin_bundle (code);
176 r_epilog = mono_ia64_create_unwind_region (&code);
177 r_body->next = r_epilog;
179 ia64_codegen_set_one_ins_per_bundle (code, FALSE);
181 ia64_codegen_close (code);
183 g_assert ((code.buf - start) <= 256);
185 mono_arch_flush_icache (start, code.buf - start);
187 di = g_malloc0 (sizeof (unw_dyn_info_t));
188 di->start_ip = (unw_word_t) start;
189 di->end_ip = (unw_word_t) code.buf;
191 di->format = UNW_INFO_FORMAT_DYNAMIC;
192 di->u.pi.name_ptr = (unw_word_t)"throw_trampoline";
193 di->u.pi.regions = r_body;
195 _U_dyn_register (di);
197 filter = ia64_create_ftnptr (start);
205 call_filter (MonoContext *ctx, gpointer ip)
207 int (*filter) (MonoContext *, gpointer);
208 gpointer fp = MONO_CONTEXT_GET_BP (ctx);
210 filter = get_real_call_filter ();
212 return filter (fp, ip);
216 * mono_arch_get_call_filter:
218 * Returns a pointer to a method which calls an exception filter. We
219 * also use this function to call finally handlers (we pass NULL as
220 * @exc object in this case).
223 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
229 /* Initialize the real filter non-lazily */
230 get_real_call_filter ();
236 throw_exception (MonoObject *exc, guint64 rethrow)
238 unw_context_t unw_ctx;
244 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
245 MonoException *mono_ex = (MonoException*)exc;
247 mono_ex->stack_trace = NULL;
250 res = unw_getcontext (&unw_ctx);
252 res = unw_init_local (&ctx.cursor, &unw_ctx);
256 * Unwind until the first managed frame. This is needed since
257 * mono_handle_exception expects the variables in the original context to
258 * correspond to the method returned by mono_find_jit_info.
261 res = unw_get_reg (&ctx.cursor, UNW_IA64_IP, &ip);
264 res = unw_get_reg (&ctx.cursor, UNW_IA64_SP, &sp);
267 ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)ip, NULL);
269 //printf ("UN: %s %lx %lx\n", ji ? ji->method->name : "", ip, sp);
274 res = unw_step (&ctx.cursor);
278 * This means an unhandled exception during the compilation of a
279 * topmost method like Main
285 ctx.precise_ip = FALSE;
287 mono_handle_exception (&ctx, exc, (gpointer)(ip), FALSE);
288 restore_context (&ctx);
290 g_assert_not_reached ();
294 get_throw_trampoline (gboolean rethrow)
297 Ia64CodegenState code;
298 gpointer ptr = throw_exception;
299 int i, in0, local0, out0;
301 unw_dyn_region_info_t *r_pro;
303 start = mono_global_codeman_reserve (256);
309 ia64_codegen_init (code, start);
310 ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, 3, 0);
311 ia64_mov_from_br (code, local0 + 1, IA64_B0);
313 /* FIXME: This depends on the current instruction emitter */
315 r_pro = g_malloc0 (_U_dyn_region_info_size (2));
317 r_pro->insn_count = 6;
319 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 2,
320 /* reg=*/ UNW_IA64_AR_PFS, /* dst=*/ UNW_IA64_GR + local0 + 0);
321 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 5,
322 /* reg=*/ UNW_IA64_RP, /* dst=*/ UNW_IA64_GR + local0 + 1);
323 g_assert ((unsigned) i <= r_pro->op_count);
326 ia64_mov (code, out0 + 0, in0 + 0);
327 ia64_adds_imm (code, out0 + 1, rethrow, IA64_R0);
329 /* Call throw_exception */
330 ia64_movl (code, GP_SCRATCH_REG, ptr);
331 ia64_ld8_inc_imm (code, GP_SCRATCH_REG2, GP_SCRATCH_REG, 8);
332 ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
333 ia64_ld8 (code, IA64_GP, GP_SCRATCH_REG);
334 ia64_br_call_reg (code, IA64_B0, IA64_B6);
337 ia64_break_i (code, 1000);
338 ia64_codegen_close (code);
340 g_assert ((code.buf - start) <= 256);
342 mono_arch_flush_icache (start, code.buf - start);
344 di = g_malloc0 (sizeof (unw_dyn_info_t));
345 di->start_ip = (unw_word_t) start;
346 di->end_ip = (unw_word_t) code.buf;
348 di->format = UNW_INFO_FORMAT_DYNAMIC;
349 di->u.pi.name_ptr = (unw_word_t)"throw_trampoline";
350 di->u.pi.regions = r_pro;
352 _U_dyn_register (di);
354 return ia64_create_ftnptr (start);
358 * mono_arch_get_throw_exception:
360 * Returns a function pointer which can be used to raise
361 * exceptions. The returned function has the following
362 * signature: void (*func) (MonoException *exc);
366 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
372 return get_throw_trampoline (FALSE);
376 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
382 return get_throw_trampoline (TRUE);
386 * mono_arch_get_throw_corlib_exception:
388 * Returns a function pointer which can be used to raise
389 * corlib exceptions. The returned function has the following
390 * signature: void (*func) (guint32 ex_token_index, guint32 offset);
391 * Here, offset is the offset which needs to be substracted from the caller IP
392 * to get the IP of the throw. Passing the offset has the advantage that it
393 * needs no relocations in the caller.
396 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
399 static gboolean inited = FALSE;
402 int i, in0, local0, out0, nout;
403 Ia64CodegenState code;
405 unw_dyn_region_info_t *r_pro;
414 start = mono_global_codeman_reserve (1024);
421 ia64_codegen_init (code, start);
422 ia64_alloc (code, local0 + 0, local0 - in0, out0 - local0, nout, 0);
423 ia64_mov_from_br (code, local0 + 1, IA64_RP);
425 r_pro = g_malloc0 (_U_dyn_region_info_size (2));
427 r_pro->insn_count = 6;
429 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 2,
430 /* reg=*/ UNW_IA64_AR_PFS, /* dst=*/ UNW_IA64_GR + local0 + 0);
431 _U_dyn_op_save_reg (&r_pro->op[i++], _U_QP_TRUE, /* when=*/ 5,
432 /* reg=*/ UNW_IA64_RP, /* dst=*/ UNW_IA64_GR + local0 + 1);
433 g_assert ((unsigned) i <= r_pro->op_count);
435 /* Call exception_from_token */
436 ia64_movl (code, out0 + 0, mono_defaults.exception_class->image);
437 ia64_mov (code, out0 + 1, in0 + 0);
438 ia64_movl (code, GP_SCRATCH_REG, MONO_TOKEN_TYPE_DEF);
439 ia64_add (code, out0 + 1, in0 + 0, GP_SCRATCH_REG);
440 ptr = mono_exception_from_token;
441 ia64_movl (code, GP_SCRATCH_REG, ptr);
442 ia64_ld8_inc_imm (code, GP_SCRATCH_REG2, GP_SCRATCH_REG, 8);
443 ia64_mov_to_br (code, IA64_B6, GP_SCRATCH_REG2);
444 ia64_ld8 (code, IA64_GP, GP_SCRATCH_REG);
445 ia64_br_call_reg (code, IA64_B0, IA64_B6);
446 ia64_mov (code, local0 + 3, IA64_R8);
448 /* Compute throw ip */
449 ia64_mov (code, local0 + 2, local0 + 1);
450 ia64_sub (code, local0 + 2, local0 + 2, in0 + 1);
452 /* Trick the unwind library into using throw_ip as the IP in the caller frame */
453 ia64_mov (code, local0 + 1, local0 + 2);
456 ia64_mov (code, out0 + 0, local0 + 3);
457 ia64_mov (code, out0 + 1, IA64_R0);
459 /* Call throw_exception */
460 ptr = throw_exception;
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);
467 ia64_break_i (code, 1002);
468 ia64_codegen_close (code);
470 g_assert ((code.buf - start) <= 1024);
472 di = g_malloc0 (sizeof (unw_dyn_info_t));
473 di->start_ip = (unw_word_t) start;
474 di->end_ip = (unw_word_t) code.buf;
476 di->format = UNW_INFO_FORMAT_DYNAMIC;
477 di->u.pi.name_ptr = (unw_word_t)"throw_corlib_exception_trampoline";
478 di->u.pi.regions = r_pro;
480 _U_dyn_register (di);
482 mono_arch_flush_icache (start, code.buf - start);
484 res = ia64_create_ftnptr (start);
490 /* mono_arch_find_jit_info:
492 * This function is used to gather information from @ctx. It return the
493 * MonoJitInfo of the corresponding function, unwinds one stack frame and
494 * stores the resulting context into @new_ctx. It also stores a string
495 * describing the stack location into @trace (if not NULL), and modifies
496 * the @lmf if necessary. @native_offset return the IP offset from the
497 * start of the function or -1 if that info is not available.
500 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
501 MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
508 new_ctx->precise_ip = FALSE;
511 err = unw_get_reg (&new_ctx->cursor, UNW_IA64_IP, &ip);
514 /* Avoid costly table lookup during stack overflow */
515 if (prev_ji && ((guint8*)ip > (guint8*)prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
518 ji = mini_jit_info_table_find (domain, (gpointer)ip, NULL);
528 unw_get_proc_name (&new_ctx->cursor, name, 256, &off);
529 printf ("F: %s\n", name);
535 if (!ji->method->wrapper_type)
541 /* This is an unmanaged frame, so just unwind through it */
542 /* FIXME: This returns -3 for the __clone2 frame in libc */
543 err = unw_step (&new_ctx->cursor);
552 //print_ctx (new_ctx);
554 err = unw_step (&new_ctx->cursor);
557 //print_ctx (new_ctx);
562 return (gpointer)(gssize)-1;
566 * mono_arch_handle_exception:
568 * @ctx: saved processor state
569 * @obj: the exception object
572 mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only)
574 /* libunwind takes care of this */
575 unw_context_t unw_ctx;
581 res = unw_getcontext (&unw_ctx);
583 res = unw_init_local (&ctx.cursor, &unw_ctx);
587 * Unwind until the first managed frame. This skips the signal handler frames
591 res = unw_get_reg (&ctx.cursor, UNW_IA64_IP, &ip);
594 ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)ip, NULL);
599 res = unw_step (&ctx.cursor);
602 ctx.precise_ip = TRUE;
604 mono_handle_exception (&ctx, obj, (gpointer)ip, test_only);
606 restore_context (&ctx);
608 g_assert_not_reached ();
612 mono_arch_ip_from_context (void *sigctx)
614 ucontext_t *ctx = (ucontext_t*)sigctx;
616 return (gpointer)ctx->uc_mcontext.sc_ip;