#include <mono/metadata/mono-debug.h>
#include <mono/metadata/profiler.h>
#include <mono/metadata/mono-endian.h>
+#include <mono/metadata/environment.h>
#include <mono/utils/mono-mmap.h>
+#include <mono/utils/mono-logger-internal.h>
#include "mini.h"
#include "debug-mini.h"
static gpointer try_more_restore_tramp = NULL;
static gpointer restore_stack_protection_tramp = NULL;
+static MonoUnhandledExceptionFunc unhandled_exception_hook = NULL;
+static gpointer unhandled_exception_hook_data = NULL;
+
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);
if (!gi->has_this)
return NULL;
- 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);
+ 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 method;
}
+/**
+ * mono_exception_walk_native_trace:
+ * @ex: The exception object whose frames should be walked
+ * @func: callback to call for each stack frame
+ * @user_data: data passed to the callback
+ *
+ * This function walks the stacktrace of an exception. For
+ * each frame the callback function is called with the relevant info.
+ * The walk ends when no more stack frames are found or when the callback
+ * returns a TRUE value.
+ */
+
+gboolean
+mono_exception_walk_trace (MonoException *ex, MonoExceptionFrameWalk func, gpointer user_data)
+{
+ MonoDomain *domain = mono_domain_get ();
+ MonoArray *ta = ex->trace_ips;
+ int len, i;
+
+ if (ta == NULL)
+ return FALSE;
+
+ len = mono_array_length (ta) >> 1;
+ for (i = 0; i < len; i++) {
+ gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
+ gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
+ MonoJitInfo *ji = mono_jit_info_table_find (domain, ip);
+
+ if (ji == NULL) {
+ if (func (NULL, ip, 0, FALSE, user_data))
+ return TRUE;
+ } else {
+ MonoMethod *method = get_method_from_stack_frame (ji, generic_info);
+ if (func (method, ji->code_start, (char *) ip - (char *) ji->code_start, TRUE, user_data))
+ return TRUE;
+ }
+ }
+
+ return len > 0;
+}
+
MonoString *
ves_icall_System_Exception_get_trace (MonoException *ex)
{
ji = frame.ji;
*native_offset = frame.native_offset;
- /* skip all wrappers ??*/
- if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
- ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
- ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
- ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
- ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE ||
- ji->method->wrapper_type == MONO_WRAPPER_NATIVE_TO_MANAGED)
+ /* The skip count passed by the caller depends on us not filtering out MANAGED_TO_NATIVE */
+ if (ji->method->wrapper_type != MONO_WRAPPER_NONE && ji->method->wrapper_type != MONO_WRAPPER_DYNAMIC_METHOD && ji->method->wrapper_type != MONO_WRAPPER_MANAGED_TO_NATIVE)
continue;
-
skip--;
} while (skip >= 0);
#define DOES_STACK_GROWS_UP 0
#endif
+#define MAX_UNMANAGED_BACKTRACE 128
+static MonoArray*
+build_native_trace (void)
+{
+/* This puppy only makes sense on mobile, IOW, ARM. */
+#if defined (HAVE_BACKTRACE_SYMBOLS) && defined (TARGET_ARM)
+ MonoArray *res;
+ void *native_trace [MAX_UNMANAGED_BACKTRACE];
+ int size = backtrace (native_trace, MAX_UNMANAGED_BACKTRACE);
+ int i;
+
+ if (!size)
+ return NULL;
+ res = mono_array_new (mono_domain_get (), mono_defaults.int_class, size);
+
+ for (i = 0; i < size; i++)
+ mono_array_set (res, gpointer, i, native_trace [i]);
+ return res;
+#else
+ return NULL;
+#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)); \
+ MONO_OBJECT_SETREF (mono_ex, native_trace_ips, build_native_trace ()); \
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)); \
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;
+#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_filters++;
+#endif
mono_debugger_call_exception_handler (ei->data.filter, MONO_CONTEXT_GET_SP (ctx), ex_obj);
/*
mono_debugger_agent_handle_exception (obj, ctx, NULL);
if (mini_get_debug_options ()->suspend_on_unhandled) {
- fprintf (stderr, "Unhandled exception, suspending...");
+ mono_runtime_printf_err ("Unhandled exception, suspending...");
while (1)
;
}
mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), ex_obj);
MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
*(mono_get_lmf_addr ()) = lmf;
+#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_depth += frame_count;
+#endif
if (obj == domain->stack_overflow_ex)
jit_tls->handling_stack_ovf = FALSE;
mono_profiler_exception_clause_handler (ji->method, ei->flags, i);
jit_tls->orig_ex_ctx_set = FALSE;
mono_debugger_call_exception_handler (ei->handler_start, MONO_CONTEXT_GET_SP (ctx), ex_obj);
+#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_finallys++;
+#endif
*(mono_get_lmf_addr ()) = lmf;
if (ji->from_llvm) {
/*
gboolean
mono_handle_exception (MonoContext *ctx, gpointer obj)
{
+#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_thrown++;
+#endif
return mono_handle_exception_internal (ctx, obj, FALSE, NULL);
}
sa.ss_flags = SS_ONSTACK;
#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
/* We print a message: after this even managed stack overflows
* may crash the runtime
*/
- fprintf (stderr, "Stack overflow in unmanaged: IP: %p, fault addr: %p\n", mono_arch_ip_from_context (ctx), fault_addr);
+ mono_runtime_printf_err ("Stack overflow in unmanaged: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
if (!jit_tls->handling_stack_ovf) {
jit_tls->restore_stack_prot = restore_stack_protection_tramp;
jit_tls->handling_stack_ovf = 1;
}
typedef struct {
- FILE *stream;
MonoMethod *omethod;
int count;
} PrintOverflowUserData;
{
MonoMethod *method = NULL;
PrintOverflowUserData *user_data = data;
- FILE *stream = user_data->stream;
gchar *location;
if (frame->ji)
return FALSE;
location = mono_debug_print_stack_frame (method, frame->native_offset, mono_domain_get ());
- fprintf (stream, " %s\n", location);
+ mono_runtime_printf_err (" %s", location);
g_free (location);
if (user_data->count == 1) {
- fprintf (stream, " <...>\n");
+ mono_runtime_printf_err (" <...>");
user_data->omethod = method;
} else {
user_data->omethod = NULL;
user_data->count ++;
} else
- fprintf (stream, " at <unknown> <0x%05x>\n", frame->native_offset);
+ mono_runtime_printf_err (" at <unknown> <0x%05x>", frame->native_offset);
return FALSE;
}
MonoContext mctx;
/* we don't do much now, but we can warn the user with a useful message */
- fprintf (stderr, "Stack overflow: IP: %p, fault addr: %p\n", mono_arch_ip_from_context (ctx), fault_addr);
+ mono_runtime_printf_err ("Stack overflow: IP: %p, fault addr: %p", mono_arch_ip_from_context (ctx), fault_addr);
#ifdef MONO_ARCH_HAVE_SIGCTX_TO_MONOCTX
mono_arch_sigctx_to_monoctx (ctx, &mctx);
- fprintf (stderr, "Stacktrace:\n");
+ mono_runtime_printf_err ("Stacktrace:");
memset (&ud, 0, sizeof (ud));
- ud.stream = stderr;
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));
+ mono_runtime_printf_err ("At %s", mono_method_full_name (ji->method, TRUE));
else
- fprintf (stderr, "At <unmanaged>.\n");
+ mono_runtime_printf_err ("At <unmanaged>.");
#endif
_exit (1);
}
static gboolean
-print_stack_frame (StackFrameInfo *frame, MonoContext *ctx, gpointer data)
+print_stack_frame_to_stderr (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, frame->native_offset, mono_domain_get ());
- fprintf (stream, " %s\n", location);
+ mono_runtime_printf_err (" %s", location);
g_free (location);
} else
- fprintf (stream, " at <unknown> <0x%05x>\n", frame->native_offset);
+ mono_runtime_printf_err (" at <unknown> <0x%05x>", frame->native_offset);
return FALSE;
}
struct sigaction sa;
#endif
MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+ const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
if (handling_sigsegv)
return;
if (mini_get_debug_options ()->suspend_on_sigsegv) {
- fprintf (stderr, "Received SIGSEGV, suspending...");
+ mono_runtime_printf_err ("Received SIGSEGV, suspending...");
while (1)
;
}
/* !jit_tls means the thread was not registered with the runtime */
if (jit_tls && mono_thread_internal_current ()) {
- fprintf (stderr, "Stacktrace:\n\n");
-
- mono_walk_stack (print_stack_frame, TRUE, stderr);
+ mono_runtime_printf_err ("Stacktrace:\n");
- fflush (stderr);
+ mono_walk_stack (print_stack_frame_to_stderr, TRUE, NULL);
}
#ifdef HAVE_BACKTRACE_SYMBOLS
void *array [256];
char **names;
int i, size;
- const char *signal_str = (signal == SIGSEGV) ? "SIGSEGV" : "SIGABRT";
- fprintf (stderr, "\nNative stacktrace:\n\n");
+ mono_runtime_printf_err ("\nNative stacktrace:\n");
size = backtrace (array, 256);
names = backtrace_symbols (array, size);
for (i =0; i < size; ++i) {
- fprintf (stderr, "\t%s\n", names [i]);
+ mono_runtime_printf_err ("\t%s", names [i]);
}
free (names);
- fflush (stderr);
-
/* Try to get more meaningful information using gdb */
#if !defined(HOST_WIN32) && defined(HAVE_SYS_SYSCALL_H) && defined(SYS_fork)
exit (1);
}
- fprintf (stderr, "\nDebug info from gdb:\n\n");
+ mono_runtime_printf_err ("\nDebug info from gdb:\n");
waitpid (pid, &status, 0);
}
#endif
+ }
+#endif
+
/*
* A SIGSEGV indicates something went very wrong so we can no longer depend
* on anything working. So try to print out lots of diagnostics, starting
* with ones which have a greater chance of working.
*/
- fprintf (stderr,
+ mono_runtime_printf_err (
"\n"
"=================================================================\n"
"Got a %s while executing native code. This usually indicates\n"
"a fatal error in the mono runtime or one of the native libraries \n"
"used by your application.\n"
- "=================================================================\n"
- "\n", signal_str);
+ "=================================================================\n",
+ signal_str);
- }
-#endif
#ifdef MONO_ARCH_USE_SIGACTION
#endif
+ /*Android abort is a fluke, it doesn't abort, it triggers another segv. */
+#if defined (PLATFORM_ANDROID)
+ exit (-1);
+#else
abort ();
+#endif
}
static void
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");
+ mono_runtime_printf ("\t<Stack traces in thread dumps not supported on this platform>");
#endif
- fprintf (stdout, "%s", text->str);
+ mono_runtime_printf ("%s", text->str);
#if PLATFORM_WIN32 && TARGET_WIN32 && _DEBUG
OutputDebugStringA(text->str);
#endif
g_string_free (text, TRUE);
- fflush (stdout);
+ mono_runtime_stdout_fflush ();
}
/*
g_error ("This target doesn't support mono_arch_setup_async_callback");
#endif
}
+
+void
+mono_install_unhandled_exception_hook (MonoUnhandledExceptionFunc func, gpointer user_data)
+{
+ unhandled_exception_hook = func;
+ unhandled_exception_hook_data = user_data;
+}
+
+void
+mono_invoke_unhandled_exception_hook (MonoObject *exc)
+{
+ if (unhandled_exception_hook) {
+ unhandled_exception_hook (exc, unhandled_exception_hook_data);
+ } else {
+ MonoObject *other = NULL;
+ MonoString *str = mono_object_to_string (exc, &other);
+ char *msg = NULL;
+
+ if (str)
+ msg = mono_string_to_utf8 (str);
+ else
+ msg = g_strdup ("Nested exception trying to figure out what went wrong");
+ mono_runtime_printf_err ("[ERROR] FATAL UNHANDLED EXCEPTION: %s", msg);
+ g_free (msg);
+#if defined(__APPLE__) && defined(__arm__)
+ g_assertion_message ("Terminating runtime due to unhandled exception");
+#else
+ exit (mono_environment_exitcode_get ());
+#endif
+ }
+
+ g_assert_not_reached ();
+}
projects / mono.git / blobdiff