mono/utils/mono-context.c

   1 /**
   2  * \file
   3  * plat independent machine state definitions
   4  *
   5  *
   6  * Copyright (c) 2011 Novell, Inc (http://www.novell.com)
   7  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   8  */
   9
  10 #include <mono/utils/mono-sigcontext.h>
  11
  12 #ifdef HAVE_UCONTEXT_H
  13 #include <ucontext.h>
  14 #endif
  15
  16 #if (defined(__i386__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_X86))
  17
  18 #include <mono/utils/mono-context.h>
  19
  20 #ifdef HOST_WIN32
  21 #include <windows.h>
  22 #endif
  23
  24 #ifdef __sun
  25 #define REG_EAX EAX
  26 #define REG_EBX EBX
  27 #define REG_ECX ECX
  28 #define REG_EDX EDX
  29 #define REG_EBP EBP
  30 #define REG_ESP ESP
  31 #define REG_ESI ESI
  32 #define REG_EDI EDI
  33 #define REG_EIP EIP
  34 #endif
  35
  36 void
  37 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
  38 {
  39 #if defined (HOST_WATCHOS)
  40         printf("WARNING: mono_arch_sigctx_to_monoctx() called!\n");
  41         mctx->eax = 0xDEADBEEF;
  42         mctx->ebx = 0xDEADBEEF;
  43         mctx->ecx = 0xDEADBEEF;
  44         mctx->edx = 0xDEADBEEF;
  45         mctx->ebp = 0xDEADBEEF;
  46         mctx->esp = 0xDEADBEEF;
  47         mctx->esi = 0xDEADBEEF;
  48         mctx->edi = 0xDEADBEEF;
  49         mctx->eip = 0xDEADBEEF;
  50 #elif MONO_CROSS_COMPILE
  51         g_assert_not_reached ();
  52 #elif defined(MONO_SIGNAL_USE_UCONTEXT_T)
  53         ucontext_t *ctx = (ucontext_t*)sigctx;
  54
  55         mctx->eax = UCONTEXT_REG_EAX (ctx);
  56         mctx->ebx = UCONTEXT_REG_EBX (ctx);
  57         mctx->ecx = UCONTEXT_REG_ECX (ctx);
  58         mctx->edx = UCONTEXT_REG_EDX (ctx);
  59         mctx->ebp = UCONTEXT_REG_EBP (ctx);
  60         mctx->esp = UCONTEXT_REG_ESP (ctx);
  61         mctx->esi = UCONTEXT_REG_ESI (ctx);
  62         mctx->edi = UCONTEXT_REG_EDI (ctx);
  63         mctx->eip = UCONTEXT_REG_EIP (ctx);
  64 #ifdef UCONTEXT_HAS_XMM
  65         if (UCONTEXT_HAS_XMM (ctx)) {
  66                 mctx->fregs [0] = UCONTEXT_REG_XMM0 (ctx);
  67                 mctx->fregs [1] = UCONTEXT_REG_XMM1 (ctx);
  68                 mctx->fregs [2] = UCONTEXT_REG_XMM2 (ctx);
  69                 mctx->fregs [3] = UCONTEXT_REG_XMM3 (ctx);
  70                 mctx->fregs [4] = UCONTEXT_REG_XMM4 (ctx);
  71                 mctx->fregs [5] = UCONTEXT_REG_XMM5 (ctx);
  72                 mctx->fregs [6] = UCONTEXT_REG_XMM6 (ctx);
  73                 mctx->fregs [7] = UCONTEXT_REG_XMM7 (ctx);
  74         }
  75 #endif
  76 #elif defined(HOST_WIN32)
  77         CONTEXT *context = (CONTEXT*)sigctx;
  78
  79         mctx->eip = context->Eip;
  80         mctx->edi = context->Edi;
  81         mctx->esi = context->Esi;
  82         mctx->ebx = context->Ebx;
  83         mctx->edx = context->Edx;
  84         mctx->ecx = context->Ecx;
  85         mctx->eax = context->Eax;
  86         mctx->ebp = context->Ebp;
  87         mctx->esp = context->Esp;
  88 #else
  89         struct sigcontext *ctx = (struct sigcontext *)sigctx;
  90
  91         mctx->eax = ctx->SC_EAX;
  92         mctx->ebx = ctx->SC_EBX;
  93         mctx->ecx = ctx->SC_ECX;
  94         mctx->edx = ctx->SC_EDX;
  95         mctx->ebp = ctx->SC_EBP;
  96         mctx->esp = ctx->SC_ESP;
  97         mctx->esi = ctx->SC_ESI;
  98         mctx->edi = ctx->SC_EDI;
  99         mctx->eip = ctx->SC_EIP;
 100 #endif
 101 }
 102
 103 void
 104 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 105 {
 106 #if defined(HOST_WATCHOS)
 107         printf("WARNING: mono_arch_monoctx_to_sigctx() called!\n");
 108 #elif MONO_CROSS_COMPILE
 109         g_assert_not_reached ();
 110 #elif defined(MONO_SIGNAL_USE_UCONTEXT_T)
 111         ucontext_t *ctx = (ucontext_t*)sigctx;
 112
 113         UCONTEXT_REG_EAX (ctx) = mctx->eax;
 114         UCONTEXT_REG_EBX (ctx) = mctx->ebx;
 115         UCONTEXT_REG_ECX (ctx) = mctx->ecx;
 116         UCONTEXT_REG_EDX (ctx) = mctx->edx;
 117         UCONTEXT_REG_EBP (ctx) = mctx->ebp;
 118         UCONTEXT_REG_ESP (ctx) = mctx->esp;
 119         UCONTEXT_REG_ESI (ctx) = mctx->esi;
 120         UCONTEXT_REG_EDI (ctx) = mctx->edi;
 121         UCONTEXT_REG_EIP (ctx) = mctx->eip;
 122 #ifdef UCONTEXT_HAS_XMM
 123         if (UCONTEXT_HAS_XMM (ctx)) {
 124                 UCONTEXT_REG_XMM0 (ctx) = mctx->fregs [0];
 125                 UCONTEXT_REG_XMM1 (ctx) = mctx->fregs [1];
 126                 UCONTEXT_REG_XMM2 (ctx) = mctx->fregs [2];
 127                 UCONTEXT_REG_XMM3 (ctx) = mctx->fregs [3];
 128                 UCONTEXT_REG_XMM4 (ctx) = mctx->fregs [4];
 129                 UCONTEXT_REG_XMM5 (ctx) = mctx->fregs [5];
 130                 UCONTEXT_REG_XMM6 (ctx) = mctx->fregs [6];
 131                 UCONTEXT_REG_XMM7 (ctx) = mctx->fregs [7];
 132         }
 133 #endif
 134 #elif defined(HOST_WIN32)
 135         CONTEXT *context = (CONTEXT*)sigctx;
 136
 137         context->Eip = mctx->eip;
 138         context->Edi = mctx->edi;
 139         context->Esi = mctx->esi;
 140         context->Ebx = mctx->ebx;
 141         context->Edx = mctx->edx;
 142         context->Ecx = mctx->ecx;
 143         context->Eax = mctx->eax;
 144         context->Ebp = mctx->ebp;
 145         context->Esp = mctx->esp;
 146 #else
 147         struct sigcontext *ctx = (struct sigcontext *)sigctx;
 148
 149         ctx->SC_EAX = mctx->eax;
 150         ctx->SC_EBX = mctx->ebx;
 151         ctx->SC_ECX = mctx->ecx;
 152         ctx->SC_EDX = mctx->edx;
 153         ctx->SC_EBP = mctx->ebp;
 154         ctx->SC_ESP = mctx->esp;
 155         ctx->SC_ESI = mctx->esi;
 156         ctx->SC_EDI = mctx->edi;
 157         ctx->SC_EIP = mctx->eip;
 158 #endif
 159 }
 160
 161 #elif (defined(__x86_64__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_AMD64)) /* defined(__i386__) */
 162
 163 #include <mono/utils/mono-context.h>
 164
 165 #ifdef HOST_WIN32
 166 #include <windows.h>
 167 #endif
 168
 169 void
 170 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 171 {
 172 #ifdef MONO_CROSS_COMPILE
 173         g_assert_not_reached ();
 174 #elif defined(MONO_SIGNAL_USE_UCONTEXT_T)
 175         ucontext_t *ctx = (ucontext_t*)sigctx;
 176
 177         mctx->gregs [AMD64_RAX] = UCONTEXT_REG_RAX (ctx);
 178         mctx->gregs [AMD64_RBX] = UCONTEXT_REG_RBX (ctx);
 179         mctx->gregs [AMD64_RCX] = UCONTEXT_REG_RCX (ctx);
 180         mctx->gregs [AMD64_RDX] = UCONTEXT_REG_RDX (ctx);
 181         mctx->gregs [AMD64_RBP] = UCONTEXT_REG_RBP (ctx);
 182         mctx->gregs [AMD64_RSP] = UCONTEXT_REG_RSP (ctx);
 183         mctx->gregs [AMD64_RSI] = UCONTEXT_REG_RSI (ctx);
 184         mctx->gregs [AMD64_RDI] = UCONTEXT_REG_RDI (ctx);
 185         mctx->gregs [AMD64_R8] = UCONTEXT_REG_R8 (ctx);
 186         mctx->gregs [AMD64_R9] = UCONTEXT_REG_R9 (ctx);
 187         mctx->gregs [AMD64_R10] = UCONTEXT_REG_R10 (ctx);
 188         mctx->gregs [AMD64_R11] = UCONTEXT_REG_R11 (ctx);
 189         mctx->gregs [AMD64_R12] = UCONTEXT_REG_R12 (ctx);
 190         mctx->gregs [AMD64_R13] = UCONTEXT_REG_R13 (ctx);
 191         mctx->gregs [AMD64_R14] = UCONTEXT_REG_R14 (ctx);
 192         mctx->gregs [AMD64_R15] = UCONTEXT_REG_R15 (ctx);
 193         mctx->gregs [AMD64_RIP] = UCONTEXT_REG_RIP (ctx);
 194
 195 #ifdef UCONTEXT_HAS_XMM
 196         if (UCONTEXT_HAS_XMM (ctx)) {
 197                 mctx->fregs [0] = UCONTEXT_REG_XMM0 (ctx);
 198                 mctx->fregs [1] = UCONTEXT_REG_XMM1 (ctx);
 199                 mctx->fregs [2] = UCONTEXT_REG_XMM2 (ctx);
 200                 mctx->fregs [3] = UCONTEXT_REG_XMM3 (ctx);
 201                 mctx->fregs [4] = UCONTEXT_REG_XMM4 (ctx);
 202                 mctx->fregs [5] = UCONTEXT_REG_XMM5 (ctx);
 203                 mctx->fregs [6] = UCONTEXT_REG_XMM6 (ctx);
 204                 mctx->fregs [7] = UCONTEXT_REG_XMM7 (ctx);
 205                 mctx->fregs [8] = UCONTEXT_REG_XMM8 (ctx);
 206                 mctx->fregs [9] = UCONTEXT_REG_XMM9 (ctx);
 207                 mctx->fregs [10] = UCONTEXT_REG_XMM10 (ctx);
 208                 mctx->fregs [11] = UCONTEXT_REG_XMM11 (ctx);
 209                 mctx->fregs [12] = UCONTEXT_REG_XMM12 (ctx);
 210                 mctx->fregs [13] = UCONTEXT_REG_XMM13 (ctx);
 211                 mctx->fregs [14] = UCONTEXT_REG_XMM14 (ctx);
 212                 mctx->fregs [15] = UCONTEXT_REG_XMM15 (ctx);
 213         }
 214 #endif
 215
 216 #elif defined(HOST_WIN32)
 217         CONTEXT *context = (CONTEXT*)sigctx;
 218
 219         mctx->gregs [AMD64_RIP] = context->Rip;
 220         mctx->gregs [AMD64_RAX] = context->Rax;
 221         mctx->gregs [AMD64_RCX] = context->Rcx;
 222         mctx->gregs [AMD64_RDX] = context->Rdx;
 223         mctx->gregs [AMD64_RBX] = context->Rbx;
 224         mctx->gregs [AMD64_RSP] = context->Rsp;
 225         mctx->gregs [AMD64_RBP] = context->Rbp;
 226         mctx->gregs [AMD64_RSI] = context->Rsi;
 227         mctx->gregs [AMD64_RDI] = context->Rdi;
 228         mctx->gregs [AMD64_R8] = context->R8;
 229         mctx->gregs [AMD64_R9] = context->R9;
 230         mctx->gregs [AMD64_R10] = context->R10;
 231         mctx->gregs [AMD64_R11] = context->R11;
 232         mctx->gregs [AMD64_R12] = context->R12;
 233         mctx->gregs [AMD64_R13] = context->R13;
 234         mctx->gregs [AMD64_R14] = context->R14;
 235         mctx->gregs [AMD64_R15] = context->R15;
 236 #elif defined(__HAIKU__)
 237         // Haiku uses sigcontext because there's no ucontext
 238         struct sigcontext *ctx = (struct sigcontext *)sigctx;
 239
 240         mctx->gregs [AMD64_RIP] = ctx->regs.rip;
 241         mctx->gregs [AMD64_RAX] = ctx->regs.rax;
 242         mctx->gregs [AMD64_RCX] = ctx->regs.rcx;
 243         mctx->gregs [AMD64_RDX] = ctx->regs.rdx;
 244         mctx->gregs [AMD64_RBX] = ctx->regs.rbx;
 245         mctx->gregs [AMD64_RSP] = ctx->regs.rsp;
 246         mctx->gregs [AMD64_RBP] = ctx->regs.rbp;
 247         mctx->gregs [AMD64_RSI] = ctx->regs.rsi;
 248         mctx->gregs [AMD64_RDI] = ctx->regs.rdi;
 249         mctx->gregs [AMD64_R8] = ctx->regs.r8;
 250         mctx->gregs [AMD64_R9] = ctx->regs.r9;
 251         mctx->gregs [AMD64_R10] = ctx->regs.r10;
 252         mctx->gregs [AMD64_R11] = ctx->regs.r11;
 253         mctx->gregs [AMD64_R12] = ctx->regs.r12;
 254         mctx->gregs [AMD64_R13] = ctx->regs.r13;
 255         mctx->gregs [AMD64_R14] = ctx->regs.r14;
 256         mctx->gregs [AMD64_R15] = ctx->regs.r15;
 257 #else
 258         g_assert_not_reached ();
 259 #endif
 260 }
 261
 262 void
 263 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 264 {
 265 #ifdef MONO_CROSS_COMPILE
 266         g_assert_not_reached ();
 267 #elif defined(MONO_SIGNAL_USE_UCONTEXT_T)
 268         ucontext_t *ctx = (ucontext_t*)sigctx;
 269
 270         UCONTEXT_REG_RAX (ctx) = mctx->gregs [AMD64_RAX];
 271         UCONTEXT_REG_RBX (ctx) = mctx->gregs [AMD64_RBX];
 272         UCONTEXT_REG_RCX (ctx) = mctx->gregs [AMD64_RCX];
 273         UCONTEXT_REG_RDX (ctx) = mctx->gregs [AMD64_RDX];
 274         UCONTEXT_REG_RBP (ctx) = mctx->gregs [AMD64_RBP];
 275         UCONTEXT_REG_RSP (ctx) = mctx->gregs [AMD64_RSP];
 276         UCONTEXT_REG_RSI (ctx) = mctx->gregs [AMD64_RSI];
 277         UCONTEXT_REG_RDI (ctx) = mctx->gregs [AMD64_RDI];
 278         UCONTEXT_REG_R8 (ctx) = mctx->gregs [AMD64_R8];
 279         UCONTEXT_REG_R9 (ctx) = mctx->gregs [AMD64_R9];
 280         UCONTEXT_REG_R10 (ctx) = mctx->gregs [AMD64_R10];
 281         UCONTEXT_REG_R11 (ctx) = mctx->gregs [AMD64_R11];
 282         UCONTEXT_REG_R12 (ctx) = mctx->gregs [AMD64_R12];
 283         UCONTEXT_REG_R13 (ctx) = mctx->gregs [AMD64_R13];
 284         UCONTEXT_REG_R14 (ctx) = mctx->gregs [AMD64_R14];
 285         UCONTEXT_REG_R15 (ctx) = mctx->gregs [AMD64_R15];
 286         UCONTEXT_REG_RIP (ctx) = mctx->gregs [AMD64_RIP];
 287
 288 #ifdef UCONTEXT_HAS_XMM
 289         if (UCONTEXT_HAS_XMM (ctx)) {
 290                 UCONTEXT_REG_XMM0 (ctx) = mctx->fregs [0];
 291                 UCONTEXT_REG_XMM1 (ctx) = mctx->fregs [1];
 292                 UCONTEXT_REG_XMM2 (ctx) = mctx->fregs [2];
 293                 UCONTEXT_REG_XMM3 (ctx) = mctx->fregs [3];
 294                 UCONTEXT_REG_XMM4 (ctx) = mctx->fregs [4];
 295                 UCONTEXT_REG_XMM5 (ctx) = mctx->fregs [5];
 296                 UCONTEXT_REG_XMM6 (ctx) = mctx->fregs [6];
 297                 UCONTEXT_REG_XMM7 (ctx) = mctx->fregs [7];
 298                 UCONTEXT_REG_XMM8 (ctx) = mctx->fregs [8];
 299                 UCONTEXT_REG_XMM9 (ctx) = mctx->fregs [9];
 300                 UCONTEXT_REG_XMM10 (ctx) = mctx->fregs [10];
 301                 UCONTEXT_REG_XMM11 (ctx) = mctx->fregs [11];
 302                 UCONTEXT_REG_XMM12 (ctx) = mctx->fregs [12];
 303                 UCONTEXT_REG_XMM13 (ctx) = mctx->fregs [13];
 304                 UCONTEXT_REG_XMM14 (ctx) = mctx->fregs [14];
 305                 UCONTEXT_REG_XMM15 (ctx) = mctx->fregs [15];
 306         }
 307 #endif
 308
 309 #elif defined(HOST_WIN32)
 310         CONTEXT *context = (CONTEXT*)sigctx;
 311
 312         context->Rip = mctx->gregs [AMD64_RIP];
 313         context->Rax = mctx->gregs [AMD64_RAX];
 314         context->Rcx = mctx->gregs [AMD64_RCX];
 315         context->Rdx = mctx->gregs [AMD64_RDX];
 316         context->Rbx = mctx->gregs [AMD64_RBX];
 317         context->Rsp = mctx->gregs [AMD64_RSP];
 318         context->Rbp = mctx->gregs [AMD64_RBP];
 319         context->Rsi = mctx->gregs [AMD64_RSI];
 320         context->Rdi = mctx->gregs [AMD64_RDI];
 321         context->R8 = mctx->gregs [AMD64_R8];
 322         context->R9 = mctx->gregs [AMD64_R9];
 323         context->R10 = mctx->gregs [AMD64_R10];
 324         context->R11 = mctx->gregs [AMD64_R11];
 325         context->R12 = mctx->gregs [AMD64_R12];
 326         context->R13 = mctx->gregs [AMD64_R13];
 327         context->R14 = mctx->gregs [AMD64_R14];
 328         context->R15 = mctx->gregs [AMD64_R15];
 329 #elif defined(__HAIKU__)
 330         // Haiku uses sigcontext because there's no ucontext
 331         struct sigcontext *ctx = (struct sigcontext *)sigctx;
 332
 333         ctx->regs.rip = mctx->gregs [AMD64_RIP];
 334         ctx->regs.rax = mctx->gregs [AMD64_RAX];
 335         ctx->regs.rcx = mctx->gregs [AMD64_RCX];
 336         ctx->regs.rdx = mctx->gregs [AMD64_RDX];
 337         ctx->regs.rbx = mctx->gregs [AMD64_RBX];
 338         ctx->regs.rsp = mctx->gregs [AMD64_RSP];
 339         ctx->regs.rbp = mctx->gregs [AMD64_RBP];
 340         ctx->regs.rsi = mctx->gregs [AMD64_RSI];
 341         ctx->regs.rdi = mctx->gregs [AMD64_RDI];
 342         ctx->regs.r8 = mctx->gregs [AMD64_R8];
 343         ctx->regs.r9 = mctx->gregs [AMD64_R9];
 344         ctx->regs.r10 = mctx->gregs [AMD64_R10];
 345         ctx->regs.r11 = mctx->gregs [AMD64_R11];
 346         ctx->regs.r12 = mctx->gregs [AMD64_R12];
 347         ctx->regs.r13 = mctx->gregs [AMD64_R13];
 348         ctx->regs.r14 = mctx->gregs [AMD64_R14];
 349         ctx->regs.r15 = mctx->gregs [AMD64_R15];
 350 #else
 351         g_assert_not_reached ();
 352 #endif
 353 }
 354
 355 #elif defined(__s390x__)
 356
 357 #include <mono/utils/mono-context.h>
 358
 359 /*------------------------------------------------------------------*/
 360 /*                                                                  */
 361 /* Name         - mono_arch_sigctx_to_monoctx.                      */
 362 /*                                                                  */
 363 /* Function     - Called from the signal handler to convert signal  */
 364 /*                context to MonoContext.                           */
 365 /*                                                                  */
 366 /*------------------------------------------------------------------*/
 367
 368 void
 369 mono_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
 370 {
 371         memcpy (mctx, ctx, sizeof(MonoContext));
 372 }
 373
 374 /*========================= End of Function ========================*/
 375
 376 /*------------------------------------------------------------------*/
 377 /*                                                                  */
 378 /* Name         - mono_arch_monoctx_to_sigctx.                      */
 379 /*                                                                  */
 380 /* Function     - Convert MonoContext structure to signal context.  */
 381 /*                                                                  */
 382 /*------------------------------------------------------------------*/
 383
 384 void
 385 mono_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
 386 {
 387         memcpy (ctx, mctx, sizeof(MonoContext));
 388 }
 389
 390 /*========================= End of Function ========================*/
 391
 392 #elif (defined(__arm__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_ARM))
 393
 394 #include <mono/utils/mono-context.h>
 395 #include <mono/arch/arm/arm-codegen.h>
 396 #include <mono/arch/arm/arm-vfp-codegen.h>
 397
 398 #ifdef HOST_WIN32
 399 #include <windows.h>
 400 #endif
 401
 402 void
 403 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 404 {
 405 #ifdef MONO_CROSS_COMPILE
 406         g_assert_not_reached ();
 407 #elif defined(HOST_WIN32)
 408         CONTEXT *context = (CONTEXT*)sigctx;
 409
 410         mctx->pc = context->Pc;
 411         mctx->cpsr = context->Cpsr;
 412         memcpy (&mctx->regs, &context->R0, sizeof (DWORD) * 16);
 413
 414         /* Why are we only copying 16 registers?! There are 32! */
 415         memcpy (&mctx->fregs, &context->D, sizeof (double) * 16);
 416 #else
 417         arm_ucontext *my_uc = (arm_ucontext*)sigctx;
 418
 419         mctx->pc = UCONTEXT_REG_PC (my_uc);
 420         mctx->regs [ARMREG_SP] = UCONTEXT_REG_SP (my_uc);
 421         mctx->cpsr = UCONTEXT_REG_CPSR (my_uc);
 422         memcpy (&mctx->regs, &UCONTEXT_REG_R0 (my_uc), sizeof (host_mgreg_t) * 16);
 423 #ifdef UCONTEXT_REG_VFPREGS
 424         memcpy (&mctx->fregs, UCONTEXT_REG_VFPREGS (my_uc), sizeof (double) * 16);
 425 #endif
 426 #endif
 427 }
 428
 429 void
 430 mono_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
 431 {
 432 #ifdef MONO_CROSS_COMPILE
 433         g_assert_not_reached ();
 434 #elif defined(HOST_WIN32)
 435         CONTEXT *context = (CONTEXT*)ctx;
 436
 437         context->Pc = mctx->pc;
 438         context->Cpsr = mctx->cpsr;
 439         memcpy (&context->R0, &mctx->regs, sizeof (DWORD) * 16);
 440
 441         /* Why are we only copying 16 registers?! There are 32! */
 442         memcpy (&context->D, &mctx->fregs, sizeof (double) * 16);
 443 #else
 444         arm_ucontext *my_uc = (arm_ucontext*)ctx;
 445
 446         UCONTEXT_REG_PC (my_uc) = mctx->pc;
 447         UCONTEXT_REG_SP (my_uc) = mctx->regs [ARMREG_SP];
 448         UCONTEXT_REG_CPSR (my_uc) = mctx->cpsr;
 449         /* The upper registers are not guaranteed to be valid */
 450         memcpy (&UCONTEXT_REG_R0 (my_uc), &mctx->regs, sizeof (host_mgreg_t) * 12);
 451 #ifdef UCONTEXT_REG_VFPREGS
 452         memcpy (UCONTEXT_REG_VFPREGS (my_uc), &mctx->fregs, sizeof (double) * 16);
 453 #endif
 454 #endif
 455 }
 456
 457 #elif (defined(__aarch64__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_ARM64))
 458
 459 #include <mono/utils/mono-context.h>
 460
 461 void
 462 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 463 {
 464 #ifdef MONO_CROSS_COMPILE
 465         g_assert_not_reached ();
 466 #else
 467         memcpy (mctx->regs, UCONTEXT_GREGS (sigctx), sizeof (host_mgreg_t) * 31);
 468         mctx->pc = UCONTEXT_REG_PC (sigctx);
 469         mctx->regs [ARMREG_SP] = UCONTEXT_REG_SP (sigctx);
 470 #ifdef __linux__
 471         struct fpsimd_context *fpctx = (struct fpsimd_context*)&((ucontext_t*)sigctx)->uc_mcontext.__reserved;
 472         int i;
 473
 474         g_assert (fpctx->head.magic == FPSIMD_MAGIC);
 475         for (i = 0; i < 32; ++i)
 476                 mctx->fregs [i] = fpctx->vregs [i];
 477 #endif
 478         /* FIXME: apple */
 479 #endif
 480 }
 481
 482 void
 483 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 484 {
 485 #ifdef MONO_CROSS_COMPILE
 486         g_assert_not_reached ();
 487 #else
 488         memcpy (UCONTEXT_GREGS (sigctx), mctx->regs, sizeof (host_mgreg_t) * 31);
 489         UCONTEXT_REG_PC (sigctx) = mctx->pc;
 490         UCONTEXT_REG_SP (sigctx) = mctx->regs [ARMREG_SP];
 491 #endif
 492 }
 493
 494 #elif (defined(__mips__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_MIPS))
 495
 496 #include <mono/utils/mono-context.h>
 497 #include <mono/arch/mips/mips-codegen.h>
 498
 499 void
 500 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 501 {
 502         int i;
 503
 504         mctx->sc_pc = UCONTEXT_REG_PC (sigctx);
 505         for (i = 0; i < 32; ++i) {
 506                 mctx->sc_regs[i] = UCONTEXT_GREGS (sigctx) [i];
 507                 mctx->sc_fpregs[i] = UCONTEXT_FPREGS (sigctx) [i];
 508         }
 509 }
 510
 511 void
 512 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 513 {
 514         int i;
 515
 516         UCONTEXT_REG_PC (sigctx) = mctx->sc_pc;
 517         for (i = 0; i < 32; ++i) {
 518                 UCONTEXT_GREGS (sigctx) [i] = mctx->sc_regs[i];
 519                 UCONTEXT_FPREGS (sigctx) [i] = mctx->sc_fpregs[i];
 520         }
 521 }
 522
 523 #elif (((defined(__ppc__) || defined(__powerpc__) || defined(__ppc64__)) && !defined(MONO_CROSS_COMPILE))) || (defined(TARGET_POWERPC))
 524
 525 #include <mono/utils/mono-context.h>
 526 #include <mono/mini/mini-ppc.h>
 527
 528 void
 529 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 530 {
 531         os_ucontext *uc = sigctx;
 532
 533         mctx->sc_ir = UCONTEXT_REG_NIP(uc);
 534         mctx->sc_sp = UCONTEXT_REG_Rn(uc, 1);
 535
 536         memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 0), sizeof (host_mgreg_t) * MONO_MAX_IREGS);
 537         memcpy (&mctx->fregs, &UCONTEXT_REG_FPRn(uc, 0), sizeof (double) * MONO_MAX_FREGS);
 538 }
 539
 540 void
 541 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 542 {
 543         os_ucontext *uc = sigctx;
 544
 545         memcpy (&UCONTEXT_REG_Rn(uc, 0), &mctx->regs, sizeof (host_mgreg_t) * MONO_MAX_IREGS);
 546         memcpy (&UCONTEXT_REG_FPRn(uc, 0), &mctx->fregs, sizeof (double) * MONO_MAX_FREGS);
 547
 548         /* The valid values for pc and sp are stored here and not in regs array */
 549         UCONTEXT_REG_NIP(uc) = mctx->sc_ir;
 550         UCONTEXT_REG_Rn(uc, 1) = mctx->sc_sp;
 551 }
 552
 553 #elif defined (TARGET_WASM)
 554
 555 #include <mono/utils/mono-context.h>
 556
 557 void
 558 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 559 {
 560         g_error ("MonoContext not supported");
 561 }
 562
 563 void
 564 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 565 {
 566         g_error ("MonoContext not supported");
 567 }
 568
 569 #elif ((defined (HOST_RISCV) || defined (HOST_RISCV64)) && !defined (MONO_CROSS_COMPILE)) || defined (TARGET_RISCV)
 570
 571 #include <mono/utils/mono-context.h>
 572
 573 void
 574 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 575 {
 576 #ifdef MONO_CROSS_COMPILE
 577         g_assert_not_reached ();
 578 #else
 579         ucontext_t *uctx = sigctx;
 580
 581         memcpy (&mctx->gregs, &uctx->uc_mcontext.gregs, sizeof (host_mgreg_t) * G_N_ELEMENTS (mctx->gregs));
 582         memcpy (&mctx->fregs, &uctx->uc_mcontext.fpregs, sizeof (double) * G_N_ELEMENTS (mctx->fregs));
 583 #endif
 584 }
 585
 586 void
 587 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 588 {
 589 #ifdef MONO_CROSS_COMPILE
 590         g_assert_not_reached ();
 591 #else
 592         ucontext_t *uctx = sigctx;
 593
 594         memcpy (&uctx->uc_mcontext.gregs, &mctx->gregs, sizeof (host_mgreg_t) * G_N_ELEMENTS (mctx->gregs));
 595         memcpy (&uctx->uc_mcontext.fpregs, &mctx->fregs, sizeof (double) * G_N_ELEMENTS (mctx->fregs));
 596 #endif
 597 }
 598
 599 #endif /* #if defined(__i386__) */