mono/mini/exceptions-amd64.c

   1 /*
   2  * exceptions-amd64.c: exception support for AMD64
   3  *
   4  * Authors:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12 #include <signal.h>
  13 #include <string.h>
  14 #include <sys/ucontext.h>
  15
  16 #include <mono/arch/amd64/amd64-codegen.h>
  17 #include <mono/metadata/appdomain.h>
  18 #include <mono/metadata/tabledefs.h>
  19 #include <mono/metadata/threads.h>
  20 #include <mono/metadata/debug-helpers.h>
  21 #include <mono/metadata/exception.h>
  22 #include <mono/metadata/gc-internal.h>
  23 #include <mono/metadata/mono-debug.h>
  24
  25 #include "mini.h"
  26 #include "mini-amd64.h"
  27
  28 #define ALIGN_TO(val,align) (((val) + ((align) - 1)) & ~((align) - 1))
  29
  30 #ifdef PLATFORM_WIN32
  31 static MonoW32ExceptionHandler fpe_handler;
  32 static MonoW32ExceptionHandler ill_handler;
  33 static MonoW32ExceptionHandler segv_handler;
  34
  35 static LPTOP_LEVEL_EXCEPTION_FILTER old_handler;
  36
  37 #define W32_SEH_HANDLE_EX(_ex) \
  38         if (_ex##_handler) _ex##_handler((int)sctx)
  39
  40 /*
  41  * Unhandled Exception Filter
  42  * Top-level per-process exception handler.
  43  */
  44 LONG CALLBACK seh_handler(EXCEPTION_POINTERS* ep)
  45 {
  46         EXCEPTION_RECORD* er;
  47         CONTEXT* ctx;
  48         MonoContext* sctx;
  49         LONG res;
  50
  51         res = EXCEPTION_CONTINUE_EXECUTION;
  52
  53         er = ep->ExceptionRecord;
  54         ctx = ep->ContextRecord;
  55         sctx = g_malloc(sizeof(MonoContext));
  56
  57         /* Copy Win32 context to UNIX style context */
  58         sctx->eax = ctx->Eax;
  59         sctx->ebx = ctx->Ebx;
  60         sctx->ecx = ctx->Ecx;
  61         sctx->edx = ctx->Edx;
  62         sctx->ebp = ctx->Ebp;
  63         sctx->esp = ctx->Esp;
  64         sctx->esi = ctx->Esi;
  65         sctx->edi = ctx->Edi;
  66         sctx->eip = ctx->Eip;
  67
  68         switch (er->ExceptionCode) {
  69         case EXCEPTION_ACCESS_VIOLATION:
  70                 W32_SEH_HANDLE_EX(segv);
  71                 break;
  72         case EXCEPTION_ILLEGAL_INSTRUCTION:
  73                 W32_SEH_HANDLE_EX(ill);
  74                 break;
  75         case EXCEPTION_INT_DIVIDE_BY_ZERO:
  76         case EXCEPTION_INT_OVERFLOW:
  77         case EXCEPTION_FLT_DIVIDE_BY_ZERO:
  78         case EXCEPTION_FLT_OVERFLOW:
  79         case EXCEPTION_FLT_UNDERFLOW:
  80         case EXCEPTION_FLT_INEXACT_RESULT:
  81                 W32_SEH_HANDLE_EX(fpe);
  82                 break;
  83         default:
  84                 break;
  85         }
  86
  87         /* Copy context back */
  88         ctx->Eax = sctx->eax;
  89         ctx->Ebx = sctx->ebx;
  90         ctx->Ecx = sctx->ecx;
  91         ctx->Edx = sctx->edx;
  92         ctx->Ebp = sctx->ebp;
  93         ctx->Esp = sctx->esp;
  94         ctx->Esi = sctx->esi;
  95         ctx->Edi = sctx->edi;
  96         ctx->Eip = sctx->eip;
  97
  98         return res;
  99 }
 100
 101 void win32_seh_init()
 102 {
 103         old_handler = SetUnhandledExceptionFilter(seh_handler);
 104 }
 105
 106 void win32_seh_cleanup()
 107 {
 108         if (old_handler) SetUnhandledExceptionFilter(old_handler);
 109 }
 110
 111 void win32_seh_set_handler(int type, MonoW32ExceptionHandler handler)
 112 {
 113         switch (type) {
 114         case SIGFPE:
 115                 fpe_handler = handler;
 116                 break;
 117         case SIGILL:
 118                 ill_handler = handler;
 119                 break;
 120         case SIGSEGV:
 121                 segv_handler = handler;
 122                 break;
 123         default:
 124                 break;
 125         }
 126 }
 127
 128 #endif /* PLATFORM_WIN32 */
 129
 130 /*
 131  * mono_arch_get_restore_context:
 132  *
 133  * Returns a pointer to a method which restores a previously saved sigcontext.
 134  */
 135 gpointer
 136 mono_arch_get_restore_context (void)
 137 {
 138         static guint8 *start = NULL;
 139         static gboolean inited = FALSE;
 140         guint8 *code;
 141
 142         if (inited)
 143                 return start;
 144
 145         /* restore_contect (MonoContext *ctx) */
 146
 147         start = code = mono_global_codeman_reserve (256);
 148
 149         /* get return address */
 150         amd64_mov_reg_membase (code, AMD64_RAX, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, rip), 8);
 151
 152         /* Restore registers */
 153         amd64_mov_reg_membase (code, AMD64_RBP, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, rbp), 8);
 154         amd64_mov_reg_membase (code, AMD64_RBX, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, rbx), 8);
 155         amd64_mov_reg_membase (code, AMD64_R12, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, r12), 8);
 156         amd64_mov_reg_membase (code, AMD64_R13, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, r13), 8);
 157         amd64_mov_reg_membase (code, AMD64_R14, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, r14), 8);
 158         amd64_mov_reg_membase (code, AMD64_R15, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, r15), 8);
 159
 160         amd64_mov_reg_membase (code, AMD64_RSP, AMD64_RDI,  G_STRUCT_OFFSET (MonoContext, rsp), 8);
 161
 162         /* jump to the saved IP */
 163         amd64_jump_reg (code, AMD64_RAX);
 164
 165         inited = TRUE;
 166
 167         return start;
 168 }
 169
 170 /*
 171  * mono_arch_get_call_filter:
 172  *
 173  * Returns a pointer to a method which calls an exception filter. We
 174  * also use this function to call finally handlers (we pass NULL as
 175  * @exc object in this case).
 176  */
 177 gpointer
 178 mono_arch_get_call_filter (void)
 179 {
 180         static guint8 *start;
 181         static gboolean inited = FALSE;
 182         int i;
 183         guint8 *code;
 184         guint32 pos;
 185
 186         if (inited)
 187                 return start;
 188
 189         start = code = mono_global_codeman_reserve (64);
 190
 191         /* call_filter (MonoContext *ctx, unsigned long eip) */
 192         code = start;
 193
 194         /* Alloc new frame */
 195         amd64_push_reg (code, AMD64_RBP);
 196         amd64_mov_reg_reg (code, AMD64_RBP, AMD64_RSP, 8);
 197
 198         /* Save callee saved regs */
 199         pos = 0;
 200         for (i = 0; i < AMD64_NREG; ++i)
 201                 if (AMD64_IS_CALLEE_SAVED_REG (i)) {
 202                         amd64_push_reg (code, i);
 203                         pos += 8;
 204                 }
 205
 206         /* Save EBP */
 207         pos += 8;
 208         amd64_push_reg (code, AMD64_RBP);
 209
 210         /* Make stack misaligned, the call will make it aligned again */
 211         if (! (pos & 8))
 212                 amd64_alu_reg_imm (code, X86_SUB, AMD64_RSP, 8);
 213
 214         /* set new EBP */
 215         amd64_mov_reg_membase (code, AMD64_RBP, AMD64_RDI, G_STRUCT_OFFSET (MonoContext, rbp), 8);
 216         /* load callee saved regs */
 217         amd64_mov_reg_membase (code, AMD64_RBX, AMD64_RDI, G_STRUCT_OFFSET (MonoContext, rbx), 8);
 218         amd64_mov_reg_membase (code, AMD64_R12, AMD64_RDI, G_STRUCT_OFFSET (MonoContext, r12), 8);
 219         amd64_mov_reg_membase (code, AMD64_R13, AMD64_RDI, G_STRUCT_OFFSET (MonoContext, r13), 8);
 220         amd64_mov_reg_membase (code, AMD64_R14, AMD64_RDI, G_STRUCT_OFFSET (MonoContext, r14), 8);
 221         amd64_mov_reg_membase (code, AMD64_R15, AMD64_RDI, G_STRUCT_OFFSET (MonoContext, r15), 8);
 222
 223         /* call the handler */
 224         amd64_call_reg (code, AMD64_RSI);
 225
 226         if (! (pos & 8))
 227                 amd64_alu_reg_imm (code, X86_ADD, AMD64_RSP, 8);
 228
 229         /* restore RBP */
 230         amd64_pop_reg (code, AMD64_RBP);
 231
 232         /* Restore callee saved regs */
 233         for (i = AMD64_NREG; i >= 0; --i)
 234                 if (AMD64_IS_CALLEE_SAVED_REG (i))
 235                         amd64_pop_reg (code, i);
 236
 237         amd64_leave (code);
 238         amd64_ret (code);
 239
 240         g_assert ((code - start) < 64);
 241
 242         inited = TRUE;
 243
 244         return start;
 245 }
 246
 247 static void
 248 throw_exception (MonoObject *exc, guint64 rip, guint64 rsp,
 249                  guint64 rbx, guint64 rbp, guint64 r12, guint64 r13,
 250                  guint64 r14, guint64 r15, guint64 rethrow)
 251 {
 252         static void (*restore_context) (MonoContext *);
 253         MonoContext ctx;
 254
 255         if (!restore_context)
 256                 restore_context = mono_arch_get_restore_context ();
 257
 258         ctx.rsp = rsp;
 259         ctx.rip = rip;
 260         ctx.rbx = rbx;
 261         ctx.rbp = rbp;
 262         ctx.r12 = r12;
 263         ctx.r13 = r13;
 264         ctx.r14 = r14;
 265         ctx.r15 = r15;
 266
 267         if (mono_debugger_throw_exception ((gpointer)(rip - 8), (gpointer)rsp, exc)) {
 268                 /*
 269                  * The debugger wants us to stop on the `throw' instruction.
 270                  * By the time we get here, it already inserted a breakpoint on
 271                  * eip - 8 (which is the address of the `mov %r15,%rdi ; callq throw').
 272                  */
 273                 ctx.rip = rip - 8;
 274                 ctx.rsp = rsp + 8;
 275                 restore_context (&ctx);
 276                 g_assert_not_reached ();
 277         }
 278
 279         /* adjust eip so that it point into the call instruction */
 280         ctx.rip -= 1;
 281
 282         if (mono_object_isinst (exc, mono_defaults.exception_class)) {
 283                 MonoException *mono_ex = (MonoException*)exc;
 284                 if (!rethrow)
 285                         mono_ex->stack_trace = NULL;
 286         }
 287         mono_handle_exception (&ctx, exc, (gpointer)rip, FALSE);
 288         restore_context (&ctx);
 289
 290         g_assert_not_reached ();
 291 }
 292
 293 static gpointer
 294 get_throw_trampoline (gboolean rethrow)
 295 {
 296         guint8* start;
 297         guint8 *code;
 298
 299         start = code = mono_global_codeman_reserve (64);
 300
 301         code = start;
 302
 303         /* Exception */
 304         amd64_mov_reg_reg (code, AMD64_RDI, AMD64_RDI, 8);
 305         /* IP */
 306         amd64_mov_reg_membase (code, AMD64_RSI, AMD64_RSP, 0, 8);
 307         /* SP */
 308         amd64_lea_membase (code, AMD64_RDX, AMD64_RSP, 8);
 309         /* Callee saved regs */
 310         amd64_mov_reg_reg (code, AMD64_RCX, AMD64_RBX, 8);
 311         amd64_mov_reg_reg (code, AMD64_R8, AMD64_RBP, 8);
 312         amd64_mov_reg_reg (code, AMD64_R9, AMD64_R12, 8);
 313         /* align stack */
 314         amd64_push_imm (code, 0);
 315         /* reverse order */
 316         amd64_push_imm (code, rethrow);
 317         amd64_push_reg (code, AMD64_R15);
 318         amd64_push_reg (code, AMD64_R14);
 319         amd64_push_reg (code, AMD64_R13);
 320
 321         amd64_mov_reg_imm (code, AMD64_R11, throw_exception);
 322         amd64_call_reg (code, AMD64_R11);
 323         amd64_breakpoint (code);
 324
 325         g_assert ((code - start) < 64);
 326
 327         return start;
 328 }
 329
 330 /**
 331  * mono_arch_get_throw_exception:
 332  *
 333  * Returns a function pointer which can be used to raise
 334  * exceptions. The returned function has the following
 335  * signature: void (*func) (MonoException *exc);
 336  *
 337  */
 338 gpointer
 339 mono_arch_get_throw_exception (void)
 340 {
 341         static guint8* start;
 342         static gboolean inited = FALSE;
 343
 344         if (inited)
 345                 return start;
 346
 347         start = get_throw_trampoline (FALSE);
 348
 349         inited = TRUE;
 350
 351         return start;
 352 }
 353
 354 gpointer
 355 mono_arch_get_rethrow_exception (void)
 356 {
 357         static guint8* start;
 358         static gboolean inited = FALSE;
 359
 360         if (inited)
 361                 return start;
 362
 363         start = get_throw_trampoline (TRUE);
 364
 365         inited = TRUE;
 366
 367         return start;
 368 }
 369
 370 gpointer
 371 mono_arch_get_throw_exception_by_name (void)
 372 {
 373         static guint8* start;
 374         static gboolean inited = FALSE;
 375         guint8 *code;
 376
 377         if (inited)
 378                 return start;
 379
 380         start = code = mono_global_codeman_reserve (64);
 381
 382         /* Not used on amd64 */
 383         amd64_breakpoint (code);
 384
 385         return start;
 386 }
 387
 388 /**
 389  * mono_arch_get_throw_corlib_exception:
 390  *
 391  * Returns a function pointer which can be used to raise
 392  * corlib exceptions. The returned function has the following
 393  * signature: void (*func) (guint32 ex_token, guint32 offset);
 394  * Here, offset is the offset which needs to be substracted from the caller IP
 395  * to get the IP of the throw. Passing the offset has the advantage that it
 396  * needs no relocations in the caller.
 397  */
 398 gpointer
 399 mono_arch_get_throw_corlib_exception (void)
 400 {
 401         static guint8* start;
 402         static gboolean inited = FALSE;
 403         guint8 *code;
 404         guint64 throw_ex;
 405
 406         if (inited)
 407                 return start;
 408
 409         start = code = mono_global_codeman_reserve (64);
 410
 411         /* Push throw_ip */
 412         amd64_push_reg (code, AMD64_RSI);
 413
 414         /* Call exception_from_token */
 415         amd64_mov_reg_reg (code, AMD64_RSI, AMD64_RDI, 8);
 416         amd64_mov_reg_imm (code, AMD64_RDI, mono_defaults.exception_class->image);
 417         amd64_mov_reg_imm (code, AMD64_R11, mono_exception_from_token);
 418         amd64_call_reg (code, AMD64_R11);
 419
 420         /* Compute throw_ip */
 421         amd64_pop_reg (code, AMD64_RSI);
 422         /* return addr */
 423         amd64_pop_reg (code, AMD64_RDX);
 424         amd64_alu_reg_reg (code, X86_SUB, AMD64_RDX, AMD64_RSI);
 425
 426         /* Put the throw_ip at the top of the misaligned stack */
 427         amd64_push_reg (code, AMD64_RDX);
 428
 429         throw_ex = (guint64)mono_arch_get_throw_exception ();
 430
 431         /* Call throw_exception */
 432         amd64_mov_reg_reg (code, AMD64_RDI, AMD64_RAX, 8);
 433         amd64_mov_reg_imm (code, AMD64_R11, throw_ex);
 434         /* The original IP is on the stack */
 435         amd64_jump_reg (code, AMD64_R11);
 436
 437         g_assert ((code - start) < 64);
 438
 439         inited = TRUE;
 440
 441         return start;
 442 }
 443
 444 /* mono_arch_find_jit_info:
 445  *
 446  * This function is used to gather information from @ctx. It return the
 447  * MonoJitInfo of the corresponding function, unwinds one stack frame and
 448  * stores the resulting context into @new_ctx. It also stores a string
 449  * describing the stack location into @trace (if not NULL), and modifies
 450  * the @lmf if necessary. @native_offset return the IP offset from the
 451  * start of the function or -1 if that info is not available.
 452  */
 453 MonoJitInfo *
 454 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
 455                          MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset,
 456                          gboolean *managed)
 457 {
 458         MonoJitInfo *ji;
 459         int i;
 460         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 461
 462         /* Avoid costly table lookup during stack overflow */
 463         if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
 464                 ji = prev_ji;
 465         else
 466                 ji = mono_jit_info_table_find (domain, ip);
 467
 468         if (managed)
 469                 *managed = FALSE;
 470
 471         if (ji != NULL) {
 472                 int offset;
 473
 474                 *new_ctx = *ctx;
 475
 476                 if (managed)
 477                         if (!ji->method->wrapper_type)
 478                                 *managed = TRUE;
 479
 480                 /*
 481                  * Some managed methods like pinvoke wrappers might have save_lmf set.
 482                  * In this case, register save/restore code is not generated by the
 483                  * JIT, so we have to restore callee saved registers from the lmf.
 484                  */
 485                 if (ji->method->save_lmf) {
 486                         /*
 487                          * We only need to do this if the exception was raised in managed
 488                          * code, since otherwise the lmf was already popped of the stack.
 489                          */
 490                         if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
 491                                 new_ctx->rbx = (*lmf)->rbx;
 492                                 new_ctx->r12 = (*lmf)->r12;
 493                                 new_ctx->r13 = (*lmf)->r13;
 494                                 new_ctx->r14 = (*lmf)->r14;
 495                                 new_ctx->r15 = (*lmf)->r15;
 496                         }
 497                 }
 498                 else {
 499                         offset = -1;
 500                         /* restore caller saved registers */
 501                         for (i = 0; i < AMD64_NREG; i ++)
 502                                 if (AMD64_IS_CALLEE_SAVED_REG (i) && (ji->used_regs & (1 << i))) {
 503                                         guint64 reg = *((guint64 *)ctx->SC_EBP + offset);
 504                                         offset --;
 505                                         switch (i) {
 506                                         case AMD64_RBX:
 507                                                 new_ctx->rbx = reg;
 508                                                 break;
 509                                         case AMD64_R12:
 510                                                 new_ctx->r12 = reg;
 511                                                 break;
 512                                         case AMD64_R13:
 513                                                 new_ctx->r13 = reg;
 514                                                 break;
 515                                         case AMD64_R14:
 516                                                 new_ctx->r14 = reg;
 517                                                 break;
 518                                         case AMD64_R15:
 519                                                 new_ctx->r15 = reg;
 520                                                 break;
 521                                         default:
 522                                                 g_assert_not_reached ();
 523                                         }
 524                                 }
 525                 }
 526
 527                 if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
 528                         /* remove any unused lmf */
 529                         *lmf = (*lmf)->previous_lmf;
 530                 }
 531
 532                 /* Pop EBP and the return address */
 533                 new_ctx->SC_ESP = ctx->SC_EBP + (2 * sizeof (gpointer));
 534                 /* we substract 1, so that the IP points into the call instruction */
 535                 new_ctx->SC_EIP = *((guint64 *)ctx->SC_EBP + 1) - 1;
 536                 new_ctx->SC_EBP = *((guint64 *)ctx->SC_EBP);
 537
 538                 /* Pop arguments off the stack */
 539                 {
 540                         MonoJitArgumentInfo *arg_info = g_newa (MonoJitArgumentInfo, mono_method_signature (ji->method)->param_count + 1);
 541
 542                         guint32 stack_to_pop = mono_arch_get_argument_info (mono_method_signature (ji->method), mono_method_signature (ji->method)->param_count, arg_info);
 543                         new_ctx->SC_ESP += stack_to_pop;
 544                 }
 545
 546                 return ji;
 547         } else if (*lmf) {
 548
 549                 *new_ctx = *ctx;
 550
 551                 if (!(*lmf)->method)
 552                         return (gpointer)-1;
 553
 554                 if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->rip))) {
 555                 } else {
 556                         memset (res, 0, sizeof (MonoJitInfo));
 557                         res->method = (*lmf)->method;
 558                 }
 559
 560                 new_ctx->SC_RIP = (*lmf)->rip;
 561                 new_ctx->SC_RBP = (*lmf)->ebp;
 562
 563                 new_ctx->SC_RBX = (*lmf)->rbx;
 564                 new_ctx->SC_R12 = (*lmf)->r12;
 565                 new_ctx->SC_R13 = (*lmf)->r13;
 566                 new_ctx->SC_R14 = (*lmf)->r14;
 567                 new_ctx->SC_R15 = (*lmf)->r15;
 568
 569                 /* the lmf is always stored on the stack, so the following
 570                  * expression points to a stack location which can be used as ESP */
 571                 new_ctx->SC_ESP = ALIGN_TO ((guint64)&((*lmf)->rip), 16);
 572
 573                 *lmf = (*lmf)->previous_lmf;
 574
 575                 return ji ? ji : res;
 576         }
 577
 578         return NULL;
 579 }
 580
 581 /**
 582  * mono_arch_handle_exception:
 583  *
 584  * @ctx: saved processor state
 585  * @obj: the exception object
 586  */
 587 gboolean
 588 mono_arch_handle_exception (void *sigctx, gpointer obj, gboolean test_only)
 589 {
 590         ucontext_t *ctx = (ucontext_t*)sigctx;
 591         MonoContext mctx;
 592
 593         mctx.rax = ctx->uc_mcontext.gregs [REG_RAX];
 594         mctx.rbx = ctx->uc_mcontext.gregs [REG_RBX];
 595         mctx.rcx = ctx->uc_mcontext.gregs [REG_RCX];
 596         mctx.rdx = ctx->uc_mcontext.gregs [REG_RDX];
 597         mctx.rbp = ctx->uc_mcontext.gregs [REG_RBP];
 598         mctx.rsp = ctx->uc_mcontext.gregs [REG_RSP];
 599         mctx.rsi = ctx->uc_mcontext.gregs [REG_RSI];
 600         mctx.rdi = ctx->uc_mcontext.gregs [REG_RDI];
 601         mctx.rip = ctx->uc_mcontext.gregs [REG_RIP];
 602         mctx.r12 = ctx->uc_mcontext.gregs [REG_R12];
 603         mctx.r13 = ctx->uc_mcontext.gregs [REG_R13];
 604         mctx.r14 = ctx->uc_mcontext.gregs [REG_R14];
 605         mctx.r15 = ctx->uc_mcontext.gregs [REG_R15];
 606
 607         mono_handle_exception (&mctx, obj, (gpointer)mctx.rip, test_only);
 608
 609         ctx->uc_mcontext.gregs [REG_RAX] = mctx.rax;
 610         ctx->uc_mcontext.gregs [REG_RBX] = mctx.rbx;
 611         ctx->uc_mcontext.gregs [REG_RCX] = mctx.rcx;
 612         ctx->uc_mcontext.gregs [REG_RDX] = mctx.rdx;
 613         ctx->uc_mcontext.gregs [REG_RBP] = mctx.rbp;
 614         ctx->uc_mcontext.gregs [REG_RSP] = mctx.rsp;
 615         ctx->uc_mcontext.gregs [REG_RSI] = mctx.rsi;
 616         ctx->uc_mcontext.gregs [REG_RDI] = mctx.rdi;
 617         ctx->uc_mcontext.gregs [REG_RIP] = mctx.rip;
 618         ctx->uc_mcontext.gregs [REG_R12] = mctx.r12;
 619         ctx->uc_mcontext.gregs [REG_R13] = mctx.r13;
 620         ctx->uc_mcontext.gregs [REG_R14] = mctx.r14;
 621         ctx->uc_mcontext.gregs [REG_R15] = mctx.r15;
 622
 623         return TRUE;
 624 }
 625
 626 gpointer
 627 mono_arch_ip_from_context (void *sigctx)
 628 {
 629         ucontext_t *ctx = (ucontext_t*)sigctx;
 630         return (gpointer)ctx->uc_mcontext.gregs [REG_RIP];
 631 }
 632