3 * exception support for MIPS
6 * Mark Mason (mason@broadcom.com)
8 * Based on exceptions-ppc.c by:
9 * Dietmar Maurer (dietmar@ximian.com)
10 * Paolo Molaro (lupus@ximian.com)
13 * (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
35 * mono_arch_get_restore_context:
37 * Returns a pointer to a method which restores a previously saved MonoContext.
38 * The first argument in a0 is the pointer to the MonoContext.
41 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
45 static guint8 start [512];
46 static int inited = 0;
47 guint32 iregs_to_restore;
58 mips_move (code, mips_at, mips_a0);
60 iregs_to_restore = (MONO_ARCH_CALLEE_SAVED_REGS \
61 | (1 << mips_sp) | (1 << mips_ra));
62 for (i = 0; i < MONO_SAVED_GREGS; ++i) {
63 //if (iregs_to_restore & (1 << i)) {
64 if (i != mips_zero && i != mips_at) {
65 MIPS_LW (code, i, mips_at, G_STRUCT_OFFSET (MonoContext, sc_regs[i]));
69 /* Get the address to return to */
70 mips_lw (code, mips_t9, mips_at, G_STRUCT_OFFSET (MonoContext, sc_pc));
72 /* jump to the saved IP */
73 mips_jr (code, mips_t9);
77 mips_break (code, 0xff);
79 g_assert ((code - start) < sizeof(start));
80 mono_arch_flush_icache (start, code - start);
81 mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
86 * mono_arch_get_call_filter:
88 * Returns a pointer to a method which calls an exception filter. We
89 * also use this function to call finally handlers (we pass NULL as
90 * @exc object in this case).
92 * This function is invoked as
93 * call_handler (MonoContext *ctx, handler)
95 * Where 'handler' is a function to be invoked as:
99 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
101 static guint8 start [320];
102 static int inited = 0;
118 g_assert ((alloc_size & (MIPS_STACK_ALIGNMENT-1)) == 0);
120 mips_addiu (code, mips_sp, mips_sp, -alloc_size);
121 mips_sw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
123 /* Save global registers on stack (s0 - s7) */
125 MIPS_SW (code, mips_s0, mips_sp, offset); offset += IREG_SIZE;
126 MIPS_SW (code, mips_s1, mips_sp, offset); offset += IREG_SIZE;
127 MIPS_SW (code, mips_s2, mips_sp, offset); offset += IREG_SIZE;
128 MIPS_SW (code, mips_s3, mips_sp, offset); offset += IREG_SIZE;
129 MIPS_SW (code, mips_s4, mips_sp, offset); offset += IREG_SIZE;
130 MIPS_SW (code, mips_s5, mips_sp, offset); offset += IREG_SIZE;
131 MIPS_SW (code, mips_s6, mips_sp, offset); offset += IREG_SIZE;
132 MIPS_SW (code, mips_s7, mips_sp, offset); offset += IREG_SIZE;
133 MIPS_SW (code, mips_fp, mips_sp, offset); offset += IREG_SIZE;
135 /* Restore global registers from MonoContext, including the frame pointer */
136 MIPS_LW (code, mips_s0, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s0]));
137 MIPS_LW (code, mips_s1, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s1]));
138 MIPS_LW (code, mips_s2, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s2]));
139 MIPS_LW (code, mips_s3, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s3]));
140 MIPS_LW (code, mips_s4, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s4]));
141 MIPS_LW (code, mips_s5, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s5]));
142 MIPS_LW (code, mips_s6, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s6]));
143 MIPS_LW (code, mips_s7, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s7]));
144 MIPS_LW (code, mips_fp, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_fp]));
146 /* a1 is the handler to call */
147 mips_move (code, mips_t9, mips_a1);
149 /* jump to the saved IP */
150 mips_jalr (code, mips_t9, mips_ra);
153 /* restore all regs from the stack */
155 MIPS_LW (code, mips_s0, mips_sp, offset); offset += IREG_SIZE;
156 MIPS_LW (code, mips_s1, mips_sp, offset); offset += IREG_SIZE;
157 MIPS_LW (code, mips_s2, mips_sp, offset); offset += IREG_SIZE;
158 MIPS_LW (code, mips_s3, mips_sp, offset); offset += IREG_SIZE;
159 MIPS_LW (code, mips_s4, mips_sp, offset); offset += IREG_SIZE;
160 MIPS_LW (code, mips_s5, mips_sp, offset); offset += IREG_SIZE;
161 MIPS_LW (code, mips_s6, mips_sp, offset); offset += IREG_SIZE;
162 MIPS_LW (code, mips_s7, mips_sp, offset); offset += IREG_SIZE;
163 MIPS_LW (code, mips_fp, mips_sp, offset); offset += IREG_SIZE;
166 mips_lw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
167 mips_addiu (code, mips_sp, mips_sp, alloc_size);
168 mips_jr (code, mips_ra);
171 g_assert ((code - start) < sizeof(start));
172 mono_arch_flush_icache (start, code - start);
173 mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
178 throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gboolean rethrow)
183 #ifdef DEBUG_EXCEPTIONS
184 g_print ("throw_exception: exc=%p eip=%p esp=%p rethrow=%d\n",
185 exc, (void *)eip, (void *) esp, rethrow);
188 /* adjust eip so that it point into the call instruction */
191 memset (&ctx, 0, sizeof (MonoContext));
193 /*g_print ("stack in throw: %p\n", esp);*/
194 memcpy (&ctx.sc_regs, (void *)(esp + MIPS_STACK_PARAM_OFFSET),
195 sizeof (gulong) * MONO_SAVED_GREGS);
196 memset (&ctx.sc_fpregs, 0, sizeof (mips_freg) * MONO_SAVED_FREGS);
197 MONO_CONTEXT_SET_IP (&ctx, eip);
199 if (mono_object_isinst_checked (exc, mono_defaults.exception_class, &error)) {
200 MonoException *mono_ex = (MonoException*)exc;
202 mono_ex->stack_trace = NULL;
203 mono_ex->trace_ips = NULL;
206 mono_error_assert_ok (&error);
207 mono_handle_exception (&ctx, exc);
208 #ifdef DEBUG_EXCEPTIONS
209 g_print ("throw_exception: restore to pc=%p sp=%p fp=%p ctx=%p\n",
210 (void *) ctx.sc_pc, (void *) ctx.sc_regs[mips_sp],
211 (void *) ctx.sc_regs[mips_fp], &ctx);
213 mono_restore_context (&ctx);
215 g_assert_not_reached ();
219 * arch_get_throw_exception_generic:
221 * Returns a function pointer which can be used to raise
222 * exceptions. The returned function has the following
223 * signature: void (*func) (MonoException *exc); or
224 * void (*func) (char *exc_name);
228 mono_arch_get_throw_exception_generic (guint8 *start, int size, int corlib, gboolean rethrow)
231 int alloc_size, pos, i;
235 //g_print ("mono_arch_get_throw_exception_generic: code=%p\n", code);
238 /* XXX - save all the FP regs on the stack ? */
240 pos += MONO_MAX_IREGS * sizeof(guint32);
242 alloc_size = MIPS_MINIMAL_STACK_SIZE + pos + 64;
243 // align to MIPS_STACK_ALIGNMENT bytes
244 alloc_size += MIPS_STACK_ALIGNMENT - 1;
245 alloc_size &= ~(MIPS_STACK_ALIGNMENT - 1);
247 g_assert ((alloc_size & (MIPS_STACK_ALIGNMENT-1)) == 0);
248 mips_addiu (code, mips_sp, mips_sp, -alloc_size);
249 mips_sw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
251 /* Save all the regs on the stack */
252 for (i = 0; i < MONO_MAX_IREGS; i++) {
254 MIPS_SW (code, i, mips_sp, i*IREG_SIZE + MIPS_STACK_PARAM_OFFSET);
256 mips_addiu (code, mips_at, mips_sp, alloc_size);
257 MIPS_SW (code, mips_at, mips_sp, i*IREG_SIZE + MIPS_STACK_PARAM_OFFSET);
262 mips_move (code, mips_a1, mips_a0);
263 mips_load (code, mips_a0, mono_defaults.corlib);
264 mips_load (code, mips_t9, mono_exception_from_token);
265 mips_jalr (code, mips_t9, mips_ra);
267 mips_move (code, mips_a0, mips_v0);
269 /* call throw_exception (exc, ip, sp, rethrow) */
271 /* exc is already in place in a0 */
275 mips_lw (code, mips_a1, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
277 mips_move (code, mips_a1, mips_ra);
279 /* current sp & rethrow */
280 mips_move (code, mips_a2, mips_sp);
281 mips_addiu (code, mips_a3, mips_zero, rethrow);
283 mips_load (code, mips_t9, throw_exception);
284 mips_jr (code, mips_t9);
286 /* we should never reach this breakpoint */
287 mips_break (code, 0xfe);
289 g_assert ((code - start) < size);
290 mono_arch_flush_icache (start, code - start);
291 mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
296 * mono_arch_get_rethrow_exception:
297 * \returns a function pointer which can be used to rethrow
298 * exceptions. The returned function has the following
299 * signature: void (*func) (MonoException *exc);
302 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
304 static guint8 start [GENERIC_EXCEPTION_SIZE];
305 static int inited = 0;
313 mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, TRUE);
319 * arch_get_throw_exception:
321 * Returns a function pointer which can be used to raise
322 * exceptions. The returned function has the following
323 * signature: void (*func) (MonoException *exc);
324 * For example to raise an arithmetic exception you can use:
326 * x86_push_imm (code, mono_get_exception_arithmetic ());
327 * x86_call_code (code, arch_get_throw_exception ());
331 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
333 static guint8 start [GENERIC_EXCEPTION_SIZE];
334 static int inited = 0;
342 mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, FALSE);
348 mono_arch_get_throw_exception_by_name (void)
350 guint8 *start, *code;
353 /* Not used on MIPS */
354 start = code = mono_global_codeman_reserve (size);
355 mips_break (code, 0xfd);
356 mono_arch_flush_icache (start, code - start);
357 mono_profiler_code_buffer_new (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL);
362 * mono_arch_get_throw_corlib_exception:
363 * \returns a function pointer which can be used to raise
364 * corlib exceptions. The returned function has the following
365 * signature: void (*func) (guint32 ex_token, guint32 offset);
366 * On MIPS, the offset argument is missing.
369 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
371 static guint8 start [GENERIC_EXCEPTION_SIZE];
372 static int inited = 0;
380 mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE, FALSE);
386 * mono_arch_unwind_frame:
388 * This function is used to gather information from @ctx, and store it in @frame_info.
389 * It unwinds one stack frame, and stores the resulting context into @new_ctx. @lmf
390 * is modified if needed.
391 * Returns TRUE on success, FALSE otherwise.
394 mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
395 MonoJitInfo *ji, MonoContext *ctx,
396 MonoContext *new_ctx, MonoLMF **lmf,
397 mgreg_t **save_locations,
398 StackFrameInfo *frame)
400 memset (frame, 0, sizeof (StackFrameInfo));
407 gpointer ip = MONO_CONTEXT_GET_IP (ctx);
408 mgreg_t regs [MONO_MAX_IREGS + 1];
410 guint32 unwind_info_len;
413 if (ji->is_trampoline)
414 frame->type = FRAME_TYPE_TRAMPOLINE;
416 frame->type = FRAME_TYPE_MANAGED;
418 unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
420 for (i = 0; i < MONO_MAX_IREGS; ++i)
421 regs [i] = new_ctx->sc_regs [i];
423 mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
424 (guint8*)ji->code_start + ji->code_size,
425 ip, NULL, regs, MONO_MAX_IREGS,
426 save_locations, MONO_MAX_IREGS, &cfa);
428 for (i = 0; i < MONO_MAX_IREGS; ++i)
429 new_ctx->sc_regs [i] = regs [i];
430 new_ctx->sc_pc = regs [mips_ra];
431 new_ctx->sc_regs [mips_sp] = (mgreg_t)cfa;
433 /* we substract 8, so that the IP points into the call instruction */
434 MONO_CONTEXT_SET_IP (new_ctx, new_ctx->sc_pc - 8);
436 /* Sanity check -- we should have made progress here */
437 g_assert (MONO_CONTEXT_GET_SP (new_ctx) != MONO_CONTEXT_GET_SP (ctx));
441 if (((mgreg_t)(*lmf)->previous_lmf) & 2) {
443 * This LMF entry is created by the soft debug code to mark transitions to
444 * managed code done during invokes.
446 MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
448 g_assert (ext->debugger_invoke);
450 memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
452 *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
454 frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
459 if (!(*lmf)->method) {
460 #ifdef DEBUG_EXCEPTIONS
461 g_print ("mono_arch_unwind_frame: bad lmf @ %p\n", (void *) *lmf);
465 g_assert (((*lmf)->magic == MIPS_LMF_MAGIC1) || ((*lmf)->magic == MIPS_LMF_MAGIC2));
467 ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL);
469 // FIXME: This can happen with multiple appdomains (bug #444383)
474 frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
476 memcpy (&new_ctx->sc_regs, (*lmf)->iregs, sizeof (gulong) * MONO_SAVED_GREGS);
477 memcpy (&new_ctx->sc_fpregs, (*lmf)->fregs, sizeof (float) * MONO_SAVED_FREGS);
478 MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
479 /* ensure that we've made progress */
480 g_assert (new_ctx->sc_pc != ctx->sc_pc);
482 *lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
491 mono_arch_ip_from_context (void *sigctx)
493 return (gpointer)(gsize)UCONTEXT_REG_PC (sigctx);
499 * Called by resuming from a signal handler.
502 handle_signal_exception (gpointer obj)
504 MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
507 memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
509 mono_handle_exception (&ctx, obj);
511 mono_restore_context (&ctx);
515 * This is the function called from the signal handler
518 mono_arch_handle_exception (void *ctx, gpointer obj)
520 #if defined(MONO_CROSS_COMPILE)
521 g_assert_not_reached ();
522 #elif defined(MONO_ARCH_USE_SIGACTION)
526 * Handling the exception in the signal handler is problematic, since the original
527 * signal is disabled, and we could run arbitrary code though the debugger. So
528 * resume into the normal stack and do most work there if possible.
530 MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
531 guint64 sp = UCONTEXT_GREGS (sigctx) [mips_sp];
533 /* Pass the ctx parameter in TLS */
534 mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
535 /* The others in registers */
536 UCONTEXT_GREGS (sigctx)[mips_a0] = (gsize)obj;
538 /* Allocate a stack frame */
540 UCONTEXT_GREGS (sigctx)[mips_sp] = sp;
542 UCONTEXT_REG_PC (sigctx) = (gsize)handle_signal_exception;
549 mono_sigctx_to_monoctx (ctx, &mctx);
551 result = mono_handle_exception (&mctx, obj);
552 /* restore the context so that returning from the signal handler will invoke
555 mono_monoctx_to_sigctx (&mctx, ctx);
561 * mono_arch_setup_resume_sighandler_ctx:
563 * Setup CTX so execution continues at FUNC.
566 mono_arch_setup_resume_sighandler_ctx (MonoContext *ctx, gpointer func)
568 MONO_CONTEXT_SET_IP (ctx,func);