2 * exceptions-ppc.c: exception support for PowerPC
5 * Dietmar Maurer (dietmar@ximian.com)
6 * Paolo Molaro (lupus@ximian.com)
7 * Andreas Faerber <andreas.faerber@web.de>
9 * (C) 2001 Ximian, Inc.
10 * (C) 2007-2008 Andreas Faerber
22 #include <mono/arch/ppc/ppc-codegen.h>
23 #include <mono/metadata/appdomain.h>
24 #include <mono/metadata/tabledefs.h>
25 #include <mono/metadata/threads.h>
26 #include <mono/metadata/debug-helpers.h>
27 #include <mono/metadata/exception.h>
28 #include <mono/metadata/mono-debug.h>
36 int sc_onstack; // sigstack state to restore
37 int sc_mask; // signal mask to restore
39 int sc_psw; // processor status word
40 int sc_sp; // stack pointer if sc_regs == NULL
41 void *sc_regs; // (kernel private) saved state
46 sigset_t uc_sigmask; // signal mask used by this context
47 stack_t uc_stack; // stack used by this context
48 struct ucontext *uc_link; // pointer to resuming context
49 size_t uc_mcsize; // size of the machine context passed in
50 mcontext_t uc_mcontext; // machine specific context
53 typedef struct ppc_exception_state {
54 unsigned long dar; // Fault registers for coredump
56 unsigned long exception;// number of powerpc exception taken
57 unsigned long pad0; // align to 16 bytes
59 unsigned long pad1[4]; // space in PCB "just in case"
60 } ppc_exception_state_t;
62 typedef struct ppc_vector_state {
63 unsigned long save_vr[32][4];
64 unsigned long save_vscr[4];
65 unsigned int save_pad5[4];
66 unsigned int save_vrvalid; // VRs that have been saved
67 unsigned int save_pad6[7];
70 typedef struct ppc_float_state {
73 unsigned int fpscr_pad; // fpscr is 64 bits, 32 bits of rubbish
74 unsigned int fpscr; // floating point status register
77 typedef struct ppc_thread_state {
78 unsigned int srr0; // Instruction address register (PC)
79 unsigned int srr1; // Machine state register (supervisor)
85 unsigned int cr; // Condition register
86 unsigned int xer; // User's integer exception register
87 unsigned int lr; // Link register
88 unsigned int ctr; // Count register
89 unsigned int mq; // MQ register (601 only)
91 unsigned int vrsave; // Vector Save Register
95 ppc_exception_state_t es;
96 ppc_thread_state_t ss;
98 ppc_vector_state_t vs;
101 typedef struct mcontext * mcontext_t;
103 Linux/PPC instead has:
105 unsigned long _unused[4];
107 unsigned long handler;
108 unsigned long oldmask;
109 struct pt_regs *regs;
112 unsigned long gpr[32];
115 unsigned long orig_gpr3; // Used for restarting system calls
120 unsigned long mq; // 601 only (not used at present)
121 // Used on APUS to hold IPL value.
122 unsigned long trap; // Reason for being here
123 // N.B. for critical exceptions on 4xx, the dar and dsisr
124 // fields are overloaded to hold srr0 and srr1.
125 unsigned long dar; // Fault registers
126 unsigned long dsisr; // on 4xx/Book-E used for ESR
127 unsigned long result; // Result of a system call
130 elf_gregset_t mc_gregs;
131 elf_fpregset_t mc_fregs;
132 unsigned long mc_pad[2];
133 elf_vrregset_t mc_vregs __attribute__((__aligned__(16)));
137 unsigned long uc_flags;
138 struct ucontext *uc_link;
141 struct mcontext *uc_regs; // points to uc_mcontext field
143 // glibc has 1024-bit signal masks, ours are 64-bit
146 struct mcontext uc_mcontext;
149 #define ELF_NGREG 48 // includes nip, msr, lr, etc.
150 #define ELF_NFPREG 33 // includes fpscr
153 typedef unsigned long elf_greg_t;
154 typedef elf_greg_t elf_gregset_t[ELF_NGREG];
156 // Floating point registers
157 typedef double elf_fpreg_t;
158 typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
164 #define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do { \
166 ppc_ldptr (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg); \
167 ppc_load_multiple_regs (code, ppc_r13, G_STRUCT_OFFSET (MonoContext, regs), ctx_reg); \
168 for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) { \
169 ppc_lfd (code, (14 + reg), \
170 G_STRUCT_OFFSET(MonoContext, fregs) + reg * sizeof (gdouble), ctx_reg); \
175 #define setup_context(ctx)
177 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
179 mono_ppc_create_pre_code_ftnptr (guint8
*code
)
181 MonoPPCFunctionDescriptor
*ftnptr
= (MonoPPCFunctionDescriptor
*)code
;
183 code
+= sizeof (MonoPPCFunctionDescriptor
);
193 * arch_get_restore_context:
195 * Returns a pointer to a method which restores a previously saved sigcontext.
196 * The first argument in r3 is the pointer to the context.
199 mono_arch_get_restore_context (MonoTrampInfo
**info
, gboolean aot
)
201 guint8
*start
, *code
;
202 int size
= MONO_PPC_32_64_CASE (128, 172) + PPC_FTNPTR_SIZE
;
203 MonoJumpInfo
*ji
= NULL
;
204 GSList
*unwind_ops
= NULL
;
206 code
= start
= mono_global_codeman_reserve (size
);
208 code
= mono_ppc_create_pre_code_ftnptr (code
);
209 restore_regs_from_context (ppc_r3
, ppc_r4
, ppc_r5
);
210 /* restore also the stack pointer */
211 ppc_ldptr (code
, ppc_sp
, G_STRUCT_OFFSET (MonoContext
, sc_sp
), ppc_r3
);
213 /* jump to the saved IP */
214 ppc_mtctr (code
, ppc_r4
);
215 ppc_bcctr (code
, PPC_BR_ALWAYS
, 0);
219 g_assert ((code
- start
) <= size
);
220 mono_arch_flush_icache (start
, code
- start
);
221 mono_profiler_code_buffer_new (start
, code
- start
, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING
, NULL
);
224 *info
= mono_tramp_info_create ("restore_context", start
, code
- start
, ji
, unwind_ops
);
229 #define SAVED_REGS_LENGTH (sizeof (gdouble) * MONO_SAVED_FREGS + sizeof (gpointer) * MONO_SAVED_GREGS)
230 #define ALIGN_STACK_FRAME_SIZE(s) (((s) + MONO_ARCH_FRAME_ALIGNMENT - 1) & ~(MONO_ARCH_FRAME_ALIGNMENT - 1))
231 /* The 64 bytes here are for outgoing arguments and a bit of spare.
232 We don't use it all, but it doesn't hurt. */
233 #define REG_SAVE_STACK_FRAME_SIZE (ALIGN_STACK_FRAME_SIZE (SAVED_REGS_LENGTH + PPC_MINIMAL_STACK_SIZE + 64))
236 emit_save_saved_regs (guint8
*code
, int pos
)
240 for (i
= 31; i
>= 14; --i
) {
241 pos
-= sizeof (gdouble
);
242 ppc_stfd (code
, i
, pos
, ppc_sp
);
244 pos
-= sizeof (gpointer
) * MONO_SAVED_GREGS
;
245 ppc_store_multiple_regs (code
, ppc_r13
, pos
, ppc_sp
);
251 * mono_arch_get_call_filter:
253 * Returns a pointer to a method which calls an exception filter. We
254 * also use this function to call finally handlers (we pass NULL as
255 * @exc object in this case).
258 mono_arch_get_call_filter (MonoTrampInfo
**info
, gboolean aot
)
260 guint8
*start
, *code
;
261 int alloc_size
, pos
, i
;
262 int size
= MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE
;
263 MonoJumpInfo
*ji
= NULL
;
264 GSList
*unwind_ops
= NULL
;
266 /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
267 code
= start
= mono_global_codeman_reserve (size
);
269 code
= mono_ppc_create_pre_code_ftnptr (code
);
272 ppc_mflr (code
, ppc_r0
);
273 ppc_stptr (code
, ppc_r0
, PPC_RET_ADDR_OFFSET
, ppc_sp
);
275 alloc_size
= REG_SAVE_STACK_FRAME_SIZE
;
277 /* allocate stack frame and set link from sp in ctx */
278 g_assert ((alloc_size
& (MONO_ARCH_FRAME_ALIGNMENT
-1)) == 0);
279 ppc_ldptr (code
, ppc_r0
, G_STRUCT_OFFSET (MonoContext
, sc_sp
), ppc_r3
);
280 ppc_ldptr_indexed (code
, ppc_r0
, ppc_r0
, ppc_r0
);
281 ppc_stptr_update (code
, ppc_r0
, -alloc_size
, ppc_sp
);
283 code
= emit_save_saved_regs (code
, alloc_size
);
285 /* restore all the regs from ctx (in r3), but not r1, the stack pointer */
286 restore_regs_from_context (ppc_r3
, ppc_r6
, ppc_r7
);
287 /* call handler at eip (r4) and set the first arg with the exception (r5) */
288 ppc_mtctr (code
, ppc_r4
);
289 ppc_mr (code
, ppc_r3
, ppc_r5
);
290 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
293 ppc_ldptr (code
, ppc_r0
, alloc_size
+ PPC_RET_ADDR_OFFSET
, ppc_sp
);
294 ppc_mtlr (code
, ppc_r0
);
296 /* restore all the regs from the stack */
298 for (i
= 31; i
>= 14; --i
) {
299 pos
-= sizeof (gdouble
);
300 ppc_lfd (code
, i
, pos
, ppc_sp
);
302 pos
-= sizeof (gpointer
) * MONO_SAVED_GREGS
;
303 ppc_load_multiple_regs (code
, ppc_r13
, pos
, ppc_sp
);
305 ppc_addic (code
, ppc_sp
, ppc_sp
, alloc_size
);
308 g_assert ((code
- start
) < size
);
309 mono_arch_flush_icache (start
, code
- start
);
310 mono_profiler_code_buffer_new (start
, code
- start
, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING
, NULL
);
313 *info
= mono_tramp_info_create ("call_filter", start
, code
- start
, ji
, unwind_ops
);
319 mono_ppc_throw_exception (MonoObject
*exc
, unsigned long eip
, unsigned long esp
, mgreg_t
*int_regs
, gdouble
*fp_regs
, gboolean rethrow
)
323 /* adjust eip so that it point into the call instruction */
326 setup_context (&ctx
);
328 /*printf ("stack in throw: %p\n", esp);*/
329 MONO_CONTEXT_SET_BP (&ctx
, esp
);
330 MONO_CONTEXT_SET_IP (&ctx
, eip
);
331 memcpy (&ctx
.regs
, int_regs
, sizeof (mgreg_t
) * MONO_SAVED_GREGS
);
332 memcpy (&ctx
.fregs
, fp_regs
, sizeof (double) * MONO_SAVED_FREGS
);
334 if (mono_object_isinst (exc
, mono_defaults
.exception_class
)) {
335 MonoException
*mono_ex
= (MonoException
*)exc
;
337 mono_ex
->stack_trace
= NULL
;
338 mono_ex
->trace_ips
= NULL
;
341 mono_handle_exception (&ctx
, exc
);
342 mono_restore_context (&ctx
);
344 g_assert_not_reached ();
348 * arch_get_throw_exception_generic:
350 * Returns a function pointer which can be used to raise
351 * exceptions. The returned function has the following
352 * signature: void (*func) (MonoException *exc); or
353 * void (*func) (guint32 ex_token, gpointer ip)
357 mono_arch_get_throw_exception_generic (int size
, MonoTrampInfo
**info
, int corlib
, gboolean rethrow
, gboolean aot
)
359 guint8
*start
, *code
;
361 MonoJumpInfo
*ji
= NULL
;
362 GSList
*unwind_ops
= NULL
;
364 code
= start
= mono_global_codeman_reserve (size
);
366 code
= mono_ppc_create_pre_code_ftnptr (code
);
370 ppc_mr (code
, ppc_r0
, ppc_r4
);
372 ppc_mflr (code
, ppc_r0
);
373 ppc_stptr (code
, ppc_r0
, PPC_RET_ADDR_OFFSET
, ppc_sp
);
375 alloc_size
= REG_SAVE_STACK_FRAME_SIZE
;
377 g_assert ((alloc_size
& (MONO_ARCH_FRAME_ALIGNMENT
-1)) == 0);
378 ppc_stptr_update (code
, ppc_sp
, -alloc_size
, ppc_sp
);
380 code
= emit_save_saved_regs (code
, alloc_size
);
384 ppc_mr (code
, ppc_r4
, ppc_r3
);
387 code
= mono_arch_emit_load_aotconst (start
, code
, &ji
, MONO_PATCH_INFO_IMAGE
, mono_defaults
.corlib
);
388 ppc_mr (code
, ppc_r3
, ppc_r12
);
389 code
= mono_arch_emit_load_aotconst (start
, code
, &ji
, MONO_PATCH_INFO_JIT_ICALL_ADDR
, "mono_exception_from_token");
390 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
391 ppc_ldptr (code
, ppc_r2
, sizeof (gpointer
), ppc_r12
);
392 ppc_ldptr (code
, ppc_r12
, 0, ppc_r12
);
394 ppc_mtctr (code
, ppc_r12
);
395 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
397 ppc_load (code
, ppc_r3
, (gulong
)mono_defaults
.corlib
);
398 ppc_load_func (code
, PPC_CALL_REG
, mono_exception_from_token
);
399 ppc_mtctr (code
, PPC_CALL_REG
);
400 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
404 /* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
406 ppc_ldptr (code
, ppc_r5
, 0, ppc_sp
);
407 /* exc is already in place in r3 */
409 ppc_ldptr (code
, ppc_r4
, PPC_RET_ADDR_OFFSET
, ppc_r5
);
411 ppc_mr (code
, ppc_r4
, ppc_r0
); /* caller ip */
412 /* pointer to the saved fp regs */
413 pos
= alloc_size
- sizeof (gdouble
) * MONO_SAVED_FREGS
;
414 ppc_addi (code
, ppc_r7
, ppc_sp
, pos
);
415 /* pointer to the saved int regs */
416 pos
-= sizeof (gpointer
) * MONO_SAVED_GREGS
;
417 ppc_addi (code
, ppc_r6
, ppc_sp
, pos
);
418 ppc_li (code
, ppc_r8
, rethrow
);
421 // This can be called from runtime code, which can't guarantee that
422 // r30 contains the got address.
423 // So emit the got address loading code too
424 code
= mono_arch_emit_load_got_addr (start
, code
, NULL
, &ji
);
425 code
= mono_arch_emit_load_aotconst (start
, code
, &ji
, MONO_PATCH_INFO_JIT_ICALL_ADDR
, "mono_ppc_throw_exception");
426 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
427 ppc_ldptr (code
, ppc_r2
, sizeof (gpointer
), ppc_r12
);
428 ppc_ldptr (code
, ppc_r12
, 0, ppc_r12
);
430 ppc_mtctr (code
, ppc_r12
);
431 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
433 ppc_load_func (code
, PPC_CALL_REG
, mono_ppc_throw_exception
);
434 ppc_mtctr (code
, PPC_CALL_REG
);
435 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
437 /* we should never reach this breakpoint */
439 g_assert ((code
- start
) <= size
);
440 mono_arch_flush_icache (start
, code
- start
);
441 mono_profiler_code_buffer_new (start
, code
- start
, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING
, NULL
);
444 *info
= mono_tramp_info_create (corlib
? "throw_corlib_exception" : (rethrow
? "rethrow_exception" : "throw_exception"), start
, code
- start
, ji
, unwind_ops
);
450 * mono_arch_get_rethrow_exception:
452 * Returns a function pointer which can be used to rethrow
453 * exceptions. The returned function has the following
454 * signature: void (*func) (MonoException *exc);
458 mono_arch_get_rethrow_exception (MonoTrampInfo
**info
, gboolean aot
)
460 int size
= MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE
;
464 return mono_arch_get_throw_exception_generic (size
, info
, FALSE
, TRUE
, aot
);
468 * arch_get_throw_exception:
470 * Returns a function pointer which can be used to raise
471 * exceptions. The returned function has the following
472 * signature: void (*func) (MonoException *exc);
473 * For example to raise an arithmetic exception you can use:
475 * x86_push_imm (code, mono_get_exception_arithmetic ());
476 * x86_call_code (code, arch_get_throw_exception ());
480 mono_arch_get_throw_exception (MonoTrampInfo
**info
, gboolean aot
)
482 int size
= MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE
;
486 return mono_arch_get_throw_exception_generic (size
, info
, FALSE
, FALSE
, aot
);
490 * mono_arch_get_throw_corlib_exception:
492 * Returns a function pointer which can be used to raise
493 * corlib exceptions. The returned function has the following
494 * signature: void (*func) (guint32 ex_token, guint32 offset);
495 * On PPC, we pass the ip instead of the offset
498 mono_arch_get_throw_corlib_exception (MonoTrampInfo
**info
, gboolean aot
)
500 int size
= MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE
;
504 return mono_arch_get_throw_exception_generic (size
, info
, TRUE
, FALSE
, aot
);
508 * mono_arch_unwind_frame:
510 * See exceptions-amd64.c for docs.
513 mono_arch_unwind_frame (MonoDomain
*domain
, MonoJitTlsData
*jit_tls
,
514 MonoJitInfo
*ji
, MonoContext
*ctx
,
515 MonoContext
*new_ctx
, MonoLMF
**lmf
,
516 mgreg_t
**save_locations
,
517 StackFrameInfo
*frame
)
519 gpointer ip
= MONO_CONTEXT_GET_IP (ctx
);
520 MonoPPCStackFrame
*sframe
;
522 memset (frame
, 0, sizeof (StackFrameInfo
));
526 setup_context (new_ctx
);
530 mgreg_t regs
[ppc_lr
+ 1];
532 guint32 unwind_info_len
;
535 if (ji
->is_trampoline
)
536 frame
->type
= FRAME_TYPE_TRAMPOLINE
;
538 frame
->type
= FRAME_TYPE_MANAGED
;
540 unwind_info
= mono_jinfo_get_unwind_info (ji
, &unwind_info_len
);
542 sframe
= (MonoPPCStackFrame
*)MONO_CONTEXT_GET_SP (ctx
);
543 MONO_CONTEXT_SET_BP (new_ctx
, sframe
->sp
);
544 if (!ji
->is_trampoline
&& jinfo_get_method (ji
)->save_lmf
) {
545 /* sframe->sp points just past the end of the LMF */
546 guint8
*lmf_addr
= (guint8
*)sframe
->sp
- sizeof (MonoLMF
);
547 memcpy (&new_ctx
->fregs
, lmf_addr
+ G_STRUCT_OFFSET (MonoLMF
, fregs
), sizeof (double) * MONO_SAVED_FREGS
);
548 memcpy (&new_ctx
->regs
, lmf_addr
+ G_STRUCT_OFFSET (MonoLMF
, iregs
), sizeof (mgreg_t
) * MONO_SAVED_GREGS
);
549 /* the calling IP is in the parent frame */
550 sframe
= (MonoPPCStackFrame
*)sframe
->sp
;
551 /* we substract 4, so that the IP points into the call instruction */
552 MONO_CONTEXT_SET_IP (new_ctx
, sframe
->lr
- 4);
554 regs
[ppc_lr
] = ctx
->sc_ir
;
555 regs
[ppc_sp
] = ctx
->sc_sp
;
556 for (i
= 0; i
< MONO_SAVED_GREGS
; ++i
)
557 regs
[ppc_r13
+ i
] = ctx
->regs
[i
];
559 mono_unwind_frame (unwind_info
, unwind_info_len
, ji
->code_start
,
560 (guint8
*)ji
->code_start
+ ji
->code_size
,
561 ip
, NULL
, regs
, ppc_lr
+ 1,
562 save_locations
, MONO_MAX_IREGS
, &cfa
);
564 /* we substract 4, so that the IP points into the call instruction */
565 MONO_CONTEXT_SET_IP (new_ctx
, regs
[ppc_lr
] - 4);
566 MONO_CONTEXT_SET_BP (new_ctx
, cfa
);
568 for (i
= 0; i
< MONO_SAVED_GREGS
; ++i
)
569 new_ctx
->regs
[i
] = regs
[ppc_r13
+ i
];
575 if ((ji
= mini_jit_info_table_find (domain
, (gpointer
)(*lmf
)->eip
, NULL
))) {
580 /* Trampoline lmf frame */
581 frame
->method
= (*lmf
)->method
;
584 /*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
585 MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
586 MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);*/
587 MONO_CONTEXT_SET_BP (new_ctx
, (*lmf
)->ebp
);
588 MONO_CONTEXT_SET_IP (new_ctx
, (*lmf
)->eip
);
589 memcpy (&new_ctx
->regs
, (*lmf
)->iregs
, sizeof (mgreg_t
) * MONO_SAVED_GREGS
);
590 memcpy (&new_ctx
->fregs
, (*lmf
)->fregs
, sizeof (double) * MONO_SAVED_FREGS
);
593 frame
->type
= FRAME_TYPE_MANAGED_TO_NATIVE
;
595 /* FIXME: what about trampoline LMF frames? see exceptions-x86.c */
597 *lmf
= (*lmf
)->previous_lmf
;
606 mono_arch_ip_from_context (void *sigctx
)
608 #ifdef MONO_CROSS_COMPILE
609 g_assert_not_reached ();
611 os_ucontext
*uc
= sigctx
;
612 return (gpointer
)UCONTEXT_REG_NIP(uc
);
617 mono_ppc_set_func_into_sigctx (void *sigctx
, void *func
)
619 #ifdef MONO_CROSS_COMPILE
620 g_assert_not_reached ();
621 #elif defined(PPC_USES_FUNCTION_DESCRIPTOR)
622 /* Have to set both the ip and the TOC reg */
623 os_ucontext
*uc
= sigctx
;
625 UCONTEXT_REG_NIP(uc
) = ((gsize
*)func
) [0];
626 UCONTEXT_REG_Rn (uc
, 2) = ((gsize
*)func
)[1];
628 g_assert_not_reached ();
633 altstack_handle_and_restore (void *sigctx
, gpointer obj
)
637 mono_sigctx_to_monoctx (sigctx
, &mctx
);
638 mono_handle_exception (&mctx
, obj
);
639 mono_restore_context (&mctx
);
643 mono_arch_handle_altstack_exception (void *sigctx
, MONO_SIG_HANDLER_INFO_TYPE
*siginfo
, gpointer fault_addr
, gboolean stack_ovf
)
645 #ifdef MONO_CROSS_COMPILE
646 g_assert_not_reached ();
648 #ifdef MONO_ARCH_USE_SIGACTION
649 os_ucontext
*uc
= (ucontext_t
*)sigctx
;
650 os_ucontext
*uc_copy
;
651 MonoJitInfo
*ji
= mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx
), NULL
);
657 /* we don't do much now, but we can warn the user with a useful message */
658 fprintf (stderr
, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx
), (gpointer
)UCONTEXT_REG_Rn(uc
, 1));
659 if (ji
&& !ji
->is_trampoline
&& jinfo_get_method (ji
))
660 method
= mono_method_full_name (jinfo_get_method (ji
), TRUE
);
662 method
= "Unmanaged";
663 fprintf (stderr
, "At %s\n", method
);
667 mono_handle_native_sigsegv (SIGSEGV
, sigctx
, siginfo
);
668 /* setup a call frame on the real stack so that control is returned there
669 * and exception handling can continue.
670 * The frame looks like:
673 * 224 is the size of the red zone
675 frame_size
= sizeof (ucontext_t
) + sizeof (gpointer
) * 16 + 224;
678 sp
= (gpointer
)(UCONTEXT_REG_Rn(uc
, 1) & ~15);
679 sp
= (gpointer
)((char*)sp
- frame_size
);
680 /* may need to adjust pointers in the new struct copy, depending on the OS */
681 uc_copy
= (ucontext_t
*)(sp
+ 16);
682 memcpy (uc_copy
, uc
, sizeof (os_ucontext
));
683 #if defined(__linux__) && !defined(__mono_ppc64__)
684 uc_copy
->uc_mcontext
.uc_regs
= (gpointer
)((char*)uc_copy
+ ((char*)uc
->uc_mcontext
.uc_regs
- (char*)uc
));
686 g_assert (mono_arch_ip_from_context (uc
) == mono_arch_ip_from_context (uc_copy
));
687 /* at the return form the signal handler execution starts in altstack_handle_and_restore() */
688 UCONTEXT_REG_LNK(uc
) = UCONTEXT_REG_NIP(uc
);
689 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
691 MonoPPCFunctionDescriptor
*handler_ftnptr
= (MonoPPCFunctionDescriptor
*)altstack_handle_and_restore
;
693 UCONTEXT_REG_NIP(uc
) = (gulong
)handler_ftnptr
->code
;
694 UCONTEXT_REG_Rn(uc
, 2) = (gulong
)handler_ftnptr
->toc
;
697 UCONTEXT_REG_NIP(uc
) = (unsigned long)altstack_handle_and_restore
;
699 UCONTEXT_REG_Rn(uc
, 1) = (unsigned long)sp
;
700 UCONTEXT_REG_Rn(uc
, PPC_FIRST_ARG_REG
) = (unsigned long)(sp
+ 16);
701 UCONTEXT_REG_Rn(uc
, PPC_FIRST_ARG_REG
+ 1) = 0;
702 UCONTEXT_REG_Rn(uc
, PPC_FIRST_ARG_REG
+ 2) = 0;
705 #endif /* !MONO_CROSS_COMPILE */
711 * Called by resuming from a signal handler.
714 handle_signal_exception (gpointer obj
)
716 MonoJitTlsData
*jit_tls
= mono_native_tls_get_value (mono_jit_tls_id
);
719 memcpy (&ctx
, &jit_tls
->ex_ctx
, sizeof (MonoContext
));
721 mono_handle_exception (&ctx
, obj
);
723 mono_restore_context (&ctx
);
727 setup_ucontext_return (void *uc
, gpointer func
)
729 #if !defined(MONO_CROSS_COMPILE)
730 UCONTEXT_REG_LNK(uc
) = UCONTEXT_REG_NIP(uc
);
731 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
733 MonoPPCFunctionDescriptor
*handler_ftnptr
= (MonoPPCFunctionDescriptor
*)func
;
735 UCONTEXT_REG_NIP(uc
) = (gulong
)handler_ftnptr
->code
;
736 UCONTEXT_REG_Rn(uc
, 2) = (gulong
)handler_ftnptr
->toc
;
739 UCONTEXT_REG_NIP(uc
) = (unsigned long)func
;
745 mono_arch_handle_exception (void *ctx
, gpointer obj
)
747 #if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
749 * Handling the exception in the signal handler is problematic, since the original
750 * signal is disabled, and we could run arbitrary code though the debugger. So
751 * resume into the normal stack and do most work there if possible.
753 MonoJitTlsData
*jit_tls
= mono_native_tls_get_value (mono_jit_tls_id
);
759 /* Pass the ctx parameter in TLS */
760 mono_sigctx_to_monoctx (sigctx
, &jit_tls
->ex_ctx
);
761 /* The others in registers */
762 UCONTEXT_REG_Rn (sigctx
, PPC_FIRST_ARG_REG
) = (gsize
)obj
;
764 /* Allocate a stack frame below the red zone */
765 /* Similar to mono_arch_handle_altstack_exception () */
769 sp
= (mgreg_t
)(UCONTEXT_REG_Rn(uc
, 1) & ~15);
770 sp
= (mgreg_t
)(sp
- frame_size
);
771 UCONTEXT_REG_Rn(uc
, 1) = (mgreg_t
)sp
;
772 setup_ucontext_return (uc
, handle_signal_exception
);
779 mono_sigctx_to_monoctx (ctx
, &mctx
);
781 result
= mono_handle_exception (&mctx
, obj
);
782 /* restore the context so that returning from the signal handler will invoke
785 mono_monoctx_to_sigctx (&mctx
, ctx
);
791 // FIX ME: This is not complete
793 mono_arch_setup_async_callback (MonoContext
*ctx
, void (*async_cb
)(void *fun
), gpointer user_data
)
795 uintptr_t sp
= (uintptr_t) MONO_CONTEXT_GET_SP(ctx
);
796 sp
-= PPC_MINIMAL_STACK_SIZE
;
797 *(unsigned long *)sp
= MONO_CONTEXT_GET_SP(ctx
);
798 MONO_CONTEXT_SET_BP(ctx
, sp
);
799 MONO_CONTEXT_SET_IP(ctx
, (unsigned long) async_cb
);