X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Fexceptions-ppc.c;h=80bbb3f9190d461b8503ca31569dd93d2ed5c9a6;hb=073752949f4e7846f3a9de365660077d44e22082;hp=f8feae5bbe67bd61fdaa39c4b92fa43a3cb17b10;hpb=0ec3b9f1d47758a88a1e6cc68e61743042524103;p=mono.git

diff --git a/mono/mini/exceptions-ppc.c b/mono/mini/exceptions-ppc.c
index f8feae5bbe6..80bbb3f9190 100644
--- a/mono/mini/exceptions-ppc.c
+++ b/mono/mini/exceptions-ppc.c
@@ -163,7 +163,7 @@ typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
 
 #define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do {	\
 		int reg;	\
-		ppc_load_reg (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg);	\
+		ppc_ldptr (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg);	\
 		ppc_load_multiple_regs (code, ppc_r13, G_STRUCT_OFFSET (MonoContext, regs), ctx_reg);	\
 		for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) {	\
 			ppc_lfd (code, (14 + reg),	\
@@ -196,21 +196,19 @@ mono_ppc_create_pre_code_ftnptr (guint8 *code)
  * The first argument in r3 is the pointer to the context.
  */
 gpointer
-mono_arch_get_restore_context (void)
+mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
 {
-	static guint8 *start = NULL;
-
-	guint8 *code;
+	guint8 *start, *code;
 	int size = MONO_PPC_32_64_CASE (128, 172) + PPC_FTNPTR_SIZE;
-
-	if (start)
-		return start;
+	MonoJumpInfo *ji = NULL;
+	GSList *unwind_ops = NULL;
 
 	code = start = mono_global_codeman_reserve (size);
-	code = mono_ppc_create_pre_code_ftnptr (code);
+	if (!aot)
+		code = mono_ppc_create_pre_code_ftnptr (code);
 	restore_regs_from_context (ppc_r3, ppc_r4, ppc_r5);
 	/* restore also the stack pointer */
-	ppc_load_reg (code, ppc_sp, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
+	ppc_ldptr (code, ppc_sp, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
 	//ppc_break (code);
 	/* jump to the saved IP */
 	ppc_mtctr (code, ppc_r4);
@@ -220,6 +218,10 @@ mono_arch_get_restore_context (void)
 
 	g_assert ((code - start) <= size);
 	mono_arch_flush_icache (start, code - start);
+
+	if (info)
+		*info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops);
+
 	return start;
 }
 
@@ -252,32 +254,30 @@ emit_save_saved_regs (guint8 *code, int pos)
  * @exc object in this case).
  */
 gpointer
-mono_arch_get_call_filter (void)
+mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
 {
-	static guint8 *start = NULL;
-
-	guint8 *code;
+	guint8 *start, *code;
 	int alloc_size, pos, i;
 	int size = MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE;
-
-	if (start)
-		return start;
+	MonoJumpInfo *ji = NULL;
+	GSList *unwind_ops = NULL;
 
 	/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
 	code = start = mono_global_codeman_reserve (size);
-	code = mono_ppc_create_pre_code_ftnptr (code);
+	if (!aot)
+		code = mono_ppc_create_pre_code_ftnptr (code);
 
 	/* store ret addr */
 	ppc_mflr (code, ppc_r0);
-	ppc_store_reg (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+	ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
 
 	alloc_size = REG_SAVE_STACK_FRAME_SIZE;
 
 	/* allocate stack frame and set link from sp in ctx */
 	g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
-	ppc_load_reg (code, ppc_r0, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
-	ppc_load_reg_indexed (code, ppc_r0, ppc_r0, ppc_r0);
-	ppc_store_reg_update (code, ppc_r0, -alloc_size, ppc_sp);
+	ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
+	ppc_ldptr_indexed (code, ppc_r0, ppc_r0, ppc_r0);
+	ppc_stptr_update (code, ppc_r0, -alloc_size, ppc_sp);
 
 	code = emit_save_saved_regs (code, alloc_size);
 
@@ -289,7 +289,7 @@ mono_arch_get_call_filter (void)
 	ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
 
 	/* epilog */
-	ppc_load_reg (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
+	ppc_ldptr (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
 	ppc_mtlr (code, ppc_r0);
 
 	/* restore all the regs from the stack */
@@ -306,18 +306,18 @@ mono_arch_get_call_filter (void)
 
 	g_assert ((code - start) < size);
 	mono_arch_flush_icache (start, code - start);
+
+	if (info)
+		*info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops);
+
 	return start;
 }
 
-static void
-throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs, gboolean rethrow)
+void
+mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow)
 {
-	static void (*restore_context) (MonoContext *);
 	MonoContext ctx;
 
-	if (!restore_context)
-		restore_context = mono_arch_get_restore_context ();
-
 	/* adjust eip so that it point into the call instruction */
 	eip -= 4;
 
@@ -326,7 +326,7 @@ throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *
 	/*printf ("stack in throw: %p\n", esp);*/
 	MONO_CONTEXT_SET_BP (&ctx, esp);
 	MONO_CONTEXT_SET_IP (&ctx, eip);
-	memcpy (&ctx.regs, int_regs, sizeof (gulong) * MONO_SAVED_GREGS);
+	memcpy (&ctx.regs, int_regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
 	memcpy (&ctx.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS);
 
 	if (mono_object_isinst (exc, mono_defaults.exception_class)) {
@@ -334,8 +334,8 @@ throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *
 		if (!rethrow)
 			mono_ex->stack_trace = NULL;
 	}
-	mono_handle_exception (&ctx, exc, (gpointer)eip, FALSE);
-	restore_context (&ctx);
+	mono_handle_exception (&ctx, exc);
+	mono_restore_context (&ctx);
 
 	g_assert_not_reached ();
 }
@@ -349,43 +349,60 @@ throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *
  * void (*func) (guint32 ex_token, gpointer ip)
  *
  */
-static gpointer 
-mono_arch_get_throw_exception_generic (guint8 *start, int size, int corlib, gboolean rethrow)
+static gpointer
+mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corlib, gboolean rethrow, gboolean aot)
 {
-	guint8 *code;
+	guint8 *start, *code;
 	int alloc_size, pos;
+	MonoJumpInfo *ji = NULL;
+	GSList *unwind_ops = NULL;
 
-	code = mono_ppc_create_pre_code_ftnptr (start);
+	code = start = mono_global_codeman_reserve (size);
+	if (!aot)
+		code = mono_ppc_create_pre_code_ftnptr (code);
 
 	/* store ret addr */
 	if (corlib)
 		ppc_mr (code, ppc_r0, ppc_r4);
 	else
 		ppc_mflr (code, ppc_r0);
-	ppc_store_reg (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+	ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
 
 	alloc_size = REG_SAVE_STACK_FRAME_SIZE;
 
 	g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
-	ppc_store_reg_update (code, ppc_sp, -alloc_size, ppc_sp);
+	ppc_stptr_update (code, ppc_sp, -alloc_size, ppc_sp);
 
 	code = emit_save_saved_regs (code, alloc_size);
 
 	//ppc_break (code);
 	if (corlib) {
 		ppc_mr (code, ppc_r4, ppc_r3);
-		ppc_load (code, ppc_r3, (gulong)mono_defaults.corlib);
-		ppc_load_func (code, ppc_r0, mono_exception_from_token);
-		ppc_mtctr (code, ppc_r0);
-		ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+
+		if (aot) {
+			code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_IMAGE, mono_defaults.corlib);
+			ppc_mr (code, ppc_r3, ppc_r11);
+			code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_exception_from_token");
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+			ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
+			ppc_ldptr (code, ppc_r11, 0, ppc_r11);
+#endif
+			ppc_mtctr (code, ppc_r11);
+			ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+		} else {
+			ppc_load (code, ppc_r3, (gulong)mono_defaults.corlib);
+			ppc_load_func (code, ppc_r0, mono_exception_from_token);
+			ppc_mtctr (code, ppc_r0);
+			ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+		}
 	}
 
 	/* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
 	/* caller sp */
-	ppc_load_reg (code, ppc_r5, 0, ppc_sp);
+	ppc_ldptr (code, ppc_r5, 0, ppc_sp);
 	/* exc is already in place in r3 */
 	if (corlib)
-		ppc_load_reg (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
+		ppc_ldptr (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
 	else
 		ppc_mr (code, ppc_r4, ppc_r0); /* caller ip */
 	/* pointer to the saved fp regs */
@@ -396,13 +413,31 @@ mono_arch_get_throw_exception_generic (guint8 *start, int size, int corlib, gboo
 	ppc_addi (code, ppc_r6, ppc_sp, pos);
 	ppc_li (code, ppc_r8, rethrow);
 
-	ppc_load_func (code, ppc_r0, throw_exception);
-	ppc_mtctr (code, ppc_r0);
-	ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+	if (aot) {
+		// This can be called from runtime code, which can't guarantee that
+		// r30 contains the got address.
+		// So emit the got address loading code too
+		code = mono_arch_emit_load_got_addr (start, code, NULL, &ji);
+		code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_ppc_throw_exception");
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+		ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
+		ppc_ldptr (code, ppc_r11, 0, ppc_r11);
+#endif
+		ppc_mtctr (code, ppc_r11);
+		ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+	} else {
+		ppc_load_func (code, ppc_r0, mono_ppc_throw_exception);
+		ppc_mtctr (code, ppc_r0);
+		ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+	}
 	/* we should never reach this breakpoint */
 	ppc_break (code);
 	g_assert ((code - start) <= size);
 	mono_arch_flush_icache (start, code - start);
+
+	if (info)
+		*info = mono_tramp_info_create (corlib ? "throw_corlib_exception" : (rethrow ? "rethrow_exception" : "throw_exception"), start, code - start, ji, unwind_ops);
+
 	return start;
 }
 
@@ -415,21 +450,15 @@ mono_arch_get_throw_exception_generic (guint8 *start, int size, int corlib, gboo
  *
  */
 gpointer
-mono_arch_get_rethrow_exception (void)
+mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
 {
-	static guint8 *start = NULL;
-	static int inited = 0;
-
-	guint8 *code;
 	int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
 
-	if (inited)
-		return start;
-	code = mono_global_codeman_reserve (size);
-	start = mono_arch_get_throw_exception_generic (code, size, FALSE, TRUE);
-	inited = 1;
-	return start;
+	if (aot)
+		size += 64;
+	return mono_arch_get_throw_exception_generic (size, info, FALSE, TRUE, aot);
 }
+
 /**
  * arch_get_throw_exception:
  *
@@ -442,53 +471,14 @@ mono_arch_get_rethrow_exception (void)
  * x86_call_code (code, arch_get_throw_exception ()); 
  *
  */
-gpointer 
-mono_arch_get_throw_exception (void)
+gpointer
+mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
 {
-	static guint8 *start = NULL;
-	static int inited = 0;
-
-	guint8 *code;
 	int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;
 
-	if (inited)
-		return start;
-	code = mono_global_codeman_reserve (size);
-	start = mono_arch_get_throw_exception_generic (code, size, FALSE, FALSE);
-	inited = 1;
-	return start;
-}
-
-/**
- * arch_get_throw_exception_by_name:
- *
- * Returns a function pointer which can be used to raise 
- * corlib exceptions. The returned function has the following 
- * signature: void (*func) (char *exc_name); 
- * For example to raise an arithmetic exception you can use:
- *
- * x86_push_imm (code, "ArithmeticException"); 
- * x86_call_code (code, arch_get_throw_exception_by_name ()); 
- *
- */
-gpointer 
-mono_arch_get_throw_exception_by_name (void)
-{
-	static guint8 *start = NULL;
-	static int inited = 0;
-
-	guint8 *code;
-	int size = 64;
-
-	if (inited)
-		return start;
-
-	/* Not used on PPC */	
-	start = code = mono_global_codeman_reserve (size);
-	ppc_break (code);
-	mono_arch_flush_icache (start, code - start);
-	inited = 1;
-	return start;
+	if (aot)
+		size += 64;
+	return mono_arch_get_throw_exception_generic (size, info, FALSE, FALSE, aot);
 }
 
 /**
@@ -499,107 +489,96 @@ mono_arch_get_throw_exception_by_name (void)
  * signature: void (*func) (guint32 ex_token, guint32 offset); 
  * On PPC, we pass the ip instead of the offset
  */
-gpointer 
-mono_arch_get_throw_corlib_exception (void)
+gpointer
+mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
 {
-	static guint8 *start = NULL;
-	static int inited = 0;
-
-	guint8 *code;
 	int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE;
 
-	if (inited)
-		return start;
-	code = mono_global_codeman_reserve (size);
-	start = mono_arch_get_throw_exception_generic (code, size, TRUE, FALSE);
-	inited = 1;
-	return start;
+	if (aot)
+		size += 64;
+	return mono_arch_get_throw_exception_generic (size, info, TRUE, FALSE, aot);
 }
 
-/* mono_arch_find_jit_info:
+/*
+ * mono_arch_find_jit_info:
  *
- * This function is used to gather information from @ctx. It return the 
- * MonoJitInfo of the corresponding function, unwinds one stack frame and
- * stores the resulting context into @new_ctx. It also stores a string 
- * describing the stack location into @trace (if not NULL), and modifies
- * the @lmf if necessary. @native_offset return the IP offset from the 
- * start of the function or -1 if that info is not available.
+ * See exceptions-amd64.c for docs.
  */
-MonoJitInfo *
-mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji, MonoContext *ctx,
-						 MonoContext *new_ctx, MonoLMF **lmf, gboolean *managed)
+gboolean
+mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, 
+							 MonoJitInfo *ji, MonoContext *ctx, 
+							 MonoContext *new_ctx, MonoLMF **lmf,
+							 mgreg_t **save_locations,
+							 StackFrameInfo *frame)
 {
-	MonoJitInfo *ji;
 	gpointer ip = MONO_CONTEXT_GET_IP (ctx);
 	MonoPPCStackFrame *sframe;
 
-	/* Avoid costly table lookup during stack overflow */
-	if (prev_ji && (ip > prev_ji->code_start && ((guint8*)ip < ((guint8*)prev_ji->code_start) + prev_ji->code_size)))
-		ji = prev_ji;
-	else
-		ji = mono_jit_info_table_find (domain, ip);
+	memset (frame, 0, sizeof (StackFrameInfo));
+	frame->ji = ji;
 
-	if (managed)
-		*managed = FALSE;
+	*new_ctx = *ctx;
+	setup_context (new_ctx);
 
 	if (ji != NULL) {
-		gint32 address;
-		int offset, i;
+		int i;
+		mgreg_t regs [ppc_lr + 1];
+		guint8 *cfa;
+		guint32 unwind_info_len;
+		guint8 *unwind_info;
 
-		*new_ctx = *ctx;
-		setup_context (new_ctx);
+		frame->type = FRAME_TYPE_MANAGED;
 
-		if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
-			/* remove any unused lmf */
-			*lmf = (*lmf)->previous_lmf;
-		}
-
-		address = (char *)ip - (char *)ji->code_start;
-
-		if (managed)
-			if (!ji->method->wrapper_type)
-				*managed = TRUE;
+		if (ji->from_aot)
+			unwind_info = mono_aot_get_unwind_info (ji, &unwind_info_len);
+		else
+			unwind_info = mono_get_cached_unwind_info (ji->used_regs, &unwind_info_len);
 
 		sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
 		MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
-		if (ji->method->save_lmf) {
-			memcpy (&new_ctx->fregs, (char*)sframe->sp - sizeof (double) * MONO_SAVED_FREGS, sizeof (double) * MONO_SAVED_FREGS);
-			memcpy (&new_ctx->regs, (char*)sframe->sp - sizeof (double) * MONO_SAVED_FREGS - sizeof (gulong) * MONO_SAVED_GREGS, sizeof (gulong) * MONO_SAVED_GREGS);
-		} else if (ji->used_regs) {
-			/* keep updated with emit_prolog in mini-ppc.c */
-			offset = 0;
-			/* FIXME handle floating point args 
-			for (i = 31; i >= 14; --i) {
-				if (ji->used_fregs & (1 << i)) {
-					offset += sizeof (double);
-					new_ctx->fregs [i - 14] = *(gulong*)((char*)sframe->sp - offset);
-				}
-			}*/
-			for (i = 31; i >= 13; --i) {
-				if (ji->used_regs & (1 << i)) {
-					offset += sizeof (gulong);
-					new_ctx->regs [i - 13] = *(gulong*)((char*)sframe->sp - offset);
-				}
-			}
+		if (jinfo_get_method (ji)->save_lmf) {
+			/* sframe->sp points just past the end of the LMF */
+			guint8 *lmf_addr = (guint8*)sframe->sp - sizeof (MonoLMF);
+			memcpy (&new_ctx->fregs, lmf_addr + G_STRUCT_OFFSET (MonoLMF, fregs), sizeof (double) * MONO_SAVED_FREGS);
+			memcpy (&new_ctx->regs, lmf_addr + G_STRUCT_OFFSET (MonoLMF, iregs), sizeof (mgreg_t) * MONO_SAVED_GREGS);
+			/* the calling IP is in the parent frame */
+			sframe = (MonoPPCStackFrame*)sframe->sp;
+			/* we substract 4, so that the IP points into the call instruction */
+			MONO_CONTEXT_SET_IP (new_ctx, sframe->lr - 4);
+		} else {
+			regs [ppc_lr] = ctx->sc_ir;
+			regs [ppc_sp] = ctx->sc_sp;
+			for (i = 0; i < MONO_SAVED_GREGS; ++i)
+				regs [ppc_r13 + i] = ctx->regs [i];
+
+			mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start, 
+							   (guint8*)ji->code_start + ji->code_size,
+							   ip, regs, ppc_lr + 1,
+							   save_locations, MONO_MAX_IREGS, &cfa);
+
+			/* we substract 4, so that the IP points into the call instruction */
+			MONO_CONTEXT_SET_IP (new_ctx, regs [ppc_lr] - 4);
+			MONO_CONTEXT_SET_BP (new_ctx, cfa);
+
+			for (i = 0; i < MONO_SAVED_GREGS; ++i)
+				new_ctx->regs [i] = regs [ppc_r13 + i];
 		}
-		/* the calling IP is in the parent frame */
-		sframe = (MonoPPCStackFrame*)sframe->sp;
-		/* we substract 4, so that the IP points into the call instruction */
-		MONO_CONTEXT_SET_IP (new_ctx, sframe->lr - 4);
 
-		return ji;
+		if (*lmf && (MONO_CONTEXT_GET_SP (ctx) >= (gpointer)(*lmf)->ebp)) {
+			/* remove any unused lmf */
+			*lmf = (*lmf)->previous_lmf;
+		}
+
+		return TRUE;
 	} else if (*lmf) {
 		
-		*new_ctx = *ctx;
-		setup_context (new_ctx);
-
-		if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
+		if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
 		} else {
 			if (!(*lmf)->method)
-				return (gpointer)-1;
+				return FALSE;
 
-			memset (res, 0, sizeof (MonoJitInfo));
-			res->method = (*lmf)->method;
+			/* Trampoline lmf frame */
+			frame->method = (*lmf)->method;
 		}
 
 		/*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
@@ -607,17 +586,20 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf
 		MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);*/
 		MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
 		MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
-		memcpy (&new_ctx->regs, (*lmf)->iregs, sizeof (gulong) * MONO_SAVED_GREGS);
+		memcpy (&new_ctx->regs, (*lmf)->iregs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
 		memcpy (&new_ctx->fregs, (*lmf)->fregs, sizeof (double) * MONO_SAVED_FREGS);
 
+		frame->ji = ji;
+		frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
+
 		/* FIXME: what about trampoline LMF frames?  see exceptions-x86.c */
 
 		*lmf = (*lmf)->previous_lmf;
 
-		return ji ? ji : res;
+		return TRUE;
 	}
 
-	return NULL;
+	return FALSE;
 }
 
 /*
@@ -626,51 +608,80 @@ mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInf
 void
 mono_arch_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
 {
+#ifdef MONO_CROSS_COMPILE
+	g_assert_not_reached ();
+#else
 	os_ucontext *uc = ctx;
 
 	mctx->sc_ir = UCONTEXT_REG_NIP(uc);
 	mctx->sc_sp = UCONTEXT_REG_Rn(uc, 1);
-	memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 13), sizeof (gulong) * MONO_SAVED_GREGS);
+	memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 13), sizeof (mgreg_t) * MONO_SAVED_GREGS);
 	memcpy (&mctx->fregs, &UCONTEXT_REG_FPRn(uc, 14), sizeof (double) * MONO_SAVED_FREGS);
+#endif
 }
 
 void
 mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
 {
+#ifdef MONO_CROSS_COMPILE
+	g_assert_not_reached ();
+#else
 	os_ucontext *uc = ctx;
 
 	UCONTEXT_REG_NIP(uc) = mctx->sc_ir;
 	UCONTEXT_REG_Rn(uc, 1) = mctx->sc_sp;
-	memcpy (&UCONTEXT_REG_Rn(uc, 13), &mctx->regs, sizeof (gulong) * MONO_SAVED_GREGS);
+	memcpy (&UCONTEXT_REG_Rn(uc, 13), &mctx->regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
 	memcpy (&UCONTEXT_REG_FPRn(uc, 14), &mctx->fregs, sizeof (double) * MONO_SAVED_FREGS);
+#endif
 }
 
 gpointer
 mono_arch_ip_from_context (void *sigctx)
 {
+#ifdef MONO_CROSS_COMPILE
+	g_assert_not_reached ();
+#else
 	os_ucontext *uc = sigctx;
 	return (gpointer)UCONTEXT_REG_NIP(uc);
+#endif
+}
+
+void
+mono_ppc_set_func_into_sigctx (void *sigctx, void *func)
+{
+#ifdef MONO_CROSS_COMPILE
+	g_assert_not_reached ();
+#elif defined(PPC_USES_FUNCTION_DESCRIPTOR)
+	/* Have to set both the ip and the TOC reg */
+	os_ucontext *uc = sigctx;
+
+	UCONTEXT_REG_NIP(uc) = ((gsize*)func) [0];
+	UCONTEXT_REG_Rn (uc, 2) = ((gsize*)func)[1];
+#else
+	g_assert_not_reached ();
+#endif
 }
 
 static void
-altstack_handle_and_restore (void *sigctx, gpointer obj, gboolean test_only)
+altstack_handle_and_restore (void *sigctx, gpointer obj)
 {
-	void (*restore_context) (MonoContext *);
 	MonoContext mctx;
 
-	restore_context = mono_arch_get_restore_context ();
 	mono_arch_sigctx_to_monoctx (sigctx, &mctx);
-	mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_ir, test_only);
-	restore_context (&mctx);
+	mono_handle_exception (&mctx, obj);
+	mono_restore_context (&mctx);
 }
 
 void
 mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf)
 {
+#ifdef MONO_CROSS_COMPILE
+	g_assert_not_reached ();
+#else
 #ifdef MONO_ARCH_USE_SIGACTION
 	os_ucontext *uc = (ucontext_t*)sigctx;
 	os_ucontext *uc_copy;
-	MonoJitInfo *ji = mono_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx));
+	MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx), NULL);
 	gpointer *sp;
 	int frame_size;
 
