*/
#include <config.h>
+
+#if _WIN32_WINNT < 0x0501
+/* Required for Vectored Exception Handling. */
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
+#endif /* _WIN32_WINNT < 0x0501 */
+
#include <glib.h>
#include <signal.h>
#include <string.h>
static MonoW32ExceptionHandler segv_handler;
LPTOP_LEVEL_EXCEPTION_FILTER mono_old_win_toplevel_exception_filter;
-guint64 mono_win_chained_exception_filter_result;
-gboolean mono_win_chained_exception_filter_didrun;
+gpointer mono_win_vectored_exception_handle;
+extern gboolean mono_win_chained_exception_needs_run;
+extern int (*gUnhandledExceptionHandler)(EXCEPTION_POINTERS*);
#ifndef PROCESS_CALLBACK_FILTER_ENABLED
# define PROCESS_CALLBACK_FILTER_ENABLED 1
#define W32_SEH_HANDLE_EX(_ex) \
if (_ex##_handler) _ex##_handler(0, ep, sctx)
+LONG CALLBACK seh_unhandled_exception_filter(EXCEPTION_POINTERS* ep)
+{
+#ifndef MONO_CROSS_COMPILE
+ if (mono_old_win_toplevel_exception_filter) {
+ return (*mono_old_win_toplevel_exception_filter)(ep);
+ }
+#endif
+
+ mono_handle_native_sigsegv (SIGSEGV, NULL);
+
+ return EXCEPTION_CONTINUE_SEARCH;
+}
+
/*
* mono_win32_get_handle_stackoverflow (void):
*
* Unhandled Exception Filter
* Top-level per-process exception handler.
*/
-LONG CALLBACK seh_handler(EXCEPTION_POINTERS* ep)
+LONG CALLBACK seh_vectored_exception_handler(EXCEPTION_POINTERS* ep)
{
EXCEPTION_RECORD* er;
CONTEXT* ctx;
struct sigcontext* sctx;
LONG res;
- mono_win_chained_exception_filter_didrun = FALSE;
+ mono_win_chained_exception_needs_run = FALSE;
res = EXCEPTION_CONTINUE_EXECUTION;
er = ep->ExceptionRecord;
break;
}
- /* Copy context back */
- ctx->Eax = sctx->eax;
- ctx->Ebx = sctx->ebx;
- ctx->Ecx = sctx->ecx;
- ctx->Edx = sctx->edx;
- ctx->Ebp = sctx->ebp;
- ctx->Esp = sctx->esp;
- ctx->Esi = sctx->esi;
- ctx->Edi = sctx->edi;
- ctx->Eip = sctx->eip;
-
- g_free (sctx);
+ if (mono_win_chained_exception_needs_run) {
+ /* Don't copy context back if we chained exception
+ * as the handler may have modfied the EXCEPTION_POINTERS
+ * directly. We don't pass sigcontext to chained handlers.
+ * Return continue search so the UnhandledExceptionFilter
+ * can correctly chain the exception.
+ */
+ res = EXCEPTION_CONTINUE_SEARCH;
+ } else {
+ /* Copy context back */
+ ctx->Eax = sctx->eax;
+ ctx->Ebx = sctx->ebx;
+ ctx->Ecx = sctx->ecx;
+ ctx->Edx = sctx->edx;
+ ctx->Ebp = sctx->ebp;
+ ctx->Esp = sctx->esp;
+ ctx->Esi = sctx->esi;
+ ctx->Edi = sctx->edi;
+ ctx->Eip = sctx->eip;
+ }
- if (mono_win_chained_exception_filter_didrun)
- res = mono_win_chained_exception_filter_result;
+ /* TODO: Find right place to free this in stack overflow case */
+ if (er->ExceptionCode != EXCEPTION_STACK_OVERFLOW)
+ g_free (sctx);
return res;
}
if (!restore_stack)
restore_stack = mono_win32_get_handle_stackoverflow ();
- mono_old_win_toplevel_exception_filter = SetUnhandledExceptionFilter(seh_handler);
+ mono_old_win_toplevel_exception_filter = SetUnhandledExceptionFilter(seh_unhandled_exception_filter);
+ mono_win_vectored_exception_handle = AddVectoredExceptionHandler (1, seh_vectored_exception_handler);
}
void win32_seh_cleanup()
{
if (mono_old_win_toplevel_exception_filter) SetUnhandledExceptionFilter(mono_old_win_toplevel_exception_filter);
+ RemoveVectoredExceptionHandler (seh_unhandled_exception_filter);
}
void win32_seh_set_handler(int type, MonoW32ExceptionHandler handler)
nacl_global_codeman_validate(&start, 128, &code);
if (info)
- *info = mono_tramp_info_create (g_strdup_printf ("restore_context"), start, code - start, ji, unwind_ops);
+ *info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops);
else {
GSList *l;
nacl_global_codeman_validate(&start, kMaxCodeSize, &code);
if (info)
- *info = mono_tramp_info_create (g_strdup_printf ("call_filter"), start, code - start, ji, unwind_ops);
+ *info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops);
else {
GSList *l;
code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, corlib ? "mono_x86_throw_corlib_exception" : "mono_x86_throw_exception");
x86_call_reg (code, X86_EAX);
} else {
- x86_call_code (code, resume_unwind ? (mono_x86_resume_unwind) : (corlib ? (gpointer)mono_x86_throw_corlib_exception : (gpointer)mono_x86_throw_exception));
+ x86_call_code (code, resume_unwind ? (gpointer)(mono_x86_resume_unwind) : (corlib ? (gpointer)mono_x86_throw_corlib_exception : (gpointer)mono_x86_throw_exception));
}
x86_breakpoint (code);
g_assert ((code - start) < kMaxCodeSize);
if (info)
- *info = mono_tramp_info_create (g_strdup (name), start, code - start, ji, unwind_ops);
+ *info = mono_tramp_info_create (name, start, code - start, ji, unwind_ops);
else {
GSList *l;
/* Pop arguments off the stack */
/*
* FIXME: LLVM doesn't push these, we can't use ji->from_llvm as it describes
- * the caller.
+ * the callee.
*/
#ifndef ENABLE_LLVM
if (ji->has_arch_eh_info)
/* 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 (mono_method_signature (method), mono_method_signature (method)->param_count, arg_info);
+ 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
g_assert ((code - start) < 128);
if (info)
- *info = mono_tramp_info_create (g_strdup ("x86_signal_exception_trampoline"), start, code - start, ji, unwind_ops);
+ *info = mono_tramp_info_create ("x86_signal_exception_trampoline", start, code - start, ji, unwind_ops);
else {
GSList *l;
/* the signature is: restore (MonoContinuation *cont, int state, MonoLMF **lmf_addr) */
/* put cont in edx */
x86_mov_reg_membase (code, X86_EDX, X86_ESP, 4, 4);
+ /* state in eax, so it's setup as the return value */
+ x86_mov_reg_membase (code, X86_EAX, X86_ESP, 8, 4);
+
/* setup the copy of the stack */
x86_mov_reg_membase (code, X86_ECX, X86_EDX, G_STRUCT_OFFSET (MonoContinuation, stack_used_size), 4);
x86_shift_reg_imm (code, X86_SHR, X86_ECX, 2);
/*x86_mov_reg_membase (code, X86_ECX, X86_ESP, 12, 4);
x86_mov_membase_reg (code, X86_ECX, 0, X86_EDX, 4);*/
- /* state in eax, so it's setup as the return value */
- x86_mov_reg_membase (code, X86_EAX, X86_ESP, 8, 4);
x86_jump_membase (code, X86_EDX, G_STRUCT_OFFSET (MonoContinuation, return_ip));
g_assert ((code - start) <= 48);
saved = start;
projects / mono.git / blobdiff