mono/utils/mono-context.c

   1 /*
   2  * mono-context.c: plat independent machine state definitions
   3  *
   4  *
   5  * Copyright (c) 2011 Novell, Inc (http://www.novell.com)
   6  */
   7
   8 #include <mono/utils/mono-sigcontext.h>
   9
  10 #ifdef HAVE_UCONTEXT_H
  11 #include <ucontext.h>
  12 #endif
  13
  14 #if (defined(__i386__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_X86))
  15
  16 #include <mono/utils/mono-context.h>
  17
  18 #ifdef __sun
  19 #define REG_EAX EAX
  20 #define REG_EBX EBX
  21 #define REG_ECX ECX
  22 #define REG_EDX EDX
  23 #define REG_EBP EBP
  24 #define REG_ESP ESP
  25 #define REG_ESI ESI
  26 #define REG_EDI EDI
  27 #define REG_EIP EIP
  28 #endif
  29
  30 void
  31 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
  32 {
  33 #if defined (__native_client__)
  34         printf("WARNING: mono_arch_sigctx_to_monoctx() called!\n");
  35         mctx->eax = 0xDEADBEEF;
  36         mctx->ebx = 0xDEADBEEF;
  37         mctx->ecx = 0xDEADBEEF;
  38         mctx->edx = 0xDEADBEEF;
  39         mctx->ebp = 0xDEADBEEF;
  40         mctx->esp = 0xDEADBEEF;
  41         mctx->esi = 0xDEADBEEF;
  42         mctx->edi = 0xDEADBEEF;
  43         mctx->eip = 0xDEADBEEF;
  44 #elif defined(MONO_SIGNAL_USE_SIGACTION)
  45         ucontext_t *ctx = (ucontext_t*)sigctx;
  46
  47         mctx->eax = UCONTEXT_REG_EAX (ctx);
  48         mctx->ebx = UCONTEXT_REG_EBX (ctx);
  49         mctx->ecx = UCONTEXT_REG_ECX (ctx);
  50         mctx->edx = UCONTEXT_REG_EDX (ctx);
  51         mctx->ebp = UCONTEXT_REG_EBP (ctx);
  52         mctx->esp = UCONTEXT_REG_ESP (ctx);
  53         mctx->esi = UCONTEXT_REG_ESI (ctx);
  54         mctx->edi = UCONTEXT_REG_EDI (ctx);
  55         mctx->eip = UCONTEXT_REG_EIP (ctx);
  56 #else
  57         struct sigcontext *ctx = (struct sigcontext *)sigctx;
  58
  59         mctx->eax = ctx->SC_EAX;
  60         mctx->ebx = ctx->SC_EBX;
  61         mctx->ecx = ctx->SC_ECX;
  62         mctx->edx = ctx->SC_EDX;
  63         mctx->ebp = ctx->SC_EBP;
  64         mctx->esp = ctx->SC_ESP;
  65         mctx->esi = ctx->SC_ESI;
  66         mctx->edi = ctx->SC_EDI;
  67         mctx->eip = ctx->SC_EIP;
  68 #endif /* if defined(__native_client__) */
  69 }
  70
  71 void
  72 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
  73 {
  74 #if defined(__native_client__)
  75         printf("WARNING: mono_arch_monoctx_to_sigctx() called!\n");
  76 #elif defined(MONO_SIGNAL_USE_SIGACTION)
  77         ucontext_t *ctx = (ucontext_t*)sigctx;
  78
  79         UCONTEXT_REG_EAX (ctx) = mctx->eax;
  80         UCONTEXT_REG_EBX (ctx) = mctx->ebx;
  81         UCONTEXT_REG_ECX (ctx) = mctx->ecx;
  82         UCONTEXT_REG_EDX (ctx) = mctx->edx;
  83         UCONTEXT_REG_EBP (ctx) = mctx->ebp;
  84         UCONTEXT_REG_ESP (ctx) = mctx->esp;
  85         UCONTEXT_REG_ESI (ctx) = mctx->esi;
  86         UCONTEXT_REG_EDI (ctx) = mctx->edi;
  87         UCONTEXT_REG_EIP (ctx) = mctx->eip;
  88 #else
  89         struct sigcontext *ctx = (struct sigcontext *)sigctx;
  90
  91         ctx->SC_EAX = mctx->eax;
  92         ctx->SC_EBX = mctx->ebx;
  93         ctx->SC_ECX = mctx->ecx;
  94         ctx->SC_EDX = mctx->edx;
  95         ctx->SC_EBP = mctx->ebp;
  96         ctx->SC_ESP = mctx->esp;
  97         ctx->SC_ESI = mctx->esi;
  98         ctx->SC_EDI = mctx->edi;
  99         ctx->SC_EIP = mctx->eip;
 100 #endif /* __native_client__ */
 101 }
 102
 103 #elif (defined(__x86_64__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_AMD64)) /* defined(__i386__) */
 104
 105 #include <mono/utils/mono-context.h>
 106
 107 void
 108 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 109 {
 110 #if defined(__native_client_codegen__) || defined(__native_client__)
 111         printf("WARNING: mono_arch_sigctx_to_monoctx() called!\n");
 112 #endif
 113
 114 #if defined(MONO_SIGNAL_USE_SIGACTION)
 115         ucontext_t *ctx = (ucontext_t*)sigctx;
 116
 117         mctx->rax = UCONTEXT_REG_RAX (ctx);
 118         mctx->rbx = UCONTEXT_REG_RBX (ctx);
 119         mctx->rcx = UCONTEXT_REG_RCX (ctx);
 120         mctx->rdx = UCONTEXT_REG_RDX (ctx);
 121         mctx->rbp = UCONTEXT_REG_RBP (ctx);
 122         mctx->rsp = UCONTEXT_REG_RSP (ctx);
 123         mctx->rsi = UCONTEXT_REG_RSI (ctx);
 124         mctx->rdi = UCONTEXT_REG_RDI (ctx);
 125         mctx->r8 = UCONTEXT_REG_R8 (ctx);
 126         mctx->r9 = UCONTEXT_REG_R9 (ctx);
 127         mctx->r10 = UCONTEXT_REG_R10 (ctx);
 128         mctx->r11 = UCONTEXT_REG_R11 (ctx);
 129         mctx->r12 = UCONTEXT_REG_R12 (ctx);
 130         mctx->r13 = UCONTEXT_REG_R13 (ctx);
 131         mctx->r14 = UCONTEXT_REG_R14 (ctx);
 132         mctx->r15 = UCONTEXT_REG_R15 (ctx);
 133         mctx->rip = UCONTEXT_REG_RIP (ctx);
 134 #else
 135         MonoContext *ctx = (MonoContext *)sigctx;
 136
 137         mctx->rax = ctx->rax;
 138         mctx->rbx = ctx->rbx;
 139         mctx->rcx = ctx->rcx;
 140         mctx->rdx = ctx->rdx;
 141         mctx->rbp = ctx->rbp;
 142         mctx->rsp = ctx->rsp;
 143         mctx->rsi = ctx->rsi;
 144         mctx->rdi = ctx->rdi;
 145         mctx->r8 = ctx->r8;
 146         mctx->r9 = ctx->r9;
 147         mctx->r10 = ctx->r10;
 148         mctx->r11 = ctx->r11;
 149         mctx->r12 = ctx->r12;
 150         mctx->r13 = ctx->r13;
 151         mctx->r14 = ctx->r14;
 152         mctx->r15 = ctx->r15;
 153         mctx->rip = ctx->rip;
 154 #endif
 155 }
 156
 157 void
 158 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 159 {
 160 #if defined(__native_client__) || defined(__native_client_codegen__)
 161   printf("WARNING: mono_arch_monoctx_to_sigctx() called!\n");
 162 #endif
 163
 164 #if defined(MONO_SIGNAL_USE_SIGACTION)
 165         ucontext_t *ctx = (ucontext_t*)sigctx;
 166
 167         UCONTEXT_REG_RAX (ctx) = mctx->rax;
 168         UCONTEXT_REG_RBX (ctx) = mctx->rbx;
 169         UCONTEXT_REG_RCX (ctx) = mctx->rcx;
 170         UCONTEXT_REG_RDX (ctx) = mctx->rdx;
 171         UCONTEXT_REG_RBP (ctx) = mctx->rbp;
 172         UCONTEXT_REG_RSP (ctx) = mctx->rsp;
 173         UCONTEXT_REG_RSI (ctx) = mctx->rsi;
 174         UCONTEXT_REG_RDI (ctx) = mctx->rdi;
 175         UCONTEXT_REG_R8 (ctx) = mctx->r8;
 176         UCONTEXT_REG_R9 (ctx) = mctx->r9;
 177         UCONTEXT_REG_R10 (ctx) = mctx->r10;
 178         UCONTEXT_REG_R11 (ctx) = mctx->r11;
 179         UCONTEXT_REG_R12 (ctx) = mctx->r12;
 180         UCONTEXT_REG_R13 (ctx) = mctx->r13;
 181         UCONTEXT_REG_R14 (ctx) = mctx->r14;
 182         UCONTEXT_REG_R15 (ctx) = mctx->r15;
 183         UCONTEXT_REG_RIP (ctx) = mctx->rip;
 184 #else
 185         MonoContext *ctx = (MonoContext *)sigctx;
 186
 187         ctx->rax = mctx->rax;
 188         ctx->rbx = mctx->rbx;
 189         ctx->rcx = mctx->rcx;
 190         ctx->rdx = mctx->rdx;
 191         ctx->rbp = mctx->rbp;
 192         ctx->rsp = mctx->rsp;
 193         ctx->rsi = mctx->rsi;
 194         ctx->rdi = mctx->rdi;
 195         ctx->r8 = mctx->r8;
 196         ctx->r9 = mctx->r9;
 197         ctx->r10 = mctx->r10;
 198         ctx->r11 = mctx->r11;
 199         ctx->r12 = mctx->r12;
 200         ctx->r13 = mctx->r13;
 201         ctx->r14 = mctx->r14;
 202         ctx->r15 = mctx->r15;
 203         ctx->rip = mctx->rip;
 204 #endif
 205 }
 206
 207 #elif defined(__s390x__)
 208
 209 #include <mono/utils/mono-context.h>
 210
 211 /*------------------------------------------------------------------*/
 212 /*                                                                  */
 213 /* Name         - mono_arch_sigctx_to_monoctx.                      */
 214 /*                                                                  */
 215 /* Function     - Called from the signal handler to convert signal  */
 216 /*                context to MonoContext.                           */
 217 /*                                                                  */
 218 /*------------------------------------------------------------------*/
 219
 220 void
 221 mono_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
 222 {
 223         memcpy (mctx, ctx, sizeof(MonoContext));
 224 }
 225
 226 /*========================= End of Function ========================*/
 227
 228 /*------------------------------------------------------------------*/
 229 /*                                                                  */
 230 /* Name         - mono_arch_monoctx_to_sigctx.                      */
 231 /*                                                                  */
 232 /* Function     - Convert MonoContext structure to signal context.  */
 233 /*                                                                  */
 234 /*------------------------------------------------------------------*/
 235
 236 void
 237 mono_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
 238 {
 239         memcpy (ctx, mctx, sizeof(MonoContext));
 240 }
 241
 242 /*========================= End of Function ========================*/
 243
 244 #elif (defined(__arm__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_ARM))
 245
 246 #include <mono/utils/mono-context.h>
 247 #include <mono/arch/arm/arm-codegen.h>
 248 #include <mono/arch/arm/arm-vfp-codegen.h>
 249
 250 void
 251 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 252 {
 253 #ifdef MONO_CROSS_COMPILE
 254         g_assert_not_reached ();
 255 #elif defined(__native_client__)
 256         g_assert_not_reached ();
 257 #else
 258         arm_ucontext *my_uc = sigctx;
 259
 260         mctx->pc = UCONTEXT_REG_PC (my_uc);
 261         mctx->regs [ARMREG_SP] = UCONTEXT_REG_SP (my_uc);
 262         mctx->cpsr = UCONTEXT_REG_CPSR (my_uc);
 263         memcpy (&mctx->regs, &UCONTEXT_REG_R0 (my_uc), sizeof (mgreg_t) * 16);
 264 #ifdef UCONTEXT_REG_VFPREGS
 265         memcpy (&mctx->fregs, UCONTEXT_REG_VFPREGS (my_uc), sizeof (double) * 16);
 266 #endif
 267 #endif
 268 }
 269
 270 void
 271 mono_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
 272 {
 273 #ifdef MONO_CROSS_COMPILE
 274         g_assert_not_reached ();
 275 #elif defined(__native_client__)
 276         g_assert_not_reached ();
 277 #else
 278         arm_ucontext *my_uc = ctx;
 279
 280         UCONTEXT_REG_PC (my_uc) = mctx->pc;
 281         UCONTEXT_REG_SP (my_uc) = mctx->regs [ARMREG_SP];
 282         UCONTEXT_REG_CPSR (my_uc) = mctx->cpsr;
 283         /* The upper registers are not guaranteed to be valid */
 284         memcpy (&UCONTEXT_REG_R0 (my_uc), &mctx->regs, sizeof (mgreg_t) * 12);
 285 #ifdef UCONTEXT_REG_VFPREGS
 286         memcpy (UCONTEXT_REG_VFPREGS (my_uc), &mctx->fregs, sizeof (double) * 16);
 287 #endif
 288 #endif
 289 }
 290
 291 #elif (defined(__aarch64__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_ARM64))
 292
 293 #include <mono/utils/mono-context.h>
 294
 295 void
 296 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 297 {
 298 #ifdef MONO_CROSS_COMPILE
 299         g_assert_not_reached ();
 300 #else
 301         memcpy (mctx->regs, UCONTEXT_GREGS (sigctx), sizeof (mgreg_t) * 31);
 302         mctx->pc = UCONTEXT_REG_PC (sigctx);
 303         mctx->regs [ARMREG_SP] = UCONTEXT_REG_SP (sigctx);
 304         /*
 305          * We don't handle fp regs, this is not currrently a
 306          * problem, since we don't allocate them globally.
 307          */
 308 #endif
 309 }
 310
 311 void
 312 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 313 {
 314 #ifdef MONO_CROSS_COMPILE
 315         g_assert_not_reached ();
 316 #else
 317         memcpy (UCONTEXT_GREGS (sigctx), mctx->regs, sizeof (mgreg_t) * 31);
 318         UCONTEXT_REG_PC (sigctx) = mctx->pc;
 319         UCONTEXT_REG_SP (sigctx) = mctx->regs [ARMREG_SP];
 320 #endif
 321 }
 322
 323 #elif (defined(__mips__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_MIPS))
 324
 325 #include <mono/utils/mono-context.h>
 326 #include <mono/arch/mips/mips-codegen.h>
 327
 328 void
 329 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
 330 {
 331         int i;
 332
 333         mctx->sc_pc = UCONTEXT_REG_PC (sigctx);
 334         for (i = 0; i < 32; ++i) {
 335                 mctx->sc_regs[i] = UCONTEXT_GREGS (sigctx) [i];
 336                 mctx->sc_fpregs[i] = UCONTEXT_FPREGS (sigctx) [i];
 337         }
 338 }
 339
 340 void
 341 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
 342 {
 343         int i;
 344
 345         UCONTEXT_REG_PC (sigctx) = mctx->sc_pc;
 346         for (i = 0; i < 32; ++i) {
 347                 UCONTEXT_GREGS (sigctx) [i] = mctx->sc_regs[i];
 348                 UCONTEXT_FPREGS (sigctx) [i] = mctx->sc_fpregs[i];
 349         }
 350 }
 351
 352 #endif /* #if defined(__i386__) */