2 * exceptions-mips.c: exception support for MIPS
5 * Mark Mason (mason@broadcom.com)
7 * Based on exceptions-ppc.c by:
8 * Dietmar Maurer (dietmar@ximian.com)
9 * Paolo Molaro (lupus@ximian.com)
12 * (C) 2001 Ximian, Inc.
21 #include <mono/arch/mips/mips-codegen.h>
22 #include <mono/metadata/appdomain.h>
23 #include <mono/metadata/tabledefs.h>
24 #include <mono/metadata/threads.h>
25 #include <mono/metadata/debug-helpers.h>
26 #include <mono/metadata/exception.h>
27 #include <mono/metadata/mono-debug.h>
30 #include "mini-mips.h"
32 #define GENERIC_EXCEPTION_SIZE 256
36 #define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do { \
39 #define restore_regs_from_context(ctx_reg,pc,tmp_reg) do { \
41 ppc_lwz (code, pc, G_STRUCT_OFFSET (MonoContext, sc_pc), ctx_reg); \
42 ppc_lmw (code, ppc_r13, ctx_reg, G_STRUCT_OFFSET (MonoContext, sc_regs)); \
43 for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) { \
44 ppc_lfd (code, (14 + reg), G_STRUCT_OFFSET(MonoLMF, sc_fpregs) + reg * sizeof (gdouble), ctx_reg); \
50 #define setup_context(ctx) do { \
51 memset ((ctx), 0, sizeof(*(ctx))); \
55 * mono_arch_get_restore_context:
57 * Returns a pointer to a method which restores a previously saved MonoContext.
58 * The first argument in a0 is the pointer to the MonoContext.
61 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
65 static guint8 start [128];
66 static int inited = 0;
67 guint32 iregs_to_restore;
78 iregs_to_restore = (MONO_ARCH_CALLEE_SAVED_REGS \
79 | (1 << mips_sp) | (1 << mips_ra));
80 for (i = 0; i < MONO_SAVED_GREGS; ++i) {
81 if (iregs_to_restore & (1 << i)) {
82 MIPS_LW (code, i, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[i]));
86 /* Get the address to return to */
87 mips_lw (code, mips_t9, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_pc));
89 /* jump to the saved IP */
90 mips_jr (code, mips_t9);
94 mips_break (code, 0xff);
96 g_assert ((code - start) < sizeof(start));
97 mono_arch_flush_icache (start, code - start);
102 * mono_arch_get_call_filter:
104 * Returns a pointer to a method which calls an exception filter. We
105 * also use this function to call finally handlers (we pass NULL as
106 * @exc object in this case).
108 * This function is invoked as
109 * call_handler (MonoContext *ctx, handler)
111 * Where 'handler' is a function to be invoked as:
115 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
117 static guint8 start [320];
118 static int inited = 0;
134 g_assert ((alloc_size & (MIPS_STACK_ALIGNMENT-1)) == 0);
136 mips_addiu (code, mips_sp, mips_sp, -alloc_size);
137 mips_sw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
139 /* Save global registers on stack (s0 - s7) */
141 MIPS_SW (code, mips_s0, mips_sp, offset); offset += IREG_SIZE;
142 MIPS_SW (code, mips_s1, mips_sp, offset); offset += IREG_SIZE;
143 MIPS_SW (code, mips_s2, mips_sp, offset); offset += IREG_SIZE;
144 MIPS_SW (code, mips_s3, mips_sp, offset); offset += IREG_SIZE;
145 MIPS_SW (code, mips_s4, mips_sp, offset); offset += IREG_SIZE;
146 MIPS_SW (code, mips_s5, mips_sp, offset); offset += IREG_SIZE;
147 MIPS_SW (code, mips_s6, mips_sp, offset); offset += IREG_SIZE;
148 MIPS_SW (code, mips_s7, mips_sp, offset); offset += IREG_SIZE;
149 MIPS_SW (code, mips_fp, mips_sp, offset); offset += IREG_SIZE;
151 /* Restore global registers from MonoContext, including the frame pointer */
152 MIPS_LW (code, mips_s0, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s0]));
153 MIPS_LW (code, mips_s1, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s1]));
154 MIPS_LW (code, mips_s2, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s2]));
155 MIPS_LW (code, mips_s3, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s3]));
156 MIPS_LW (code, mips_s4, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s4]));
157 MIPS_LW (code, mips_s5, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s5]));
158 MIPS_LW (code, mips_s6, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s6]));
159 MIPS_LW (code, mips_s7, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s7]));
160 MIPS_LW (code, mips_fp, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_fp]));
162 /* a1 is the handler to call */
163 mips_move (code, mips_t9, mips_a1);
165 /* jump to the saved IP */
166 mips_jalr (code, mips_t9, mips_ra);
169 /* restore all regs from the stack */
171 MIPS_LW (code, mips_s0, mips_sp, offset); offset += IREG_SIZE;
172 MIPS_LW (code, mips_s1, mips_sp, offset); offset += IREG_SIZE;
173 MIPS_LW (code, mips_s2, mips_sp, offset); offset += IREG_SIZE;
174 MIPS_LW (code, mips_s3, mips_sp, offset); offset += IREG_SIZE;
175 MIPS_LW (code, mips_s4, mips_sp, offset); offset += IREG_SIZE;
176 MIPS_LW (code, mips_s5, mips_sp, offset); offset += IREG_SIZE;
177 MIPS_LW (code, mips_s6, mips_sp, offset); offset += IREG_SIZE;
178 MIPS_LW (code, mips_s7, mips_sp, offset); offset += IREG_SIZE;
179 MIPS_LW (code, mips_fp, mips_sp, offset); offset += IREG_SIZE;
182 mips_lw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
183 mips_addiu (code, mips_sp, mips_sp, alloc_size);
184 mips_jr (code, mips_ra);
187 g_assert ((code - start) < sizeof(start));
188 mono_arch_flush_icache (start, code - start);
193 throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gboolean rethrow)
195 static void (*restore_context) (MonoContext *);
198 #ifdef DEBUG_EXCEPTIONS
199 g_print ("throw_exception: exc=%p eip=%p esp=%p rethrow=%d\n",
200 exc, (void *)eip, (void *) esp, rethrow);
203 if (!restore_context)
204 restore_context = mono_get_restore_context ();
206 /* adjust eip so that it point into the call instruction */
209 setup_context (&ctx);
211 /*g_print ("stack in throw: %p\n", esp);*/
212 memcpy (&ctx.sc_regs, (void *)(esp + MIPS_STACK_PARAM_OFFSET),
213 sizeof (gulong) * MONO_SAVED_GREGS);
214 memset (&ctx.sc_fpregs, 0, sizeof (mips_freg) * MONO_SAVED_FREGS);
215 MONO_CONTEXT_SET_IP (&ctx, eip);
217 if (mono_object_isinst (exc, mono_defaults.exception_class)) {
218 MonoException *mono_ex = (MonoException*)exc;
220 mono_ex->stack_trace = NULL;
222 mono_handle_exception (&ctx, exc, (void *)eip, FALSE);
223 #ifdef DEBUG_EXCEPTIONS
224 g_print ("throw_exception: restore to pc=%p sp=%p fp=%p ctx=%p\n",
225 (void *) ctx.sc_pc, (void *) ctx.sc_regs[mips_sp],
226 (void *) ctx.sc_regs[mips_fp], &ctx);
228 restore_context (&ctx);
230 g_assert_not_reached ();
234 * arch_get_throw_exception_generic:
236 * Returns a function pointer which can be used to raise
237 * exceptions. The returned function has the following
238 * signature: void (*func) (MonoException *exc); or
239 * void (*func) (char *exc_name);
243 mono_arch_get_throw_exception_generic (guint8 *start, int size, int corlib, gboolean rethrow)
246 int alloc_size, pos, i;
250 //g_print ("mono_arch_get_throw_exception_generic: code=%p\n", code);
253 /* XXX - save all the FP regs on the stack ? */
255 pos += MONO_MAX_IREGS * sizeof(guint32);
257 alloc_size = MIPS_MINIMAL_STACK_SIZE + pos + 64;
258 // align to MIPS_STACK_ALIGNMENT bytes
259 alloc_size += MIPS_STACK_ALIGNMENT - 1;
260 alloc_size &= ~(MIPS_STACK_ALIGNMENT - 1);
262 g_assert ((alloc_size & (MIPS_STACK_ALIGNMENT-1)) == 0);
263 mips_addiu (code, mips_sp, mips_sp, -alloc_size);
264 mips_sw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
266 /* Save all the regs on the stack */
267 for (i = 0; i < MONO_MAX_IREGS; i++) {
269 MIPS_SW (code, i, mips_sp, i*IREG_SIZE + MIPS_STACK_PARAM_OFFSET);
271 mips_addiu (code, mips_at, mips_sp, alloc_size);
272 MIPS_SW (code, mips_at, mips_sp, i*IREG_SIZE + MIPS_STACK_PARAM_OFFSET);
277 mips_move (code, mips_a1, mips_a0);
278 mips_load (code, mips_a0, mono_defaults.corlib);
279 mips_load (code, mips_t9, mono_exception_from_token);
280 mips_jalr (code, mips_t9, mips_ra);
282 mips_move (code, mips_a0, mips_v0);
284 /* call throw_exception (exc, ip, sp, rethrow) */
286 /* exc is already in place in a0 */
290 mips_lw (code, mips_a1, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
292 mips_move (code, mips_a1, mips_ra);
294 /* current sp & rethrow */
295 mips_move (code, mips_a2, mips_sp);
296 mips_addiu (code, mips_a3, mips_zero, rethrow);
298 mips_load (code, mips_t9, throw_exception);
299 mips_jr (code, mips_t9);
301 /* we should never reach this breakpoint */
302 mips_break (code, 0xfe);
304 g_assert ((code - start) < size);
305 mono_arch_flush_icache (start, code - start);
310 * mono_arch_get_rethrow_exception:
312 * Returns a function pointer which can be used to rethrow
313 * exceptions. The returned function has the following
314 * signature: void (*func) (MonoException *exc);
318 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
320 static guint8 start [GENERIC_EXCEPTION_SIZE];
321 static int inited = 0;
329 mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, TRUE);
335 * arch_get_throw_exception:
337 * Returns a function pointer which can be used to raise
338 * exceptions. The returned function has the following
339 * signature: void (*func) (MonoException *exc);
340 * For example to raise an arithmetic exception you can use:
342 * x86_push_imm (code, mono_get_exception_arithmetic ());
343 * x86_call_code (code, arch_get_throw_exception ());
347 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
349 static guint8 start [GENERIC_EXCEPTION_SIZE];
350 static int inited = 0;
358 mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, FALSE);
364 mono_arch_get_throw_exception_by_name (void)
366 guint8 *start, *code;
369 /* Not used on MIPS */
370 start = code = mono_global_codeman_reserve (size);
371 mips_break (code, 0xfd);
372 mono_arch_flush_icache (start, code - start);
377 * mono_arch_get_throw_corlib_exception:
379 * Returns a function pointer which can be used to raise
380 * corlib exceptions. The returned function has the following
381 * signature: void (*func) (guint32 ex_token, guint32 offset);
382 * On MIPS, the offset argument is missing.
385 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
387 static guint8 start [GENERIC_EXCEPTION_SIZE];
388 static int inited = 0;
396 mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE, FALSE);
402 glist_to_array (GList *list, MonoClass *eclass)
404 MonoDomain *domain = mono_domain_get ();
411 len = g_list_length (list);
412 res = mono_array_new (domain, eclass, len);
414 for (i = 0; list; list = list->next, i++)
415 mono_array_set (res, gpointer, i, list->data);
420 /* mono_arch_find_jit_info:
422 * This function is used to gather information from @ctx. It returns the
423 * MonoJitInfo of the corresponding function, unwinds one stack frame and
424 * stores the resulting context into @new_ctx. It also stores a string
425 * describing the stack location into @trace (if not NULL), and modifies
426 * the @lmf if necessary. @native_offset return the IP offset from the
427 * start of the function or -1 if that info is not available.
430 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
431 MonoJitInfo *res, MonoJitInfo *prev_ji,
432 MonoContext *ctx, MonoContext *new_ctx,
433 MonoLMF **lmf, gboolean *managed)
436 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
437 gpointer fp = MONO_CONTEXT_GET_BP (ctx);
440 /* Avoid costly table lookup during stack overflow */
441 if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
444 ji = mini_jit_info_table_find (domain, ip, NULL);
449 memcpy (new_ctx, ctx, sizeof (MonoContext));
456 if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
457 /* remove any unused lmf */
458 *lmf = (*lmf)->previous_lmf;
461 address = (char *)ip - (char *)ji->code_start;
464 if (!ji->method->wrapper_type)
468 fp = MONO_CONTEXT_GET_BP (ctx);
470 /* Compute the previous stack frame */
471 sp = (guint32)(fp) - (short)(*(guint32 *)(ji->code_start));
473 /* Sanity check the frame */
474 if (!sp || (sp == 0xffffffff)
475 || (sp & 0x07) || (sp < 64*1024)) {
476 #ifdef DEBUG_EXCEPTIONS
477 g_print ("mono_arch_find_jit_info: bad stack sp=%p\n", (void *) sp);
482 if (ji->method->save_lmf && 0) {
483 /* only enable this when prologue stops emitting
484 * normal save of s-regs when save_lmf is true.
485 * Will have to sync with prologue code at that point.
487 memcpy (&new_ctx->sc_fpregs,
488 (char*)sp - sizeof (float) * MONO_SAVED_FREGS,
489 sizeof (float) * MONO_SAVED_FREGS);
490 memcpy (&new_ctx->sc_regs,
491 (char*)sp - sizeof (float) * MONO_SAVED_FREGS - sizeof (gulong) * MONO_SAVED_GREGS,
492 sizeof (gulong) * MONO_SAVED_GREGS);
493 } else if (ji->used_regs) {
495 guint32 mask = ji->used_regs;
497 /* these all happen before adjustment of fp */
498 /* Look for sw ??, ????(sp) */
499 insn = ((guint32 *)ji->code_start) + 1;
500 while (!*insn || ((*insn & 0xffe00000) == 0xafa00000) || ((*insn & 0xffe00000) == 0xffa00000)) {
501 int reg = (*insn >> 16) & 0x1f;
502 guint32 addr = (((guint32)fp) + (short)(*insn & 0x0000ffff));
505 if ((*insn & 0xffe00000) == 0xafa00000)
506 new_ctx->sc_regs [reg] = *(guint32 *)addr;
508 new_ctx->sc_regs [reg] = *(guint64 *)addr;
511 MONO_CONTEXT_SET_SP (new_ctx, sp);
512 MONO_CONTEXT_SET_BP (new_ctx, sp);
513 /* assert that we found all registers we were supposed to */
516 /* we substract 8, so that the IP points into the call instruction */
517 MONO_CONTEXT_SET_IP (new_ctx, new_ctx->sc_regs[mips_ra] - 8);
519 /* Sanity check -- we should have made progress here */
520 g_assert (new_ctx->sc_pc != ctx->sc_pc);
523 if (!(*lmf)->method) {
524 #ifdef DEBUG_EXCEPTIONS
525 g_print ("mono_arch_find_jit_info: bad lmf @ %p\n", (void *) *lmf);
529 g_assert (((*lmf)->magic == MIPS_LMF_MAGIC1) || ((*lmf)->magic == MIPS_LMF_MAGIC2));
531 if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
533 memset (res, 0, MONO_SIZEOF_JIT_INFO);
534 res->method = (*lmf)->method;
536 memcpy (&new_ctx->sc_regs, (*lmf)->iregs, sizeof (gulong) * MONO_SAVED_GREGS);
537 memcpy (&new_ctx->sc_fpregs, (*lmf)->fregs, sizeof (float) * MONO_SAVED_FREGS);
538 MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
539 /* ensure that we've made progress */
540 g_assert (new_ctx->sc_pc != ctx->sc_pc);
541 *lmf = (*lmf)->previous_lmf;
543 return ji ? ji : res;
550 mono_arch_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
553 struct sigcontext *ctx = (struct sigcontext *)sigctx;
555 mctx->sc_pc = ctx->sc_pc;
556 for (i = 0; i < 32; ++i) {
557 mctx->sc_regs[i] = ctx->sc_regs[i];
558 mctx->sc_fpregs[i] = ctx->sc_fpregs[i];
563 mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
566 struct sigcontext *ctx = (struct sigcontext *)sigctx;
568 ctx->sc_pc = mctx->sc_pc;
569 for (i = 0; i < 32; ++i) {
570 ctx->sc_regs[i] = mctx->sc_regs[i];
571 ctx->sc_fpregs[i] = mctx->sc_fpregs[i];
576 mono_arch_ip_from_context (void *sigctx)
578 struct sigcontext *ctx = (struct sigcontext *)sigctx;
579 return (gpointer)(guint32)ctx->sc_pc;
583 * This is the function called from the signal handler
586 mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
591 mono_arch_sigctx_to_monoctx (ctx, &mctx);
592 #ifdef DEBUG_EXCEPTIONS
593 g_print ("mono_arch_handle_exception: pc=%p\n", (void *) mctx.sc_pc);
595 mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_pc, test_only);
598 #ifdef DEBUG_EXCEPTIONS
599 g_print ("mono_arch_handle_exception: restore pc=%p\n", (void *)mctx.sc_pc);
601 /* restore the context so that returning from the signal handler
602 * will invoke the catch clause
604 mono_arch_monoctx_to_sigctx (&mctx, ctx);
611 mono_arch_has_unwind_info (gconstpointer addr)