#include <mono/metadata/gc-internals.h>
#include <mono/metadata/debug-internals.h>
#include <mono/metadata/mono-debug.h>
-#include <mono/metadata/profiler.h>
+#include <mono/metadata/profiler-private.h>
#include <mono/metadata/mono-endian.h>
#include <mono/metadata/environment.h>
#include <mono/metadata/mono-mlist.h>
#include "mini-llvm-cpp.h"
#endif
+#ifdef TARGET_ARM
+#include "mini-arm.h"
+#endif
+
#ifndef MONO_ARCH_CONTEXT_DEF
#define MONO_ARCH_CONTEXT_DEF
#endif
#define MONO_ARCH_STACK_GROWS_UP 0
#endif
+/*
+ * Raw frame information is stored in MonoException.trace_ips as an IntPtr[].
+ * This structure represents one entry.
+ * This should consists of pointers only.
+ */
+typedef struct
+{
+ gpointer ip;
+ gpointer generic_info;
+} ExceptionTraceIp;
+
+/* Number of words in trace_ips belonging to one entry */
+#define TRACE_IP_ENTRY_SIZE (sizeof (ExceptionTraceIp) / sizeof (gpointer))
+
static gpointer restore_context_func, call_filter_func;
static gpointer throw_exception_func, rethrow_exception_func;
static gpointer throw_corlib_exception_func;
for (i = 0; i < table->num_holes; ++i) {
MonoTryBlockHoleJitInfo *hole = &table->holes [i];
- if (hole->clause == clause && hole->offset <= offset && hole->offset + hole->length > offset)
+ if (ji->clauses [hole->clause].try_offset == ji->clauses [clause].try_offset && hole->offset <= offset && hole->offset + hole->length > offset)
return FALSE;
}
return TRUE;
memset (unwinder, 0, sizeof (Unwinder));
}
+#if defined(__GNUC__) && defined(TARGET_ARM64)
+/* gcc 4.9.2 seems to miscompile this on arm64 */
+static __attribute__((optimize("O0"))) gboolean
+#else
static gboolean
+#endif
unwinder_unwind_frame (Unwinder *unwinder,
MonoDomain *domain, MonoJitTlsData *jit_tls,
MonoJitInfo *prev_ji, MonoContext *ctx,
if (ta == NULL)
return FALSE;
- len = mono_array_length (ta) >> 1;
+ len = mono_array_length (ta) / TRACE_IP_ENTRY_SIZE;
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);
+ ExceptionTraceIp trace_ip;
+
+ memcpy (&trace_ip, mono_array_addr_fast (ta, ExceptionTraceIp, i), sizeof (ExceptionTraceIp));
+ gpointer ip = trace_ip.ip;
+ gpointer generic_info = trace_ip.generic_info;
MonoJitInfo *ji = mono_jit_info_table_find (domain, (char *)ip);
if (ji == NULL) {
return res;
}
- len = mono_array_length (ta) >> 1;
+ len = mono_array_length (ta) / TRACE_IP_ENTRY_SIZE;
res = mono_array_new_checked (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0, &error);
if (mono_error_set_pending_exception (&error))
mono_error_set_pending_exception (&error);
return NULL;
}
- gpointer ip = mono_array_get (ta, gpointer, i * 2 + 0);
- gpointer generic_info = mono_array_get (ta, gpointer, i * 2 + 1);
+ ExceptionTraceIp trace_ip;
+ memcpy (&trace_ip, mono_array_addr_fast (ta, ExceptionTraceIp, i), sizeof (ExceptionTraceIp));
+ gpointer ip = trace_ip.ip;
+ gpointer generic_info = trace_ip.generic_info;
MonoMethod *method;
ji = mono_jit_info_table_find (domain, (char *)ip);
mgreg_t *new_reg_locations [MONO_MAX_IREGS];
gboolean get_reg_locations = unwind_options & MONO_UNWIND_REG_LOCATIONS;
gboolean async = mono_thread_info_is_async_context ();
+ Unwinder unwinder;
if (mono_llvm_only) {
GSList *l, *ips;
memcpy (&ctx, start_ctx, sizeof (MonoContext));
memset (reg_locations, 0, sizeof (reg_locations));
+ unwinder_init (&unwinder);
+
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, get_reg_locations ? new_reg_locations : NULL, &frame);
+ res = unwinder_unwind_frame (&unwinder, domain, jit_tls, NULL, &ctx, &new_ctx, NULL, &lmf, get_reg_locations ? new_reg_locations : NULL, &frame);
if (!res)
return;
mono_ex = (MonoException*)obj;
MonoArray *initial_trace_ips = mono_ex->trace_ips;
if (initial_trace_ips) {
- int len = mono_array_length (initial_trace_ips) >> 1;
+ int len = mono_array_length (initial_trace_ips) / TRACE_IP_ENTRY_SIZE;
for (i = 0; i < (len - 1); i++) {
- gpointer ip = mono_array_get (initial_trace_ips, gpointer, i * 2 + 0);
- gpointer generic_info = mono_array_get (initial_trace_ips, gpointer, i * 2 + 1);
- trace_ips = g_list_prepend (trace_ips, ip);
- trace_ips = g_list_prepend (trace_ips, generic_info);
+ for (int j = 0; j < TRACE_IP_ENTRY_SIZE; ++j) {
+ gpointer p = mono_array_get (initial_trace_ips, gpointer, (i * TRACE_IP_ENTRY_SIZE) + j);
+ trace_ips = g_list_prepend (trace_ips, p);
+ }
}
}
gpointer ip;
if (in_interp)
- ip = (guint16*)ji->code_start + frame.native_offset;
+ ip = (guint8*)ji->code_start + frame.native_offset;
else
ip = MONO_CONTEXT_GET_IP (ctx);
mono_print_thread_dump_from_ctx (ctx);
}
jit_tls->orig_ex_ctx_set = TRUE;
- mono_profiler_exception_thrown (obj);
+ MONO_PROFILER_RAISE (exception_throw, (obj));
jit_tls->orig_ex_ctx_set = FALSE;
res = mono_handle_exception_internal_first_pass (&ctx_cp, obj, &first_filter_idx, &ji, &prev_ji, non_exception);
lmf = jit_tls->resume_state.lmf;
first_filter_idx = jit_tls->resume_state.first_filter_idx;
filter_idx = jit_tls->resume_state.filter_idx;
+ in_interp = FALSE;
} else {
unwind_res = unwinder_unwind_frame (&unwinder, domain, jit_tls, NULL, ctx, &new_ctx, NULL, &lmf, NULL, &frame);
if (!unwind_res) {
}
if (in_interp)
- ip = (guint16*)ji->code_start + frame.native_offset;
+ ip = (guint8*)ji->code_start + frame.native_offset;
else
ip = MONO_CONTEXT_GET_IP (ctx);
if (mono_trace_is_enabled () && mono_trace_eval (method))
g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (method, TRUE));
jit_tls->orig_ex_ctx_set = TRUE;
- mono_profiler_exception_clause_handler (method, ei->flags, i);
+ MONO_PROFILER_RAISE (exception_clause, (method, i, ei->flags, ex_obj));
jit_tls->orig_ex_ctx_set = FALSE;
mini_set_abort_threshold (ctx);
* like the call which transitioned to JITted code has succeeded, but the
* return value register etc. is not set, so we have to be careful.
*/
- mono_interp_set_resume_state (mono_ex, &frame, ei->handler_start);
+ mono_interp_set_resume_state (jit_tls, mono_ex, frame.interp_frame, ei->handler_start);
/* Undo the IP adjustment done by mono_arch_unwind_frame () */
-#ifdef TARGET_AMD64
+#if defined(TARGET_AMD64)
ctx->gregs [AMD64_RIP] ++;
+#elif defined(TARGET_ARM)
+ ctx->pc ++;
+ if (mono_arm_thumb_supported ())
+ ctx->pc |= 1;
+#elif defined(TARGET_ARM64)
+ ctx->pc ++;
#else
NOT_IMPLEMENTED;
#endif
if (mono_trace_is_enabled () && mono_trace_eval (method))
g_print ("EXCEPTION: fault clause %d of %s\n", i, mono_method_full_name (method, TRUE));
jit_tls->orig_ex_ctx_set = TRUE;
- mono_profiler_exception_clause_handler (method, ei->flags, i);
+ MONO_PROFILER_RAISE (exception_clause, (method, i, ei->flags, ex_obj));
jit_tls->orig_ex_ctx_set = FALSE;
mini_set_abort_threshold (ctx);
call_filter (ctx, ei->handler_start);
if (mono_trace_is_enabled () && mono_trace_eval (method))
g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (method, TRUE));
jit_tls->orig_ex_ctx_set = TRUE;
- mono_profiler_exception_clause_handler (method, ei->flags, i);
+ MONO_PROFILER_RAISE (exception_clause, (method, i, ei->flags, ex_obj));
jit_tls->orig_ex_ctx_set = FALSE;
#ifndef DISABLE_PERFCOUNTERS
mono_perfcounters->exceptions_finallys++;
}
jit_tls->orig_ex_ctx_set = TRUE;
- mono_profiler_exception_method_leave (method);
+ MONO_PROFILER_RAISE (method_exception_leave, (method, ex_obj));
jit_tls->orig_ex_ctx_set = FALSE;
*ctx = new_ctx;
* mono_handle_exception:
* \param ctx saved processor state
* \param obj the exception object
+ *
+ * Handle the exception OBJ starting from the state CTX. Modify CTX to point to the handler clause if the exception is caught, and
+ * return TRUE.
*/
gboolean
mono_handle_exception (MonoContext *ctx, MonoObject *obj)
#endif
}
-static gboolean handling_sigsegv = FALSE;
+static gboolean handle_crash_loop = FALSE;
/*
* mono_handle_native_crash:
#endif
MonoJitTlsData *jit_tls = (MonoJitTlsData *)mono_tls_get_jit_tls ();
- gboolean is_sigsegv = !strcmp ("SIGSEGV", signal);
-
- if (handling_sigsegv && is_sigsegv)
+ if (handle_crash_loop)
return;
if (mini_get_debug_options ()->suspend_on_native_crash) {
#endif
}
- /* To prevent infinite loops when the stack walk causes a crash */
- if (is_sigsegv)
- handling_sigsegv = TRUE;
+ /* prevent infinite loops in crash handling */
+ handle_crash_loop = TRUE;
/* !jit_tls means the thread was not registered with the runtime */
if (jit_tls && mono_thread_internal_current ()) {
continue;
/*If ip points to the first instruction it means the handler block didn't start
so we can leave its execution to the EH machinery*/
- if (ei->handler_start < ip && ip < ei->data.handler_end) {
+ if (ei->handler_start <= ip && ip < ei->data.handler_end) {
pdata->ji = ji;
pdata->ei = ei;
pdata->ctx = *ctx;
clause = &ji->clauses [i];
if (clause->flags != MONO_EXCEPTION_CLAUSE_FINALLY)
continue;
- if (clause->handler_start < ip && clause->data.handler_end > ip)
+ if (clause->handler_start <= ip && clause->data.handler_end > ip)
break;
}
if (i == ji->num_clauses)
return NULL;
- /*If we stopped on the instruction right before the try, we haven't actually started executing it*/
- if (ip == clause->handler_start)
- return NULL;
-
return mono_arch_install_handler_block_guard (ji, clause, ctx, mono_create_handler_block_trampoline ());
}
size_t upper = mono_array_length (mono_ex->trace_ips);
- for (int i = 0; i < upper; i+= 2) {
+ for (int i = 0; i < upper; i += TRACE_IP_ENTRY_SIZE) {
gpointer curr_ip = mono_array_get (mono_ex->trace_ips, gpointer, i);
- gpointer curr_info = mono_array_get (mono_ex->trace_ips, gpointer, i + 1);
- trace_ips = g_list_append (trace_ips, curr_ip);
- trace_ips = g_list_append (trace_ips, curr_info);
-
+ for (int j = 0; j < TRACE_IP_ENTRY_SIZE; ++j) {
+ gpointer p = mono_array_get (mono_ex->trace_ips, gpointer, i + j);
+ trace_ips = g_list_append (trace_ips, p);
+ }
if (ip == curr_ip)
break;
}
g_assert_not_reached ();
}
#endif
-
-#ifndef ENABLE_INTERPRETER
-/* Stubs of interpreter functions */
-void
-mono_interp_set_resume_state (MonoException *ex, StackFrameInfo *frame, gpointer handler_ip)
-{
- g_assert_not_reached ();
-}
-
-void
-mono_interp_run_finally (StackFrameInfo *frame, int clause_index, gpointer handler_ip)
-{
- g_assert_not_reached ();
-}
-
-void
-mono_interp_frame_iter_init (MonoInterpStackIter *iter, gpointer interp_exit_data)
-{
- g_assert_not_reached ();
-}
-
-gboolean
-mono_interp_frame_iter_next (MonoInterpStackIter *iter, StackFrameInfo *frame)
-{
- g_assert_not_reached ();
- return FALSE;
-}
-#endif
projects / mono.git / blobdiff