mono/mini/exceptions-ppc.c

   1 /*
   2  * exceptions-ppc.c: exception support for PowerPC
   3  *
   4  * Authors:
   5  *   Dietmar Maurer (dietmar@ximian.com)
   6  *   Paolo Molaro (lupus@ximian.com)
   7  *   Andreas Faerber <andreas.faerber@web.de>
   8  *
   9  * (C) 2001 Ximian, Inc.
  10  * (C) 2007-2008 Andreas Faerber
  11  */
  12
  13 #include <config.h>
  14 #include <glib.h>
  15 #include <signal.h>
  16 #include <string.h>
  17 #include <stddef.h>
  18 #if HAVE_UCONTEXT_H
  19 #include <ucontext.h>
  20 #endif
  21
  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>
  29
  30 #include "mini.h"
  31 #include "mini-ppc.h"
  32
  33 /*
  34
  35 struct sigcontext {
  36     int      sc_onstack;     // sigstack state to restore
  37     int      sc_mask;        // signal mask to restore
  38     int      sc_ir;          // pc
  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
  42 };
  43
  44 struct ucontext {
  45         int             uc_onstack;
  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
  51 };
  52
  53 typedef struct ppc_exception_state {
  54         unsigned long dar;      // Fault registers for coredump
  55         unsigned long dsisr;
  56         unsigned long exception;// number of powerpc exception taken
  57         unsigned long pad0;     // align to 16 bytes
  58
  59         unsigned long pad1[4];  // space in PCB "just in case"
  60 } ppc_exception_state_t;
  61
  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];
  68 } ppc_vector_state_t;
  69
  70 typedef struct ppc_float_state {
  71         double  fpregs[32];
  72
  73         unsigned int fpscr_pad; // fpscr is 64 bits, 32 bits of rubbish
  74         unsigned int fpscr;     // floating point status register
  75 } ppc_float_state_t;
  76
  77 typedef struct ppc_thread_state {
  78         unsigned int srr0;      // Instruction address register (PC)
  79         unsigned int srr1;      // Machine state register (supervisor)
  80         unsigned int r0;
  81         unsigned int r1;
  82         unsigned int r2;
  83         ...
  84         unsigned int r31;
  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)
  90
  91         unsigned int vrsave;    // Vector Save Register
  92 } ppc_thread_state_t;
  93
  94 struct mcontext {
  95         ppc_exception_state_t   es;
  96         ppc_thread_state_t      ss;
  97         ppc_float_state_t       fs;
  98         ppc_vector_state_t      vs;
  99 };
 100
 101 typedef struct mcontext  * mcontext_t;
 102
 103 Linux/PPC instead has:
 104 struct sigcontext {
 105         unsigned long   _unused[4];
 106         int             signal;
 107         unsigned long   handler;
 108         unsigned long   oldmask;
 109         struct pt_regs  *regs;
 110 };
 111 struct pt_regs {
 112         unsigned long gpr[32];
 113         unsigned long nip;
 114         unsigned long msr;
 115         unsigned long orig_gpr3;        // Used for restarting system calls
 116         unsigned long ctr;
 117         unsigned long link;
 118         unsigned long xer;
 119         unsigned long ccr;
 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
 128 };
 129 struct mcontext {
 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)));
 134 };
 135
 136 struct ucontext {
 137         unsigned long    uc_flags;
 138         struct ucontext *uc_link;
 139         stack_t          uc_stack;
 140         int              uc_pad[7];
 141         struct mcontext *uc_regs;       // points to uc_mcontext field
 142         sigset_t         uc_sigmask;
 143         // glibc has 1024-bit signal masks, ours are 64-bit
 144         int              uc_maskext[30];
 145         int              uc_pad2[3];
 146         struct mcontext  uc_mcontext;
 147 };
 148
 149 #define ELF_NGREG       48      // includes nip, msr, lr, etc.
 150 #define ELF_NFPREG      33      // includes fpscr
 151
 152 // General registers
 153 typedef unsigned long elf_greg_t;
 154 typedef elf_greg_t elf_gregset_t[ELF_NGREG];
 155
 156 // Floating point registers
 157 typedef double elf_fpreg_t;
 158 typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
 159
 160
 161 */
 162
 163
 164 #define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do {  \
 165                 int reg;        \
 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); \
 171                 }       \
 172         } while (0)
 173
 174 /* nothing to do */
 175 #define setup_context(ctx)
 176
 177 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
 178 guint8*
 179 mono_ppc_create_pre_code_ftnptr (guint8 *code)
 180 {
 181         MonoPPCFunctionDescriptor *ftnptr = (MonoPPCFunctionDescriptor*)code;
 182
 183         code += sizeof (MonoPPCFunctionDescriptor);
 184         ftnptr->code = code;
 185         ftnptr->toc = NULL;
 186         ftnptr->env = NULL;
 187
 188         return code;
 189 }
 190 #endif
 191
 192 /*
 193  * arch_get_restore_context:
 194  *
 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.
 197  */
 198 gpointer
 199 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
 200 {
 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;
 205
 206         code = start = mono_global_codeman_reserve (size);
 207         if (!aot)
 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);
 212         //ppc_break (code);
 213         /* jump to the saved IP */
 214         ppc_mtctr (code, ppc_r4);
 215         ppc_bcctr (code, PPC_BR_ALWAYS, 0);
 216         /* never reached */
 217         ppc_break (code);
 218
 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);
 222
 223         if (info)
 224                 *info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops);
 225
 226         return start;
 227 }
 228
 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))
 234
 235 static guint8*
 236 emit_save_saved_regs (guint8 *code, int pos)
 237 {
 238         int i;
 239
 240         for (i = 31; i >= 14; --i) {
 241                 pos -= sizeof (gdouble);
 242                 ppc_stfd (code, i, pos, ppc_sp);
 243         }
 244         pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
 245         ppc_store_multiple_regs (code, ppc_r13, pos, ppc_sp);
 246
 247         return code;
 248 }
 249
 250 /*
 251  * mono_arch_get_call_filter:
 252  *
 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).
 256  */
 257 gpointer
 258 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
 259 {
 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;
 265
 266         /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
 267         code = start = mono_global_codeman_reserve (size);
 268         if (!aot)
 269                 code = mono_ppc_create_pre_code_ftnptr (code);
 270
 271         /* store ret addr */
 272         ppc_mflr (code, ppc_r0);
 273         ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
 274
 275         alloc_size = REG_SAVE_STACK_FRAME_SIZE;
 276
 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);
 282
 283         code = emit_save_saved_regs (code, alloc_size);
 284
 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);
 291
 292         /* epilog */
 293         ppc_ldptr (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
 294         ppc_mtlr (code, ppc_r0);
 295
 296         /* restore all the regs from the stack */
 297         pos = alloc_size;
 298         for (i = 31; i >= 14; --i) {
 299                 pos -= sizeof (gdouble);
 300                 ppc_lfd (code, i, pos, ppc_sp);
 301         }
 302         pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
 303         ppc_load_multiple_regs (code, ppc_r13, pos, ppc_sp);
 304
 305         ppc_addic (code, ppc_sp, ppc_sp, alloc_size);
 306         ppc_blr (code);
 307
 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);
 311
 312         if (info)
 313                 *info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops);
 314
 315         return start;
 316 }
 317
 318 void
 319 mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow)
 320 {
 321         MonoError error;
 322         MonoContext ctx;
 323
 324         /* adjust eip so that it point into the call instruction */
 325         eip -= 4;
 326
 327         setup_context (&ctx);
 328
 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);
 334
 335         if (mono_object_isinst (exc, mono_defaults.exception_class, &error)) {
 336                 MonoException *mono_ex = (MonoException*)exc;
 337                 if (!rethrow) {
 338                         mono_ex->stack_trace = NULL;
 339                         mono_ex->trace_ips = NULL;
 340                 }
 341         }
 342         mono_error_assert_ok (&error);
 343         mono_handle_exception (&ctx, exc);
 344         mono_restore_context (&ctx);
 345
 346         g_assert_not_reached ();
 347 }
 348
 349 /**
 350  * arch_get_throw_exception_generic:
 351  *
 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)
 356  *
 357  */
 358 static gpointer
 359 mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corlib, gboolean rethrow, gboolean aot)
 360 {
 361         guint8 *start, *code;
 362         int alloc_size, pos;
 363         MonoJumpInfo *ji = NULL;
 364         GSList *unwind_ops = NULL;
 365
 366         code = start = mono_global_codeman_reserve (size);
 367         if (!aot)
 368                 code = mono_ppc_create_pre_code_ftnptr (code);
 369
 370         /* store ret addr */
 371         if (corlib)
 372                 ppc_mr (code, ppc_r0, ppc_r4);
 373         else
 374                 ppc_mflr (code, ppc_r0);
 375         ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
 376
 377         alloc_size = REG_SAVE_STACK_FRAME_SIZE;
 378
 379         g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
 380         ppc_stptr_update (code, ppc_sp, -alloc_size, ppc_sp);
 381
 382         code = emit_save_saved_regs (code, alloc_size);
 383
 384         //ppc_break (code);
 385         if (corlib) {
 386                 ppc_mr (code, ppc_r4, ppc_r3);
 387
 388                 if (aot) {
 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);
 395 #endif
 396                         ppc_mtctr (code, ppc_r12);
 397                         ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
 398                 } else {
 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);
 403                 }
 404         }
 405
 406         /* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
 407         /* caller sp */
 408         ppc_ldptr (code, ppc_r5, 0, ppc_sp);
 409         /* exc is already in place in r3 */
 410         if (corlib)
 411                 ppc_ldptr (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
 412         else
 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);
 421
 422         if (aot) {
 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);
 431 #endif
 432                 ppc_mtctr (code, ppc_r12);
 433                 ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
 434         } else {
 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);
 438         }
 439         /* we should never reach this breakpoint */
 440         ppc_break (code);
 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);
 444
 445         if (info)
 446                 *info = mono_tramp_info_create (corlib ? "throw_corlib_exception" : (rethrow ? "rethrow_exception" : "throw_exception"), start, code - start, ji, unwind_ops);
 447
 448         return start;
 449 }
 450
 451 /**
 452  * mono_arch_get_rethrow_exception:
 453  *
 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);
 457  *
 458  */
 459 gpointer
 460 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
 461 {
 462         int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
 463
 464         if (aot)
 465                 size += 64;
 466         return mono_arch_get_throw_exception_generic (size, info, FALSE, TRUE, aot);
 467 }
 468
 469 /**
 470  * arch_get_throw_exception:
 471  *
 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:
 476  *
 477  * x86_push_imm (code, mono_get_exception_arithmetic ());
 478  * x86_call_code (code, arch_get_throw_exception ());
 479  *
 480  */
 481 gpointer
 482 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
 483 {
 484         int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
 485
 486         if (aot)
 487                 size += 64;
 488         return mono_arch_get_throw_exception_generic (size, info, FALSE, FALSE, aot);
 489 }
 490
 491 /**
 492  * mono_arch_get_throw_corlib_exception:
 493  *
 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
 498  */
 499 gpointer
 500 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
 501 {
 502         int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE;
 503
 504         if (aot)
 505                 size += 64;
 506         return mono_arch_get_throw_exception_generic (size, info, TRUE, FALSE, aot);
 507 }
 508
 509 /*
 510  * mono_arch_unwind_frame:
 511  *
 512  * See exceptions-amd64.c for docs.
 513  */
 514 gboolean
 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)
 520 {
 521         gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 522         MonoPPCStackFrame *sframe;
 523
 524         memset (frame, 0, sizeof (StackFrameInfo));
 525         frame->ji = ji;
 526
 527         *new_ctx = *ctx;
 528         setup_context (new_ctx);
 529
 530         if (ji != NULL) {
 531                 int i;
 532                 mgreg_t regs [ppc_lr + 1];
 533                 guint8 *cfa;
 534                 guint32 unwind_info_len;
 535                 guint8 *unwind_info;
 536
 537                 if (ji->is_trampoline)
 538                         frame->type = FRAME_TYPE_TRAMPOLINE;
 539                 else
 540                         frame->type = FRAME_TYPE_MANAGED;
 541
 542                 unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);
 543
 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);
 555                 } else {
 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];
 560
 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);
 565
 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);
 569
 570                         for (i = 0; i < MONO_SAVED_GREGS; ++i)
 571                                 new_ctx->regs [i] = regs [ppc_r13 + i];
 572                 }
 573
 574                 return TRUE;
 575         } else if (*lmf) {
 576
 577                 if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
 578                 } else {
 579                         if (!(*lmf)->method)
 580                                 return FALSE;
 581
 582                         /* Trampoline lmf frame */
 583                         frame->method = (*lmf)->method;
 584                 }
 585
 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);
 593
 594                 frame->ji = ji;
 595                 frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
 596
 597                 /* FIXME: what about trampoline LMF frames?  see exceptions-x86.c */
 598
 599                 *lmf = (*lmf)->previous_lmf;
 600
 601                 return TRUE;
 602         }
 603
 604         return FALSE;
 605 }
 606
 607 gpointer
 608 mono_arch_ip_from_context (void *sigctx)
 609 {
 610 #ifdef MONO_CROSS_COMPILE
 611         g_assert_not_reached ();
 612 #else
 613         os_ucontext *uc = sigctx;
 614         return (gpointer)UCONTEXT_REG_NIP(uc);
 615 #endif
 616 }
 617
 618 void
 619 mono_ppc_set_func_into_sigctx (void *sigctx, void *func)
 620 {
 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;
 626
 627         UCONTEXT_REG_NIP(uc) = ((gsize*)func) [0];
 628         UCONTEXT_REG_Rn (uc, 2) = ((gsize*)func)[1];
 629 #else
 630         g_assert_not_reached ();
 631 #endif
 632 }
 633
 634 static void
 635 altstack_handle_and_restore (void *sigctx, gpointer obj)
 636 {
 637         MonoContext mctx;
 638
 639         mono_sigctx_to_monoctx (sigctx, &mctx);
 640         mono_handle_exception (&mctx, obj);
 641         mono_restore_context (&mctx);
 642 }
 643
 644 void
 645 mono_arch_handle_altstack_exception (void *sigctx, MONO_SIG_HANDLER_INFO_TYPE *siginfo, gpointer fault_addr, gboolean stack_ovf)
 646 {
 647 #ifdef MONO_CROSS_COMPILE
 648         g_assert_not_reached ();
 649 #else
 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);
 654         gpointer *sp;
 655         int frame_size;
 656
 657         if (stack_ovf) {
 658                 const char *method;
 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);
 663                 else
 664                         method = "Unmanaged";
 665                 fprintf (stderr, "At %s\n", method);
 666                 abort ();
 667         }
 668         if (!ji)
 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:
 673          *   ucontext struct
 674          *   ...
 675          * 224 is the size of the red zone
 676          */
 677         frame_size = sizeof (ucontext_t) + sizeof (gpointer) * 16 + 224;
 678         frame_size += 15;
 679         frame_size &= ~15;
 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));
 687 #endif
 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
 692         {
 693                 MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)altstack_handle_and_restore;
 694
 695                 UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
 696                 UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
 697         }
 698 #else
 699         UCONTEXT_REG_NIP(uc) = (unsigned long)altstack_handle_and_restore;
 700 #endif
 701         UCONTEXT_REG_Rn(uc, 1) = (unsigned long)sp;
 702         UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG) = (unsigned long)(sp + 16);
 703         UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 1) = 0;
 704         UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 2) = 0;
 705 #endif
 706
 707 #endif /* !MONO_CROSS_COMPILE */
 708 }
 709
 710 /*
 711  * handle_exception:
 712  *
 713  *   Called by resuming from a signal handler.
 714  */
 715 static void
 716 handle_signal_exception (gpointer obj)
 717 {
 718         MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
 719         MonoContext ctx;
 720
 721         memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
 722
 723         mono_handle_exception (&ctx, obj);
 724
 725         mono_restore_context (&ctx);
 726 }
 727
 728 static void
 729 setup_ucontext_return (void *uc, gpointer func)
 730 {
 731 #if !defined(MONO_CROSS_COMPILE)
 732         UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
 733 #ifdef PPC_USES_FUNCTION_DESCRIPTOR
 734         {
 735                 MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)func;
 736
 737                 UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
 738                 UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
 739         }
 740 #else
 741         UCONTEXT_REG_NIP(uc) = (unsigned long)func;
 742 #endif
 743 #endif
 744 }
 745
 746 gboolean
 747 mono_arch_handle_exception (void *ctx, gpointer obj)
 748 {
 749 #if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
 750         /*
 751          * Handling the exception in the signal handler is problematic, since the original
 752          * signal is disabled, and we could run arbitrary code though the debugger. So
 753          * resume into the normal stack and do most work there if possible.
 754          */
 755         MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
 756         mgreg_t sp;
 757         void *sigctx = ctx;
 758         int frame_size;
 759         void *uc = sigctx;
 760
 761         /* Pass the ctx parameter in TLS */
 762         mono_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
 763         /* The others in registers */
 764         UCONTEXT_REG_Rn (sigctx, PPC_FIRST_ARG_REG) = (gsize)obj;
 765
 766         /* Allocate a stack frame below the red zone */
 767         /* Similar to mono_arch_handle_altstack_exception () */
 768         frame_size = 224;
 769         frame_size += 15;
 770         frame_size &= ~15;
 771         sp = (mgreg_t)(UCONTEXT_REG_Rn(uc, 1) & ~15);
 772         sp = (mgreg_t)(sp - frame_size);
 773         UCONTEXT_REG_Rn(uc, 1) = (mgreg_t)sp;
 774         setup_ucontext_return (uc, handle_signal_exception);
 775
 776         return TRUE;
 777 #else
 778         MonoContext mctx;
 779         gboolean result;
 780
 781         mono_sigctx_to_monoctx (ctx, &mctx);
 782
 783         result = mono_handle_exception (&mctx, obj);
 784         /* restore the context so that returning from the signal handler will invoke
 785          * the catch clause
 786          */
 787         mono_monoctx_to_sigctx (&mctx, ctx);
 788         return result;
 789 #endif
 790 }
 791
 792
 793 // FIX ME: This is not complete
 794 void
 795 mono_arch_setup_async_callback (MonoContext *ctx, void (*async_cb)(void *fun), gpointer user_data)
 796 {
 797         uintptr_t sp = (uintptr_t) MONO_CONTEXT_GET_SP(ctx);
 798         sp -= PPC_MINIMAL_STACK_SIZE;
 799         *(unsigned long *)sp = MONO_CONTEXT_GET_SP(ctx);
 800         MONO_CONTEXT_SET_BP(ctx, sp);
 801         MONO_CONTEXT_SET_IP(ctx, (unsigned long) async_cb);
 802 }
 803