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
mono_sigctx_to_monoctx(void * sigctx,MonoContext * mctx)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
mono_monoctx_to_sigctx(MonoContext * mctx,void * sigctx)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
mono_sigctx_to_monoctx(void * sigctx,MonoContext * mctx)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 #else
237 g_assert_not_reached ();
238 #endif
239 }
240
241 void
mono_monoctx_to_sigctx(MonoContext * mctx,void * sigctx)242 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
243 {
244 #ifdef MONO_CROSS_COMPILE
245 g_assert_not_reached ();
246 #elif defined(MONO_SIGNAL_USE_UCONTEXT_T)
247 ucontext_t *ctx = (ucontext_t*)sigctx;
248
249 UCONTEXT_REG_RAX (ctx) = mctx->gregs [AMD64_RAX];
250 UCONTEXT_REG_RBX (ctx) = mctx->gregs [AMD64_RBX];
251 UCONTEXT_REG_RCX (ctx) = mctx->gregs [AMD64_RCX];
252 UCONTEXT_REG_RDX (ctx) = mctx->gregs [AMD64_RDX];
253 UCONTEXT_REG_RBP (ctx) = mctx->gregs [AMD64_RBP];
254 UCONTEXT_REG_RSP (ctx) = mctx->gregs [AMD64_RSP];
255 UCONTEXT_REG_RSI (ctx) = mctx->gregs [AMD64_RSI];
256 UCONTEXT_REG_RDI (ctx) = mctx->gregs [AMD64_RDI];
257 UCONTEXT_REG_R8 (ctx) = mctx->gregs [AMD64_R8];
258 UCONTEXT_REG_R9 (ctx) = mctx->gregs [AMD64_R9];
259 UCONTEXT_REG_R10 (ctx) = mctx->gregs [AMD64_R10];
260 UCONTEXT_REG_R11 (ctx) = mctx->gregs [AMD64_R11];
261 UCONTEXT_REG_R12 (ctx) = mctx->gregs [AMD64_R12];
262 UCONTEXT_REG_R13 (ctx) = mctx->gregs [AMD64_R13];
263 UCONTEXT_REG_R14 (ctx) = mctx->gregs [AMD64_R14];
264 UCONTEXT_REG_R15 (ctx) = mctx->gregs [AMD64_R15];
265 UCONTEXT_REG_RIP (ctx) = mctx->gregs [AMD64_RIP];
266
267 #ifdef UCONTEXT_HAS_XMM
268 if (UCONTEXT_HAS_XMM (ctx)) {
269 UCONTEXT_REG_XMM0 (ctx) = mctx->fregs [0];
270 UCONTEXT_REG_XMM1 (ctx) = mctx->fregs [1];
271 UCONTEXT_REG_XMM2 (ctx) = mctx->fregs [2];
272 UCONTEXT_REG_XMM3 (ctx) = mctx->fregs [3];
273 UCONTEXT_REG_XMM4 (ctx) = mctx->fregs [4];
274 UCONTEXT_REG_XMM5 (ctx) = mctx->fregs [5];
275 UCONTEXT_REG_XMM6 (ctx) = mctx->fregs [6];
276 UCONTEXT_REG_XMM7 (ctx) = mctx->fregs [7];
277 UCONTEXT_REG_XMM8 (ctx) = mctx->fregs [8];
278 UCONTEXT_REG_XMM9 (ctx) = mctx->fregs [9];
279 UCONTEXT_REG_XMM10 (ctx) = mctx->fregs [10];
280 UCONTEXT_REG_XMM11 (ctx) = mctx->fregs [11];
281 UCONTEXT_REG_XMM12 (ctx) = mctx->fregs [12];
282 UCONTEXT_REG_XMM13 (ctx) = mctx->fregs [13];
283 UCONTEXT_REG_XMM14 (ctx) = mctx->fregs [14];
284 UCONTEXT_REG_XMM15 (ctx) = mctx->fregs [15];
285 }
286 #endif
287
288 #elif defined(HOST_WIN32)
289 CONTEXT *context = (CONTEXT*)sigctx;
290
291 context->Rip = mctx->gregs [AMD64_RIP];
292 context->Rax = mctx->gregs [AMD64_RAX];
293 context->Rcx = mctx->gregs [AMD64_RCX];
294 context->Rdx = mctx->gregs [AMD64_RDX];
295 context->Rbx = mctx->gregs [AMD64_RBX];
296 context->Rsp = mctx->gregs [AMD64_RSP];
297 context->Rbp = mctx->gregs [AMD64_RBP];
298 context->Rsi = mctx->gregs [AMD64_RSI];
299 context->Rdi = mctx->gregs [AMD64_RDI];
300 context->R8 = mctx->gregs [AMD64_R8];
301 context->R9 = mctx->gregs [AMD64_R9];
302 context->R10 = mctx->gregs [AMD64_R10];
303 context->R11 = mctx->gregs [AMD64_R11];
304 context->R12 = mctx->gregs [AMD64_R12];
305 context->R13 = mctx->gregs [AMD64_R13];
306 context->R14 = mctx->gregs [AMD64_R14];
307 context->R15 = mctx->gregs [AMD64_R15];
308 #else
309 g_assert_not_reached ();
310 #endif
311 }
312
313 #elif defined(__s390x__)
314
315 #include <mono/utils/mono-context.h>
316
317 /*------------------------------------------------------------------*/
318 /* */
319 /* Name - mono_arch_sigctx_to_monoctx. */
320 /* */
321 /* Function - Called from the signal handler to convert signal */
322 /* context to MonoContext. */
323 /* */
324 /*------------------------------------------------------------------*/
325
326 void
mono_sigctx_to_monoctx(void * ctx,MonoContext * mctx)327 mono_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
328 {
329 memcpy (mctx, ctx, sizeof(MonoContext));
330 }
331
332 /*========================= End of Function ========================*/
333
334 /*------------------------------------------------------------------*/
335 /* */
336 /* Name - mono_arch_monoctx_to_sigctx. */
337 /* */
338 /* Function - Convert MonoContext structure to signal context. */
339 /* */
340 /*------------------------------------------------------------------*/
341
342 void
mono_monoctx_to_sigctx(MonoContext * mctx,void * ctx)343 mono_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
344 {
345 memcpy (ctx, mctx, sizeof(MonoContext));
346 }
347
348 /*========================= End of Function ========================*/
349
350 #elif (defined(__arm__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_ARM))
351
352 #include <mono/utils/mono-context.h>
353 #include <mono/arch/arm/arm-codegen.h>
354 #include <mono/arch/arm/arm-vfp-codegen.h>
355
356 void
mono_sigctx_to_monoctx(void * sigctx,MonoContext * mctx)357 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
358 {
359 #ifdef MONO_CROSS_COMPILE
360 g_assert_not_reached ();
361 #else
362 arm_ucontext *my_uc = sigctx;
363
364 mctx->pc = UCONTEXT_REG_PC (my_uc);
365 mctx->regs [ARMREG_SP] = UCONTEXT_REG_SP (my_uc);
366 mctx->cpsr = UCONTEXT_REG_CPSR (my_uc);
367 memcpy (&mctx->regs, &UCONTEXT_REG_R0 (my_uc), sizeof (mgreg_t) * 16);
368 #ifdef UCONTEXT_REG_VFPREGS
369 memcpy (&mctx->fregs, UCONTEXT_REG_VFPREGS (my_uc), sizeof (double) * 16);
370 #endif
371 #endif
372 }
373
374 void
mono_monoctx_to_sigctx(MonoContext * mctx,void * ctx)375 mono_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
376 {
377 #ifdef MONO_CROSS_COMPILE
378 g_assert_not_reached ();
379 #else
380 arm_ucontext *my_uc = ctx;
381
382 UCONTEXT_REG_PC (my_uc) = mctx->pc;
383 UCONTEXT_REG_SP (my_uc) = mctx->regs [ARMREG_SP];
384 UCONTEXT_REG_CPSR (my_uc) = mctx->cpsr;
385 /* The upper registers are not guaranteed to be valid */
386 memcpy (&UCONTEXT_REG_R0 (my_uc), &mctx->regs, sizeof (mgreg_t) * 12);
387 #ifdef UCONTEXT_REG_VFPREGS
388 memcpy (UCONTEXT_REG_VFPREGS (my_uc), &mctx->fregs, sizeof (double) * 16);
389 #endif
390 #endif
391 }
392
393 #elif (defined(__aarch64__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_ARM64))
394
395 #include <mono/utils/mono-context.h>
396
397 void
mono_sigctx_to_monoctx(void * sigctx,MonoContext * mctx)398 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
399 {
400 #ifdef MONO_CROSS_COMPILE
401 g_assert_not_reached ();
402 #else
403 memcpy (mctx->regs, UCONTEXT_GREGS (sigctx), sizeof (mgreg_t) * 31);
404 mctx->pc = UCONTEXT_REG_PC (sigctx);
405 mctx->regs [ARMREG_SP] = UCONTEXT_REG_SP (sigctx);
406 #ifdef __linux__
407 struct fpsimd_context *fpctx = (struct fpsimd_context*)&((ucontext_t*)sigctx)->uc_mcontext.__reserved;
408 int i;
409
410 g_assert (fpctx->head.magic == FPSIMD_MAGIC);
411 for (i = 0; i < 32; ++i)
412 mctx->fregs [i] = fpctx->vregs [i];
413 #endif
414 /* FIXME: apple */
415 #endif
416 }
417
418 void
mono_monoctx_to_sigctx(MonoContext * mctx,void * sigctx)419 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
420 {
421 #ifdef MONO_CROSS_COMPILE
422 g_assert_not_reached ();
423 #else
424 memcpy (UCONTEXT_GREGS (sigctx), mctx->regs, sizeof (mgreg_t) * 31);
425 UCONTEXT_REG_PC (sigctx) = mctx->pc;
426 UCONTEXT_REG_SP (sigctx) = mctx->regs [ARMREG_SP];
427 #endif
428 }
429
430 #elif (defined(__mips__) && !defined(MONO_CROSS_COMPILE)) || (defined(TARGET_MIPS))
431
432 #include <mono/utils/mono-context.h>
433 #include <mono/arch/mips/mips-codegen.h>
434
435 void
mono_sigctx_to_monoctx(void * sigctx,MonoContext * mctx)436 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
437 {
438 int i;
439
440 mctx->sc_pc = UCONTEXT_REG_PC (sigctx);
441 for (i = 0; i < 32; ++i) {
442 mctx->sc_regs[i] = UCONTEXT_GREGS (sigctx) [i];
443 mctx->sc_fpregs[i] = UCONTEXT_FPREGS (sigctx) [i];
444 }
445 }
446
447 void
mono_monoctx_to_sigctx(MonoContext * mctx,void * sigctx)448 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
449 {
450 int i;
451
452 UCONTEXT_REG_PC (sigctx) = mctx->sc_pc;
453 for (i = 0; i < 32; ++i) {
454 UCONTEXT_GREGS (sigctx) [i] = mctx->sc_regs[i];
455 UCONTEXT_FPREGS (sigctx) [i] = mctx->sc_fpregs[i];
456 }
457 }
458
459 #elif (((defined(__ppc__) || defined(__powerpc__) || defined(__ppc64__)) && !defined(MONO_CROSS_COMPILE))) || (defined(TARGET_POWERPC))
460
461 #include <mono/utils/mono-context.h>
462 #include <mono/mini/mini-ppc.h>
463
464 void
mono_sigctx_to_monoctx(void * sigctx,MonoContext * mctx)465 mono_sigctx_to_monoctx (void *sigctx, MonoContext *mctx)
466 {
467 os_ucontext *uc = sigctx;
468
469 mctx->sc_ir = UCONTEXT_REG_NIP(uc);
470 mctx->sc_sp = UCONTEXT_REG_Rn(uc, 1);
471
472 memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 0), sizeof (mgreg_t) * MONO_MAX_IREGS);
473 memcpy (&mctx->fregs, &UCONTEXT_REG_FPRn(uc, 0), sizeof (double) * MONO_MAX_FREGS);
474 }
475
476 void
mono_monoctx_to_sigctx(MonoContext * mctx,void * sigctx)477 mono_monoctx_to_sigctx (MonoContext *mctx, void *sigctx)
478 {
479 os_ucontext *uc = sigctx;
480
481 memcpy (&UCONTEXT_REG_Rn(uc, 0), &mctx->regs, sizeof (mgreg_t) * MONO_MAX_IREGS);
482 memcpy (&UCONTEXT_REG_FPRn(uc, 0), &mctx->fregs, sizeof (double) * MONO_MAX_FREGS);
483
484 /* The valid values for pc and sp are stored here and not in regs array */
485 UCONTEXT_REG_NIP(uc) = mctx->sc_ir;
486 UCONTEXT_REG_Rn(uc, 1) = mctx->sc_sp;
487 }
488
489 #endif /* #if defined(__i386__) */
490