* Mono Team (mono-list@lists.ximian.com)
*
* Copyright 2001-2003 Ximian, Inc.
- * Copyright 2003-2008 Ximian, Inc.
+ * Copyright 2003-2008 Novell, Inc.
+ * Copyright 2011 Xamarin Inc (http://www.xamarin.com).
*/
#include <config.h>
static void try_more_restore (void);
static void restore_stack_protection (void);
static void mono_walk_stack_full (MonoJitStackWalk func, MonoContext *start_ctx, MonoDomain *domain, MonoJitTlsData *jit_tls, MonoLMF *lmf, MonoUnwindOptions unwind_options, gpointer user_data);
+static void mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx);
+static void mono_runtime_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data);
void
mono_exceptions_init (void)
{
+ MonoRuntimeExceptionHandlingCallbacks cbs;
if (mono_aot_only) {
restore_context_func = mono_aot_get_trampoline ("restore_context");
call_filter_func = mono_aot_get_trampoline ("call_filter");
#ifdef MONO_ARCH_HAVE_EXCEPTIONS_INIT
mono_arch_exceptions_init ();
#endif
+ cbs.mono_walk_stack_with_ctx = mono_runtime_walk_stack_with_ctx;
+ cbs.mono_walk_stack_with_state = mono_walk_stack_with_state;
+ cbs.mono_raise_exception = mono_get_throw_exception ();
+ cbs.mono_raise_exception_with_ctx = mono_raise_exception_with_ctx;
+ cbs.mono_install_handler_block_guard = mono_install_handler_block_guard;
+ mono_install_eh_callbacks (&cbs);
}
gpointer
if (!gi->has_this)
return NULL;
- if (gi->this_in_reg)
- info = mono_arch_context_get_int_reg (ctx, gi->this_reg);
- else
- info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, gi->this_reg) +
- gi->this_offset);
+ info = NULL;
+ /*
+ * Search location list if available, it contains the precise location of the
+ * argument for every pc offset, even if the method was interrupted while it was in
+ * its prolog.
+ */
+ if (gi->nlocs) {
+ int offset = (mgreg_t)MONO_CONTEXT_GET_IP (ctx) - (mgreg_t)ji->code_start;
+ int i;
+
+ for (i = 0; i < gi->nlocs; ++i) {
+ MonoDwarfLocListEntry *entry = &gi->locations [i];
+
+ if (offset >= entry->from && (offset < entry->to || entry->to == 0)) {
+ if (entry->is_reg)
+ info = (gpointer)mono_arch_context_get_int_reg (ctx, entry->reg);
+ else
+ info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, entry->reg) + entry->offset);
+ break;
+ }
+ }
+ g_assert (i < gi->nlocs);
+ } else {
+ if (gi->this_in_reg)
+ info = (gpointer)mono_arch_context_get_int_reg (ctx, gi->this_reg);
+ else
+ info = *(gpointer*)(gpointer)((char*)mono_arch_context_get_int_reg (ctx, gi->this_reg) +
+ gi->this_offset);
+ }
+
if (mono_method_get_context (ji->method)->method_inst) {
return info;
} else if ((ji->method->flags & METHOD_ATTRIBUTE_STATIC) || ji->method->klass->valuetype) {
return res;
}
-typedef struct {
- MonoStackWalk func;
- gpointer user_data;
-} StackWalkUserData;
-
-static gboolean
-stack_walk_adapter (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
+static void
+mono_runtime_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data)
{
- StackWalkUserData *d = data;
-
- switch (frame->type) {
- case FRAME_TYPE_DEBUGGER_INVOKE:
- case FRAME_TYPE_MANAGED_TO_NATIVE:
- return FALSE;
- case FRAME_TYPE_MANAGED:
- g_assert (frame->ji);
- return d->func (frame->ji->method, frame->native_offset, frame->il_offset, frame->managed, d->user_data);
- break;
- default:
- g_assert_not_reached ();
- return FALSE;
+ if (!start_ctx) {
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ if (jit_tls && jit_tls->orig_ex_ctx_set)
+ start_ctx = &jit_tls->orig_ex_ctx;
}
+ mono_walk_stack_with_ctx (func, start_ctx, unwind_options, user_data);
}
-
-void
-mono_jit_walk_stack_from_ctx (MonoStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, gpointer user_data)
-{
- StackWalkUserData d;
-
- d.func = func;
- d.user_data = user_data;
-
- mono_walk_stack_with_ctx (stack_walk_adapter, start_ctx, unwind_options, &d);
-}
-
-void
-mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data)
-{
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
- MonoUnwindOptions unwind_options = do_il_offset ? MONO_UNWIND_LOOKUP_ALL : MONO_UNWIND_DEFAULT;
- if (jit_tls && jit_tls->orig_ex_ctx_set)
- mono_jit_walk_stack_from_ctx (func, &jit_tls->orig_ex_ctx, unwind_options, user_data);
- else
- mono_jit_walk_stack_from_ctx (func, NULL, unwind_options, user_data);
-}
-
-/*unwind the current thread starting at @context*/
+/**
+ * mono_walk_stack_with_ctx:
+ *
+ * Unwind the current thread starting at @start_ctx.
+ *
+ * If @start_ctx is null, we capture the current context.
+ */
void
mono_walk_stack_with_ctx (MonoJitStackWalk func, MonoContext *start_ctx, MonoUnwindOptions unwind_options, void *user_data)
{
+ MonoContext extra_ctx;
MonoInternalThread *thread = mono_thread_internal_current ();
-
- g_assert (start_ctx);
+ MONO_ARCH_CONTEXT_DEF
if (!thread || !thread->jit_data)
return;
+ if (!start_ctx) {
+ mono_arch_flush_register_windows ();
+
+#ifdef MONO_INIT_CONTEXT_FROM_CURRENT
+ MONO_INIT_CONTEXT_FROM_CURRENT (&extra_ctx);
+#else
+ MONO_INIT_CONTEXT_FROM_FUNC (&extra_ctx, mono_walk_stack_with_ctx);
+#endif
+ start_ctx = &extra_ctx;
+ }
+
mono_walk_stack_full (func, start_ctx, mono_domain_get (), thread->jit_data, mono_get_lmf (), unwind_options, user_data);
}
-/*if @state is null, we capture the current context.*/
+/**
+ * mono_walk_stack_with_state:
+ *
+ * Unwind a thread described by @state.
+ *
+ * State must be valid (state->valid == TRUE).
+ *
+ * If you are using this function to unwind another thread, make sure it is suspended.
+ *
+ * If @state is null, we capture the current context.
+ */
void
mono_walk_stack_with_state (MonoJitStackWalk func, MonoThreadUnwindState *state, MonoUnwindOptions unwind_options, void *user_data)
{
+ MonoThreadUnwindState extra_state;
+ if (!state) {
+ if (!mono_thread_state_init_from_current (&extra_state))
+ return;
+ state = &extra_state;
+ }
+
+ g_assert (state->valid);
+
mono_walk_stack_full (func,
&state->ctx,
state->unwind_data [MONO_UNWIND_DATA_DOMAIN],
unwind_options, user_data);
}
-/*TODO this will replace mono_walk_stack */
void
-mono_walk_stack_simple (MonoJitStackWalk func, MonoUnwindOptions options, void *user_data)
+mono_walk_stack (MonoJitStackWalk func, MonoUnwindOptions options, void *user_data)
{
MonoThreadUnwindState state;
if (!mono_thread_state_init_from_current (&state))
}
/**
- * mono_walk_stack:
+ * mono_walk_stack_full:
* @func: callback to call for each stack frame
* @domain: starting appdomain, can be NULL to use the current domain
* @unwind_options: what extra information the unwinder should gather
* function is called with the relevant info. The walk ends when no more
* managed stack frames are found or when the callback returns a TRUE value.
*/
-void
-mono_walk_stack (MonoJitStackWalk func, MonoDomain *domain, MonoContext *start_ctx, MonoUnwindOptions unwind_options, MonoInternalThread *thread, MonoLMF *lmf, gpointer user_data)
-{
- MonoJitTlsData *jit_tls;
- MonoContext ctx;
- MONO_ARCH_CONTEXT_DEF
-
- mono_arch_flush_register_windows ();
-
- if (!thread) {
- thread = mono_thread_internal_current ();
- lmf = mono_get_lmf ();
- }
-
- /* A NULL thread->jit_data can happen in a small window during thread startup: the thread
- * allocation happens, we do a stack walk (for example with
- * --profile=log:nocalls and xsp) but the jit is not fully setup for the thread
- * yet. Of course there are no stack frames, so just returning is ok.
- * A NULL thread can happen during domain unload with the same test.
- */
- if (!thread || !thread->jit_data)
- return;
- jit_tls = thread->jit_data;
- if (!start_ctx) {
-#ifdef MONO_INIT_CONTEXT_FROM_CURRENT
- MONO_INIT_CONTEXT_FROM_CURRENT (&ctx);
-#else
- MONO_INIT_CONTEXT_FROM_FUNC (&ctx, mono_walk_stack);
-#endif
- g_assert (thread == mono_thread_internal_current ());
- start_ctx = &ctx;
- }
-
- mono_walk_stack_full (func, start_ctx, domain, jit_tls, lmf, unwind_options, user_data);
-}
-
static void
mono_walk_stack_full (MonoJitStackWalk func, MonoContext *start_ctx, MonoDomain *domain, MonoJitTlsData *jit_tls, MonoLMF *lmf, MonoUnwindOptions unwind_options, gpointer user_data)
{
- gint il_offset;
+ gint il_offset, i;
MonoContext ctx, new_ctx;
StackFrameInfo frame;
gboolean res;
+ mgreg_t *reg_locations [MONO_MAX_IREGS];
+ mgreg_t *new_reg_locations [MONO_MAX_IREGS];
+ gboolean get_reg_locations = unwind_options & MONO_UNWIND_REG_LOCATIONS;
g_assert (start_ctx);
g_assert (domain);
g_assert (jit_tls);
- g_assert (lmf);
+ /*The LMF will be null if the target have no managed frames.*/
+ /* g_assert (lmf); */
memcpy (&ctx, start_ctx, sizeof (MonoContext));
+ memset (reg_locations, 0, sizeof (reg_locations));
while (MONO_CONTEXT_GET_SP (&ctx) < jit_tls->end_of_stack) {
frame.lmf = lmf;
- res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, NULL, &frame);
+ res = mono_find_jit_info_ext (domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, get_reg_locations ? new_reg_locations : NULL, &frame);
if (!res)
return;
frame.actual_method = frame.method;
}
+ if (get_reg_locations)
+ frame.reg_locations = reg_locations;
+
if (func (&frame, &ctx, user_data))
return;
+
+ if (get_reg_locations) {
+ for (i = 0; i < MONO_MAX_IREGS; ++i)
+ if (new_reg_locations [i])
+ reg_locations [i] = new_reg_locations [i];
+ }
ctx = new_ctx;
}
MonoString **file, gint32 *line, gint32 *column)
{
MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoJitInfo *ji = NULL;
MonoContext ctx, new_ctx;
MonoSecurityFrame*
ves_icall_System_Security_SecurityFrame_GetSecurityFrame (gint32 skip)
{
- MonoDomain *domain = mono_domain_get ();
MonoFrameSecurityInfo si;
si.skips = skip;
si.frame = NULL;
- mono_walk_stack (callback_get_first_frame_security_info, domain, NULL, MONO_UNWIND_DEFAULT, NULL, NULL, &si);
+ mono_walk_stack (callback_get_first_frame_security_info, MONO_UNWIND_DEFAULT, &si);
return (si.skips == 0) ? si.frame : NULL;
}
MonoArray*
ves_icall_System_Security_SecurityFrame_GetSecurityStack (gint32 skip)
{
- MonoDomain *domain = mono_domain_get ();
MonoSecurityStack ss;
#if defined(__ia64__) || defined(__s390__) || defined(__s390x__)
ss.skips = skip;
ss.count = 0;
ss.maximum = MONO_CAS_INITIAL_STACK_SIZE;
- ss.stack = mono_array_new (domain, mono_defaults.runtimesecurityframe_class, ss.maximum);
- mono_walk_stack (callback_get_stack_frames_security_info, domain, NULL, MONO_UNWIND_DEFAULT, NULL, NULL, &ss);
+ ss.stack = mono_array_new (mono_domain_get (), mono_defaults.runtimesecurityframe_class, ss.maximum);
+ mono_walk_stack (callback_get_stack_frames_security_info, MONO_UNWIND_DEFAULT, &ss);
/* g_warning ("STACK RESULT: %d out of %d", ss.count, ss.maximum); */
return ss.stack;
}
{
MonoJitInfo *ji;
MonoInternalThread *t = mono_thread_internal_current ();
- GSList *l;
+ gpointer *refs;
if (out_domain)
*out_domain = NULL;
}
}
- for (l = t->appdomain_refs; l; l = l->next) {
- if (l->data != domain) {
- ji = mono_jit_info_table_find ((MonoDomain*)l->data, addr);
+ refs = (t->appdomain_refs) ? *(gpointer *) t->appdomain_refs : NULL;
+ for (; refs && *refs; refs++) {
+ if (*refs != domain && *refs != mono_get_root_domain ()) {
+ ji = mono_jit_info_table_find ((MonoDomain*) *refs, addr);
if (ji) {
if (out_domain)
- *out_domain = (MonoDomain*)l->data;
+ *out_domain = (MonoDomain*) *refs;
return ji;
}
}
#define DOES_STACK_GROWS_UP 0
#endif
+
+#define setup_managed_stacktrace_information() do { \
+ if (mono_ex && !initial_trace_ips) { \
+ trace_ips = g_list_reverse (trace_ips); \
+ MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class)); \
+ if (has_dynamic_methods) \
+ /* These methods could go away anytime, so compute the stack trace now */ \
+ MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex)); \
+ } \
+ g_list_free (trace_ips); \
+ trace_ips = NULL; \
+} while (0)
/*
* mono_handle_exception_internal_first_pass:
*
* OUT_FILTER_IDX. Return TRUE if the exception is caught, FALSE otherwise.
*/
static gboolean
-mono_handle_exception_internal_first_pass (MonoContext *ctx, gpointer obj, gpointer original_ip, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoObject *non_exception)
+mono_handle_exception_internal_first_pass (MonoContext *ctx, gpointer obj, gint32 *out_filter_idx, MonoJitInfo **out_ji, MonoObject *non_exception)
{
MonoDomain *domain = mono_domain_get ();
MonoJitInfo *ji;
static int (*call_filter) (MonoContext *, gpointer) = NULL;
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoArray *initial_trace_ips = NULL;
GList *trace_ips = NULL;
}
if (!unwind_res) {
- if (mono_ex && !initial_trace_ips) {
- trace_ips = g_list_reverse (trace_ips);
- MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
- if (has_dynamic_methods)
- /* These methods could go away anytime, so compute the stack trace now */
- MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
- }
- g_list_free (trace_ips);
+ setup_managed_stacktrace_information ();
return FALSE;
}
ex_obj = obj;
if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER) {
+ gboolean is_user_frame = ji->method->wrapper_type == MONO_WRAPPER_NONE || ji->method->wrapper_type == MONO_WRAPPER_DYNAMIC_METHOD;
mono_perfcounters->exceptions_filters++;
mono_debugger_call_exception_handler (ei->data.filter, MONO_CONTEXT_GET_SP (ctx), ex_obj);
- if (mono_ex && !initial_trace_ips) {
- trace_ips = g_list_reverse (trace_ips);
- MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
- if (has_dynamic_methods)
- /* These methods could go away anytime, so compute the stack trace now */
- MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
- }
- g_list_free (trace_ips);
- trace_ips = NULL;
+ /*
+ Here's the thing, if this is a filter clause done by a wrapper like runtime invoke, we don't want to
+ trim the stackframe since if it returns FALSE we lose information.
+
+ FIXME Not 100% sure if it's a good idea even with user clauses.
+ */
+ if (is_user_frame)
+ setup_managed_stacktrace_information ();
if (ji->from_llvm) {
#ifdef MONO_CONTEXT_SET_LLVM_EXC_REG
filter_idx ++;
if (filtered) {
+ if (!is_user_frame)
+ setup_managed_stacktrace_information ();
/* mono_debugger_agent_handle_exception () needs this */
MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
return TRUE;
}
if (ei->flags == MONO_EXCEPTION_CLAUSE_NONE && mono_object_isinst (ex_obj, catch_class)) {
- if (mono_ex && !initial_trace_ips) {
- trace_ips = g_list_reverse (trace_ips);
- MONO_OBJECT_SETREF (mono_ex, trace_ips, glist_to_array (trace_ips, mono_defaults.int_class));
- if (has_dynamic_methods)
- /* These methods could go away anytime, so compute the stack trace now */
- MONO_OBJECT_SETREF (mono_ex, stack_trace, ves_icall_System_Exception_get_trace (mono_ex));
- }
- g_list_free (trace_ips);
+ setup_managed_stacktrace_information ();
if (out_ji)
*out_ji = ji;
* @resume: whenever to resume unwinding based on the state in MonoJitTlsData.
*/
static gboolean
-mono_handle_exception_internal (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean resume, MonoJitInfo **out_ji)
+mono_handle_exception_internal (MonoContext *ctx, gpointer obj, gboolean resume, MonoJitInfo **out_ji)
{
MonoDomain *domain = mono_domain_get ();
MonoJitInfo *ji;
static int (*call_filter) (MonoContext *, gpointer) = NULL;
static void (*restore_context) (void *);
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoException *mono_ex;
gboolean stack_overflow = FALSE;
mono_profiler_exception_thrown (obj);
jit_tls->orig_ex_ctx_set = FALSE;
- res = mono_handle_exception_internal_first_pass (&ctx_cp, obj, original_ip, &first_filter_idx, &ji, non_exception);
+ res = mono_handle_exception_internal_first_pass (&ctx_cp, obj, &first_filter_idx, &ji, non_exception);
if (!res) {
- if (mono_break_on_exc)
+ if (mini_get_debug_options ()->break_on_exc)
G_BREAKPOINT ();
mono_debugger_agent_handle_exception (obj, ctx, NULL);
* The debugger wants us to stop only if this exception is user-unhandled.
*/
- ret = mono_handle_exception_internal_first_pass (&ctx_cp, obj, MONO_CONTEXT_GET_IP (ctx), NULL, &ji, NULL);
+ ret = mono_handle_exception_internal_first_pass (&ctx_cp, obj, NULL, &ji, NULL);
if (ret && (ji != NULL) && (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE)) {
/*
* The exception is handled in a runtime-invoke wrapper, that means that it's unhandled
{
static int (*call_filter) (MonoContext *, gpointer) = NULL;
MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoLMF *lmf = mono_get_lmf ();
MonoContext ctx, new_ctx;
MonoJitInfo *ji, rji;
* mono_handle_exception:
* @ctx: saved processor state
* @obj: the exception object
- * @test_only: only test if the exception is caught, but dont call handlers
*/
gboolean
-mono_handle_exception (MonoContext *ctx, gpointer obj, gpointer original_ip, gboolean test_only)
+mono_handle_exception (MonoContext *ctx, gpointer obj)
{
- if (!test_only)
- mono_perfcounters->exceptions_thrown++;
+ mono_perfcounters->exceptions_thrown++;
- g_assert (!test_only);
- return mono_handle_exception_internal (ctx, obj, original_ip, FALSE, NULL);
+ return mono_handle_exception_internal (ctx, obj, FALSE, NULL);
}
#ifdef MONO_ARCH_SIGSEGV_ON_ALTSTACK
mono_setup_altstack (MonoJitTlsData *tls)
{
size_t stsize = 0;
- struct sigaltstack sa;
+ stack_t sa;
guint8 *staddr = NULL;
if (mono_running_on_valgrind ())
sa.ss_sp = tls->signal_stack;
sa.ss_size = MONO_ARCH_SIGNAL_STACK_SIZE;
+#if __APPLE__
+ sa.ss_flags = 0;
+#else
sa.ss_flags = SS_ONSTACK;
- sigaltstack (&sa, NULL);
+#endif
+ g_assert (sigaltstack (&sa, NULL) == 0);
+
+ mono_gc_register_altstack ((char*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size, (char*)staddr + stsize - ((char*)tls->stack_ovf_guard_base + tls->stack_ovf_guard_size), tls->signal_stack, tls->signal_stack_size);
}
void
mono_free_altstack (MonoJitTlsData *tls)
{
- struct sigaltstack sa;
+ stack_t sa;
int err;
sa.ss_sp = tls->signal_stack;
return unprotect_size == jit_tls->stack_ovf_guard_size;
}
-static void
+static G_GNUC_UNUSED void
try_more_restore (void)
{
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
if (try_restore_stack_protection (jit_tls, 500))
jit_tls->restore_stack_prot = NULL;
}
-static void
+static G_GNUC_UNUSED void
restore_stack_protection (void)
{
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
MonoException *ex = mono_domain_get ()->stack_overflow_ex;
/* if we can't restore the stack protection, keep a callback installed so
* we'll try to restore as much stack as we can at each return from unmanaged
} PrintOverflowUserData;
static gboolean
-print_overflow_stack_frame (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed, gpointer data)
+print_overflow_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
+ MonoMethod *method = NULL;
PrintOverflowUserData *user_data = data;
FILE *stream = user_data->stream;
gchar *location;
+ if (frame->ji)
+ method = frame->ji->method;
+
if (method) {
if (user_data->count == 0) {
/* The first frame is in its prolog, so a line number cannot be computed */
if (method == user_data->omethod)
return FALSE;
- location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
+ location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
fprintf (stream, " %s\n", location);
g_free (location);
user_data->count ++;
} else
- fprintf (stream, " at <unknown> <0x%05x>\n", native_offset);
+ fprintf (stream, " at <unknown> <0x%05x>\n", frame->native_offset);
return FALSE;
}
memset (&ud, 0, sizeof (ud));
ud.stream = stderr;
- mono_jit_walk_stack_from_ctx (print_overflow_stack_frame, &mctx, MONO_UNWIND_LOOKUP_ACTUAL_METHOD, &ud);
+ mono_walk_stack_with_ctx (print_overflow_stack_frame, &mctx, MONO_UNWIND_LOOKUP_ACTUAL_METHOD, &ud);
#else
if (ji && ji->method)
fprintf (stderr, "At %s\n", mono_method_full_name (ji->method, TRUE));
}
static gboolean
-print_stack_frame (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed, gpointer data)
+print_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
FILE *stream = (FILE*)data;
+ MonoMethod *method = NULL;
+ if (frame->ji)
+ method = frame->ji->method;
if (method) {
- gchar *location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
+ gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
fprintf (stream, " %s\n", location);
g_free (location);
} else
- fprintf (stream, " at <unknown> <0x%05x>\n", native_offset);
+ fprintf (stream, " at <unknown> <0x%05x>\n", frame->native_offset);
return FALSE;
}
static G_GNUC_UNUSED gboolean
-print_stack_frame_to_string (MonoMethod *method, gint32 native_offset, gint32 il_offset, gboolean managed,
- gpointer data)
+print_stack_frame_to_string (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
GString *p = (GString*)data;
+ MonoMethod *method = NULL;
+ if (frame->ji)
+ method = frame->ji->method;
if (method) {
- gchar *location = mono_debug_print_stack_frame (method, native_offset, mono_domain_get ());
+ gchar *location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
g_string_append_printf (p, " %s\n", location);
g_free (location);
} else
- g_string_append_printf (p, " at <unknown> <0x%05x>\n", native_offset);
+ g_string_append_printf (p, " at <unknown> <0x%05x>\n", frame->native_offset);
return FALSE;
}
#ifdef MONO_ARCH_USE_SIGACTION
struct sigaction sa;
#endif
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
if (handling_sigsegv)
return;
if (jit_tls && mono_thread_internal_current ()) {
fprintf (stderr, "Stacktrace:\n\n");
- mono_jit_walk_stack (print_stack_frame, TRUE, stderr);
+ mono_walk_stack (print_stack_frame, TRUE, stderr);
fflush (stderr);
}
#if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
if (!mini_get_debug_options ()->no_gdb_backtrace && !mono_debug_using_mono_debugger ()) {
/* From g_spawn_command_line_sync () in eglib */
- int res;
- int stdout_pipe [2] = { -1, -1 };
pid_t pid;
int status;
- char buffer [1024];
+ pid_t crashed_pid = getpid ();
- res = pipe (stdout_pipe);
- g_assert (res != -1);
-
//pid = fork ();
/*
* glibc fork acquires some locks, so if the crash happened inside malloc/free,
pid = mono_runtime_syscall_fork ();
if (pid == 0) {
- close (stdout_pipe [0]);
- dup2 (stdout_pipe [1], STDOUT_FILENO);
-
- for (i = getdtablesize () - 1; i >= 3; i--)
- close (i);
-
- if (!mono_gdb_render_native_backtraces ())
- close (STDOUT_FILENO);
+ dup2 (STDERR_FILENO, STDOUT_FILENO);
+ mono_gdb_render_native_backtraces (crashed_pid);
exit (1);
}
- close (stdout_pipe [1]);
-
fprintf (stderr, "\nDebug info from gdb:\n\n");
-
- while (1) {
- int nread = read (stdout_pipe [0], buffer, 1024);
-
- if (nread <= 0)
- break;
- write (STDERR_FILENO, buffer, nread);
- }
-
- waitpid (pid, &status, WNOHANG);
+ waitpid (pid, &status, 0);
}
#endif
/*
mono_print_thread_dump_internal (void *sigctx, MonoContext *start_ctx)
{
MonoInternalThread *thread = mono_thread_internal_current ();
-#if defined(__i386__) || defined(__x86_64__)
+#ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
MonoContext ctx;
#endif
GString* text = g_string_new (0);
else
mono_arch_sigctx_to_monoctx (sigctx, &ctx);
- mono_jit_walk_stack_from_ctx (print_stack_frame_to_string, &ctx, MONO_UNWIND_LOOKUP_ALL, text);
+ mono_walk_stack_with_ctx (print_stack_frame_to_string, &ctx, MONO_UNWIND_LOOKUP_ALL, text);
#else
printf ("\t<Stack traces in thread dumps not supported on this platform>\n");
#endif
void
mono_resume_unwind (MonoContext *ctx)
{
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
static void (*restore_context) (MonoContext *);
MonoContext new_ctx;
MONO_CONTEXT_SET_SP (ctx, MONO_CONTEXT_GET_SP (&jit_tls->resume_state.ctx));
new_ctx = *ctx;
- mono_handle_exception_internal (&new_ctx, jit_tls->resume_state.ex_obj, NULL, TRUE, NULL);
+ mono_handle_exception_internal (&new_ctx, jit_tls->resume_state.ex_obj, TRUE, NULL);
if (!restore_context)
restore_context = mono_get_restore_context ();
/*
* Finds the bottom handler block running and install a block guard if needed.
+ * FIXME add full-aot support.
*/
gboolean
-mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx)
+mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
{
FindHandlerBlockData data = { 0 };
- MonoDomain *domain = mono_domain_get ();
- MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
+ MonoJitTlsData *jit_tls = ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS];
gpointer resume_ip;
+ /* FIXME */
+ if (mono_aot_only)
+ return FALSE;
+
/* Guard against a null MonoJitTlsData. This can happens if the thread receives the
* interrupt signal before the JIT has time to initialize its TLS data for the given thread.
*/
if (!jit_tls || jit_tls->handler_block_return_address)
return FALSE;
- mono_walk_stack (find_last_handler_block, domain, ctx, MONO_UNWIND_SIGNAL_SAFE, NULL, NULL, &data);
+ mono_walk_stack_with_state (find_last_handler_block, ctx, MONO_UNWIND_SIGNAL_SAFE, &data);
if (!data.ji)
return FALSE;
jit_tls->handler_block_return_address = resume_ip;
jit_tls->handler_block = data.ei;
-#ifndef HOST_WIN32
- /*Clear current thread from been wapi interrupted otherwise things can go south*/
- wapi_clear_interruption ();
-#endif
return TRUE;
}
#else
gboolean
-mono_install_handler_block_guard (MonoInternalThread *thread, MonoContext *ctx)
+mono_install_handler_block_guard (MonoThreadUnwindState *ctx)
{
return FALSE;
}
MonoJitTlsData *jit_tls = NULL;
if (mini_get_debug_options ()->better_cast_details) {
- jit_tls = TlsGetValue (mono_jit_tls_id);
+ jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
jit_tls->class_cast_from = from;
jit_tls->class_cast_to = to;
}
return FALSE;
}
- mono_arch_sigctx_to_monoctx (sigctx, &ctx->ctx);
+ if (sigctx)
+ mono_arch_sigctx_to_monoctx (sigctx, &ctx->ctx);
+ else
+#if MONO_ARCH_HAS_MONO_CONTEXT && !defined(MONO_CROSS_COMPILE)
+ MONO_CONTEXT_GET_CURRENT (ctx->ctx);
+#else
+ g_error ("Use a null sigctx requires a working mono-context");
+#endif
+
ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
#endif
}
+gboolean
+mono_thread_state_init_from_monoctx (MonoThreadUnwindState *ctx, MonoContext *mctx)
+{
+ MonoInternalThread *thread = mono_thread_internal_current ();
+ if (!thread || !thread->jit_data) {
+ ctx->valid = FALSE;
+ return FALSE;
+ }
+
+ ctx->ctx = *mctx;
+ ctx->unwind_data [MONO_UNWIND_DATA_DOMAIN] = mono_domain_get ();
+ ctx->unwind_data [MONO_UNWIND_DATA_LMF] = mono_get_lmf ();
+ ctx->unwind_data [MONO_UNWIND_DATA_JIT_TLS] = thread->jit_data;
+ ctx->valid = TRUE;
+ return TRUE;
+}
/*returns false if the thread is not attached*/
gboolean
ctx->valid = TRUE;
return TRUE;
}
+
+static void
+mono_raise_exception_with_ctx (MonoException *exc, MonoContext *ctx)
+{
+ void (*restore_context) (MonoContext *);
+ restore_context = mono_get_restore_context ();
+
+ mono_handle_exception (ctx, exc);
+ restore_context (ctx);
+}
+
+/*FIXME Move all monoctx -> sigctx conversion to signal handlers once all archs support utils/mono-context */
+void
+mono_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
+{
+#ifdef MONO_ARCH_HAVE_SETUP_ASYNC_CALLBACK
+ MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ jit_tls->ex_ctx = *ctx;
+
+ mono_arch_setup_async_callback (ctx, async_cb, user_data);
+#else
+ g_error ("This target doesn't support mono_arch_setup_async_callback");
+#endif
+}
projects / mono.git / blobdiff