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
)
324 /* adjust eip so that it point into the call instruction */
327 setup_context (&ctx
);
329 /*printf ("stack in throw: %p\n", esp);*/
330 MONO_CONTEXT_SET_BP (&ctx
, esp
);
331 MONO_CONTEXT_SET_IP (&ctx
, eip
);
332 memcpy (&ctx
.regs
, int_regs
, sizeof (mgreg_t
) * MONO_SAVED_GREGS
);
333 memcpy (&ctx
.fregs
, fp_regs
, sizeof (double) * MONO_SAVED_FREGS
);
335 if (mono_object_isinst_checked (exc
, mono_defaults
.exception_class
, &error
)) {
336 MonoException
*mono_ex
= (MonoException
*)exc
;
338 mono_ex
->stack_trace
= NULL
;
339 mono_ex
->trace_ips
= NULL
;
342 mono_error_assert_ok (&error
);
343 mono_handle_exception (&ctx
, exc
);
344 mono_restore_context (&ctx
);
346 g_assert_not_reached ();
350 * arch_get_throw_exception_generic:
352 * Returns a function pointer which can be used to raise
353 * exceptions. The returned function has the following
354 * signature: void (*func) (MonoException *exc); or
355 * void (*func) (guint32 ex_token, gpointer ip)
359 mono_arch_get_throw_exception_generic (int size
, MonoTrampInfo
**info
, int corlib
, gboolean rethrow
, gboolean aot
)
361 guint8
*start
, *code
;
363 MonoJumpInfo
*ji
= NULL
;
364 GSList
*unwind_ops
= NULL
;
366 code
= start
= mono_global_codeman_reserve (size
);
368 code
= mono_ppc_create_pre_code_ftnptr (code
);
372 ppc_mr (code
, ppc_r0
, ppc_r4
);
374 ppc_mflr (code
, ppc_r0
);
375 ppc_stptr (code
, ppc_r0
, PPC_RET_ADDR_OFFSET
, ppc_sp
);
377 alloc_size
= REG_SAVE_STACK_FRAME_SIZE
;
379 g_assert ((alloc_size
& (MONO_ARCH_FRAME_ALIGNMENT
-1)) == 0);
380 ppc_stptr_update (code
, ppc_sp
, -alloc_size
, ppc_sp
);
382 code
= emit_save_saved_regs (code
, alloc_size
);
386 ppc_mr (code
, ppc_r4
, ppc_r3
);
389 code
= mono_arch_emit_load_aotconst (start
, code
, &ji
, MONO_PATCH_INFO_IMAGE
, mono_defaults
.corlib
);
390 ppc_mr (code
, ppc_r3
, ppc_r12
);
391 code
= mono_arch_emit_load_aotconst (start
, code
, &ji
, MONO_PATCH_INFO_JIT_ICALL_ADDR
, "mono_exception_from_token");
392 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
393 ppc_ldptr (code
, ppc_r2
, sizeof (gpointer
), ppc_r12
);
394 ppc_ldptr (code
, ppc_r12
, 0, ppc_r12
);
396 ppc_mtctr (code
, ppc_r12
);
397 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
399 ppc_load (code
, ppc_r3
, (gulong
)mono_defaults
.corlib
);
400 ppc_load_func (code
, PPC_CALL_REG
, mono_exception_from_token
);
401 ppc_mtctr (code
, PPC_CALL_REG
);
402 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
406 /* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
408 ppc_ldptr (code
, ppc_r5
, 0, ppc_sp
);
409 /* exc is already in place in r3 */
411 ppc_ldptr (code
, ppc_r4
, PPC_RET_ADDR_OFFSET
, ppc_r5
);
413 ppc_mr (code
, ppc_r4
, ppc_r0
); /* caller ip */
414 /* pointer to the saved fp regs */
415 pos
= alloc_size
- sizeof (gdouble
) * MONO_SAVED_FREGS
;
416 ppc_addi (code
, ppc_r7
, ppc_sp
, pos
);
417 /* pointer to the saved int regs */
418 pos
-= sizeof (gpointer
) * MONO_SAVED_GREGS
;
419 ppc_addi (code
, ppc_r6
, ppc_sp
, pos
);
420 ppc_li (code
, ppc_r8
, rethrow
);
423 // This can be called from runtime code, which can't guarantee that
424 // r30 contains the got address.
425 // So emit the got address loading code too
426 code
= mono_arch_emit_load_got_addr (start
, code
, NULL
, &ji
);
427 code
= mono_arch_emit_load_aotconst (start
, code
, &ji
, MONO_PATCH_INFO_JIT_ICALL_ADDR
, "mono_ppc_throw_exception");
428 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
429 ppc_ldptr (code
, ppc_r2
, sizeof (gpointer
), ppc_r12
);
430 ppc_ldptr (code
, ppc_r12
, 0, ppc_r12
);
432 ppc_mtctr (code
, ppc_r12
);
433 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
435 ppc_load_func (code
, PPC_CALL_REG
, mono_ppc_throw_exception
);
436 ppc_mtctr (code
, PPC_CALL_REG
);
437 ppc_bcctrl (code
, PPC_BR_ALWAYS
, 0);
439 /* we should never reach this breakpoint */
441 g_assert ((code
- start
) <= size
);
442 mono_arch_flush_icache (start
, code
- start
);
443 mono_profiler_code_buffer_new (start
, code
- start
, MONO_PROFILER_CODE_BUFFER_EXCEPTION_HANDLING
, NULL
);
446 *info
= mono_tramp_info_create (corlib
? "throw_corlib_exception" : (rethrow
? "rethrow_exception" : "throw_exception"), start
, code
- start
, ji
, unwind_ops
);
452 * mono_arch_get_rethrow_exception:
454 * Returns a function pointer which can be used to rethrow
455 * exceptions. The returned function has the following
456 * signature: void (*func) (MonoException *exc);
460 mono_arch_get_rethrow_exception (MonoTrampInfo
**info
, gboolean aot
)
462 int size
= MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE
;
466 return mono_arch_get_throw_exception_generic (size
, info
, FALSE
, TRUE
, aot
);
470 * arch_get_throw_exception:
472 * Returns a function pointer which can be used to raise
473 * exceptions. The returned function has the following
474 * signature: void (*func) (MonoException *exc);
475 * For example to raise an arithmetic exception you can use:
477 * x86_push_imm (code, mono_get_exception_arithmetic ());
478 * x86_call_code (code, arch_get_throw_exception ());
482 mono_arch_get_throw_exception (MonoTrampInfo
**info
, gboolean aot
)
484 int size
= MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE
;
488 return mono_arch_get_throw_exception_generic (size
, info
, FALSE
, FALSE
, aot
);
492 * mono_arch_get_throw_corlib_exception:
494 * Returns a function pointer which can be used to raise
495 * corlib exceptions. The returned function has the following
496 * signature: void (*func) (guint32 ex_token, guint32 offset);
497 * On PPC, we pass the ip instead of the offset
500 mono_arch_get_throw_corlib_exception (MonoTrampInfo
**info
, gboolean aot
)
502 int size
= MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE
;
506 return mono_arch_get_throw_exception_generic (size
, info
, TRUE
, FALSE
, aot
);
510 * mono_arch_unwind_frame:
512 * See exceptions-amd64.c for docs.
515 mono_arch_unwind_frame (MonoDomain
*domain
, MonoJitTlsData
*jit_tls
,
516 MonoJitInfo
*ji
, MonoContext
*ctx
,
517 MonoContext
*new_ctx
, MonoLMF
**lmf
,
518 mgreg_t
**save_locations
,
519 StackFrameInfo
*frame
)
521 gpointer ip
= MONO_CONTEXT_GET_IP (ctx
);
522 MonoPPCStackFrame
*sframe
;
524 memset (frame
, 0, sizeof (StackFrameInfo
));
528 setup_context (new_ctx
);
532 mgreg_t regs
[ppc_lr
+ 1];
534 guint32 unwind_info_len
;
537 if (ji
->is_trampoline
)
538 frame
->type
= FRAME_TYPE_TRAMPOLINE
;
540 frame
->type
= FRAME_TYPE_MANAGED
;
542 unwind_info
= mono_jinfo_get_unwind_info (ji
, &unwind_info_len
);
544 sframe
= (MonoPPCStackFrame
*)MONO_CONTEXT_GET_SP (ctx
);
545 MONO_CONTEXT_SET_BP (new_ctx
, sframe
->sp
);
546 if (!ji
->is_trampoline
&& jinfo_get_method (ji
)->save_lmf
) {
547 /* sframe->sp points just past the end of the LMF */
548 guint8
*lmf_addr
= (guint8
*)sframe
->sp
- sizeof (MonoLMF
);
549 memcpy (&new_ctx
->fregs
, lmf_addr
+ G_STRUCT_OFFSET (MonoLMF
, fregs
), sizeof (double) * MONO_SAVED_FREGS
);
550 memcpy (&new_ctx
->regs
, lmf_addr
+ G_STRUCT_OFFSET (MonoLMF
, iregs
), sizeof (mgreg_t
) * MONO_SAVED_GREGS
);
551 /* the calling IP is in the parent frame */
552 sframe
= (MonoPPCStackFrame
*)sframe
->sp
;
553 /* we substract 4, so that the IP points into the call instruction */
554 MONO_CONTEXT_SET_IP (new_ctx
, sframe
->lr
- 4);
556 regs
[ppc_lr
] = ctx
->sc_ir
;
557 regs
[ppc_sp
] = ctx
->sc_sp
;
558 for (i
= 0; i
< MONO_SAVED_GREGS
; ++i
)
559 regs
[ppc_r13
+ i
] = ctx
->regs
[i
];
561 mono_unwind_frame (unwind_info
, unwind_info_len
, ji
->code_start
,
562 (guint8
*)ji
->code_start
+ ji
->code_size
,
563 ip
, NULL
, regs
, ppc_lr
+ 1,
564 save_locations
, MONO_MAX_IREGS
, &cfa
);
566 /* we substract 4, so that the IP points into the call instruction */
567 MONO_CONTEXT_SET_IP (new_ctx
, regs
[ppc_lr
] - 4);
568 MONO_CONTEXT_SET_BP (new_ctx
, cfa
);
570 for (i
= 0; i
< MONO_SAVED_GREGS
; ++i
)
571 new_ctx
->regs
[i
] = regs
[ppc_r13
+ i
];
577 if ((ji
= mini_jit_info_table_find (domain
, (gpointer
)(*lmf
)->eip
, NULL
))) {
582 /* Trampoline lmf frame */
583 frame
->method
= (*lmf
)->method
;
586 /*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
587 MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
588 MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);*/
589 MONO_CONTEXT_SET_BP (new_ctx
, (*lmf
)->ebp
);
590 MONO_CONTEXT_SET_IP (new_ctx
, (*lmf
)->eip
);
591 memcpy (&new_ctx
->regs
, (*lmf
)->iregs
, sizeof (mgreg_t
) * MONO_SAVED_GREGS
);
592 memcpy (&new_ctx
->fregs
, (*lmf
)->fregs
, sizeof (double) * MONO_SAVED_FREGS
);
595 frame
->type
= FRAME_TYPE_MANAGED_TO_NATIVE
;
597 /* FIXME: what about trampoline LMF frames? see exceptions-x86.c */
599 *lmf
= (*lmf
)->previous_lmf
;
608 mono_arch_ip_from_context (void *sigctx
)
610 #ifdef MONO_CROSS_COMPILE
611 g_assert_not_reached ();
613 os_ucontext
*uc
= sigctx
;
614 return (gpointer
)UCONTEXT_REG_NIP(uc
);
619 mono_ppc_set_func_into_sigctx (void *sigctx
, void *func
)
621 #ifdef MONO_CROSS_COMPILE
622 g_assert_not_reached ();
623 #elif defined(PPC_USES_FUNCTION_DESCRIPTOR)
624 /* Have to set both the ip and the TOC reg */
625 os_ucontext
*uc
= sigctx
;
627 UCONTEXT_REG_NIP(uc
) = ((gsize
*)func
) [0];
628 UCONTEXT_REG_Rn (uc
, 2) = ((gsize
*)func
)[1];
630 g_assert_not_reached ();
635 altstack_handle_and_restore (void *sigctx
, gpointer obj
)
639 mono_sigctx_to_monoctx (sigctx
, &mctx
);
640 mono_handle_exception (&mctx
, obj
);
641 mono_restore_context (&mctx
);
645 mono_arch_handle_altstack_exception (void *sigctx
, MONO_SIG_HANDLER_INFO_TYPE
*siginfo
, gpointer fault_addr
, gboolean stack_ovf
)
647 #ifdef MONO_CROSS_COMPILE
648 g_assert_not_reached ();
650 #ifdef MONO_ARCH_USE_SIGACTION
651 os_ucontext
*uc
= (ucontext_t
*)sigctx
;
652 os_ucontext
*uc_copy
;
653 MonoJitInfo
*ji
= mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx
), NULL
);
659 /* we don't do much now, but we can warn the user with a useful message */
660 fprintf (stderr
, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx
), (gpointer
)UCONTEXT_REG_Rn(uc
, 1));
661 if (ji
&& !ji
->is_trampoline
&& jinfo_get_method (ji
))
662 method
= mono_method_full_name (jinfo_get_method (ji
), TRUE
);
664 method
= "Unmanaged";
665 fprintf (stderr
, "At %s\n", method
);
669 mono_handle_native_sigsegv (SIGSEGV
, sigctx
, siginfo
);
670 /* setup a call frame on the real stack so that control is returned there
671 * and exception handling can continue.
672 * The frame looks like:
675 * 224 is the size of the red zone
677 frame_size
= sizeof (ucontext_t
) + sizeof (gpointer
) * 16 + 224;
680 sp
= (gpointer
)(UCONTEXT_REG_Rn(uc
, 1) & ~15);
681 sp
= (gpointer
)((char*)sp
- frame_size
);
682 /* may need to adjust pointers in the new struct copy, depending on the OS */
683 uc_copy
= (ucontext_t
*)(sp
+ 16);
684 memcpy (uc_copy
, uc
, sizeof (os_ucontext
));
685 #if defined(__linux__) && !defined(__mono_ppc64__)
686 uc_copy
->uc_mcontext
.uc_regs
= (gpointer
)((char*)uc_copy
+ ((char*)uc
->uc_mcontext
.uc_regs
- (char*)uc
));
688 g_assert (mono_arch_ip_from_context (uc
) == mono_arch_ip_from_context (uc_copy
));
689 /* at the return form the signal handler execution starts in altstack_handle_and_restore() */
690 UCONTEXT_REG_LNK(uc
) = UCONTEXT_REG_NIP(uc
);
691 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
693 MonoPPCFunctionDescriptor
*handler_ftnptr
= (MonoPPCFunctionDescriptor
*)altstack_handle_and_restore
;
695 UCONTEXT_REG_NIP(uc
) = (gulong
)handler_ftnptr
->code
;
696 UCONTEXT_REG_Rn(uc
, 2) = (gulong
)handler_ftnptr
->toc
;
699 UCONTEXT_REG_NIP(uc
) = (unsigned long)altstack_handle_and_restore
;
701 /* ELF v2 ABI calling convention requires to put the target address into
702 * r12 if we use the global entry point of a function. */
703 UCONTEXT_REG_Rn(uc
, 12) = (unsigned long) altstack_handle_and_restore
;
706 UCONTEXT_REG_Rn(uc
, 1) = (unsigned long)sp
;
707 UCONTEXT_REG_Rn(uc
, PPC_FIRST_ARG_REG
) = (unsigned long)(sp
+ 16);
708 UCONTEXT_REG_Rn(uc
, PPC_FIRST_ARG_REG
+ 1) = 0;
709 UCONTEXT_REG_Rn(uc
, PPC_FIRST_ARG_REG
+ 2) = 0;
712 #endif /* !MONO_CROSS_COMPILE */
718 * Called by resuming from a signal handler.
721 handle_signal_exception (gpointer obj
)
723 MonoJitTlsData
*jit_tls
= mono_native_tls_get_value (mono_jit_tls_id
);
726 memcpy (&ctx
, &jit_tls
->ex_ctx
, sizeof (MonoContext
));
728 mono_handle_exception (&ctx
, obj
);
730 mono_restore_context (&ctx
);
734 setup_ucontext_return (void *uc
, gpointer func
)
736 #if !defined(MONO_CROSS_COMPILE)
737 UCONTEXT_REG_LNK(uc
) = UCONTEXT_REG_NIP(uc
);
738 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
740 MonoPPCFunctionDescriptor
*handler_ftnptr
= (MonoPPCFunctionDescriptor
*)func
;
742 UCONTEXT_REG_NIP(uc
) = (gulong
)handler_ftnptr
->code
;
743 UCONTEXT_REG_Rn(uc
, 2) = (gulong
)handler_ftnptr
->toc
;
746 UCONTEXT_REG_NIP(uc
) = (unsigned long)func
;
748 /* ELF v2 ABI calling convention requires to put the target address into
749 * r12 if we use the global entry point of a function. */
750 UCONTEXT_REG_Rn(uc
, 12) = (unsigned long) func
;
757 mono_arch_handle_exception (void *ctx
, gpointer obj
)
759 #if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
761 * Handling the exception in the signal handler is problematic, since the original
762 * signal is disabled, and we could run arbitrary code though the debugger. So
763 * resume into the normal stack and do most work there if possible.
765 MonoJitTlsData
*jit_tls
= mono_native_tls_get_value (mono_jit_tls_id
);
771 /* Pass the ctx parameter in TLS */
772 mono_sigctx_to_monoctx (sigctx
, &jit_tls
->ex_ctx
);
773 /* The others in registers */
774 UCONTEXT_REG_Rn (sigctx
, PPC_FIRST_ARG_REG
) = (gsize
)obj
;
776 /* Allocate a stack frame below the red zone */
777 /* Similar to mono_arch_handle_altstack_exception () */
781 sp
= (mgreg_t
)(UCONTEXT_REG_Rn(uc
, 1) & ~15);
782 sp
= (mgreg_t
)(sp
- frame_size
);
783 UCONTEXT_REG_Rn(uc
, 1) = (mgreg_t
)sp
;
784 setup_ucontext_return (uc
, handle_signal_exception
);
791 mono_sigctx_to_monoctx (ctx
, &mctx
);
793 result
= mono_handle_exception (&mctx
, obj
);
794 /* restore the context so that returning from the signal handler will invoke
797 mono_monoctx_to_sigctx (&mctx
, ctx
);
803 // FIX ME: This is not complete
805 mono_arch_setup_async_callback (MonoContext
*ctx
, void (*async_cb
)(void *fun
), gpointer user_data
)
807 uintptr_t sp
= (uintptr_t) MONO_CONTEXT_GET_SP(ctx
);
808 sp
-= PPC_MINIMAL_STACK_SIZE
;
809 *(unsigned long *)sp
= MONO_CONTEXT_GET_SP(ctx
);
810 MONO_CONTEXT_SET_BP(ctx
, sp
);
811 MONO_CONTEXT_SET_IP(ctx
, (unsigned long) async_cb
);