void
mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow)
{
MonoContext ctx;
/* adjust eip so that it point into the call instruction */
eip -= 4;
setup_context (&ctx);
/*printf ("stack in throw: %p\n", esp);*/
MONO_CONTEXT_SET_BP (&ctx, esp);
MONO_CONTEXT_SET_IP (&ctx, eip);
memcpy (&ctx.regs, int_regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
memcpy (&ctx.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS);
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
mono_handle_exception (&ctx, exc);
mono_restore_context (&ctx);
g_assert_not_reached ();
}
void
mono_arm_throw_exception (MonoObject *exc, mgreg_t pc, mgreg_t sp, mgreg_t *int_regs, gdouble *fp_regs)
{
MonoContext ctx;
gboolean rethrow = pc & 1;
pc &= ~1; /* clear the optional rethrow bit */
/* adjust eip so that it point into the call instruction */
pc -= 4;
/*printf ("stack in throw: %p\n", esp);*/
MONO_CONTEXT_SET_BP (&ctx, int_regs [ARMREG_FP - 4]);
MONO_CONTEXT_SET_SP (&ctx, sp);
MONO_CONTEXT_SET_IP (&ctx, pc);
memcpy (((guint8*)&ctx.regs) + (ARMREG_R4 * sizeof (mgreg_t)), int_regs, 8 * sizeof (mgreg_t));
memcpy (&ctx.fregs, fp_regs, sizeof (double) * 16);
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
mono_handle_exception (&ctx, exc);
mono_restore_context (&ctx);
g_assert_not_reached ();
}
/*
* The first few arguments are dummy, to force the other arguments to be passed on
* the stack, this avoids overwriting the argument registers in the throw trampoline.
*/
void
mono_amd64_throw_exception (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4,
guint64 dummy5, guint64 dummy6,
MonoContext *mctx, MonoObject *exc, gboolean rethrow)
{
MonoContext ctx;
/* mctx is on the caller's stack */
memcpy (&ctx, mctx, sizeof (MonoContext));
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow) {
mono_ex->stack_trace = NULL;
mono_ex->trace_ips = NULL;
}
}
/* adjust eip so that it point into the call instruction */
ctx.gregs [AMD64_RIP] --;
mono_handle_exception (&ctx, exc);
mono_restore_context (&ctx);
g_assert_not_reached ();
}
void
mono_arm_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
gboolean rethrow = eip & 1;
if (!restore_context)
restore_context = mono_get_restore_context ();
eip &= ~1; /* clear the optional rethrow bit */
/* adjust eip so that it point into the call instruction */
eip -= 4;
/*printf ("stack in throw: %p\n", esp);*/
MONO_CONTEXT_SET_BP (&ctx, int_regs [ARMREG_FP - 4]);
MONO_CONTEXT_SET_SP (&ctx, esp);
MONO_CONTEXT_SET_IP (&ctx, eip);
memcpy (((guint8*)&ctx.regs) + (4 * 4), int_regs, sizeof (gulong) * 8);
/* memcpy (&ctx.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS); */
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
mono_handle_exception (&ctx, exc, (gpointer)(eip + 4), FALSE);
restore_context (&ctx);
g_assert_not_reached ();
}
static void
throw_exception (MonoObject *exc, gpointer sp, gpointer ip, gboolean rethrow)
{
MonoContext ctx;
static void (*restore_context) (MonoContext *);
gpointer *window;
if (!restore_context)
restore_context = mono_get_restore_context ();
window = MONO_SPARC_WINDOW_ADDR (sp);
ctx.sp = (gpointer*)sp;
ctx.ip = ip;
ctx.fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (sp) [sparc_i6 - 16]);
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
}
/*
* The first few arguments are dummy, to force the other arguments to be passed on
* the stack, this avoids overwriting the argument registers in the throw trampoline.
*/
void
mono_amd64_throw_exception (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4,
guint64 dummy5, guint64 dummy6,
mgreg_t *regs, mgreg_t rip,
MonoObject *exc, gboolean rethrow)
{
MonoContext ctx;
ctx.rsp = regs [AMD64_RSP];
ctx.rip = rip;
ctx.rbx = regs [AMD64_RBX];
ctx.rbp = regs [AMD64_RBP];
ctx.r12 = regs [AMD64_R12];
ctx.r13 = regs [AMD64_R13];
ctx.r14 = regs [AMD64_R14];
ctx.r15 = regs [AMD64_R15];
ctx.rdi = regs [AMD64_RDI];
ctx.rsi = regs [AMD64_RSI];
ctx.rax = regs [AMD64_RAX];
ctx.rcx = regs [AMD64_RCX];
ctx.rdx = regs [AMD64_RDX];
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
/* adjust eip so that it point into the call instruction */
ctx.rip -= 1;
mono_handle_exception (&ctx, exc);
mono_restore_context (&ctx);
g_assert_not_reached ();
}
static void
throw_exception (MonoObject *exc, guint64 rethrow)
{
unw_context_t unw_ctx;
MonoContext ctx;
MonoJitInfo *ji;
unw_word_t ip, sp;
int res;
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow) {
mono_ex->stack_trace = NULL;
mono_ex->trace_ips = NULL;
}
}
res = unw_getcontext (&unw_ctx);
g_assert (res == 0);
res = unw_init_local (&ctx.cursor, &unw_ctx);
g_assert (res == 0);
/*
* Unwind until the first managed frame. This is needed since
* mono_handle_exception expects the variables in the original context to
* correspond to the method returned by mono_find_jit_info.
*/
while (TRUE) {
res = unw_get_reg (&ctx.cursor, UNW_IA64_IP, &ip);
g_assert (res == 0);
res = unw_get_reg (&ctx.cursor, UNW_IA64_SP, &sp);
g_assert (res == 0);
ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)ip, NULL);
//printf ("UN: %s %lx %lx\n", ji ? jinfo_get_method (ji)->name : "", ip, sp);
if (ji)
break;
res = unw_step (&ctx.cursor);
if (res == 0) {
/*
* This means an unhandled exception during the compilation of a
* topmost method like Main
*/
break;
}
g_assert (res >= 0);
}
ctx.precise_ip = FALSE;
mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
}
/*
* mono_x86_throw_exception:
*
* C function called from the throw trampolines.
*/
void
mono_x86_throw_exception (mgreg_t *regs, MonoObject *exc,
mgreg_t eip, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
if (!restore_context)
restore_context = mono_get_restore_context ();
ctx.esp = regs [X86_ESP];
ctx.eip = eip;
ctx.ebp = regs [X86_EBP];
ctx.edi = regs [X86_EDI];
ctx.esi = regs [X86_ESI];
ctx.ebx = regs [X86_EBX];
ctx.edx = regs [X86_EDX];
ctx.ecx = regs [X86_ECX];
ctx.eax = regs [X86_EAX];
#ifdef __APPLE__
/* The OSX ABI specifies 16 byte alignment at call sites */
g_assert ((ctx.esp % MONO_ARCH_FRAME_ALIGNMENT) == 0);
#endif
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
if (mono_debug_using_mono_debugger ()) {
guint8 buf [16], *code;
mono_breakpoint_clean_code (NULL, (gpointer)eip, 8, buf, sizeof (buf));
code = buf + 8;
if (buf [3] == 0xe8) {
MonoContext ctx_cp = ctx;
ctx_cp.eip = eip - 5;
if (mono_debugger_handle_exception (&ctx_cp, exc)) {
restore_context (&ctx_cp);
g_assert_not_reached ();
}
}
}
/* adjust eip so that it point into the call instruction */
ctx.eip -= 1;
mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
}
/*
* The first few arguments are dummy, to force the other arguments to be passed on
* the stack, this avoids overwriting the argument registers in the throw trampoline.
*/
void
mono_amd64_throw_exception (guint64 dummy1, guint64 dummy2, guint64 dummy3, guint64 dummy4,
guint64 dummy5, guint64 dummy6,
mgreg_t *regs, mgreg_t rip,
MonoObject *exc, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
if (!restore_context)
restore_context = mono_get_restore_context ();
ctx.rsp = regs [AMD64_RSP];
ctx.rip = rip;
ctx.rbx = regs [AMD64_RBX];
ctx.rbp = regs [AMD64_RBP];
ctx.r12 = regs [AMD64_R12];
ctx.r13 = regs [AMD64_R13];
ctx.r14 = regs [AMD64_R14];
ctx.r15 = regs [AMD64_R15];
ctx.rdi = regs [AMD64_RDI];
ctx.rsi = regs [AMD64_RSI];
ctx.rax = regs [AMD64_RAX];
ctx.rcx = regs [AMD64_RCX];
ctx.rdx = regs [AMD64_RDX];
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
if (mono_debug_using_mono_debugger ()) {
guint8 buf [16];
mono_breakpoint_clean_code (NULL, (gpointer)rip, 8, buf, sizeof (buf));
if (buf [3] == 0xe8) {
MonoContext ctx_cp = ctx;
ctx_cp.rip = rip - 5;
if (mono_debugger_handle_exception (&ctx_cp, exc)) {
restore_context (&ctx_cp);
g_assert_not_reached ();
}
}
}
/* adjust eip so that it point into the call instruction */
ctx.rip -= 1;
mono_handle_exception (&ctx, exc);
restore_context (&ctx);
g_assert_not_reached ();
}
static void
throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gboolean rethrow)
{
static void (*restore_context) (MonoContext *);
MonoContext ctx;
#ifdef DEBUG_EXCEPTIONS
g_print ("throw_exception: exc=%p eip=%p esp=%p rethrow=%d\n",
exc, (void *)eip, (void *) esp, rethrow);
#endif
if (!restore_context)
restore_context = mono_get_restore_context ();
/* adjust eip so that it point into the call instruction */
eip -= 8;
setup_context (&ctx);
/*g_print ("stack in throw: %p\n", esp);*/
memcpy (&ctx.sc_regs, (void *)(esp + MIPS_STACK_PARAM_OFFSET),
sizeof (gulong) * MONO_SAVED_GREGS);
memset (&ctx.sc_fpregs, 0, sizeof (mips_freg) * MONO_SAVED_FREGS);
MONO_CONTEXT_SET_IP (&ctx, eip);
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
mono_handle_exception (&ctx, exc, (void *)eip, FALSE);
#ifdef DEBUG_EXCEPTIONS
g_print ("throw_exception: restore to pc=%p sp=%p fp=%p ctx=%p\n",
(void *) ctx.sc_pc, (void *) ctx.sc_regs[mips_sp],
(void *) ctx.sc_regs[mips_fp], &ctx);
#endif
restore_context (&ctx);
g_assert_not_reached ();
}
caddr_t
dotnet_get_instance_name (int instance)
{
MonoArray *v_args;
MonoObject *mono_ret;
caddr_t ret = NULL;
MonoDomain *domain = virtuoso_domain;
char *utf8;
get_mono_thread ();
v_args = MAKE_PARAM_ARRAY (domain, 1);
SET_INT_ARG (domain, v_args, 0, instance);
mono_ret = call_mono (VIRTCLR_NAME, "VInvoke:get_instance_name", v_args, domain);
if (!mono_ret || !mono_object_isinst (mono_ret, mono_get_string_class ()))
GPF_T1 ("not a string in dotnet_get_instance_name");
utf8 = mono_string_to_utf8 ((MonoString *)mono_ret);
ret = box_dv_short_string (utf8);
g_free (utf8);
return ret;
}
/*
* mono_x86_throw_exception:
*
* C function called from the throw trampolines.
*/
void
mono_x86_throw_exception (mgreg_t *regs, MonoObject *exc,
mgreg_t eip, gboolean rethrow)
{
MonoContext ctx;
ctx.esp = regs [X86_ESP];
ctx.eip = eip;
ctx.ebp = regs [X86_EBP];
ctx.edi = regs [X86_EDI];
ctx.esi = regs [X86_ESI];
ctx.ebx = regs [X86_EBX];
ctx.edx = regs [X86_EDX];
ctx.ecx = regs [X86_ECX];
ctx.eax = regs [X86_EAX];
#ifdef __APPLE__
/* The OSX ABI specifies 16 byte alignment at call sites */
g_assert ((ctx.esp % MONO_ARCH_FRAME_ALIGNMENT) == 0);
#endif
if (mono_object_isinst (exc, mono_defaults.exception_class)) {
MonoException *mono_ex = (MonoException*)exc;
if (!rethrow)
mono_ex->stack_trace = NULL;
}
/* adjust eip so that it point into the call instruction */
ctx.eip -= 1;
mono_handle_exception (&ctx, exc);
mono_restore_context (&ctx);
g_assert_not_reached ();
}
void
virt_mono_throw_unhandled_exception (MonoObject *exc)
{
caddr_t err;
char *message = (char *) "";
const char *name = (const char *) "";
MonoString *str;
MonoMethod *method;
MonoClass *klass;
gboolean free_message = FALSE;
gint i;
if (mono_object_isinst (exc, mono_get_exception_class ()))
{
klass = mono_object_get_class (exc);
method = NULL;
while (klass && method == NULL)
{
gpointer m_iter = NULL;
for (method = mono_class_get_methods (klass, &m_iter); method != NULL;
method = mono_class_get_methods (klass, &m_iter))
{
MonoMethodSignature *sig = mono_method_signature (method);
guint32 flags = 0;
const char *name = mono_method_get_name (method);
mono_method_get_flags (method, &flags);
if (!strcmp ("ToString", name) &&
sig->param_count == 0
#ifdef OLD_KIT_1_1_5
&& (flags & METHOD_ATTRIBUTE_VIRTUAL)
&& (flags & METHOD_ATTRIBUTE_PUBLIC)
#endif
)
{
break;
}
method = NULL;
}
if (method == NULL)
klass = mono_class_get_parent (klass);
}
g_assert (method);
str = (MonoString *) mono_runtime_invoke (method, exc, NULL, NULL);
if (str) {
message = mono_string_to_utf8 (str);
free_message = TRUE;
name = mono_class_get_name (klass);
}
}
/*
* g_printerr ("\nUnhandled Exception: %s.%s: %s\n", exc->vtable->klass->name_space,
* exc->vtable->klass->name, message);
*/
g_printerr ("\nUnhandled Exception: %s\n", message);
err = srv_make_new_error ("42000", "MN001", "Unhandled Mono Exception [%.200s]: %.200s",
name, message);
if (free_message)
g_free (message);
sqlr_resignal (err);
}
