void
mono_arch_handle_altstack_exception (void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, gpointer fault_addr, gboolean stack_ovf)
{
#ifdef MONO_ARCH_USE_SIGACTION
MonoException *exc = NULL;
ucontext_t *ctx = (ucontext_t*)sigctx;
MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)UCONTEXT_REG_EIP (ctx), NULL);
gpointer *sp;
int frame_size;
/* if we didn't find a managed method for the ip address and it matches the fault
* address, we assume we followed a broken pointer during an indirect call, so
* we try the lookup again with the return address pushed on the stack
*/
if (!ji && fault_addr == (gpointer)UCONTEXT_REG_EIP (ctx)) {
glong *sp = (gpointer)UCONTEXT_REG_ESP (ctx);
ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)sp [0], NULL);
if (ji)
UCONTEXT_REG_EIP (ctx) = sp [0];
}
if (stack_ovf)
exc = mono_domain_get ()->stack_overflow_ex;
if (!ji)
mono_handle_native_sigsegv (SIGSEGV, sigctx, siginfo);
/* setup a call frame on the real stack so that control is returned there
* and exception handling can continue.
* If this was a stack overflow the caller already ensured the stack pages
* needed have been unprotected.
* The frame looks like:
* ucontext struct
* test_only arg
* exception arg
* ctx arg
* return ip
*/
// FIXME: test_only is no more.
frame_size = sizeof (MonoContext) + sizeof (gpointer) * 4;
frame_size += 15;
frame_size &= ~15;
sp = (gpointer)(UCONTEXT_REG_ESP (ctx) & ~15);
sp = (gpointer)((char*)sp - frame_size);
/* the incoming arguments are aligned to 16 bytes boundaries, so the return address IP
* goes at sp [-1]
*/
sp [-1] = (gpointer)UCONTEXT_REG_EIP (ctx);
sp [0] = sp + 4;
sp [1] = exc;
sp [2] = (gpointer)stack_ovf;
mono_sigctx_to_monoctx (sigctx, (MonoContext*)(sp + 4));
/* at the return form the signal handler execution starts in altstack_handle_and_restore() */
UCONTEXT_REG_EIP (ctx) = (unsigned long)altstack_handle_and_restore;
UCONTEXT_REG_ESP (ctx) = (unsigned long)(sp - 1);
#endif
}
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 ();
}
void
mono_trace_enter_method (MonoMethod *method, char *ebp)
{
int i, j;
MonoClass *klass;
MonoObject *o;
MonoJitArgumentInfo *arg_info;
MonoMethodSignature *sig;
char *fname;
MonoGenericSharingContext *gsctx = NULL;
if (!trace_spec.enabled)
return;
while (output_lock != 0 || InterlockedCompareExchange (&output_lock, 1, 0) != 0)
mono_thread_info_yield ();
fname = mono_method_full_name (method, TRUE);
indent (1);
printf ("ENTER: %s(", fname);
g_free (fname);
if (!ebp) {
printf (") ip: %p\n", RETURN_ADDRESS_N (1));
goto unlock;
}
sig = mono_method_signature (method);
arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1));
if (method->is_inflated) {
/* FIXME: Might be better to pass the ji itself */
MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), RETURN_ADDRESS (), NULL);
if (ji) {
gsctx = mono_jit_info_get_generic_sharing_context (ji);
if (gsctx && gsctx->is_gsharedvt) {
/* Needs a ctx to get precise method */
printf (") <gsharedvt>\n");
goto unlock;
}
}
}
mono_arch_get_argument_info (sig, sig->param_count, arg_info);
if (MONO_TYPE_ISSTRUCT (mono_method_signature (method)->ret)) {
g_assert (!mono_method_signature (method)->ret->byref);
printf ("VALUERET:%p, ", *((gpointer *)(ebp + 8)));
}
if (mono_method_signature (method)->hasthis) {
gpointer *this = (gpointer *)(ebp + arg_info [0].offset);
if (method->klass->valuetype) {
printf ("value:%p, ", *arg_in_stack_slot(this, gpointer *));
} else {
/* mono_arch_find_jit_info:
*
* This function is used to gather information from @ctx. It return the
* MonoJitInfo of the corresponding function, unwinds one stack frame and
* stores the resulting context into @new_ctx. It also stores a string
* describing the stack location into @trace (if not NULL), and modifies
* the @lmf if necessary. @native_offset return the IP offset from the
* start of the function or -1 if that info is not available.
*/
gboolean
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer *window;
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
frame->managed = FALSE;
*new_ctx = *ctx;
if (ji != NULL) {
frame->type = FRAME_TYPE_MANAGED;
if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*lmf = (*lmf)->previous_lmf;
}
/* Restore ip and sp from the saved register window */
window = MONO_SPARC_WINDOW_ADDR (ctx->sp);
new_ctx->ip = window [sparc_i7 - 16];
new_ctx->sp = (gpointer*)(window [sparc_i6 - 16]);
new_ctx->fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (new_ctx->sp) [sparc_i6 - 16]);
return TRUE;
}
else {
if (!(*lmf))
return FALSE;
if (!(*lmf)->method)
return FALSE;
ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->ip, NULL);
if (!ji)
return FALSE;
frame->ji = ji;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
new_ctx->ip = (*lmf)->ip;
new_ctx->sp = (*lmf)->sp;
new_ctx->fp = (*lmf)->ebp;
*lmf = (*lmf)->previous_lmf;
return TRUE;
}
}
static void
altstack_handle_and_restore (MonoContext *ctx, MonoObject *obj, gboolean stack_ovf)
{
MonoContext mctx;
MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), MONO_CONTEXT_GET_IP (ctx), NULL);
if (!ji)
mono_handle_native_sigsegv (SIGSEGV, NULL, NULL);
mctx = *ctx;
mono_handle_exception (&mctx, obj);
if (stack_ovf)
prepare_for_guard_pages (&mctx);
mono_restore_context (&mctx);
}
static PRUNTIME_FUNCTION
MONO_GET_RUNTIME_FUNCTION_CALLBACK ( DWORD64 ControlPc, IN PVOID Context )
{
MonoJitInfo *ji;
guint64 pos;
PMonoUnwindInfo targetinfo;
MonoDomain *domain = mono_domain_get ();
ji = mini_jit_info_table_find (domain, (char*)ControlPc, NULL);
if (!ji)
return 0;
pos = (guint64)(((char*)ji->code_start) + ji->code_size);
targetinfo = (PMonoUnwindInfo)ALIGN_TO (pos, 8);
targetinfo->runtimeFunction.UnwindData = ((DWORD64)&targetinfo->unwindInfo) - ((DWORD64)Context);
return &targetinfo->runtimeFunction;
}
void
mono_arch_handle_altstack_exception (void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, gpointer fault_addr, gboolean stack_ovf)
{
#if defined(MONO_ARCH_USE_SIGACTION)
MonoException *exc = NULL;
MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (char *)UCONTEXT_REG_RIP (sigctx), NULL);
gpointer *sp;
int frame_size;
MonoContext *copied_ctx;
if (stack_ovf)
exc = mono_domain_get ()->stack_overflow_ex;
if (!ji)
mono_handle_native_sigsegv (SIGSEGV, sigctx, siginfo);
/* setup a call frame on the real stack so that control is returned there
* and exception handling can continue.
* The frame looks like:
* ucontext struct
* ...
* return ip
* 128 is the size of the red zone
*/
frame_size = sizeof (MonoContext) + sizeof (gpointer) * 4 + 128;
frame_size += 15;
frame_size &= ~15;
sp = (gpointer *)(UCONTEXT_REG_RSP (sigctx) & ~15);
sp = (gpointer *)((char*)sp - frame_size);
copied_ctx = (MonoContext*)(sp + 4);
/* the arguments must be aligned */
sp [-1] = (gpointer)UCONTEXT_REG_RIP (sigctx);
mono_sigctx_to_monoctx (sigctx, copied_ctx);
/* at the return form the signal handler execution starts in altstack_handle_and_restore() */
UCONTEXT_REG_RIP (sigctx) = (unsigned long)altstack_handle_and_restore;
UCONTEXT_REG_RSP (sigctx) = (unsigned long)(sp - 1);
UCONTEXT_REG_RDI (sigctx) = (unsigned long)(copied_ctx);
UCONTEXT_REG_RSI (sigctx) = (guint64)exc;
UCONTEXT_REG_RDX (sigctx) = stack_ovf;
#endif
}
/**
* mono_arch_handle_exception:
*
* @ctx: saved processor state
* @obj: the exception object
*/
gboolean
mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only)
{
/* libunwind takes care of this */
unw_context_t unw_ctx;
MonoContext ctx;
MonoJitInfo *ji;
unw_word_t ip;
int res;
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 skips the signal handler frames
* too.
*/
while (TRUE) {
res = unw_get_reg (&ctx.cursor, UNW_IA64_IP, &ip);
g_assert (res == 0);
ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)ip, NULL);
if (ji)
break;
res = unw_step (&ctx.cursor);
g_assert (res >= 0);
}
ctx.precise_ip = TRUE;
mono_handle_exception (&ctx, obj, (gpointer)ip, test_only);
restore_context (&ctx);
g_assert_not_reached ();
}
/* mono_arch_find_jit_info:
*
* This function is used to gather information from @ctx. It return the
* MonoJitInfo of the corresponding function, unwinds one stack frame and
* stores the resulting context into @new_ctx. It also stores a string
* describing the stack location into @trace (if not NULL), and modifies
* the @lmf if necessary. @native_offset return the IP offset from the
* start of the function or -1 if that info is not available.
*/
MonoJitInfo *
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
{
MonoJitInfo *ji;
int err;
unw_word_t ip;
*new_ctx = *ctx;
new_ctx->precise_ip = FALSE;
while (TRUE) {
err = unw_get_reg (&new_ctx->cursor, UNW_IA64_IP, &ip);
g_assert (err == 0);
/* Avoid costly table lookup during stack overflow */
if (prev_ji && ((guint8*)ip > (guint8*)prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
ji = prev_ji;
else
ji = mini_jit_info_table_find (domain, (gpointer)ip, NULL);
if (managed)
*managed = FALSE;
/*
{
char name[256];
unw_word_t off;
unw_get_proc_name (&new_ctx->cursor, name, 256, &off);
printf ("F: %s\n", name);
}
*/
if (ji != NULL) {
if (managed)
if (!ji->method->wrapper_type)
*managed = TRUE;
break;
}
/* This is an unmanaged frame, so just unwind through it */
/* FIXME: This returns -3 for the __clone2 frame in libc */
err = unw_step (&new_ctx->cursor);
if (err < 0)
break;
if (err == 0)
break;
}
if (ji) {
//print_ctx (new_ctx);
err = unw_step (&new_ctx->cursor);
g_assert (err >= 0);
//print_ctx (new_ctx);
return ji;
}
else
return (gpointer)(gssize)-1;
}
/*
* mini_add_method_trampoline:
*
* Add static rgctx/gsharedvt_in trampoline to M/COMPILED_METHOD if needed. Return the trampoline address, or
* COMPILED_METHOD if no trampoline is needed.
* ORIG_METHOD is the method the caller originally called i.e. an iface method, or NULL.
*/
gpointer
mini_add_method_trampoline (MonoMethod *orig_method, MonoMethod *m, gpointer compiled_method, gboolean add_static_rgctx_tramp)
{
gpointer addr = compiled_method;
gboolean callee_gsharedvt, callee_array_helper;
MonoJitInfo *ji =
mini_jit_info_table_find (mono_domain_get (), mono_get_addr_from_ftnptr (compiled_method), NULL);
// FIXME: This loads information from AOT
callee_gsharedvt = ji_is_gsharedvt (ji);
callee_array_helper = FALSE;
if (m->wrapper_type == MONO_WRAPPER_MANAGED_TO_MANAGED) {
WrapperInfo *info = mono_marshal_get_wrapper_info (m);
/*
* generic array helpers.
* Have to replace the wrappers with the original generic instances.
*/
if (info && info->subtype == WRAPPER_SUBTYPE_GENERIC_ARRAY_HELPER) {
callee_array_helper = TRUE;
m = info->d.generic_array_helper.method;
}
} else if (m->wrapper_type == MONO_WRAPPER_UNKNOWN) {
WrapperInfo *info = mono_marshal_get_wrapper_info (m);
/* Same for synchronized inner wrappers */
if (info && info->subtype == WRAPPER_SUBTYPE_SYNCHRONIZED_INNER) {
m = info->d.synchronized_inner.method;
}
}
if (!orig_method)
orig_method = m;
if (callee_gsharedvt)
g_assert (m->is_inflated);
addr = compiled_method;
if (callee_gsharedvt && mini_is_gsharedvt_variable_signature (mono_method_signature (ji->method))) {
MonoGenericSharingContext *gsctx;
MonoMethodSignature *sig, *gsig;
/* Here m is a generic instance, while ji->method is the gsharedvt method implementing it */
/* Call from normal/gshared code to gsharedvt code with variable signature */
gsctx = mono_jit_info_get_generic_sharing_context (ji);
sig = mono_method_signature (m);
gsig = mono_method_signature (ji->method);
addr = mini_get_gsharedvt_wrapper (TRUE, compiled_method, sig, gsig, gsctx, -1, FALSE);
//printf ("IN: %s\n", mono_method_full_name (m, TRUE));
}
if (add_static_rgctx_tramp && !callee_array_helper)
addr = mono_create_static_rgctx_trampoline (m, addr);
return addr;
}
/*
* mono_arch_unwind_frame:
*
* This function is used to gather information from @ctx, and store it in @frame_info.
* It unwinds one stack frame, and stores the resulting context into @new_ctx. @lmf
* is modified if needed.
* Returns TRUE on success, FALSE otherwise.
*/
gboolean
mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
int err;
unw_word_t ip;
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
new_ctx->precise_ip = FALSE;
if (!ji) {
while (TRUE) {
err = unw_get_reg (&new_ctx->cursor, UNW_IA64_IP, &ip);
g_assert (err == 0);
ji = mini_jit_info_table_find (domain, (gpointer)ip, NULL);
/*
{
char name[256];
unw_word_t off;
unw_get_proc_name (&new_ctx->cursor, name, 256, &off);
printf ("F: %s\n", name);
}
*/
if (ji)
break;
/* This is an unmanaged frame, so just unwind through it */
/* FIXME: This returns -3 for the __clone2 frame in libc */
err = unw_step (&new_ctx->cursor);
if (err < 0)
break;
if (err == 0)
break;
}
}
if (ji) {
frame->type = FRAME_TYPE_MANAGED;
frame->ji = ji;
//print_ctx (new_ctx);
err = unw_step (&new_ctx->cursor);
g_assert (err >= 0);
//print_ctx (new_ctx);
return TRUE;
}
else
return FALSE;
}
/*
* mono_arch_find_jit_info:
*
* This function is used to gather information from @ctx, and store it in @frame_info.
* It unwinds one stack frame, and stores the resulting context into @new_ctx. @lmf
* is modified if needed.
* Returns TRUE on success, FALSE otherwise.
*/
gboolean
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
mgreg_t regs [MONO_MAX_IREGS + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
frame->type = FRAME_TYPE_MANAGED;
if (ji->from_aot)
unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
else
unwind_info = mono_get_cached_unwind_info (ji->used_regs, &unwind_info_len);
frame->unwind_info = unwind_info;
frame->unwind_info_len = unwind_info_len;
regs [AMD64_RAX] = new_ctx->rax;
regs [AMD64_RBX] = new_ctx->rbx;
regs [AMD64_RCX] = new_ctx->rcx;
regs [AMD64_RDX] = new_ctx->rdx;
regs [AMD64_RBP] = new_ctx->rbp;
regs [AMD64_RSP] = new_ctx->rsp;
regs [AMD64_RSI] = new_ctx->rsi;
regs [AMD64_RDI] = new_ctx->rdi;
regs [AMD64_RIP] = new_ctx->rip;
regs [AMD64_R12] = new_ctx->r12;
regs [AMD64_R13] = new_ctx->r13;
regs [AMD64_R14] = new_ctx->r14;
regs [AMD64_R15] = new_ctx->r15;
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, regs, MONO_MAX_IREGS + 1,
save_locations, MONO_MAX_IREGS, &cfa);
new_ctx->rax = regs [AMD64_RAX];
new_ctx->rbx = regs [AMD64_RBX];
new_ctx->rcx = regs [AMD64_RCX];
new_ctx->rdx = regs [AMD64_RDX];
new_ctx->rbp = regs [AMD64_RBP];
new_ctx->rsp = regs [AMD64_RSP];
new_ctx->rsi = regs [AMD64_RSI];
new_ctx->rdi = regs [AMD64_RDI];
new_ctx->rip = regs [AMD64_RIP];
new_ctx->r12 = regs [AMD64_R12];
new_ctx->r13 = regs [AMD64_R13];
new_ctx->r14 = regs [AMD64_R14];
new_ctx->r15 = regs [AMD64_R15];
/* The CFA becomes the new SP value */
new_ctx->rsp = (mgreg_t)cfa;
/* Adjust IP */
new_ctx->rip --;
if (*lmf && ((*lmf) != jit_tls->first_lmf) && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->rsp)) {
/* remove any unused lmf */
*lmf = (gpointer)(((guint64)(*lmf)->previous_lmf) & ~3);
}
#ifndef MONO_AMD64_NO_PUSHES
/* Pop arguments off the stack */
if (ji->has_arch_eh_info)
new_ctx->rsp += mono_jit_info_get_arch_eh_info (ji)->stack_size;
#endif
return TRUE;
} else if (*lmf) {
guint64 rip;
if (((guint64)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((guint64)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
if (((guint64)(*lmf)->previous_lmf) & 1) {
/* This LMF has the rip field set */
rip = (*lmf)->rip;
} else if ((*lmf)->rsp == 0) {
/* Top LMF entry */
return FALSE;
} else {
/*
* The rsp field is set just before the call which transitioned to native
* code. Obtain the rip from the stack.
*/
rip = *(guint64*)((*lmf)->rsp - sizeof(mgreg_t));
}
ji = mini_jit_info_table_find (domain, (gpointer)rip, NULL);
/*
* FIXME: ji == NULL can happen when a managed-to-native wrapper is interrupted
* in the soft debugger suspend code, since (*lmf)->rsp no longer points to the
* return address.
*/
//g_assert (ji);
if (!ji)
return FALSE;
/* Adjust IP */
rip --;
frame->ji = ji;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
new_ctx->rip = rip;
new_ctx->rbp = (*lmf)->rbp;
new_ctx->rsp = (*lmf)->rsp;
new_ctx->rbx = (*lmf)->rbx;
new_ctx->r12 = (*lmf)->r12;
new_ctx->r13 = (*lmf)->r13;
new_ctx->r14 = (*lmf)->r14;
new_ctx->r15 = (*lmf)->r15;
#ifdef TARGET_WIN32
new_ctx->rdi = (*lmf)->rdi;
new_ctx->rsi = (*lmf)->rsi;
#endif
*lmf = (gpointer)(((guint64)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
/*
* mono_arch_unwind_frame:
*
* See exceptions-amd64.c for docs;
*/
gboolean
mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
int i;
mono_unwind_reg_t regs [MONO_MAX_IREGS + 1 + 8];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
if (ji->is_trampoline)
frame->type = FRAME_TYPE_TRAMPOLINE;
else
frame->type = FRAME_TYPE_MANAGED;
unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
/*
printf ("%s %p %p\n", ji->d.method->name, ji->code_start, ip);
mono_print_unwind_info (unwind_info, unwind_info_len);
*/
for (i = 0; i < 16; ++i)
regs [i] = new_ctx->regs [i];
#ifdef TARGET_IOS
/* On IOS, d8..d15 are callee saved. They are mapped to 8..15 in unwind.c */
for (i = 0; i < 8; ++i)
regs [MONO_MAX_IREGS + i] = *(guint64*)&(new_ctx->fregs [8 + i]);
#endif
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, NULL, regs, MONO_MAX_IREGS + 8,
save_locations, MONO_MAX_IREGS, &cfa);
for (i = 0; i < 16; ++i)
new_ctx->regs [i] = regs [i];
new_ctx->pc = regs [ARMREG_LR];
new_ctx->regs [ARMREG_SP] = (gsize)cfa;
#ifdef TARGET_IOS
for (i = 0; i < 8; ++i)
new_ctx->fregs [8 + i] = *(double*)&(regs [MONO_MAX_IREGS + i]);
#endif
/* Clear thumb bit */
new_ctx->pc &= ~1;
/* we substract 1, so that the IP points into the call instruction */
new_ctx->pc--;
return TRUE;
} else if (*lmf) {
if (((gsize)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->ip, NULL))) {
frame->ji = ji;
} else {
if (!(*lmf)->method)
return FALSE;
frame->method = (*lmf)->method;
}
/*
* The LMF is saved at the start of the method using:
* ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_SP)
* ARM_PUSH (code, 0x5ff0);
* So it stores the register state as it existed at the caller. We need to
* produce the register state which existed at the time of the call which
* transitioned to native call, so we save the sp/fp/ip in the LMF.
*/
memcpy (&new_ctx->regs [0], &(*lmf)->iregs [0], sizeof (mgreg_t) * 13);
new_ctx->pc = (*lmf)->ip;
new_ctx->regs [ARMREG_SP] = (*lmf)->sp;
new_ctx->regs [ARMREG_FP] = (*lmf)->fp;
/* Clear thumb bit */
new_ctx->pc &= ~1;
/* we substract 1, so that the IP points into the call instruction */
new_ctx->pc--;
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
/*
* mono_arch_unwind_frame:
*
* See exceptions-amd64.c for docs.
*/
gboolean
mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
gssize regs [MONO_MAX_IREGS + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
if (ji->is_trampoline)
frame->type = FRAME_TYPE_TRAMPOLINE;
else
frame->type = FRAME_TYPE_MANAGED;
unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
regs [X86_EAX] = new_ctx->eax;
regs [X86_EBX] = new_ctx->ebx;
regs [X86_ECX] = new_ctx->ecx;
regs [X86_EDX] = new_ctx->edx;
regs [X86_ESP] = new_ctx->esp;
regs [X86_EBP] = new_ctx->ebp;
regs [X86_ESI] = new_ctx->esi;
regs [X86_EDI] = new_ctx->edi;
regs [X86_NREG] = new_ctx->eip;
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, NULL, regs, MONO_MAX_IREGS + 1,
save_locations, MONO_MAX_IREGS, &cfa);
new_ctx->eax = regs [X86_EAX];
new_ctx->ebx = regs [X86_EBX];
new_ctx->ecx = regs [X86_ECX];
new_ctx->edx = regs [X86_EDX];
new_ctx->esp = regs [X86_ESP];
new_ctx->ebp = regs [X86_EBP];
new_ctx->esi = regs [X86_ESI];
new_ctx->edi = regs [X86_EDI];
new_ctx->eip = regs [X86_NREG];
/* The CFA becomes the new SP value */
new_ctx->esp = (gssize)cfa;
/* Adjust IP */
new_ctx->eip --;
return TRUE;
} else if (*lmf) {
if (((guint64)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
frame->ji = ji;
} else {
if (!(*lmf)->method)
return FALSE;
frame->method = (*lmf)->method;
}
new_ctx->esi = (*lmf)->esi;
new_ctx->edi = (*lmf)->edi;
new_ctx->ebx = (*lmf)->ebx;
new_ctx->ebp = (*lmf)->ebp;
new_ctx->eip = (*lmf)->eip;
/* Adjust IP */
new_ctx->eip --;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
/* Check if we are in a trampoline LMF frame */
if ((guint32)((*lmf)->previous_lmf) & 1) {
/* lmf->esp is set by the trampoline code */
new_ctx->esp = (*lmf)->esp;
}
else
/* the lmf is always stored on the stack, so the following
* expression points to a stack location which can be used as ESP */
new_ctx->esp = (unsigned long)&((*lmf)->eip);
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
/* mono_arch_find_jit_info:
*
* This function is used to gather information from @ctx. It return the
* MonoJitInfo of the corresponding function, unwinds one stack frame and
* stores the resulting context into @new_ctx. It also stores a string
* describing the stack location into @trace (if not NULL), and modifies
* the @lmf if necessary. @native_offset return the IP offset from the
* start of the function or -1 if that info is not available.
*/
MonoJitInfo *
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
{
MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
gpointer *window;
/* Avoid costly table lookup during stack overflow */
if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
ji = prev_ji;
else
ji = mini_jit_info_table_find (domain, ip, NULL);
if (managed)
*managed = FALSE;
if (ji != NULL) {
*new_ctx = *ctx;
if (managed)
if (!ji->method->wrapper_type)
*managed = TRUE;
if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*lmf = (*lmf)->previous_lmf;
}
/* Restore ip and sp from the saved register window */
window = MONO_SPARC_WINDOW_ADDR (ctx->sp);
new_ctx->ip = window [sparc_i7 - 16];
new_ctx->sp = (gpointer*)(window [sparc_i6 - 16]);
new_ctx->fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (new_ctx->sp) [sparc_i6 - 16]);
return ji;
}
else {
if (!(*lmf))
return NULL;
*new_ctx = *ctx;
if (!(*lmf)->method)
return (gpointer)-1;
if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->ip, NULL))) {
} else {
memset (res, 0, MONO_SIZEOF_JIT_INFO);
res->method = (*lmf)->method;
}
new_ctx->ip = (*lmf)->ip;
new_ctx->sp = (*lmf)->sp;
new_ctx->fp = (*lmf)->ebp;
*lmf = (*lmf)->previous_lmf;
return ji ? ji : res;
}
}
/* mono_arch_find_jit_info:
*
* This function is used to gather information from @ctx. It returns the
* MonoJitInfo of the corresponding function, unwinds one stack frame and
* stores the resulting context into @new_ctx. It also stores a string
* describing the stack location into @trace (if not NULL), and modifies
* the @lmf if necessary. @native_offset return the IP offset from the
* start of the function or -1 if that info is not available.
*/
MonoJitInfo *
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *res, MonoJitInfo *prev_ji,
MonoContext *ctx, MonoContext *new_ctx,
MonoLMF **lmf, gboolean *managed)
{
MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
gpointer fp = MONO_CONTEXT_GET_BP (ctx);
guint32 sp;
/* Avoid costly table lookup during stack overflow */
if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
ji = prev_ji;
else
ji = mini_jit_info_table_find (domain, ip, NULL);
if (managed)
*managed = FALSE;
memcpy (new_ctx, ctx, sizeof (MonoContext));
if (ji != NULL) {
int i;
gint32 address;
int offset = 0;
if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*lmf = (*lmf)->previous_lmf;
}
address = (char *)ip - (char *)ji->code_start;
if (managed)
if (!ji->method->wrapper_type)
*managed = TRUE;
/* My stack frame */
fp = MONO_CONTEXT_GET_BP (ctx);
/* Compute the previous stack frame */
sp = (guint32)(fp) - (short)(*(guint32 *)(ji->code_start));
/* Sanity check the frame */
if (!sp || (sp == 0xffffffff)
|| (sp & 0x07) || (sp < 64*1024)) {
#ifdef DEBUG_EXCEPTIONS
g_print ("mono_arch_find_jit_info: bad stack sp=%p\n", (void *) sp);
#endif
return (gpointer)-1;
}
if (ji->method->save_lmf && 0) {
/* only enable this when prologue stops emitting
* normal save of s-regs when save_lmf is true.
* Will have to sync with prologue code at that point.
*/
memcpy (&new_ctx->sc_fpregs,
(char*)sp - sizeof (float) * MONO_SAVED_FREGS,
sizeof (float) * MONO_SAVED_FREGS);
memcpy (&new_ctx->sc_regs,
(char*)sp - sizeof (float) * MONO_SAVED_FREGS - sizeof (gulong) * MONO_SAVED_GREGS,
sizeof (gulong) * MONO_SAVED_GREGS);
} else if (ji->used_regs) {
guint32 *insn;
guint32 mask = ji->used_regs;
/* these all happen before adjustment of fp */
/* Look for sw ??, ????(sp) */
insn = ((guint32 *)ji->code_start) + 1;
while (!*insn || ((*insn & 0xffe00000) == 0xafa00000) || ((*insn & 0xffe00000) == 0xffa00000)) {
int reg = (*insn >> 16) & 0x1f;
guint32 addr = (((guint32)fp) + (short)(*insn & 0x0000ffff));
mask &= ~(1 << reg);
if ((*insn & 0xffe00000) == 0xafa00000)
new_ctx->sc_regs [reg] = *(guint32 *)addr;
else
new_ctx->sc_regs [reg] = *(guint64 *)addr;
insn++;
}
MONO_CONTEXT_SET_SP (new_ctx, sp);
MONO_CONTEXT_SET_BP (new_ctx, sp);
/* assert that we found all registers we were supposed to */
g_assert (!mask);
}
/*
* mono_arch_unwind_frame:
*
* See exceptions-amd64.c for docs;
*/
gboolean
mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
mgreg_t regs [MONO_MAX_IREGS + 8 + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
frame->type = FRAME_TYPE_MANAGED;
unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
memcpy (regs, &new_ctx->regs, sizeof (mgreg_t) * 32);
/* v8..v15 are callee saved */
memcpy (regs + MONO_MAX_IREGS, &(new_ctx->fregs [8]), sizeof (mgreg_t) * 8);
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, NULL, regs, MONO_MAX_IREGS + 8,
save_locations, MONO_MAX_IREGS, &cfa);
memcpy (&new_ctx->regs, regs, sizeof (mgreg_t) * 32);
memcpy (&(new_ctx->fregs [8]), regs + MONO_MAX_IREGS, sizeof (mgreg_t) * 8);
new_ctx->pc = regs [ARMREG_LR];
new_ctx->regs [ARMREG_SP] = (mgreg_t)cfa;
if (*lmf && (*lmf)->gregs [MONO_ARCH_LMF_REG_SP] && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->gregs [MONO_ARCH_LMF_REG_SP])) {
/* remove any unused lmf */
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
}
/* we substract 1, so that the IP points into the call instruction */
new_ctx->pc--;
return TRUE;
} else if (*lmf) {
if (((gsize)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->pc, NULL);
if (!ji)
return FALSE;
g_assert (MONO_ARCH_LMF_REGS == ((0x3ff << 19) | (1 << ARMREG_FP) | (1 << ARMREG_SP)));
memcpy (&new_ctx->regs [ARMREG_R19], &(*lmf)->gregs [0], sizeof (mgreg_t) * 10);
new_ctx->regs [ARMREG_FP] = (*lmf)->gregs [MONO_ARCH_LMF_REG_FP];
new_ctx->regs [ARMREG_SP] = (*lmf)->gregs [MONO_ARCH_LMF_REG_SP];
new_ctx->pc = (*lmf)->pc;
/* we substract 1, so that the IP points into the call instruction */
new_ctx->pc--;
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
/*
* mono_arch_find_jit_info:
*
* See exceptions-amd64.c for docs.
*/
gboolean
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
gssize regs [MONO_MAX_IREGS + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
frame->type = FRAME_TYPE_MANAGED;
if (ji->from_aot)
unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
else
unwind_info = mono_get_cached_unwind_info (ji->used_regs, &unwind_info_len);
regs [X86_EAX] = new_ctx->eax;
regs [X86_EBX] = new_ctx->ebx;
regs [X86_ECX] = new_ctx->ecx;
regs [X86_EDX] = new_ctx->edx;
regs [X86_ESP] = new_ctx->esp;
regs [X86_EBP] = new_ctx->ebp;
regs [X86_ESI] = new_ctx->esi;
regs [X86_EDI] = new_ctx->edi;
regs [X86_NREG] = new_ctx->eip;
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, regs, MONO_MAX_IREGS + 1,
save_locations, MONO_MAX_IREGS, &cfa);
new_ctx->eax = regs [X86_EAX];
new_ctx->ebx = regs [X86_EBX];
new_ctx->ecx = regs [X86_ECX];
new_ctx->edx = regs [X86_EDX];
new_ctx->esp = regs [X86_ESP];
new_ctx->ebp = regs [X86_EBP];
new_ctx->esi = regs [X86_ESI];
new_ctx->edi = regs [X86_EDI];
new_ctx->eip = regs [X86_NREG];
/* The CFA becomes the new SP value */
new_ctx->esp = (gssize)cfa;
/* Adjust IP */
new_ctx->eip --;
if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
}
/* Pop arguments off the stack */
/*
* FIXME: LLVM doesn't push these, we can't use ji->from_llvm as it describes
* the callee.
*/
#ifndef ENABLE_LLVM
if (ji->has_arch_eh_info)
new_ctx->esp += mono_jit_info_get_arch_eh_info (ji)->stack_size;
#endif
return TRUE;
} else if (*lmf) {
if (((guint64)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
} else {
if (!((guint32)((*lmf)->previous_lmf) & 1))
/* Top LMF entry */
return FALSE;
g_assert_not_reached ();
/* Trampoline lmf frame */
frame->method = (*lmf)->method;
}
new_ctx->esi = (*lmf)->esi;
new_ctx->edi = (*lmf)->edi;
new_ctx->ebx = (*lmf)->ebx;
new_ctx->ebp = (*lmf)->ebp;
new_ctx->eip = (*lmf)->eip;
/* Adjust IP */
new_ctx->eip --;
frame->ji = ji;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
/* Check if we are in a trampoline LMF frame */
if ((guint32)((*lmf)->previous_lmf) & 1) {
/* lmf->esp is set by the trampoline code */
new_ctx->esp = (*lmf)->esp;
/* Pop arguments off the stack */
/* FIXME: Handle the delegate case too ((*lmf)->method == NULL) */
/* FIXME: Handle the IMT/vtable case too */
#if 0
#ifndef ENABLE_LLVM
if ((*lmf)->method) {
MonoMethod *method = (*lmf)->method;
MonoJitArgumentInfo *arg_info = g_newa (MonoJitArgumentInfo, mono_method_signature (method)->param_count + 1);
guint32 stack_to_pop = mono_arch_get_argument_info (NULL, mono_method_signature (method), mono_method_signature (method)->param_count, arg_info);
new_ctx->esp += stack_to_pop;
}
#endif
#endif
}
else
/* the lmf is always stored on the stack, so the following
* expression points to a stack location which can be used as ESP */
new_ctx->esp = (unsigned long)&((*lmf)->eip);
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
void
mono_arch_handle_altstack_exception (void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, gpointer fault_addr, gboolean stack_ovf)
{
#ifdef MONO_CROSS_COMPILE
g_assert_not_reached ();
#else
#ifdef MONO_ARCH_USE_SIGACTION
os_ucontext *uc = (ucontext_t*)sigctx;
os_ucontext *uc_copy;
MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx), NULL);
gpointer *sp;
int frame_size;
if (stack_ovf) {
const char *method;
/* we don't do much now, but we can warn the user with a useful message */
fprintf (stderr, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx), (gpointer)UCONTEXT_REG_Rn(uc, 1));
if (ji && !ji->is_trampoline && jinfo_get_method (ji))
method = mono_method_full_name (jinfo_get_method (ji), TRUE);
else
method = "Unmanaged";
fprintf (stderr, "At %s\n", method);
abort ();
}
if (!ji)
mono_handle_native_crash ("SIGSEGV", sigctx, siginfo);
/* setup a call frame on the real stack so that control is returned there
* and exception handling can continue.
* The frame looks like:
* ucontext struct
* ...
* 224 is the size of the red zone
*/
frame_size = sizeof (ucontext_t) + sizeof (gpointer) * 16 + 224;
frame_size += 15;
frame_size &= ~15;
sp = (gpointer)(UCONTEXT_REG_Rn(uc, 1) & ~15);
sp = (gpointer)((char*)sp - frame_size);
/* may need to adjust pointers in the new struct copy, depending on the OS */
uc_copy = (ucontext_t*)(sp + 16);
memcpy (uc_copy, uc, sizeof (os_ucontext));
#if defined(__linux__) && !defined(__mono_ppc64__)
uc_copy->uc_mcontext.uc_regs = (gpointer)((char*)uc_copy + ((char*)uc->uc_mcontext.uc_regs - (char*)uc));
#endif
g_assert (mono_arch_ip_from_context (uc) == mono_arch_ip_from_context (uc_copy));
/* at the return form the signal handler execution starts in altstack_handle_and_restore() */
UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
{
MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)altstack_handle_and_restore;
UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
}
#else
UCONTEXT_REG_NIP(uc) = (unsigned long)altstack_handle_and_restore;
#if _CALL_ELF == 2
/* ELF v2 ABI calling convention requires to put the target address into
* r12 if we use the global entry point of a function. */
UCONTEXT_REG_Rn(uc, 12) = (unsigned long) altstack_handle_and_restore;
#endif
#endif
UCONTEXT_REG_Rn(uc, 1) = (unsigned long)sp;
UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG) = (unsigned long)(sp + 16);
UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 1) = 0;
UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 2) = 0;
#endif
#endif /* !MONO_CROSS_COMPILE */
}
/*
* mono_arch_unwind_frame:
*
* See exceptions-amd64.c for docs.
*/
gboolean
mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
MonoPPCStackFrame *sframe;
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
setup_context (new_ctx);
if (ji != NULL) {
int i;
mgreg_t regs [ppc_lr + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
if (ji->is_trampoline)
frame->type = FRAME_TYPE_TRAMPOLINE;
else
frame->type = FRAME_TYPE_MANAGED;
unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
if (!ji->is_trampoline && jinfo_get_method (ji)->save_lmf) {
/* sframe->sp points just past the end of the LMF */
guint8 *lmf_addr = (guint8*)sframe->sp - sizeof (MonoLMF);
memcpy (&new_ctx->fregs [MONO_PPC_FIRST_SAVED_FREG], lmf_addr + G_STRUCT_OFFSET (MonoLMF, fregs), sizeof (double) * MONO_SAVED_FREGS);
memcpy (&new_ctx->regs [MONO_PPC_FIRST_SAVED_GREG], lmf_addr + G_STRUCT_OFFSET (MonoLMF, iregs), sizeof (mgreg_t) * MONO_SAVED_GREGS);
/* the calling IP is in the parent frame */
sframe = (MonoPPCStackFrame*)sframe->sp;
/* we substract 4, so that the IP points into the call instruction */
MONO_CONTEXT_SET_IP (new_ctx, sframe->lr - 4);
} else {
regs [ppc_lr] = ctx->sc_ir;
regs [ppc_sp] = ctx->sc_sp;
for (i = MONO_PPC_FIRST_SAVED_GREG; i < MONO_MAX_IREGS; ++i)
regs [i] = ctx->regs [i];
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, NULL, regs, ppc_lr + 1,
save_locations, MONO_MAX_IREGS, &cfa);
/* we substract 4, so that the IP points into the call instruction */
MONO_CONTEXT_SET_IP (new_ctx, regs [ppc_lr] - 4);
MONO_CONTEXT_SET_BP (new_ctx, cfa);
for (i = MONO_PPC_FIRST_SAVED_GREG; i < MONO_MAX_IREGS; ++i)
new_ctx->regs [i] = regs [i];
}
return TRUE;
} else if (*lmf) {
if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
} else {
if (!(*lmf)->method)
return FALSE;
/* Trampoline lmf frame */
frame->method = (*lmf)->method;
}
/*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);*/
MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
memcpy (&new_ctx->regs [MONO_PPC_FIRST_SAVED_GREG], (*lmf)->iregs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
memcpy (&new_ctx->fregs [MONO_PPC_FIRST_SAVED_FREG], (*lmf)->fregs, sizeof (double) * MONO_SAVED_FREGS);
frame->ji = ji;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
/* FIXME: what about trampoline LMF frames? see exceptions-x86.c */
*lmf = (*lmf)->previous_lmf;
return TRUE;
}
return FALSE;
}
/*
* mono_arch_find_jit_info:
*
* This function is used to gather information from @ctx, and store it in @frame_info.
* It unwinds one stack frame, and stores the resulting context into @new_ctx. @lmf
* is modified if needed.
* Returns TRUE on success, FALSE otherwise.
*/
gboolean
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
int i;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
mgreg_t regs [MONO_MAX_IREGS + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
frame->type = FRAME_TYPE_MANAGED;
unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
for (i = 0; i < MONO_MAX_IREGS; ++i)
regs [i] = new_ctx->sc_regs [i];
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, NULL, regs, MONO_MAX_IREGS,
save_locations, MONO_MAX_IREGS, &cfa);
for (i = 0; i < MONO_MAX_IREGS; ++i)
new_ctx->sc_regs [i] = regs [i];
new_ctx->sc_pc = regs [mips_ra];
new_ctx->sc_regs [mips_sp] = (mgreg_t)cfa;
/* we substract 8, so that the IP points into the call instruction */
MONO_CONTEXT_SET_IP (new_ctx, new_ctx->sc_pc - 8);
/* Sanity check -- we should have made progress here */
g_assert (MONO_CONTEXT_GET_SP (new_ctx) != MONO_CONTEXT_GET_SP (ctx));
return TRUE;
} else if (*lmf) {
if (((mgreg_t)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
if (!(*lmf)->method) {
#ifdef DEBUG_EXCEPTIONS
g_print ("mono_arch_find_jit_info: bad lmf @ %p\n", (void *) *lmf);
#endif
return FALSE;
}
g_assert (((*lmf)->magic == MIPS_LMF_MAGIC1) || ((*lmf)->magic == MIPS_LMF_MAGIC2));
ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL);
if (!ji) {
// FIXME: This can happen with multiple appdomains (bug #444383)
return FALSE;
}
frame->ji = ji;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
memcpy (&new_ctx->sc_regs, (*lmf)->iregs, sizeof (gulong) * MONO_SAVED_GREGS);
memcpy (&new_ctx->sc_fpregs, (*lmf)->fregs, sizeof (float) * MONO_SAVED_FREGS);
MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
/* ensure that we've made progress */
g_assert (new_ctx->sc_pc != ctx->sc_pc);
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
/*
* mono_arch_find_jit_info:
*
* See exceptions-amd64.c for docs;
*/
gboolean
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
int i;
gssize regs [MONO_MAX_IREGS + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
frame->type = FRAME_TYPE_MANAGED;
if (ji->from_aot)
unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
else
unwind_info = mono_get_cached_unwind_info (ji->used_regs, &unwind_info_len);
for (i = 0; i < 16; ++i)
regs [i] = new_ctx->regs [i];
mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
(guint8*)ji->code_start + ji->code_size,
ip, regs, MONO_MAX_IREGS,
save_locations, MONO_MAX_IREGS, &cfa);
for (i = 0; i < 16; ++i)
new_ctx->regs [i] = regs [i];
new_ctx->pc = regs [ARMREG_LR];
new_ctx->regs [ARMREG_SP] = (gsize)cfa;
if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->sp)) {
/* remove any unused lmf */
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
}
/* Clear thumb bit */
new_ctx->pc &= ~1;
/* we substract 1, so that the IP points into the call instruction */
new_ctx->pc--;
return TRUE;
} else if (*lmf) {
if (((gsize)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->ip, NULL))) {
frame->ji = ji;
} else {
if (!(*lmf)->method)
return FALSE;
frame->method = (*lmf)->method;
}
/*
* The LMF is saved at the start of the method using:
* ARM_MOV_REG_REG (code, ARMREG_IP, ARMREG_SP)
* ARM_PUSH (code, 0x5ff0);
* So it stores the register state as it existed at the caller. We need to
* produce the register state which existed at the time of the call which
* transitioned to native call, so we save the sp/fp/ip in the LMF.
*/
memcpy (&new_ctx->regs [0], &(*lmf)->iregs [0], sizeof (mgreg_t) * 13);
new_ctx->pc = (*lmf)->ip;
new_ctx->regs [ARMREG_SP] = (*lmf)->sp;
new_ctx->regs [ARMREG_FP] = (*lmf)->fp;
/* Clear thumb bit */
new_ctx->pc &= ~1;
/* we substract 1, so that the IP points into the call instruction */
new_ctx->pc--;
*lmf = (gpointer)(((gsize)(*lmf)->previous_lmf) & ~3);
return TRUE;
}
return FALSE;
}
/*
* mono_arch_unwind_frame:
*
* This function is used to gather information from @ctx, and store it in @frame_info.
* It unwinds one stack frame, and stores the resulting context into @new_ctx. @lmf
* is modified if needed.
* Returns TRUE on success, FALSE otherwise.
*/
gboolean
mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *ji, MonoContext *ctx,
MonoContext *new_ctx, MonoLMF **lmf,
mgreg_t **save_locations,
StackFrameInfo *frame)
{
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
int i;
memset (frame, 0, sizeof (StackFrameInfo));
frame->ji = ji;
*new_ctx = *ctx;
if (ji != NULL) {
mgreg_t regs [MONO_MAX_IREGS + 1];
guint8 *cfa;
guint32 unwind_info_len;
guint8 *unwind_info;
guint8 *epilog = NULL;
if (ji->is_trampoline)
frame->type = FRAME_TYPE_TRAMPOLINE;
else
frame->type = FRAME_TYPE_MANAGED;
unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
frame->unwind_info = unwind_info;
frame->unwind_info_len = unwind_info_len;
/*
printf ("%s %p %p\n", ji->d.method->name, ji->code_start, ip);
mono_print_unwind_info (unwind_info, unwind_info_len);
*/
/* LLVM compiled code doesn't have this info */
if (ji->has_arch_eh_info)
epilog = (guint8*)ji->code_start + ji->code_size - mono_jinfo_get_epilog_size (ji);
for (i = 0; i < AMD64_NREG; ++i)
regs [i] = new_ctx->gregs [i];
mono_unwind_frame (unwind_info, unwind_info_len, (guint8 *)ji->code_start,
(guint8*)ji->code_start + ji->code_size,
(guint8 *)ip, epilog ? &epilog : NULL, regs, MONO_MAX_IREGS + 1,
save_locations, MONO_MAX_IREGS, &cfa);
for (i = 0; i < AMD64_NREG; ++i)
new_ctx->gregs [i] = regs [i];
/* The CFA becomes the new SP value */
new_ctx->gregs [AMD64_RSP] = (mgreg_t)cfa;
/* Adjust IP */
new_ctx->gregs [AMD64_RIP] --;
return TRUE;
} else if (*lmf) {
guint64 rip;
if (((guint64)(*lmf)->previous_lmf) & 2) {
/*
* This LMF entry is created by the soft debug code to mark transitions to
* managed code done during invokes.
*/
MonoLMFExt *ext = (MonoLMFExt*)(*lmf);
g_assert (ext->debugger_invoke);
memcpy (new_ctx, &ext->ctx, sizeof (MonoContext));
*lmf = (MonoLMF *)(((guint64)(*lmf)->previous_lmf) & ~7);
frame->type = FRAME_TYPE_DEBUGGER_INVOKE;
return TRUE;
}
if (((guint64)(*lmf)->previous_lmf) & 4) {
MonoLMFTramp *ext = (MonoLMFTramp*)(*lmf);
rip = (guint64)MONO_CONTEXT_GET_IP (ext->ctx);
} else if (((guint64)(*lmf)->previous_lmf) & 1) {
/* This LMF has the rip field set */
rip = (*lmf)->rip;
} else if ((*lmf)->rsp == 0) {
/* Top LMF entry */
return FALSE;
} else {
/*
* The rsp field is set just before the call which transitioned to native
* code. Obtain the rip from the stack.
*/
rip = *(guint64*)((*lmf)->rsp - sizeof(mgreg_t));
}
ji = mini_jit_info_table_find (domain, (char *)rip, NULL);
/*
* FIXME: ji == NULL can happen when a managed-to-native wrapper is interrupted
* in the soft debugger suspend code, since (*lmf)->rsp no longer points to the
* return address.
*/
//g_assert (ji);
if (!ji)
return FALSE;
frame->ji = ji;
frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
if (((guint64)(*lmf)->previous_lmf) & 4) {
MonoLMFTramp *ext = (MonoLMFTramp*)(*lmf);
/* Trampoline frame */
for (i = 0; i < AMD64_NREG; ++i)
new_ctx->gregs [i] = ext->ctx->gregs [i];
/* Adjust IP */
new_ctx->gregs [AMD64_RIP] --;
} else {
/*
* The registers saved in the LMF will be restored using the normal unwind info,
* when the wrapper frame is processed.
*/
/* Adjust IP */
rip --;
new_ctx->gregs [AMD64_RIP] = rip;
new_ctx->gregs [AMD64_RSP] = (*lmf)->rsp;
new_ctx->gregs [AMD64_RBP] = (*lmf)->rbp;
for (i = 0; i < AMD64_NREG; ++i) {
if (AMD64_IS_CALLEE_SAVED_REG (i) && i != AMD64_RBP)
new_ctx->gregs [i] = 0;
}
}
*lmf = (MonoLMF *)(((guint64)(*lmf)->previous_lmf) & ~7);
return TRUE;
}
return FALSE;
}