/**
* arch_get_throw_exception_generic:
*
* Returns a function pointer which can be used to raise
* exceptions. The returned function has the following
* signature: void (*func) (MonoException *exc); or
* void (*func) (char *exc_name);
*
*/
static gpointer
mono_arch_get_throw_exception_generic (guint8 *start, int size, int corlib, gboolean rethrow)
{
guint8 *code;
int alloc_size, pos, i;
code = start;
//g_print ("mono_arch_get_throw_exception_generic: code=%p\n", code);
pos = 0;
/* XXX - save all the FP regs on the stack ? */
pos += MONO_MAX_IREGS * sizeof(guint32);
alloc_size = MIPS_MINIMAL_STACK_SIZE + pos + 64;
// align to MIPS_STACK_ALIGNMENT bytes
alloc_size += MIPS_STACK_ALIGNMENT - 1;
alloc_size &= ~(MIPS_STACK_ALIGNMENT - 1);
g_assert ((alloc_size & (MIPS_STACK_ALIGNMENT-1)) == 0);
mips_addiu (code, mips_sp, mips_sp, -alloc_size);
mips_sw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
/* Save all the regs on the stack */
for (i = 0; i < MONO_MAX_IREGS; i++) {
if (i != mips_sp)
MIPS_SW (code, i, mips_sp, i*IREG_SIZE + MIPS_STACK_PARAM_OFFSET);
else {
mips_addiu (code, mips_at, mips_sp, alloc_size);
MIPS_SW (code, mips_at, mips_sp, i*IREG_SIZE + MIPS_STACK_PARAM_OFFSET);
}
}
if (corlib) {
mips_move (code, mips_a1, mips_a0);
mips_load (code, mips_a0, mono_defaults.corlib);
mips_load (code, mips_t9, mono_exception_from_token);
mips_jalr (code, mips_t9, mips_ra);
mips_nop (code);
mips_move (code, mips_a0, mips_v0);
}
/* call throw_exception (exc, ip, sp, rethrow) */
/* exc is already in place in a0 */
/* pointer to ip */
if (corlib)
mips_lw (code, mips_a1, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
else
mips_move (code, mips_a1, mips_ra);
/* current sp & rethrow */
mips_move (code, mips_a2, mips_sp);
mips_addiu (code, mips_a3, mips_zero, rethrow);
mips_load (code, mips_t9, throw_exception);
mips_jr (code, mips_t9);
mips_nop (code);
/* we should never reach this breakpoint */
mips_break (code, 0xfe);
g_assert ((code - start) < size);
mono_arch_flush_icache (start, code - start);
return start;
}
/*
* mono_arch_get_call_filter:
*
* Returns a pointer to a method which calls an exception filter. We
* also use this function to call finally handlers (we pass NULL as
* @exc object in this case).
*
* This function is invoked as
* call_handler (MonoContext *ctx, handler)
*
* Where 'handler' is a function to be invoked as:
* handler (void)
*/
gpointer
mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
{
static guint8 start [320];
static int inited = 0;
guint8 *code;
int alloc_size;
int offset;
g_assert (!aot);
if (info)
*info = NULL;
if (inited)
return start;
inited = 1;
code = start;
alloc_size = 64;
g_assert ((alloc_size & (MIPS_STACK_ALIGNMENT-1)) == 0);
mips_addiu (code, mips_sp, mips_sp, -alloc_size);
mips_sw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
/* Save global registers on stack (s0 - s7) */
offset = 16;
MIPS_SW (code, mips_s0, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s1, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s2, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s3, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s4, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s5, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s6, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_s7, mips_sp, offset); offset += IREG_SIZE;
MIPS_SW (code, mips_fp, mips_sp, offset); offset += IREG_SIZE;
/* Restore global registers from MonoContext, including the frame pointer */
MIPS_LW (code, mips_s0, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s0]));
MIPS_LW (code, mips_s1, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s1]));
MIPS_LW (code, mips_s2, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s2]));
MIPS_LW (code, mips_s3, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s3]));
MIPS_LW (code, mips_s4, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s4]));
MIPS_LW (code, mips_s5, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s5]));
MIPS_LW (code, mips_s6, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s6]));
MIPS_LW (code, mips_s7, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_s7]));
MIPS_LW (code, mips_fp, mips_a0, G_STRUCT_OFFSET (MonoContext, sc_regs[mips_fp]));
/* a1 is the handler to call */
mips_move (code, mips_t9, mips_a1);
/* jump to the saved IP */
mips_jalr (code, mips_t9, mips_ra);
mips_nop (code);
/* restore all regs from the stack */
offset = 16;
MIPS_LW (code, mips_s0, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s1, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s2, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s3, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s4, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s5, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s6, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_s7, mips_sp, offset); offset += IREG_SIZE;
MIPS_LW (code, mips_fp, mips_sp, offset); offset += IREG_SIZE;
/* epilog */
mips_lw (code, mips_ra, mips_sp, alloc_size + MIPS_RET_ADDR_OFFSET);
mips_addiu (code, mips_sp, mips_sp, alloc_size);
mips_jr (code, mips_ra);
mips_nop (code);
g_assert ((code - start) < sizeof(start));
mono_arch_flush_icache (start, code - start);
return start;
}