@@ -678,8 +689,8 @@ mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean
 		const char *method;
 		/* we don't do much now, but we can warn the user with a useful message */
 		fprintf (stderr, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx), (gpointer)UCONTEXT_REG_Rn(uc, 1));
-		if (ji && ji->method)
-			method = mono_method_full_name (ji->method, TRUE);
+		if (ji && jinfo_get_method (ji))
+			method = mono_method_full_name (jinfo_get_method (ji), TRUE);
 		else
 			method = "Unmanaged";
 		fprintf (stderr, "At %s\n", method);
@@ -723,27 +734,88 @@ mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean
 	UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 1) = 0;
 	UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 2) = 0;
 #endif
+
+#endif /* !MONO_CROSS_COMPILE */
+}
+
+/*
+ * handle_exception:
+ *
+ *   Called by resuming from a signal handler.
+ */
+static void
+handle_signal_exception (gpointer obj)
+{
+	MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+	MonoContext ctx;
+
+	memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));
+
+	mono_handle_exception (&ctx, obj);
+
+	mono_restore_context (&ctx);
+}
+
+static void
+setup_ucontext_return (void *uc, gpointer func)
+{
+#if !defined(MONO_CROSS_COMPILE)
+	UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
+#ifdef PPC_USES_FUNCTION_DESCRIPTOR
+	{
+		MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)func;
+
+		UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
+		UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
+	}
+#else
+	UCONTEXT_REG_NIP(uc) = (unsigned long)func;
+#endif
+#endif
 }
 
 gboolean
-mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+mono_arch_handle_exception (void *ctx, gpointer obj)
 {
+#if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
+	/*
+	 * Handling the exception in the signal handler is problematic, since the original
+	 * signal is disabled, and we could run arbitrary code though the debugger. So
+	 * resume into the normal stack and do most work there if possible.
+	 */
+	MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
+	mgreg_t sp;
+	void *sigctx = ctx;
+	int frame_size;
+	void *uc = sigctx;
+
+	/* Pass the ctx parameter in TLS */
+	mono_arch_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
+	/* The others in registers */
+	UCONTEXT_REG_Rn (sigctx, PPC_FIRST_ARG_REG) = (gsize)obj;
+
+	/* Allocate a stack frame below the red zone */
+	/* Similar to mono_arch_handle_altstack_exception () */
+	frame_size = 224;
+	frame_size += 15;
+	frame_size &= ~15;
+	sp = (mgreg_t)(UCONTEXT_REG_Rn(uc, 1) & ~15);
+	sp = (mgreg_t)(sp - frame_size);
+	UCONTEXT_REG_Rn(uc, 1) = (mgreg_t)sp;
+	setup_ucontext_return (uc, handle_signal_exception);
+
+	return TRUE;
+#else
 	MonoContext mctx;
 	gboolean result;
 
 	mono_arch_sigctx_to_monoctx (ctx, &mctx);
 
-	result = mono_handle_exception (&mctx, obj, (gpointer)mctx.sc_ir, test_only);
+	result = mono_handle_exception (&mctx, obj);
 	/* restore the context so that returning from the signal handler will invoke
 	 * the catch clause 
 	 */
 	mono_arch_monoctx_to_sigctx (&mctx, ctx);
 	return result;
+#endif
 }
-
-gboolean
-mono_arch_has_unwind_info (gconstpointer addr)
-{
-	return FALSE;
-}
-