mono/mini/exceptions-x86.c

   1 /**
   2  * \file
   3  * exception support for x86
   4  *
   5  * Authors:
   6  *   Dietmar Maurer (dietmar@ximian.com)
   7  *
   8  * (C) 2001 Ximian, Inc.
   9  */
  10
  11 #include <config.h>
  12
  13 #include <glib.h>
  14 #include <signal.h>
  15 #include <string.h>
  16 #ifdef HAVE_UCONTEXT_H
  17 #include <ucontext.h>
  18 #endif
  19
  20 #include <mono/metadata/abi-details.h>
  21 #include <mono/arch/x86/x86-codegen.h>
  22 #include <mono/metadata/appdomain.h>
  23 #include <mono/metadata/tabledefs.h>
  24 #include <mono/metadata/threads.h>
  25 #include <mono/metadata/debug-helpers.h>
  26 #include <mono/metadata/exception.h>
  27 #include <mono/metadata/gc-internals.h>
  28 #include <mono/metadata/mono-debug.h>
  29 #include <mono/utils/mono-mmap.h>
  30
  31 #include "mini.h"
  32 #include "mini-x86.h"
  33 #include "mini-runtime.h"
  34 #include "tasklets.h"
  35 #include "aot-runtime.h"
  36
  37 static gpointer signal_exception_trampoline;
  38
  39 gpointer
  40 mono_x86_get_signal_exception_trampoline (MonoTrampInfo **info, gboolean aot);
  41
  42 #ifdef TARGET_WIN32
  43 static void (*restore_stack) (void *);
  44
  45 static MonoW32ExceptionHandler fpe_handler;
  46 static MonoW32ExceptionHandler ill_handler;
  47 static MonoW32ExceptionHandler segv_handler;
  48
  49 LPTOP_LEVEL_EXCEPTION_FILTER mono_old_win_toplevel_exception_filter;
  50 gpointer mono_win_vectored_exception_handle;
  51 extern int (*gUnhandledExceptionHandler)(EXCEPTION_POINTERS*);
  52
  53 #ifndef PROCESS_CALLBACK_FILTER_ENABLED
  54 #       define PROCESS_CALLBACK_FILTER_ENABLED 1
  55 #endif
  56
  57 #define W32_SEH_HANDLE_EX(_ex) \
  58         if (_ex##_handler) _ex##_handler(er->ExceptionCode, &info, ctx)
  59
  60 LONG CALLBACK seh_unhandled_exception_filter(EXCEPTION_POINTERS* ep)
  61 {
  62 #ifndef MONO_CROSS_COMPILE
  63         if (mono_old_win_toplevel_exception_filter) {
  64                 return (*mono_old_win_toplevel_exception_filter)(ep);
  65         }
  66 #endif
  67
  68         mono_handle_native_crash ("SIGSEGV", NULL, NULL);
  69
  70         return EXCEPTION_CONTINUE_SEARCH;
  71 }
  72
  73 /*
  74  * mono_win32_get_handle_stackoverflow (void):
  75  *
  76  * Returns a pointer to a method which restores the current context stack
  77  * and calls handle_exceptions, when done restores the original stack.
  78  */
  79 static gpointer
  80 mono_win32_get_handle_stackoverflow (void)
  81 {
  82         static guint8 *start = NULL;
  83         guint8 *code;
  84
  85         if (start)
  86                 return start;
  87
  88         /* restore_contect (void *sigctx) */
  89         start = code = mono_global_codeman_reserve (128);
  90
  91         /* load context into ebx */
  92         x86_mov_reg_membase (code, X86_EBX, X86_ESP, 4, 4);
  93
  94         /* move current stack into edi for later restore */
  95         x86_mov_reg_reg (code, X86_EDI, X86_ESP);
  96
  97         /* use the new freed stack from sigcontext */
  98         /* XXX replace usage of struct sigcontext with MonoContext so we can use MONO_STRUCT_OFFSET */
  99         x86_mov_reg_membase (code, X86_ESP, X86_EBX,  G_STRUCT_OFFSET (struct sigcontext, esp), 4);
 100
 101         /* get the current domain */
 102         x86_call_code (code, mono_domain_get);
 103
 104         /* get stack overflow exception from domain object */
 105         x86_mov_reg_membase (code, X86_EAX, X86_EAX, G_STRUCT_OFFSET (MonoDomain, stack_overflow_ex), 4);
 106
 107         /* call mono_arch_handle_exception (sctx, stack_overflow_exception_obj) */
 108         x86_push_reg (code, X86_EAX);
 109         x86_push_reg (code, X86_EBX);
 110         x86_call_code (code, mono_arch_handle_exception);
 111
 112         /* restore the SEH handler stack */
 113         x86_mov_reg_reg (code, X86_ESP, X86_EDI);
 114
 115         /* return */
 116         x86_ret (code);
 117
 118         mono_arch_flush_icache (start, code - start);
 119         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL));
 120
 121         return start;
 122 }
 123
 124 /* Special hack to workaround the fact that the
 125  * when the SEH handler is called the stack is
 126  * to small to recover.
 127  *
 128  * Stack walking part of this method is from mono_handle_exception
 129  *
 130  * The idea is simple;
 131  *  - walk the stack to free some space (64k)
 132  *  - set esp to new stack location
 133  *  - call mono_arch_handle_exception with stack overflow exception
 134  *  - set esp to SEH handlers stack
 135  *  - done
 136  */
 137 static void
 138 win32_handle_stack_overflow (EXCEPTION_POINTERS* ep, CONTEXT *sctx)
 139 {
 140         SYSTEM_INFO si;
 141         DWORD page_size;
 142         MonoDomain *domain = mono_domain_get ();
 143         MonoJitInfo rji;
 144         MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
 145         MonoLMF *lmf = jit_tls->lmf;
 146         MonoContext initial_ctx;
 147         MonoContext ctx;
 148         guint32 free_stack = 0;
 149         StackFrameInfo frame;
 150
 151         mono_sigctx_to_monoctx (sctx, &ctx);
 152
 153         /* get our os page size */
 154         GetSystemInfo(&si);
 155         page_size = si.dwPageSize;
 156
 157         /* Let's walk the stack to recover
 158          * the needed stack space (if possible)
 159          */
 160         memset (&rji, 0, sizeof (rji));
 161
 162         initial_ctx = ctx;
 163         free_stack = (guint8*)(MONO_CONTEXT_GET_BP (&ctx)) - (guint8*)(MONO_CONTEXT_GET_BP (&initial_ctx));
 164
 165         /* try to free 64kb from our stack */
 166         do {
 167                 MonoContext new_ctx;
 168
 169                 mono_arch_unwind_frame (domain, jit_tls, &rji, &ctx, &new_ctx, &lmf, NULL, &frame);
 170                 if (!frame.ji) {
 171                         g_warning ("Exception inside function without unwind info");
 172                         g_assert_not_reached ();
 173                 }
 174
 175                 if (frame.ji != (gpointer)-1) {
 176                         free_stack = (guint8*)(MONO_CONTEXT_GET_BP (&ctx)) - (guint8*)(MONO_CONTEXT_GET_BP (&initial_ctx));
 177                 }
 178
 179                 /* todo: we should call abort if ji is -1 */
 180                 ctx = new_ctx;
 181         } while (free_stack < 64 * 1024 && frame.ji != (gpointer) -1);
 182
 183         mono_monoctx_to_sigctx (&ctx, sctx);
 184
 185         /* todo: install new stack-guard page */
 186
 187         /* use the new stack and call mono_arch_handle_exception () */
 188         restore_stack (sctx);
 189 }
 190
 191 /*
 192  * Unhandled Exception Filter
 193  * Top-level per-process exception handler.
 194  */
 195 LONG CALLBACK seh_vectored_exception_handler(EXCEPTION_POINTERS* ep)
 196 {
 197         EXCEPTION_RECORD* er;
 198         CONTEXT* ctx;
 199         LONG res;
 200         MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
 201         MonoWindowsSigHandlerInfo info = { TRUE, ep };
 202
 203         /* If the thread is not managed by the runtime return early */
 204         if (!jit_tls)
 205                 return EXCEPTION_CONTINUE_SEARCH;
 206
 207         res = EXCEPTION_CONTINUE_EXECUTION;
 208
 209         er = ep->ExceptionRecord;
 210         ctx = ep->ContextRecord;
 211
 212         switch (er->ExceptionCode) {
 213         case EXCEPTION_STACK_OVERFLOW:
 214                 win32_handle_stack_overflow (ep, ctx);
 215                 break;
 216         case EXCEPTION_ACCESS_VIOLATION:
 217                 W32_SEH_HANDLE_EX(segv);
 218                 break;
 219         case EXCEPTION_ILLEGAL_INSTRUCTION:
 220                 W32_SEH_HANDLE_EX(ill);
 221                 break;
 222         case EXCEPTION_INT_DIVIDE_BY_ZERO:
 223         case EXCEPTION_INT_OVERFLOW:
 224         case EXCEPTION_FLT_DIVIDE_BY_ZERO:
 225         case EXCEPTION_FLT_OVERFLOW:
 226         case EXCEPTION_FLT_UNDERFLOW:
 227         case EXCEPTION_FLT_INEXACT_RESULT:
 228                 W32_SEH_HANDLE_EX(fpe);
 229                 break;
 230         default:
 231                 info.handled = FALSE;
 232                 break;
 233         }
 234
 235         if (!info.handled) {
 236                 /* Don't copy context back if we chained exception
 237                 * as the handler may have modfied the EXCEPTION_POINTERS
 238                 * directly. We don't pass sigcontext to chained handlers.
 239                 * Return continue search so the UnhandledExceptionFilter
 240                 * can correctly chain the exception.
 241                 */
 242                 res = EXCEPTION_CONTINUE_SEARCH;
 243         }
 244
 245         return res;
 246 }
 247
 248 void win32_seh_init()
 249 {
 250         /* install restore stack helper */
 251         if (!restore_stack)
 252                 restore_stack = (void (*) (void*))mono_win32_get_handle_stackoverflow ();
 253
 254         mono_old_win_toplevel_exception_filter = SetUnhandledExceptionFilter(seh_unhandled_exception_filter);
 255         mono_win_vectored_exception_handle = AddVectoredExceptionHandler (1, seh_vectored_exception_handler);
 256 }
 257
 258 void win32_seh_cleanup()
 259 {
 260         if (mono_old_win_toplevel_exception_filter)
 261                 SetUnhandledExceptionFilter(mono_old_win_toplevel_exception_filter);
 262         RemoveVectoredExceptionHandler (mono_win_vectored_exception_handle);
 263 }
 264
 265 void win32_seh_set_handler(int type, MonoW32ExceptionHandler handler)
 266 {
 267         switch (type) {
 268         case SIGFPE:
 269                 fpe_handler = handler;
 270                 break;
 271         case SIGILL:
 272                 ill_handler = handler;
 273                 break;
 274         case SIGSEGV:
 275                 segv_handler = handler;
 276                 break;
 277         default:
 278                 break;
 279         }
 280 }
 281
 282 #endif /* TARGET_WIN32 */
 283
 284 /*
 285  * mono_arch_get_restore_context:
 286  *
 287  * Returns a pointer to a method which restores a previously saved sigcontext.
 288  */
 289 gpointer
 290 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
 291 {
 292         guint8 *start = NULL;
 293         guint8 *code;
 294         MonoJumpInfo *ji = NULL;
 295         GSList *unwind_ops = NULL;
 296
 297         /* restore_contect (MonoContext *ctx) */
 298
 299         start = code = mono_global_codeman_reserve (128);
 300
 301         /* load ctx */
 302         x86_mov_reg_membase (code, X86_EAX, X86_ESP, 4, 4);
 303
 304         /* restore EBX */
 305         x86_mov_reg_membase (code, X86_EBX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, ebx), 4);
 306
 307         /* restore EDI */
 308         x86_mov_reg_membase (code, X86_EDI, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, edi), 4);
 309
 310         /* restore ESI */
 311         x86_mov_reg_membase (code, X86_ESI, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, esi), 4);
 312
 313         /* restore EDX */
 314         x86_mov_reg_membase (code, X86_EDX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, edx), 4);
 315
 316         /*
 317          * The context resides on the stack, in the stack frame of the
 318          * caller of this function.  The stack pointer that we need to
 319          * restore is potentially many stack frames higher up, so the
 320          * distance between them can easily be more than the red zone
 321          * size.  Hence the stack pointer can be restored only after
 322          * we have finished loading everything from the context.
 323          */
 324
 325         /* load ESP into EBP */
 326         x86_mov_reg_membase (code, X86_EBP, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, esp), 4);
 327         /* load return address into ECX */
 328         x86_mov_reg_membase (code, X86_ECX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, eip), 4);
 329         /* save the return addr to the restored stack - 4 */
 330         x86_mov_membase_reg (code, X86_EBP, -4, X86_ECX, 4);
 331
 332         /* load EBP into ECX */
 333         x86_mov_reg_membase (code, X86_ECX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, ebp), 4);
 334         /* save EBP to the restored stack - 8 */
 335         x86_mov_membase_reg (code, X86_EBP, -8, X86_ECX, 4);
 336
 337         /* load EAX into ECX */
 338         x86_mov_reg_membase (code, X86_ECX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, eax), 4);
 339         /* save EAX to the restored stack - 12 */
 340         x86_mov_membase_reg (code, X86_EBP, -12, X86_ECX, 4);
 341
 342         /* restore ECX */
 343         x86_mov_reg_membase (code, X86_ECX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, ecx), 4);
 344
 345         /* restore ESP - 12 */
 346         x86_lea_membase (code, X86_ESP, X86_EBP, -12);
 347         /* restore EAX */
 348         x86_pop_reg (code, X86_EAX);
 349         /* restore EBP */
 350         x86_pop_reg (code, X86_EBP);
 351         /* jump to the saved IP */
 352         x86_ret (code);
 353
 354         if (info)
 355                 *info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops);
 356         else {
 357                 GSList *l;
 358
 359                 for (l = unwind_ops; l; l = l->next)
 360                         g_free (l->data);
 361                 g_slist_free (unwind_ops);
 362         }
 363
 364         mono_arch_flush_icache (start, code - start);
 365         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL));
 366
 367         return start;
 368 }
 369
 370 /*
 371  * mono_arch_get_call_filter:
 372  *
 373  * Returns a pointer to a method which calls an exception filter. We
 374  * also use this function to call finally handlers (we pass NULL as
 375  * @exc object in this case).
 376  */
 377 gpointer
 378 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
 379 {
 380         guint8* start;
 381         guint8 *code;
 382         MonoJumpInfo *ji = NULL;
 383         GSList *unwind_ops = NULL;
 384         guint kMaxCodeSize = 64;
 385
 386         /* call_filter (MonoContext *ctx, unsigned long eip) */
 387         start = code = mono_global_codeman_reserve (kMaxCodeSize);
 388
 389         x86_push_reg (code, X86_EBP);
 390         x86_mov_reg_reg (code, X86_EBP, X86_ESP);
 391         x86_push_reg (code, X86_EBX);
 392         x86_push_reg (code, X86_EDI);
 393         x86_push_reg (code, X86_ESI);
 394
 395         /* load ctx */
 396         x86_mov_reg_membase (code, X86_EAX, X86_EBP, 8, 4);
 397         /* load eip */
 398         x86_mov_reg_membase (code, X86_ECX, X86_EBP, 12, 4);
 399         /* save EBP */
 400         x86_push_reg (code, X86_EBP);
 401
 402         /* set new EBP */
 403         x86_mov_reg_membase (code, X86_EBP, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, ebp), 4);
 404         /* restore registers used by global register allocation (EBX & ESI) */
 405         x86_mov_reg_membase (code, X86_EBX, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, ebx), 4);
 406         x86_mov_reg_membase (code, X86_ESI, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, esi), 4);
 407         x86_mov_reg_membase (code, X86_EDI, X86_EAX,  MONO_STRUCT_OFFSET (MonoContext, edi), 4);
 408
 409         /* align stack and save ESP */
 410         x86_mov_reg_reg (code, X86_EDX, X86_ESP);
 411         x86_alu_reg_imm (code, X86_AND, X86_ESP, -MONO_ARCH_FRAME_ALIGNMENT);
 412         g_assert (MONO_ARCH_FRAME_ALIGNMENT >= 8);
 413         x86_alu_reg_imm (code, X86_SUB, X86_ESP, MONO_ARCH_FRAME_ALIGNMENT - 8);
 414         x86_push_reg (code, X86_EDX);
 415
 416         /* call the handler */
 417         x86_call_reg (code, X86_ECX);
 418
 419         /* restore ESP */
 420         x86_pop_reg (code, X86_ESP);
 421
 422         /* restore EBP */
 423         x86_pop_reg (code, X86_EBP);
 424
 425         /* restore saved regs */
 426         x86_pop_reg (code, X86_ESI);
 427         x86_pop_reg (code, X86_EDI);
 428         x86_pop_reg (code, X86_EBX);
 429         x86_leave (code);
 430         x86_ret (code);
 431
 432         if (info)
 433                 *info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops);
 434         else {
 435                 GSList *l;
 436
 437                 for (l = unwind_ops; l; l = l->next)
 438                         g_free (l->data);
 439                 g_slist_free (unwind_ops);
 440         }
 441
 442         mono_arch_flush_icache (start, code - start);
 443         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL));
 444
 445         g_assert ((code - start) < kMaxCodeSize);
 446         return start;
 447 }
 448
 449 /*
 450  * mono_x86_throw_exception:
 451  *
 452  *   C function called from the throw trampolines.
 453  */
 454 void
 455 mono_x86_throw_exception (host_mgreg_t *regs, MonoObject *exc,
 456                                                   host_mgreg_t eip, gboolean rethrow, gboolean preserve_ips)
 457 {
 458         ERROR_DECL (error);
 459         MonoContext ctx;
 460
 461         ctx.esp = regs [X86_ESP];
 462         ctx.eip = eip;
 463         ctx.ebp = regs [X86_EBP];
 464         ctx.edi = regs [X86_EDI];
 465         ctx.esi = regs [X86_ESI];
 466         ctx.ebx = regs [X86_EBX];
 467         ctx.edx = regs [X86_EDX];
 468         ctx.ecx = regs [X86_ECX];
 469         ctx.eax = regs [X86_EAX];
 470
 471 #ifdef __APPLE__
 472         /* The OSX ABI specifies 16 byte alignment at call sites */
 473         g_assert ((ctx.esp % MONO_ARCH_FRAME_ALIGNMENT) == 0);
 474 #endif
 475
 476         if (mono_object_isinst_checked (exc, mono_defaults.exception_class, error)) {
 477                 MonoException *mono_ex = (MonoException*)exc;
 478                 if (!rethrow) {
 479                         mono_ex->stack_trace = NULL;
 480                         mono_ex->trace_ips = NULL;
 481                 } else if (preserve_ips) {
 482                         mono_ex->caught_in_unmanaged = TRUE;
 483                 }
 484         }
 485         mono_error_assert_ok (error);
 486
 487         /* adjust eip so that it point into the call instruction */
 488         ctx.eip -= 1;
 489
 490         mono_handle_exception (&ctx, exc);
 491
 492         mono_restore_context (&ctx);
 493
 494         g_assert_not_reached ();
 495 }
 496
 497 void
 498 mono_x86_throw_corlib_exception (host_mgreg_t *regs, guint32 ex_token_index,
 499                                                                  host_mgreg_t eip, gint32 pc_offset)
 500 {
 501         guint32 ex_token = MONO_TOKEN_TYPE_DEF | ex_token_index;
 502         MonoException *ex;
 503
 504         ex = mono_exception_from_token (m_class_get_image (mono_defaults.exception_class), ex_token);
 505
 506         eip -= pc_offset;
 507
 508         /* Negate the ip adjustment done in mono_x86_throw_exception () */
 509         eip += 1;
 510
 511         mono_x86_throw_exception (regs, (MonoObject*)ex, eip, FALSE, FALSE);
 512 }
 513
 514 static void
 515 mono_x86_resume_unwind (host_mgreg_t *regs, MonoObject *exc,
 516                                                 host_mgreg_t eip, gboolean rethrow)
 517 {
 518         MonoContext ctx;
 519
 520         ctx.esp = regs [X86_ESP];
 521         ctx.eip = eip;
 522         ctx.ebp = regs [X86_EBP];
 523         ctx.edi = regs [X86_EDI];
 524         ctx.esi = regs [X86_ESI];
 525         ctx.ebx = regs [X86_EBX];
 526         ctx.edx = regs [X86_EDX];
 527         ctx.ecx = regs [X86_ECX];
 528         ctx.eax = regs [X86_EAX];
 529
 530         mono_resume_unwind (&ctx);
 531 }
 532
 533 /*
 534  * get_throw_trampoline:
 535  *
 536  *  Generate a call to mono_x86_throw_exception/
 537  * mono_x86_throw_corlib_exception.
 538  * If LLVM is true, generate code which assumes the caller is LLVM generated code,
 539  * which doesn't push the arguments.
 540  */
 541 static guint8*
 542 get_throw_trampoline (const char *name, gboolean rethrow, gboolean llvm, gboolean corlib, gboolean llvm_abs, gboolean resume_unwind, MonoTrampInfo **info, gboolean aot, gboolean preserve_ips)
 543 {
 544         guint8 *start, *code, *labels [16];
 545         int i, stack_size, stack_offset, arg_offsets [5], regs_offset;
 546         MonoJumpInfo *ji = NULL;
 547         GSList *unwind_ops = NULL;
 548         guint kMaxCodeSize = 192;
 549
 550         start = code = mono_global_codeman_reserve (kMaxCodeSize);
 551
 552         stack_size = 128;
 553
 554         /*
 555          * On apple, the stack is misaligned by the pushing of the return address.
 556          */
 557         if (!llvm && corlib)
 558                 /* On OSX, we don't generate alignment code to save space */
 559                 stack_size += 4;
 560         else
 561                 stack_size += MONO_ARCH_FRAME_ALIGNMENT - 4;
 562
 563         /*
 564          * The stack looks like this:
 565          * <pc offset> (only if corlib is TRUE)
 566          * <exception object>/<type token>
 567          * <return addr> <- esp (unaligned on apple)
 568          */
 569
 570         unwind_ops = mono_arch_get_cie_program ();
 571
 572         /* Alloc frame */
 573         x86_alu_reg_imm (code, X86_SUB, X86_ESP, stack_size);
 574         mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, stack_size + 4);
 575
 576         arg_offsets [0] = 0;
 577         arg_offsets [1] = 4;
 578         arg_offsets [2] = 8;
 579         arg_offsets [3] = 12;
 580         arg_offsets [4] = 16;
 581         regs_offset = 20;
 582
 583         /* Save registers */
 584         for (i = 0; i < X86_NREG; ++i)
 585                 if (i != X86_ESP)
 586                         x86_mov_membase_reg (code, X86_ESP, regs_offset + (i * 4), i, 4);
 587         /* Calculate the offset between the current sp and the sp of the caller */
 588         if (llvm) {
 589                 /* LLVM doesn't push the arguments */
 590                 stack_offset = stack_size + 4;
 591         } else {
 592                 if (corlib) {
 593                         /* Two arguments */
 594                         stack_offset = stack_size + 4 + 8;
 595 #ifdef __APPLE__
 596                         /* We don't generate stack alignment code on osx to save space */
 597 #endif
 598                 } else {
 599                         /* One argument + stack alignment */
 600                         stack_offset = stack_size + 4 + 4;
 601 #ifdef __APPLE__
 602                         /* Pop the alignment added by OP_THROW too */
 603                         stack_offset += MONO_ARCH_FRAME_ALIGNMENT - 4;
 604 #else
 605                         if (mono_do_x86_stack_align)
 606                                 stack_offset += MONO_ARCH_FRAME_ALIGNMENT - 4;
 607 #endif
 608                 }
 609         }
 610         /* Save ESP */
 611         x86_lea_membase (code, X86_EAX, X86_ESP, stack_offset);
 612         x86_mov_membase_reg (code, X86_ESP, regs_offset + (X86_ESP * 4), X86_EAX, 4);
 613
 614         /* Clear fp stack */
 615         labels [0] = code;
 616         x86_fnstsw (code);
 617         x86_shift_reg_imm (code, X86_SHR, X86_EAX, 11);
 618         x86_alu_reg_imm (code, X86_AND, X86_EAX, 7);
 619         x86_alu_reg_imm (code, X86_CMP, X86_EAX, 0);
 620         labels [1] = code;
 621         x86_branch8 (code, X86_CC_EQ, 0, FALSE);
 622         x86_fstp (code, 0);
 623         x86_jump_code (code, labels [0]);
 624         mono_x86_patch (labels [1], code);
 625
 626         /* Set arg1 == regs */
 627         x86_lea_membase (code, X86_EAX, X86_ESP, regs_offset);
 628         x86_mov_membase_reg (code, X86_ESP, arg_offsets [0], X86_EAX, 4);
 629         /* Set arg2 == exc/ex_token_index */
 630         if (resume_unwind)
 631                 x86_mov_reg_imm (code, X86_EAX, 0);
 632         else
 633                 x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size + 4, 4);
 634         x86_mov_membase_reg (code, X86_ESP, arg_offsets [1], X86_EAX, 4);
 635         /* Set arg3 == eip */
 636         if (llvm_abs)
 637                 x86_alu_reg_reg (code, X86_XOR, X86_EAX, X86_EAX);
 638         else
 639                 x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size, 4);
 640         x86_mov_membase_reg (code, X86_ESP, arg_offsets [2], X86_EAX, 4);
 641         /* Set arg4 == rethrow/pc_offset */
 642         if (resume_unwind) {
 643                 x86_mov_membase_imm (code, X86_ESP, arg_offsets [3], 0, 4);
 644         } else if (corlib) {
 645                 x86_mov_reg_membase (code, X86_EAX, X86_ESP, stack_size + 8, 4);
 646                 if (llvm_abs) {
 647                         /*
 648                          * The caller is LLVM code which passes the absolute address not a pc offset,
 649                          * so compensate by passing 0 as 'ip' and passing the negated abs address as
 650                          * the pc offset.
 651                          */
 652                         x86_neg_reg (code, X86_EAX);
 653                 }
 654                 x86_mov_membase_reg (code, X86_ESP, arg_offsets [3], X86_EAX, 4);
 655         } else {
 656                 x86_mov_membase_imm (code, X86_ESP, arg_offsets [3], rethrow, 4);
 657
 658                 /* Set arg4 == preserve_ips */
 659                 x86_mov_membase_imm (code, X86_ESP, arg_offsets [4], preserve_ips, 4);
 660         }
 661         /* Make the call */
 662         if (aot) {
 663                 // This can be called from runtime code, which can't guarantee that
 664                 // ebx contains the got address.
 665                 // So emit the got address loading code too
 666                 code = mono_arch_emit_load_got_addr (start, code, NULL, &ji);
 667                 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");
 668                 x86_call_reg (code, X86_EAX);
 669         } else {
 670                 x86_call_code (code, resume_unwind ? (gpointer)(mono_x86_resume_unwind) : (corlib ? (gpointer)mono_x86_throw_corlib_exception : (gpointer)mono_x86_throw_exception));
 671         }
 672         x86_breakpoint (code);
 673
 674         g_assert ((code - start) < kMaxCodeSize);
 675
 676         if (info)
 677                 *info = mono_tramp_info_create (name, start, code - start, ji, unwind_ops);
 678         else {
 679                 GSList *l;
 680
 681                 for (l = unwind_ops; l; l = l->next)
 682                         g_free (l->data);
 683                 g_slist_free (unwind_ops);
 684         }
 685
 686         mono_arch_flush_icache (start, code - start);
 687         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL));
 688
 689         return start;
 690 }
 691
 692 /**
 693  * mono_arch_get_throw_exception:
 694  * \returns a function pointer which can be used to raise
 695  * exceptions. The returned function has the following
 696  * signature: void (*func) (MonoException *exc);
 697  * For example to raise an arithmetic exception you can use:
 698  *
 699  * x86_push_imm (code, mono_get_exception_arithmetic ());
 700  * x86_call_code (code, arch_get_throw_exception ());
 701  *
 702  */
 703 gpointer
 704 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
 705 {
 706         return get_throw_trampoline ("throw_exception", FALSE, FALSE, FALSE, FALSE, FALSE, info, aot, FALSE);
 707 }
 708
 709 gpointer
 710 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
 711 {
 712         return get_throw_trampoline ("rethrow_exception", TRUE, FALSE, FALSE, FALSE, FALSE, info, aot, FALSE);
 713 }
 714
 715 gpointer
 716 mono_arch_get_rethrow_preserve_exception (MonoTrampInfo **info, gboolean aot)
 717 {
 718         return get_throw_trampoline ("rethrow_preserve_exception", TRUE, FALSE, FALSE, FALSE, FALSE, info, aot, TRUE);
 719 }
 720
 721 /**
 722  * mono_arch_get_throw_corlib_exception:
 723  * \returns a function pointer which can be used to raise
 724  * corlib exceptions. The returned function has the following
 725  * signature: void (*func) (guint32 ex_token, guint32 offset);
 726  * Here, offset is the offset which needs to be substracted from the caller IP
 727  * to get the IP of the throw. Passing the offset has the advantage that it
 728  * needs no relocations in the caller.
 729  */
 730 gpointer
 731 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
 732 {
 733         return get_throw_trampoline ("throw_corlib_exception", FALSE, FALSE, TRUE, FALSE, FALSE, info, aot, FALSE);
 734 }
 735
 736 void
 737 mono_arch_exceptions_init (void)
 738 {
 739         guint8 *tramp;
 740         MonoTrampInfo *tinfo;
 741
 742 /*
 743  * If we're running WoW64, we need to set the usermode exception policy
 744  * for SEHs to behave. This requires hotfix http://support.microsoft.com/kb/976038
 745  * or (eventually) Windows 7 SP1.
 746  */
 747 #ifdef TARGET_WIN32
 748         HMODULE kernel32 = LoadLibraryW (L"kernel32.dll");
 749         if (kernel32) {
 750                 typedef BOOL (WINAPI * SetProcessUserModeExceptionPolicy_t) (DWORD dwFlags);
 751                 typedef BOOL (WINAPI * GetProcessUserModeExceptionPolicy_t) (PDWORD dwFlags);
 752                 GetProcessUserModeExceptionPolicy_t const getter = (GetProcessUserModeExceptionPolicy_t)GetProcAddress (kernel32, "GetProcessUserModeExceptionPolicy");
 753                 if (getter) {
 754                         SetProcessUserModeExceptionPolicy_t const setter = (SetProcessUserModeExceptionPolicy_t)GetProcAddress (kernel32, "SetProcessUserModeExceptionPolicy");
 755                         if (setter) {
 756                                 DWORD flags = 0;
 757                                 if (getter (&flags))
 758                                         setter (flags & ~PROCESS_CALLBACK_FILTER_ENABLED);
 759                         }
 760                 }
 761         }
 762 #endif
 763
 764         if (mono_aot_only) {
 765                 signal_exception_trampoline = mono_aot_get_trampoline ("x86_signal_exception_trampoline");
 766                 return;
 767         }
 768
 769         /* LLVM needs different throw trampolines */
 770         tramp = get_throw_trampoline ("llvm_throw_exception_trampoline", FALSE, TRUE, FALSE, FALSE, FALSE, &tinfo, FALSE,  FALSE);
 771         mono_register_jit_icall (tramp, "llvm_throw_exception_trampoline", NULL, TRUE);
 772         mono_tramp_info_register (tinfo, NULL);
 773
 774         tramp = get_throw_trampoline ("llvm_rethrow_exception_trampoline", TRUE, TRUE, FALSE, FALSE, FALSE, &tinfo, FALSE, FALSE);
 775         mono_register_jit_icall (tramp, "llvm_rethrow_exception_trampoline", NULL, TRUE);
 776         mono_tramp_info_register (tinfo, NULL);
 777
 778         tramp = get_throw_trampoline ("llvm_throw_corlib_exception_trampoline", FALSE, TRUE, TRUE, FALSE, FALSE, &tinfo, FALSE, FALSE);
 779         mono_register_jit_icall (tramp, "llvm_throw_corlib_exception_trampoline", NULL, TRUE);
 780         mono_tramp_info_register (tinfo, NULL);
 781
 782         tramp = get_throw_trampoline ("llvm_throw_corlib_exception_abs_trampoline", FALSE, TRUE, TRUE, TRUE, FALSE, &tinfo, FALSE, FALSE);
 783         mono_register_jit_icall (tramp, "llvm_throw_corlib_exception_abs_trampoline", NULL, TRUE);
 784         mono_tramp_info_register (tinfo, NULL);
 785
 786         tramp = get_throw_trampoline ("llvm_resume_unwind_trampoline", FALSE, FALSE, FALSE, FALSE, TRUE, &tinfo, FALSE, FALSE);
 787         mono_register_jit_icall (tramp, "llvm_resume_unwind_trampoline", NULL, TRUE);
 788         mono_tramp_info_register (tinfo, NULL);
 789
 790         signal_exception_trampoline = mono_x86_get_signal_exception_trampoline (&tinfo, FALSE);
 791         mono_tramp_info_register (tinfo, NULL);
 792 }
 793
 794 /*
 795  * mono_arch_unwind_frame:
 796  *
 797  * See exceptions-amd64.c for docs.
 798  */
 799 gboolean
 800 mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
 801                                                          MonoJitInfo *ji, MonoContext *ctx,
 802                                                          MonoContext *new_ctx, MonoLMF **lmf,
 803                                                          host_mgreg_t **save_locations,
 804                                                          StackFrameInfo *frame)
 805 {
 806         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 807
 808         memset (frame, 0, sizeof (StackFrameInfo));
 809         frame->ji = ji;
 810
 811         *new_ctx = *ctx;
 812
 813         if (ji != NULL) {
 814                 host_mgreg_t regs [MONO_MAX_IREGS + 1];
 815                 guint8 *cfa;
 816                 guint32 unwind_info_len;
 817                 guint8 *unwind_info;
 818
 819                 if (ji->is_trampoline)
 820                         frame->type = FRAME_TYPE_TRAMPOLINE;
 821                 else
 822                         frame->type = FRAME_TYPE_MANAGED;
 823
 824                 unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
 825
 826                 regs [X86_EAX] = new_ctx->eax;
 827                 regs [X86_EBX] = new_ctx->ebx;
 828                 regs [X86_ECX] = new_ctx->ecx;
 829                 regs [X86_EDX] = new_ctx->edx;
 830                 regs [X86_ESP] = new_ctx->esp;
 831                 regs [X86_EBP] = new_ctx->ebp;
 832                 regs [X86_ESI] = new_ctx->esi;
 833                 regs [X86_EDI] = new_ctx->edi;
 834                 regs [X86_NREG] = new_ctx->eip;
 835
 836                 gboolean success = mono_unwind_frame ((guint8*)unwind_info, unwind_info_len, (guint8*)ji->code_start,
 837                                                    (guint8*)ji->code_start + ji->code_size,
 838                                                    (guint8*)ip, NULL, regs, MONO_MAX_IREGS + 1,
 839                                                    save_locations, MONO_MAX_IREGS, &cfa);
 840
 841                 if (!success)
 842                         return FALSE;
 843
 844                 new_ctx->eax = regs [X86_EAX];
 845                 new_ctx->ebx = regs [X86_EBX];
 846                 new_ctx->ecx = regs [X86_ECX];
 847                 new_ctx->edx = regs [X86_EDX];
 848                 new_ctx->esp = regs [X86_ESP];
 849                 new_ctx->ebp = regs [X86_EBP];
 850                 new_ctx->esi = regs [X86_ESI];
 851                 new_ctx->edi = regs [X86_EDI];
 852                 new_ctx->eip = regs [X86_NREG];
 853
 854                 /* The CFA becomes the new SP value */
 855                 new_ctx->esp = (gssize)cfa;
 856
 857                 /* Adjust IP */
 858                 new_ctx->eip --;
 859
 860                 return TRUE;
 861         } else if (*lmf) {
 862                 g_assert ((((gsize)(*lmf)->previous_lmf) & 2) == 0);
 863
 864                 if ((ji = mini_jit_info_table_find (domain, (gpointer)(uintptr_t)(*lmf)->eip, NULL))) {
 865                         frame->ji = ji;
 866                 } else {
 867                         if (!(*lmf)->method)
 868                                 return FALSE;
 869                         frame->method = (*lmf)->method;
 870                 }
 871
 872                 new_ctx->esi = (*lmf)->esi;
 873                 new_ctx->edi = (*lmf)->edi;
 874                 new_ctx->ebx = (*lmf)->ebx;
 875                 new_ctx->ebp = (*lmf)->ebp;
 876                 new_ctx->eip = (*lmf)->eip;
 877
 878                 /* Adjust IP */
 879                 new_ctx->eip --;
 880
 881                 frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
 882
 883                 /* Check if we are in a trampoline LMF frame */
 884                 if ((gsize)((*lmf)->previous_lmf) & 1) {
 885                         /* lmf->esp is set by the trampoline code */
 886                         new_ctx->esp = (*lmf)->esp;
 887                 }
 888                 else
 889                         /* the lmf is always stored on the stack, so the following
 890                          * expression points to a stack location which can be used as ESP */
 891                         new_ctx->esp = (unsigned long)&((*lmf)->eip);
 892
 893                 *lmf = (MonoLMF*)(((gsize)(*lmf)->previous_lmf) & ~3);
 894
 895                 return TRUE;
 896         }
 897
 898         return FALSE;
 899 }
 900
 901 gpointer
 902 mono_arch_ip_from_context (void *sigctx)
 903 {
 904 #if defined(HOST_WATCHOS)
 905         printf("WARNING: mono_arch_ip_from_context() called!\n");
 906         return (NULL);
 907 #elif defined(MONO_CROSS_COMPILE)
 908         g_assert_not_reached ();
 909         return NULL;
 910 #elif defined(MONO_ARCH_USE_SIGACTION)
 911         ucontext_t *ctx = (ucontext_t*)sigctx;
 912         return (gpointer)UCONTEXT_REG_EIP (ctx);
 913 #elif defined(HOST_WIN32)
 914         return (gpointer)((CONTEXT*)sigctx)->Eip;
 915 #else
 916         struct sigcontext *ctx = sigctx;
 917         return (gpointer)ctx->SC_EIP;
 918 #endif
 919 }
 920
 921 /*
 922  * handle_exception:
 923  *
 924  *   Called by resuming from a signal handler.
 925  */
 926 static void
 927 handle_signal_exception (gpointer obj)
 928 {
 929         MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
 930         MonoContext ctx;
 931
 932         memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
 933
 934         mono_handle_exception (&ctx, (MonoObject*)obj);
 935
 936         mono_restore_context (&ctx);
 937 }
 938
 939 /*
 940  * mono_x86_get_signal_exception_trampoline:
 941  *
 942  *   This x86 specific trampoline is used to call handle_signal_exception.
 943  */
 944 gpointer
 945 mono_x86_get_signal_exception_trampoline (MonoTrampInfo **info, gboolean aot)
 946 {
 947         guint8 *start, *code;
 948         MonoJumpInfo *ji = NULL;
 949         GSList *unwind_ops = NULL;
 950         int stack_size;
 951
 952         start = code = mono_global_codeman_reserve (128);
 953
 954         /* FIXME no unwind before we push ip */
 955         /* Caller ip */
 956         x86_push_reg (code, X86_ECX);
 957
 958         mono_add_unwind_op_def_cfa (unwind_ops, code, start, X86_ESP, 4);
 959         mono_add_unwind_op_offset (unwind_ops, code, start, X86_NREG, -4);
 960
 961         /* Fix the alignment to be what apple expects */
 962         stack_size = 12;
 963
 964         x86_alu_reg_imm (code, X86_SUB, X86_ESP, stack_size);
 965         mono_add_unwind_op_def_cfa_offset (unwind_ops, code, start, stack_size + 4);
 966
 967         /* Arg1 */
 968         x86_mov_membase_reg (code, X86_ESP, 0, X86_EAX, 4);
 969         /* Branch to target */
 970         x86_call_reg (code, X86_EDX);
 971
 972         g_assert ((code - start) < 128);
 973
 974         if (info)
 975                 *info = mono_tramp_info_create ("x86_signal_exception_trampoline", start, code - start, ji, unwind_ops);
 976         else {
 977                 GSList *l;
 978
 979                 for (l = unwind_ops; l; l = l->next)
 980                         g_free (l->data);
 981                 g_slist_free (unwind_ops);
 982         }
 983
 984         mono_arch_flush_icache (start, code - start);
 985         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL));
 986
 987         return start;
 988 }
 989
 990
 991 void
 992 mono_arch_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
 993 {
 994         /*
 995          * Can't pass the obj on the stack, since we are executing on the
 996          * same stack. Can't save it into MonoJitTlsData, since it needs GC tracking.
 997          * So put it into a register, and branch to a trampoline which
 998          * pushes it.
 999          */
1000         ctx->eax = (host_mgreg_t)(gsize)user_data;
1001         ctx->ecx = ctx->eip;
1002         ctx->edx = (host_mgreg_t)(gsize)async_cb;
1003
1004         /*align the stack*/
1005         ctx->esp = (ctx->esp - 16) & ~15;
1006         ctx->eip = (host_mgreg_t)(gsize)signal_exception_trampoline;
1007 }
1008
1009 gboolean
1010 mono_arch_handle_exception (void *sigctx, gpointer obj)
1011 {
1012 #if defined(MONO_ARCH_USE_SIGACTION)
1013         MonoContext mctx;
1014         ucontext_t *ctx = (ucontext_t*)sigctx;
1015
1016         /*
1017          * Handling the exception in the signal handler is problematic, since the original
1018          * signal is disabled, and we could run arbitrary code though the debugger. So
1019          * resume into the normal stack and do most work there if possible.
1020          */
1021         MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
1022
1023         /* Pass the ctx parameter in TLS */
1024         mono_sigctx_to_monoctx (ctx, &jit_tls->ex_ctx);
1025
1026         mctx = jit_tls->ex_ctx;
1027         mono_setup_async_callback (&mctx, handle_signal_exception, obj);
1028         mono_monoctx_to_sigctx (&mctx, sigctx);
1029
1030         return TRUE;
1031 #elif defined (TARGET_WIN32)
1032         MonoContext mctx;
1033         MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
1034
1035         mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
1036
1037         mctx = jit_tls->ex_ctx;
1038         mono_setup_async_callback (&mctx, handle_signal_exception, obj);
1039         mono_monoctx_to_sigctx (&mctx, sigctx);
1040
1041         return TRUE;
1042 #else
1043         MonoContext mctx;
1044
1045         mono_sigctx_to_monoctx (sigctx, &mctx);
1046
1047         mono_handle_exception (&mctx, obj);
1048
1049         mono_monoctx_to_sigctx (&mctx, sigctx);
1050
1051         return TRUE;
1052 #endif
1053 }
1054
1055 static MonoObject*
1056 restore_soft_guard_pages (void)
1057 {
1058         MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
1059
1060         if (jit_tls->stack_ovf_guard_base)
1061                 mono_mprotect (jit_tls->stack_ovf_guard_base, jit_tls->stack_ovf_guard_size, MONO_MMAP_NONE);
1062
1063         if (jit_tls->stack_ovf_pending) {
1064                 MonoDomain *domain = mono_domain_get ();
1065                 jit_tls->stack_ovf_pending = 0;
1066                 return (MonoObject *) domain->stack_overflow_ex;
1067         }
1068         return NULL;
1069 }
1070
1071 /*
1072  * this function modifies mctx so that when it is restored, it
1073  * won't execcute starting at mctx.eip, but in a function that
1074  * will restore the protection on the soft-guard pages and return back to
1075  * continue at mctx.eip.
1076  */
1077 static void
1078 prepare_for_guard_pages (MonoContext *mctx)
1079 {
1080         gpointer *sp;
1081         sp = (gpointer*)(mctx->esp);
1082         sp -= 1;
1083         /* the return addr */
1084         sp [0] = (gpointer)(mctx->eip);
1085         mctx->eip = (unsigned long)restore_soft_guard_pages;
1086         mctx->esp = (unsigned long)sp;
1087 }
1088
1089
1090 static void
1091 altstack_handle_and_restore (MonoContext *ctx, gpointer obj, gboolean stack_ovf)
1092 {
1093         MonoContext mctx;
1094
1095         mctx = *ctx;
1096
1097         mono_handle_exception (&mctx, (MonoObject*)obj);
1098         if (stack_ovf) {
1099                 MonoJitTlsData *jit_tls = mono_tls_get_jit_tls ();
1100                 jit_tls->stack_ovf_pending = 1;
1101                 prepare_for_guard_pages (&mctx);
1102         }
1103         mono_restore_context (&mctx);
1104 }
1105
1106 void
1107 mono_arch_handle_altstack_exception (void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, gpointer fault_addr, gboolean stack_ovf)
1108 {
1109 #if defined (MONO_ARCH_USE_SIGACTION) && !defined (MONO_CROSS_COMPILE)
1110         MonoException *exc = NULL;
1111         ucontext_t *ctx = (ucontext_t*)sigctx;
1112         MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)UCONTEXT_REG_EIP (ctx), NULL);
1113         gpointer *sp;
1114         int frame_size;
1115
1116         /* if we didn't find a managed method for the ip address and it matches the fault
1117          * address, we assume we followed a broken pointer during an indirect call, so
1118          * we try the lookup again with the return address pushed on the stack
1119          */
1120         if (!ji && fault_addr == (gpointer)UCONTEXT_REG_EIP (ctx)) {
1121                 glong *sp = (glong*)UCONTEXT_REG_ESP (ctx);
1122                 ji = mini_jit_info_table_find (mono_domain_get (), (gpointer)sp [0], NULL);
1123                 if (ji)
1124                         UCONTEXT_REG_EIP (ctx) = sp [0];
1125         }
1126         if (stack_ovf)
1127                 exc = mono_domain_get ()->stack_overflow_ex;
1128         if (!ji) {
1129                 MonoContext mctx;
1130                 mono_sigctx_to_monoctx (sigctx, &mctx);
1131                 mono_handle_native_crash ("SIGSEGV", &mctx, siginfo);
1132         }
1133         /* setup a call frame on the real stack so that control is returned there
1134          * and exception handling can continue.
1135          * If this was a stack overflow the caller already ensured the stack pages
1136          * needed have been unprotected.
1137          * The frame looks like:
1138          *   ucontext struct
1139          *   test_only arg
1140          *   exception arg
1141          *   ctx arg
1142          *   return ip
1143          */
1144         // FIXME: test_only is no more.
1145         frame_size = sizeof (MonoContext) + sizeof (gpointer) * 4;
1146         frame_size += 15;
1147         frame_size &= ~15;
1148         sp = (gpointer*)(UCONTEXT_REG_ESP (ctx) & ~15);
1149         sp = (gpointer*)((char*)sp - frame_size);
1150         /* the incoming arguments are aligned to 16 bytes boundaries, so the return address IP
1151          * goes at sp [-1]
1152          */
1153         sp [-1] = (gpointer)UCONTEXT_REG_EIP (ctx);
1154         sp [0] = sp + 4;
1155         sp [1] = exc;
1156         sp [2] = (gpointer)stack_ovf;
1157         mono_sigctx_to_monoctx (sigctx, (MonoContext*)(sp + 4));
1158         /* at the return form the signal handler execution starts in altstack_handle_and_restore() */
1159         UCONTEXT_REG_EIP (ctx) = (unsigned long)altstack_handle_and_restore;
1160         UCONTEXT_REG_ESP (ctx) = (unsigned long)(sp - 1);
1161 #endif
1162 }
1163
1164 #if MONO_SUPPORT_TASKLETS
1165 MonoContinuationRestore
1166 mono_tasklets_arch_restore (void)
1167 {
1168         static guint8* saved = NULL;
1169         guint8 *code, *start;
1170
1171         if (saved)
1172                 return (MonoContinuationRestore)saved;
1173         code = start = mono_global_codeman_reserve (48);
1174         /* the signature is: restore (MonoContinuation *cont, int state, MonoLMF **lmf_addr) */
1175         /* put cont in edx */
1176         x86_mov_reg_membase (code, X86_EDX, X86_ESP, 4, 4);
1177         /* state in eax, so it's setup as the return value */
1178         x86_mov_reg_membase (code, X86_EAX, X86_ESP, 8, 4);
1179         /* lmf_addr in ebx */
1180         x86_mov_reg_membase(code, X86_EBX, X86_ESP, 0x0C, 4);
1181
1182         /* setup the copy of the stack */
1183         x86_mov_reg_membase (code, X86_ECX, X86_EDX, MONO_STRUCT_OFFSET (MonoContinuation, stack_used_size), 4);
1184         x86_shift_reg_imm (code, X86_SHR, X86_ECX, 2);
1185         x86_cld (code);
1186         x86_mov_reg_membase (code, X86_ESI, X86_EDX, MONO_STRUCT_OFFSET (MonoContinuation, saved_stack), 4);
1187         x86_mov_reg_membase (code, X86_EDI, X86_EDX, MONO_STRUCT_OFFSET (MonoContinuation, return_sp), 4);
1188         x86_prefix (code, X86_REP_PREFIX);
1189         x86_movsl (code);
1190
1191         /* now restore the registers from the LMF */
1192         x86_mov_reg_membase (code, X86_ECX, X86_EDX, MONO_STRUCT_OFFSET (MonoContinuation, lmf), 4);
1193         x86_mov_reg_membase (code, X86_EBP, X86_ECX, MONO_STRUCT_OFFSET (MonoLMF, ebp), 4);
1194         x86_mov_reg_membase (code, X86_ESP, X86_ECX, MONO_STRUCT_OFFSET (MonoLMF, esp), 4);
1195
1196         /* restore the lmf chain */
1197         /*x86_mov_reg_membase (code, X86_ECX, X86_ESP, 12, 4);
1198         x86_mov_membase_reg (code, X86_ECX, 0, X86_EDX, 4);*/
1199
1200         x86_jump_membase (code, X86_EDX, MONO_STRUCT_OFFSET (MonoContinuation, return_ip));
1201
1202         mono_arch_flush_icache (start, code - start);
1203         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING, NULL));
1204         g_assert ((code - start) <= 48);
1205
1206         saved = start;
1207         return (MonoContinuationRestore)saved;
1208 }
1209 #endif
1210
1211 /*
1212  * mono_arch_setup_resume_sighandler_ctx:
1213  *
1214  *   Setup CTX so execution continues at FUNC.
1215  */
1216 void
1217 mono_arch_setup_resume_sighandler_ctx (MonoContext *ctx, gpointer func)
1218 {
1219         int align = (((gint32)MONO_CONTEXT_GET_SP (ctx)) % MONO_ARCH_FRAME_ALIGNMENT + 4);
1220
1221         if (align != 0)
1222                 MONO_CONTEXT_SET_SP (ctx, (gsize)MONO_CONTEXT_GET_SP (ctx) - align);
1223
1224         MONO_CONTEXT_SET_IP (ctx, func);
1225 }