/*
- * exception.c: exception support
+ * exceptions-ppc.c: exception support for PowerPC
*
* Authors:
* Dietmar Maurer (dietmar@ximian.com)
+ * Paolo Molaro (lupus@ximian.com)
*
* (C) 2001 Ximian, Inc.
*/
#include <config.h>
#include <glib.h>
#include <signal.h>
+#include <string.h>
+#include <ucontext.h>
-#include <mono/arch/x86/x86-codegen.h>
+#include <mono/arch/ppc/ppc-codegen.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/exception.h>
+#include <mono/metadata/mono-debug.h>
#include "mini.h"
#include "mini-ppc.h"
-#include "debug-private.h"
-typedef struct sigcontext MonoContext;
+static gboolean arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only);
-/* we have the stack pointer, not the base pointer in sigcontext */
-#define MONO_CONTEXT_SET_IP(ctx,ip) do { (ctx)->sc_ir = (int)ip; } while (0);
-#define MONO_CONTEXT_SET_BP(ctx,bp) do { (ctx)->sc_sp = (int)bp; } while (0);
-
-#define MONO_CONTEXT_GET_IP(ctx) ((gpointer)((ctx)->sc_ir))
-#define MONO_CONTEXT_GET_BP(ctx) ((gpointer)((ctx)->sc_sp))
-
-/* disbale this for now */
-#undef MONO_USE_EXC_TABLES
-
-#ifdef MONO_USE_EXC_TABLES
-
-/*************************************/
-/* STACK UNWINDING STUFF */
-/*************************************/
-
-/* These definitions are from unwind-dw2.c in glibc 2.2.5 */
-
-/* For x86 */
-#define DWARF_FRAME_REGISTERS 17
-
-typedef struct frame_state
-{
- void *cfa;
- void *eh_ptr;
- long cfa_offset;
- long args_size;
- long reg_or_offset[DWARF_FRAME_REGISTERS+1];
- unsigned short cfa_reg;
- unsigned short retaddr_column;
- char saved[DWARF_FRAME_REGISTERS+1];
-} frame_state;
-
-#if 0
-
-static long
-get_sigcontext_reg (struct sigcontext *ctx, int dwarf_regnum)
-{
- switch (dwarf_regnum) {
- case X86_EAX:
- return ctx->eax;
- case X86_EBX:
- return ctx->ebx;
- case X86_ECX:
- return ctx->ecx;
- case X86_EDX:
- return ctx->edx;
- case X86_ESI:
- return ctx->esi;
- case X86_EDI:
- return ctx->edi;
- case X86_EBP:
- return ctx->ebp;
- case X86_ESP:
- return ctx->esp;
- default:
- g_assert_not_reached ();
- }
-
- return 0;
-}
-
-static void
-set_sigcontext_reg (struct sigcontext *ctx, int dwarf_regnum, long value)
-{
- switch (dwarf_regnum) {
- case X86_EAX:
- ctx->eax = value;
- break;
- case X86_EBX:
- ctx->ebx = value;
- break;
- case X86_ECX:
- ctx->ecx = value;
- break;
- case X86_EDX:
- ctx->edx = value;
- break;
- case X86_ESI:
- ctx->esi = value;
- break;
- case X86_EDI:
- ctx->edi = value;
- break;
- case X86_EBP:
- ctx->ebp = value;
- break;
- case X86_ESP:
- ctx->esp = value;
- break;
- case 8:
- ctx->eip = value;
- break;
- default:
- g_assert_not_reached ();
- }
-}
-
-typedef struct frame_state * (*framesf) (void *, struct frame_state *);
-
-static framesf frame_state_for = NULL;
-
-static gboolean inited = FALSE;
-
-typedef char ** (*get_backtrace_symbols_type) (void *__const *__array, int __size);
-
-static get_backtrace_symbols_type get_backtrace_symbols = NULL;
-
-static void
-init_frame_state_for (void)
-{
- GModule *module;
-
- /*
- * There are two versions of __frame_state_for: one in libgcc.a and the
- * other in glibc.so. We need the version from glibc.
- * For more info, see this:
- * http://gcc.gnu.org/ml/gcc/2002-08/msg00192.html
- */
- if ((module = g_module_open ("libc.so.6", G_MODULE_BIND_LAZY))) {
-
- if (!g_module_symbol (module, "__frame_state_for", (gpointer*)&frame_state_for))
- frame_state_for = NULL;
-
- if (!g_module_symbol (module, "backtrace_symbols", (gpointer*)&get_backtrace_symbols)) {
- get_backtrace_symbols = NULL;
- frame_state_for = NULL;
- }
-
- g_module_close (module);
- }
-
- inited = TRUE;
-}
-
-#endif
-
-/* mono_arch_has_unwind_info:
- *
- * Tests if a function has an DWARF exception table able to restore
- * all caller saved registers.
- */
-gboolean
-mono_arch_has_unwind_info (MonoMethod *method)
-{
-#if 0
- struct frame_state state_in;
- struct frame_state *res;
-
- if (!inited)
- init_frame_state_for ();
-
- if (!frame_state_for)
- return FALSE;
-
- g_assert (method->addr);
-
- memset (&state_in, 0, sizeof (state_in));
-
- /* offset 10 is just a guess, but it works for all methods tested */
- if ((res = frame_state_for ((char *)method->addr + 10, &state_in))) {
-
- if (res->saved [X86_EBX] != 1 ||
- res->saved [X86_EDI] != 1 ||
- res->saved [X86_EBP] != 1 ||
- res->saved [X86_ESI] != 1) {
- return FALSE;
- }
- return TRUE;
- } else {
- return FALSE;
- }
-#else
- return FALSE;
-#endif
-}
+/*
-struct stack_frame
-{
- void *next;
- void *return_address;
+struct sigcontext {
+ int sc_onstack; // sigstack state to restore
+ int sc_mask; // signal mask to restore
+ int sc_ir; // pc
+ int sc_psw; // processor status word
+ int sc_sp; // stack pointer if sc_regs == NULL
+ void *sc_regs; // (kernel private) saved state
};
-static MonoJitInfo *
-ppc_unwind_native_frame (MonoDomain *domain, MonoJitTlsData *jit_tls, struct sigcontext *ctx,
- struct sigcontext *new_ctx, MonoLMF *lmf, char **trace)
-{
-#if 0
- struct stack_frame *frame;
- gpointer max_stack;
- MonoJitInfo *ji;
- struct frame_state state_in;
- struct frame_state *res;
-
- if (trace)
- *trace = NULL;
-
- if (!inited)
- init_frame_state_for ();
-
- if (!frame_state_for)
- return FALSE;
-
- frame = MONO_CONTEXT_GET_BP (ctx);
-
- max_stack = lmf && lmf->method ? lmf : jit_tls->end_of_stack;
-
- *new_ctx = *ctx;
+struct ucontext {
+ int uc_onstack;
+ sigset_t uc_sigmask; // signal mask used by this context
+ stack_t uc_stack; // stack used by this context
+ struct ucontext *uc_link; // pointer to resuming context
+ size_t uc_mcsize; // size of the machine context passed in
+ mcontext_t uc_mcontext; // machine specific context
+};
- memset (&state_in, 0, sizeof (state_in));
+typedef struct ppc_exception_state {
+ unsigned long dar; // Fault registers for coredump
+ unsigned long dsisr;
+ unsigned long exception;// number of powerpc exception taken
+ unsigned long pad0; // align to 16 bytes
+
+ unsigned long pad1[4]; // space in PCB "just in case"
+} ppc_exception_state_t;
+
+typedef struct ppc_vector_state {
+ unsigned long save_vr[32][4];
+ unsigned long save_vscr[4];
+ unsigned int save_pad5[4];
+ unsigned int save_vrvalid; // VRs that have been saved
+ unsigned int save_pad6[7];
+} ppc_vector_state_t;
+
+typedef struct ppc_float_state {
+ double fpregs[32];
+
+ unsigned int fpscr_pad; // fpscr is 64 bits, 32 bits of rubbish
+ unsigned int fpscr; // floating point status register
+} ppc_float_state_t;
+
+typedef struct ppc_thread_state {
+ unsigned int srr0; // Instruction address register (PC)
+ unsigned int srr1; // Machine state register (supervisor)
+ unsigned int r0;
+ unsigned int r1;
+ unsigned int r2;
+ ...
+ unsigned int r31;
+ unsigned int cr; // Condition register
+ unsigned int xer; // User's integer exception register
+ unsigned int lr; // Link register
+ unsigned int ctr; // Count register
+ unsigned int mq; // MQ register (601 only)
+
+ unsigned int vrsave; // Vector Save Register
+} ppc_thread_state_t;
+
+struct mcontext {
+ ppc_exception_state_t es;
+ ppc_thread_state_t ss;
+ ppc_float_state_t fs;
+ ppc_vector_state_t vs;
+};
- while ((gpointer)frame->next < (gpointer)max_stack) {
- gpointer ip, addr = frame->return_address;
- void *cfa;
- char *tmp, **symbols;
+typedef struct mcontext * mcontext_t;
- if (trace) {
- ip = MONO_CONTEXT_GET_IP (new_ctx);
- symbols = get_backtrace_symbols (&ip, 1);
- if (*trace)
- tmp = g_strdup_printf ("%s\nin (unmanaged) %s", *trace, symbols [0]);
- else
- tmp = g_strdup_printf ("in (unmanaged) %s", symbols [0]);
+Linux/PPC instead has:
+struct sigcontext {
+ unsigned long _unused[4];
+ int signal;
+ unsigned long handler;
+ unsigned long oldmask;
+ struct pt_regs *regs;
+};
+struct pt_regs {
+ unsigned long gpr[32];
+ unsigned long nip;
+ unsigned long msr;
+ unsigned long orig_gpr3; // Used for restarting system calls
+ unsigned long ctr;
+ unsigned long link;
+ unsigned long xer;
+ unsigned long ccr;
+ unsigned long mq; // 601 only (not used at present)
+ // Used on APUS to hold IPL value.
+ unsigned long trap; // Reason for being here
+ // N.B. for critical exceptions on 4xx, the dar and dsisr
+ // fields are overloaded to hold srr0 and srr1.
+ unsigned long dar; // Fault registers
+ unsigned long dsisr; // on 4xx/Book-E used for ESR
+ unsigned long result; // Result of a system call
+};
+struct mcontext {
+ elf_gregset_t mc_gregs;
+ elf_fpregset_t mc_fregs;
+ unsigned long mc_pad[2];
+ elf_vrregset_t mc_vregs __attribute__((__aligned__(16)));
+};
- free (symbols);
- g_free (*trace);
- *trace = tmp;
- }
+struct ucontext {
+ unsigned long uc_flags;
+ struct ucontext *uc_link;
+ stack_t uc_stack;
+ int uc_pad[7];
+ struct mcontext *uc_regs; // points to uc_mcontext field
+ sigset_t uc_sigmask;
+ // glibc has 1024-bit signal masks, ours are 64-bit
+ int uc_maskext[30];
+ int uc_pad2[3];
+ struct mcontext uc_mcontext;
+};
- if ((res = frame_state_for (addr, &state_in))) {
- int i;
+#define ELF_NGREG 48 // includes nip, msr, lr, etc.
+#define ELF_NFPREG 33 // includes fpscr
- cfa = (gint8*) (get_sigcontext_reg (new_ctx, res->cfa_reg) + res->cfa_offset);
- frame = (struct stack_frame *)((gint8*)cfa - 8);
- for (i = 0; i < DWARF_FRAME_REGISTERS + 1; i++) {
- int how = res->saved[i];
- long val;
- g_assert ((how == 0) || (how == 1));
-
- if (how == 1) {
- val = * (long*) ((gint8*)cfa + res->reg_or_offset[i]);
- set_sigcontext_reg (new_ctx, i, val);
- }
- }
- new_ctx->esp = (long)cfa;
-
- if (res->saved [X86_EBX] == 1 &&
- res->saved [X86_EDI] == 1 &&
- res->saved [X86_EBP] == 1 &&
- res->saved [X86_ESI] == 1 &&
- (ji = mono_jit_info_table_find (domain, frame->return_address))) {
- //printf ("FRAME CFA %s\n", mono_method_full_name (ji->method, TRUE));
- return ji;
- }
+// General registers
+typedef unsigned long elf_greg_t;
+typedef elf_greg_t elf_gregset_t[ELF_NGREG];
- } else {
- //printf ("FRAME %p %p %p\n", frame, MONO_CONTEXT_GET_IP (new_ctx), mono_jit_info_table_find (domain, MONO_CONTEXT_GET_IP (new_ctx)));
+// Floating point registers
+typedef double elf_fpreg_t;
+typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];
- MONO_CONTEXT_SET_IP (new_ctx, frame->return_address);
- frame = frame->next;
- MONO_CONTEXT_SET_BP (new_ctx, frame);
- /* stop if !frame or when we detect an unexpected managed frame */
- if (!frame || mono_jit_info_table_find (domain, frame->return_address)) {
- if (trace) {
- g_free (*trace);
- *trace = NULL;
- }
- return NULL;
- }
- }
- }
+*/
- //if (!lmf)
- //g_assert_not_reached ();
- if (trace) {
- g_free (*trace);
- *trace = NULL;
- }
-#endif
- return NULL;
-}
+#define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do { \
+ int reg; \
+ ppc_lwz (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg); \
+ ppc_lmw (code, ppc_r13, ctx_reg, G_STRUCT_OFFSET (MonoContext, regs)); \
+ for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) { \
+ ppc_lfd (code, (14 + reg), G_STRUCT_OFFSET(MonoLMF, fregs) + reg * sizeof (gdouble), ctx_reg); \
+ } \
+ } while (0)
-#endif
+/* nothing to do */
+#define setup_context(ctx)
/*
* arch_get_restore_context:
*
* Returns a pointer to a method which restores a previously saved sigcontext.
+ * The first argument in r3 is the pointer to the context.
*/
static gpointer
arch_get_restore_context (void)
{
- static guint8 *start = NULL;
guint8 *code;
+ static guint8 start [128];
+ static int inited = 0;
- if (start)
+ if (inited)
return start;
+ inited = 1;
-#if 0
- /* restore_contect (struct sigcontext *ctx) */
- /* we do not restore X86_EAX, X86_EDX */
-
- start = code = g_malloc (1024);
-
- /* load ctx */
- x86_mov_reg_membase (code, X86_EAX, X86_ESP, 4, 4);
-
- /* get return address, stored in EDX */
- x86_mov_reg_membase (code, X86_EDX, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EIP), 4);
- /* restore EBX */
- x86_mov_reg_membase (code, X86_EBX, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EBX), 4);
- /* restore EDI */
- x86_mov_reg_membase (code, X86_EDI, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EDI), 4);
- /* restore ESI */
- x86_mov_reg_membase (code, X86_ESI, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_ESI), 4);
- /* restore ESP */
- x86_mov_reg_membase (code, X86_ESP, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_ESP), 4);
- /* restore EBP */
- x86_mov_reg_membase (code, X86_EBP, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EBP), 4);
-
+ code = start;
+ restore_regs_from_context (ppc_r3, ppc_r4, ppc_r5);
+ /* restore also the stack pointer */
+ ppc_lwz (code, ppc_sp, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
+ //ppc_break (code);
/* jump to the saved IP */
- x86_jump_reg (code, X86_EDX);
+ ppc_mtctr (code, ppc_r4);
+ ppc_bcctr (code, PPC_BR_ALWAYS, 0);
+ /* never reached */
+ ppc_break (code);
-#endif
+ g_assert ((code - start) < sizeof(start));
return start;
}
static gpointer
arch_get_call_filter (void)
{
- static guint8 start [64];
+ static guint8 start [320];
static int inited = 0;
guint8 *code;
+ int alloc_size, pos, i;
if (inited)
return start;
inited = 1;
- /* call_filter (struct sigcontext *ctx, unsigned long eip, gpointer exc) */
+ /* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
code = start;
-#if 0
- x86_push_reg (code, X86_EBP);
- x86_mov_reg_reg (code, X86_EBP, X86_ESP, 4);
- x86_push_reg (code, X86_EBX);
- x86_push_reg (code, X86_EDI);
- x86_push_reg (code, X86_ESI);
-
- /* load ctx */
- x86_mov_reg_membase (code, X86_EAX, X86_EBP, 8, 4);
- /* load eip */
- x86_mov_reg_membase (code, X86_ECX, X86_EBP, 12, 4);
- /* save EBP */
- x86_push_reg (code, X86_EBP);
- /* push exc */
- x86_push_membase (code, X86_EBP, 16);
- /* set new EBP */
- x86_mov_reg_membase (code, X86_EBP, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EBP), 4);
- /* restore registers used by global register allocation (EBX & ESI) */
- x86_mov_reg_membase (code, X86_EBX, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EBX), 4);
- x86_mov_reg_membase (code, X86_ESI, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_ESI), 4);
- x86_mov_reg_membase (code, X86_EDI, X86_EAX, G_STRUCT_OFFSET (struct sigcontext, SC_EDI), 4);
- /* save the ESP - this is used by endfinally */
- x86_mov_membase_reg (code, X86_EBP, mono_exc_esp_offset, X86_ESP, 4);
- /* call the handler */
- x86_call_reg (code, X86_ECX);
- x86_alu_reg_imm (code, X86_ADD, X86_ESP, 4);
- /* restore EBP */
- x86_pop_reg (code, X86_EBP);
- /* restore saved regs */
- x86_pop_reg (code, X86_ESI);
- x86_pop_reg (code, X86_EDI);
- x86_pop_reg (code, X86_EBX);
- x86_leave (code);
- x86_ret (code);
-
- g_assert ((code - start) < 64);
-#endif
+ /* save all the regs on the stack */
+ pos = 0;
+ for (i = 31; i >= 14; --i) {
+ pos += sizeof (gdouble);
+ ppc_stfd (code, i, -pos, ppc_sp);
+ }
+ pos += sizeof (gulong) * MONO_SAVED_GREGS;
+ ppc_stmw (code, ppc_r13, ppc_sp, -pos);
+
+ ppc_mflr (code, ppc_r0);
+ ppc_stw (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+
+ alloc_size = PPC_MINIMAL_STACK_SIZE + pos + 64;
+ // align to PPC_STACK_ALIGNMENT bytes
+ alloc_size += PPC_STACK_ALIGNMENT - 1;
+ alloc_size &= ~(PPC_STACK_ALIGNMENT - 1);
+
+ g_assert ((alloc_size & (PPC_STACK_ALIGNMENT-1)) == 0);
+ ppc_stwu (code, ppc_sp, -alloc_size, ppc_sp);
+
+ /* restore all the regs from ctx (in r3), but not r1, the stack pointer */
+ restore_regs_from_context (ppc_r3, ppc_r6, ppc_r7);
+ /* call handler at eip (r4) and set the first arg with the exception (r5) */
+ ppc_mtctr (code, ppc_r4);
+ ppc_mr (code, ppc_r3, ppc_r5);
+ ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
+
+ /* epilog */
+ ppc_lwz (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
+ ppc_mtlr (code, ppc_r0);
+ ppc_addic (code, ppc_sp, ppc_sp, alloc_size);
+
+ /* restore all the regs from the stack */
+ pos = 0;
+ for (i = 31; i >= 14; --i) {
+ pos += sizeof (double);
+ ppc_lfd (code, i, -pos, ppc_sp);
+ }
+ pos += sizeof (gulong) * MONO_SAVED_GREGS;
+ ppc_lmw (code, ppc_r13, ppc_sp, -pos);
+
+ ppc_blr (code);
+
+ g_assert ((code - start) < sizeof(start));
return start;
}
static void
-throw_exception (unsigned long eax, unsigned long ecx, unsigned long edx, unsigned long ebx,
- unsigned long esi, unsigned long edi, unsigned long ebp, MonoObject *exc,
- unsigned long eip, unsigned long esp)
+throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, gulong *int_regs, gdouble *fp_regs, gboolean rethrow)
{
- static void (*restore_context) (struct sigcontext *);
- struct sigcontext ctx;
+ static void (*restore_context) (MonoContext *);
+ MonoContext ctx;
if (!restore_context)
restore_context = arch_get_restore_context ();
/* adjust eip so that it point into the call instruction */
- eip -= 1;
-
-#if 0
- ctx.SC_ESP = esp;
- ctx.SC_EIP = eip;
- ctx.SC_EBP = ebp;
- ctx.SC_EDI = edi;
- ctx.SC_ESI = esi;
- ctx.SC_EBX = ebx;
- ctx.SC_EDX = edx;
- ctx.SC_ECX = ecx;
- ctx.SC_EAX = eax;
-#endif
- mono_arch_handle_exception (&ctx, exc, FALSE);
+ eip -= 4;
+
+ setup_context (&ctx);
+
+ /*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.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS);
+
+ if (mono_object_isinst (exc, mono_defaults.exception_class)) {
+ MonoException *mono_ex = (MonoException*)exc;
+ if (!rethrow)
+ mono_ex->stack_trace = NULL;
+ }
+ arch_handle_exception (&ctx, exc, FALSE);
restore_context (&ctx);
g_assert_not_reached ();
}
+/**
+ * arch_get_throw_exception_generic:
+ *
+ * Returns a function pointer which can be used to raise
+ * exceptions. The returned function has the following
+ * signature: void (*func) (MonoException *exc); or
+ * void (*func) (char *exc_name);
+ *
+ */
+static gpointer
+mono_arch_get_throw_exception_generic (guint8 *start, int size, int by_name, gboolean rethrow)
+{
+ guint8 *code;
+ int alloc_size, pos, i;
+
+ code = start;
+
+ /* save all the regs on the stack */
+ pos = 0;
+ for (i = 31; i >= 14; --i) {
+ pos += sizeof (gdouble);
+ ppc_stfd (code, i, -pos, ppc_sp);
+ }
+ pos += sizeof (gulong) * MONO_SAVED_GREGS;
+ ppc_stmw (code, ppc_r13, ppc_sp, -pos);
+
+ ppc_mflr (code, ppc_r0);
+ ppc_stw (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);
+
+ alloc_size = PPC_MINIMAL_STACK_SIZE + pos + 64;
+ // align to PPC_STACK_ALIGNMENT bytes
+ alloc_size += PPC_STACK_ALIGNMENT - 1;
+ alloc_size &= ~(PPC_STACK_ALIGNMENT - 1);
+
+ g_assert ((alloc_size & (PPC_STACK_ALIGNMENT-1)) == 0);
+ ppc_stwu (code, ppc_sp, -alloc_size, ppc_sp);
+
+ //ppc_break (code);
+ if (by_name) {
+ ppc_mr (code, ppc_r5, ppc_r3);
+ ppc_load (code, ppc_r3, mono_defaults.corlib);
+ ppc_load (code, ppc_r4, "System");
+ ppc_load (code, ppc_r0, mono_exception_from_name);
+ 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_lwz (code, ppc_r5, 0, ppc_sp);
+ /* exc is already in place in r3 */
+ if (by_name)
+ ppc_lwz (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 */
+ pos = alloc_size - sizeof (double) * MONO_SAVED_FREGS;
+ ppc_addi (code, ppc_r7, ppc_sp, pos);
+ /* pointer to the saved int regs */
+ pos -= sizeof (gulong) * MONO_SAVED_GREGS;
+ ppc_addi (code, ppc_r6, ppc_sp, pos);
+ ppc_li (code, ppc_r8, rethrow);
+
+ ppc_load (code, ppc_r0, 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);
+ return start;
+}
+
+/**
+ * mono_arch_get_rethrow_exception:
+ *
+ * Returns a function pointer which can be used to rethrow
+ * exceptions. The returned function has the following
+ * signature: void (*func) (MonoException *exc);
+ *
+ */
+gpointer
+mono_arch_get_rethrow_exception (void)
+{
+ static guint8 start [132];
+ static int inited = 0;
+
+ if (inited)
+ return start;
+ mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, TRUE);
+ inited = 1;
+ return start;
+}
/**
* arch_get_throw_exception:
*
gpointer
mono_arch_get_throw_exception (void)
{
- static guint8 start [24];
+ static guint8 start [132];
static int inited = 0;
- guint8 *code;
if (inited)
return start;
-
+ mono_arch_get_throw_exception_generic (start, sizeof (start), FALSE, FALSE);
inited = 1;
- code = start;
-
-#if 0
- x86_push_reg (code, X86_ESP);
- x86_push_membase (code, X86_ESP, 4); /* IP */
- x86_push_membase (code, X86_ESP, 12); /* exception */
- x86_push_reg (code, X86_EBP);
- x86_push_reg (code, X86_EDI);
- x86_push_reg (code, X86_ESI);
- x86_push_reg (code, X86_EBX);
- x86_push_reg (code, X86_EDX);
- x86_push_reg (code, X86_ECX);
- x86_push_reg (code, X86_EAX);
- x86_call_code (code, throw_exception);
- /* we should never reach this breakpoint */
- x86_breakpoint (code);
-
- g_assert ((code - start) < 24);
-#endif
return start;
}
gpointer
mono_arch_get_throw_exception_by_name (void)
{
- static guint8 start [32];
+ static guint8 start [168];
static int inited = 0;
- guint8 *code;
if (inited)
return start;
-
+ mono_arch_get_throw_exception_generic (start, sizeof (start), TRUE, FALSE);
inited = 1;
- code = start;
-#if 0
- x86_push_membase (code, X86_ESP, 4); /* exception name */
- x86_push_imm (code, "System");
- x86_push_imm (code, mono_defaults.exception_class->image);
- x86_call_code (code, mono_exception_from_name);
- x86_alu_reg_imm (code, X86_ADD, X86_ESP, 12);
- /* save the newly create object (overwrite exception name)*/
- x86_mov_membase_reg (code, X86_ESP, 4, X86_EAX, 4);
- x86_jump_code (code, mono_arch_get_throw_exception ());
-
- g_assert ((code - start) < 32);
-#endif
return start;
}
* the @lmf if necessary. @native_offset return the IP offset from the
* start of the function or -1 if that info is not available.
*/
-static MonoJitInfo *
-mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoContext *ctx,
- MonoContext *new_ctx, char **trace, MonoLMF **lmf, int *native_offset,
- gboolean *managed)
+MonoJitInfo *
+mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls, MonoJitInfo *res, MonoJitInfo *prev_ji,
+ MonoContext *ctx, MonoContext *new_ctx, char **trace, MonoLMF **lmf,
+ int *native_offset, gboolean *managed)
{
MonoJitInfo *ji;
gpointer ip = MONO_CONTEXT_GET_IP (ctx);
-
- ji = mono_jit_info_table_find (domain, ip);
+ unsigned long *ptr;
+ char *p;
+ 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);
if (trace)
*trace = NULL;
if (ji != NULL) {
char *source_location, *tmpaddr, *fname;
gint32 address, iloffset;
- int offset;
+ int offset, i;
+ gulong *ctx_regs;
*new_ctx = *ctx;
+ setup_context (new_ctx);
if (*lmf && (MONO_CONTEXT_GET_BP (ctx) >= (gpointer)(*lmf)->ebp)) {
/* remove any unused lmf */
*managed = TRUE;
if (trace) {
- if (mono_debug_format != MONO_DEBUG_FORMAT_NONE)
- mono_debug_make_symbols ();
-
- source_location = mono_debug_source_location_from_address (ji->method, address, NULL);
- iloffset = mono_debug_il_offset_from_address (ji->method, address);
- source_location = NULL;
- iloffset = -1;
+ source_location = mono_debug_source_location_from_address (ji->method, address, NULL, domain);
+ iloffset = mono_debug_il_offset_from_address (ji->method, address, domain);
if (iloffset < 0)
tmpaddr = g_strdup_printf ("<0x%05x>", address);
g_free (source_location);
g_free (tmpaddr);
}
-#if 0
- offset = -1;
- /* restore caller saved registers */
- if (ji->used_regs & X86_EBX_MASK) {
- new_ctx->SC_EBX = *((int *)ctx->SC_EBP + offset);
- offset--;
- }
- if (ji->used_regs & X86_EDI_MASK) {
- new_ctx->SC_EDI = *((int *)ctx->SC_EBP + offset);
- offset--;
- }
- if (ji->used_regs & X86_ESI_MASK) {
- new_ctx->SC_ESI = *((int *)ctx->SC_EBP + offset);
+ sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_BP (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);
+ }
+ }
}
+ /* 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);
- new_ctx->SC_ESP = ctx->SC_EBP;
- /* we substract 1, so that the IP points into the call instruction */
- new_ctx->SC_EIP = *((int *)ctx->SC_EBP + 1) - 1;
- new_ctx->SC_EBP = *((int *)ctx->SC_EBP);
-#endif
- return ji;
-#ifdef MONO_USE_EXC_TABLES
- } else if ((ji = ppc_unwind_native_frame (domain, jit_tls, ctx, new_ctx, *lmf, trace))) {
return ji;
-#endif
} else if (*lmf) {
*new_ctx = *ctx;
+ setup_context (new_ctx);
if (!(*lmf)->method)
return (gpointer)-1;
- if (trace)
- *trace = g_strdup_printf ("in (unmanaged) %s", mono_method_full_name ((*lmf)->method, TRUE));
+ if (trace) {
+ char *fname = mono_method_full_name ((*lmf)->method, TRUE);
+ *trace = g_strdup_printf ("in (unmanaged) %s", fname);
+ g_free (fname);
+ }
- ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip);
- g_assert (ji != NULL);
-
-#if 0
- new_ctx->SC_ESI = (*lmf)->esi;
- new_ctx->SC_EDI = (*lmf)->edi;
- new_ctx->SC_EBX = (*lmf)->ebx;
- new_ctx->SC_EBP = (*lmf)->ebp;
- new_ctx->SC_EIP = (*lmf)->eip;
- /* the lmf is always stored on the stack, so the following
- * expression points to a stack location which can be used as ESP */
- new_ctx->SC_ESP = (unsigned long)&((*lmf)->eip);
-#endif
+ if ((ji = mono_jit_info_table_find (domain, (gpointer)(*lmf)->eip))) {
+ } else {
+ memset (res, 0, sizeof (MonoJitInfo));
+ res->method = (*lmf)->method;
+ }
+
+ /*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_BP (ctx);
+ MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
+ 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->fregs, (*lmf)->fregs, sizeof (double) * MONO_SAVED_FREGS);
*lmf = (*lmf)->previous_lmf;
- return ji;
-
+ return ji ? ji : res;
}
return NULL;
}
-MonoArray *
-ves_icall_get_trace (MonoException *exc, gint32 skip, MonoBoolean need_file_info)
-{
- MonoDomain *domain = mono_domain_get ();
- MonoArray *res;
- MonoArray *ta = exc->trace_ips;
- int i, len;
-
- len = mono_array_length (ta);
-
- res = mono_array_new (domain, mono_defaults.stack_frame_class, len > skip ? len - skip : 0);
-
- for (i = skip; i < len; i++) {
- MonoJitInfo *ji;
- MonoStackFrame *sf = (MonoStackFrame *)mono_object_new (domain, mono_defaults.stack_frame_class);
- gpointer ip = mono_array_get (ta, gpointer, i);
-
- ji = mono_jit_info_table_find (domain, ip);
- g_assert (ji != NULL);
-
- sf->method = mono_method_get_object (domain, ji->method, NULL);
- sf->native_offset = (char *)ip - (char *)ji->code_start;
-
- sf->il_offset = mono_debug_il_offset_from_address (ji->method, sf->native_offset);
- sf->il_offset = -1;
-
- if (need_file_info) {
- gchar *filename;
-
- filename = mono_debug_source_location_from_address (ji->method, sf->native_offset, &sf->line);
- filename = NULL;
-
- sf->filename = filename? mono_string_new (domain, filename): NULL;
- sf->column = 0;
-
- g_free (filename);
- }
-
- mono_array_set (res, gpointer, i, sf);
- }
-
- return res;
-}
-
void
-mono_jit_walk_stack (MonoStackWalk func, gpointer user_data) {
+mono_jit_walk_stack (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) {
MonoDomain *domain = mono_domain_get ();
MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
MonoLMF *lmf = jit_tls->lmf;
- MonoJitInfo *ji;
+ MonoJitInfo *ji, rji;
gint native_offset, il_offset;
gboolean managed;
+ MonoPPCStackFrame *sframe;
MonoContext ctx, new_ctx;
- MONO_CONTEXT_SET_IP (&ctx, __builtin_return_address (0));
- MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (1));
+ setup_context (&ctx);
+ setup_context (&new_ctx);
+
+#ifdef __APPLE__
+ __asm__ volatile("lwz %0,0(r1)" : "=r" (sframe));
+#else
+ __asm__ volatile("lwz %0,0(1)" : "=r" (sframe));
+#endif
+ //MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
+ MONO_CONTEXT_SET_BP (&ctx, sframe->sp);
+ sframe = (MonoPPCStackFrame*)sframe->sp;
+ MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
while (MONO_CONTEXT_GET_BP (&ctx) < jit_tls->end_of_stack) {
- ji = mono_arch_find_jit_info (domain, jit_tls, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
+ ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, &native_offset, &managed);
g_assert (ji);
if (ji == (gpointer)-1)
return;
- il_offset = mono_debug_il_offset_from_address (ji->method, native_offset);
+ il_offset = do_il_offset ? mono_debug_il_offset_from_address (ji->method, native_offset, domain): -1;
if (func (ji->method, native_offset, il_offset, managed, user_data))
return;
ctx = new_ctx;
+ setup_context (&ctx);
}
}
MonoDomain *domain = mono_domain_get ();
MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
MonoLMF *lmf = jit_tls->lmf;
- MonoJitInfo *ji;
+ MonoJitInfo *ji, rji;
MonoContext ctx, new_ctx;
+ MonoPPCStackFrame *sframe;
- MONO_CONTEXT_SET_IP (&ctx, ves_icall_get_frame_info);
- MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (0));
+#ifdef __APPLE__
+ __asm__ volatile("lwz %0,0(r1)" : "=r" (sframe));
+#else
+ __asm__ volatile("lwz %0,0(1)" : "=r" (sframe));
+#endif
+ MONO_CONTEXT_SET_BP (&ctx, sframe->sp);
+ sframe = (MonoPPCStackFrame*)sframe->sp;
+ MONO_CONTEXT_SET_IP (&ctx, sframe->lr);
+ /*MONO_CONTEXT_SET_IP (&ctx, ves_icall_get_frame_info);
+ MONO_CONTEXT_SET_BP (&ctx, __builtin_frame_address (0));*/
skip++;
do {
- ji = mono_arch_find_jit_info (domain, jit_tls, &ctx, &new_ctx, NULL, &lmf, native_offset, NULL);
+ ji = mono_arch_find_jit_info (domain, jit_tls, &rji, NULL, &ctx, &new_ctx, NULL, &lmf, native_offset, NULL);
ctx = new_ctx;
if (!ji || ji == (gpointer)-1 || MONO_CONTEXT_GET_BP (&ctx) >= jit_tls->end_of_stack)
return FALSE;
- if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE)
+ /* skip all wrappers ??*/
+ if (ji->method->wrapper_type == MONO_WRAPPER_RUNTIME_INVOKE ||
+ ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE_WITH_CHECK ||
+ ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_INVOKE ||
+ ji->method->wrapper_type == MONO_WRAPPER_XDOMAIN_DISPATCH ||
+ ji->method->wrapper_type == MONO_WRAPPER_REMOTING_INVOKE)
continue;
skip--;
} while (skip >= 0);
*method = mono_method_get_object (domain, ji->method, NULL);
- *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset);
- *iloffset = -1;
+ *iloffset = mono_debug_il_offset_from_address (ji->method, *native_offset, domain);
if (need_file_info) {
gchar *filename;
- filename = mono_debug_source_location_from_address (ji->method, *native_offset, line);
- filename = NULL;
+ filename = mono_debug_source_location_from_address (ji->method, *native_offset, line, domain);
*file = filename? mono_string_new (domain, filename): NULL;
*column = 0;
return TRUE;
}
+/*
+ * This is the function called from the signal handler
+ */
+#ifdef __APPLE__
+gboolean
+mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+{
+ struct ucontext *uc = ctx;
+ MonoContext mctx;
+ gboolean result;
+
+ mctx.sc_ir = uc->uc_mcontext->ss.srr0;
+ mctx.sc_sp = uc->uc_mcontext->ss.r1;
+ memcpy (&mctx.regs, &uc->uc_mcontext->ss.r13, sizeof (gulong) * MONO_SAVED_GREGS);
+ memcpy (&mctx.fregs, &uc->uc_mcontext->fs.fpregs [14], sizeof (double) * MONO_SAVED_FREGS);
+
+ result = arch_handle_exception (&mctx, obj, test_only);
+ /* restore the context so that returning from the signal handler will invoke
+ * the catch clause
+ */
+ uc->uc_mcontext->ss.srr0 = mctx.sc_ir;
+ uc->uc_mcontext->ss.r1 = mctx.sc_sp;
+ memcpy (&uc->uc_mcontext->ss.r13, &mctx.regs, sizeof (gulong) * MONO_SAVED_GREGS);
+ memcpy (&uc->uc_mcontext->fs.fpregs [14], &mctx.fregs, sizeof (double) * MONO_SAVED_FREGS);
+ return result;
+}
+
+gpointer
+mono_arch_ip_from_context (void *sigctx)
+{
+ struct ucontext *uc = sigctx;
+ return (gpointer)uc->uc_mcontext->ss.srr0;
+}
+
+#else
+/* Linux */
+gboolean
+mono_arch_handle_exception (void *ctx, gpointer obj, gboolean test_only)
+{
+ struct ucontext *uc = ctx;
+ MonoContext mctx;
+ gboolean result;
+
+ mctx.sc_ir = uc->uc_mcontext.uc_regs->gregs [PT_NIP];
+ mctx.sc_sp = uc->uc_mcontext.uc_regs->gregs [PT_R1];
+ memcpy (&mctx.regs, &uc->uc_mcontext.uc_regs->gregs [PT_R13], sizeof (gulong) * MONO_SAVED_GREGS);
+ memcpy (&mctx.fregs, &uc->uc_mcontext.uc_regs->fpregs.fpregs [14], sizeof (double) * MONO_SAVED_FREGS);
+
+ result = arch_handle_exception (&mctx, obj, test_only);
+ /* restore the context so that returning from the signal handler will invoke
+ * the catch clause
+ */
+ uc->uc_mcontext.uc_regs->gregs [PT_NIP] = mctx.sc_ir;
+ uc->uc_mcontext.uc_regs->gregs [PT_R1] = mctx.sc_sp;
+ memcpy (&uc->uc_mcontext.uc_regs->gregs [PT_R13], &mctx.regs, sizeof (gulong) * MONO_SAVED_GREGS);
+ memcpy (&uc->uc_mcontext.uc_regs->fpregs.fpregs [14], &mctx.fregs, sizeof (double) * MONO_SAVED_FREGS);
+ return result;
+}
+
+gpointer
+mono_arch_ip_from_context (void *sigctx)
+{
+ struct ucontext *uc = sigctx;
+ return (gpointer)uc->uc_mcontext.uc_regs->gregs [PT_NIP];
+}
+
+#endif
+
/**
* arch_handle_exception:
* @ctx: saved processor state
*
*
*/
-gboolean
-mono_arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only)
+static gboolean
+arch_handle_exception (MonoContext *ctx, gpointer obj, gboolean test_only)
{
MonoDomain *domain = mono_domain_get ();
- MonoJitInfo *ji;
+ MonoJitInfo *ji, rji;
static int (*call_filter) (MonoContext *, gpointer, gpointer) = NULL;
MonoJitTlsData *jit_tls = TlsGetValue (mono_jit_tls_id);
MonoLMF *lmf = jit_tls->lmf;
GList *trace_ips = NULL;
+ MonoException *mono_ex;
+ MonoString *initial_stack_trace = NULL;
+ GString *trace_str = NULL;
+ int frame_count = 0;
g_assert (ctx != NULL);
if (!obj) {
obj = (MonoObject *)ex;
}
- g_assert (mono_object_isinst (obj, mono_defaults.exception_class));
+ if (mono_object_isinst (obj, mono_defaults.exception_class)) {
+ mono_ex = (MonoException*)obj;
+ initial_stack_trace = mono_ex->stack_trace;
+ } else {
+ mono_ex = NULL;
+ }
+
if (!call_filter)
call_filter = arch_get_call_filter ();
if (!test_only) {
MonoContext ctx_cp = *ctx;
- if (mono_jit_trace_calls)
+ setup_context (&ctx_cp);
+ if (mono_jit_trace_calls != NULL)
g_print ("EXCEPTION handling: %s\n", mono_object_class (obj)->name);
- if (!mono_arch_handle_exception (&ctx_cp, obj, TRUE)) {
- if (mono_break_on_exc) {
- if (mono_debug_format != MONO_DEBUG_FORMAT_NONE)
- mono_debug_make_symbols ();
+ if (!arch_handle_exception (&ctx_cp, obj, TRUE)) {
+ if (mono_break_on_exc)
G_BREAKPOINT ();
- }
mono_unhandled_exception (obj);
}
}
+ memset (&rji, 0, sizeof (rji));
+
while (1) {
MonoContext new_ctx;
char *trace = NULL;
+ gboolean need_trace = FALSE;
- ji = mono_arch_find_jit_info (domain, jit_tls, ctx, &new_ctx,
- test_only ? &trace : NULL, &lmf, NULL, NULL);
+ if (test_only && (frame_count < 1000)) {
+ need_trace = TRUE;
+ if (!trace_str)
+ trace_str = g_string_new ("");
+ }
+ setup_context (&new_ctx);
+ ji = mono_arch_find_jit_info (domain, jit_tls, &rji, &rji, ctx, &new_ctx,
+ need_trace ? &trace : NULL, &lmf, NULL, NULL);
if (!ji) {
g_warning ("Exception inside function without unwind info");
g_assert_not_reached ();
}
if (ji != (gpointer)-1) {
+ frame_count ++;
- if (test_only && ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE) {
- char *tmp, *strace;
-
- trace_ips = g_list_append (trace_ips, MONO_CONTEXT_GET_IP (ctx));
-
- if (!((MonoException*)obj)->stack_trace)
- strace = g_strdup ("");
- else
- strace = mono_string_to_utf8 (((MonoException*)obj)->stack_trace);
-
- tmp = g_strdup_printf ("%s%s\n", strace, trace);
- g_free (strace);
-
- ((MonoException*)obj)->stack_trace = mono_string_new (domain, tmp);
+ if (test_only && ji->method->wrapper_type != MONO_WRAPPER_RUNTIME_INVOKE && mono_ex) {
+ if (!initial_stack_trace && (frame_count < 1000)) {
+ trace_ips = g_list_prepend (trace_ips, MONO_CONTEXT_GET_IP (ctx));
- g_free (tmp);
+ g_string_append (trace_str, trace);
+ g_string_append_c (trace_str, '\n');
+ }
}
if (ji->num_clauses) {
for (i = 0; i < ji->num_clauses; i++) {
MonoJitExceptionInfo *ei = &ji->clauses [i];
+ gboolean filtered = FALSE;
if (ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
MONO_CONTEXT_GET_IP (ctx) <= ei->try_end) {
/* catch block */
+
+ if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE) || (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)) {
+ /* store the exception object int cfg->excvar */
+ g_assert (ei->exvar_offset);
+ /* need to use the frame pointer (ppc_r31), not r1 (regs start from register r13): methods with clauses always have r31 */
+ *((gpointer *)((char *)(ctx->regs [ppc_r31-13]) + ei->exvar_offset)) = obj;
+ if (!initial_stack_trace && trace_str) {
+ mono_ex->stack_trace = mono_string_new (domain, trace_str->str);
+ }
+ }
+
+ if (ei->flags == MONO_EXCEPTION_CLAUSE_FILTER)
+ filtered = call_filter (ctx, ei->data.filter, mono_ex);
+
if ((ei->flags == MONO_EXCEPTION_CLAUSE_NONE &&
- mono_object_isinst (obj, mono_class_get (ji->method->klass->image, ei->data.token))) ||
- ((ei->flags == MONO_EXCEPTION_CLAUSE_FILTER &&
- call_filter (ctx, ei->data.filter, obj)))) {
+ mono_object_isinst (obj, ei->data.catch_class)) || filtered) {
if (test_only) {
- ((MonoException*)obj)->trace_ips = glist_to_array (trace_ips);
+ if (mono_ex) {
+ trace_ips = g_list_reverse (trace_ips);
+ mono_ex->trace_ips = glist_to_array (trace_ips);
+ }
g_list_free (trace_ips);
+ g_free (trace);
+ if (trace_str)
+ g_string_free (trace_str, TRUE);
return TRUE;
}
- if (mono_jit_trace_calls)
+ if (mono_jit_trace_calls != NULL)
g_print ("EXCEPTION: catch found at clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
+ /*printf ("stack for catch: %p\n", MONO_CONTEXT_GET_BP (ctx));*/
MONO_CONTEXT_SET_IP (ctx, ei->handler_start);
- *((gpointer *)(MONO_CONTEXT_GET_BP (ctx) + ji->exvar_offset)) = obj;
jit_tls->lmf = lmf;
+ g_free (trace);
+ if (trace_str)
+ g_string_free (trace_str, TRUE);
return 0;
}
- }
- }
-
- /* no handler found - we need to call all finally handlers */
- if (!test_only) {
- for (i = 0; i < ji->num_clauses; i++) {
- MonoJitExceptionInfo *ei = &ji->clauses [i];
-
- if (ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
+ if (!test_only && ei->try_start <= MONO_CONTEXT_GET_IP (ctx) &&
MONO_CONTEXT_GET_IP (ctx) < ei->try_end &&
(ei->flags & MONO_EXCEPTION_CLAUSE_FINALLY)) {
- if (mono_jit_trace_calls)
+ if (mono_jit_trace_calls != NULL)
g_print ("EXCEPTION: finally clause %d of %s\n", i, mono_method_full_name (ji->method, TRUE));
call_filter (ctx, ei->handler_start, NULL);
}
+
}
}
}
g_free (trace);
*ctx = new_ctx;
+ setup_context (ctx);
if ((ji == (gpointer)-1) || MONO_CONTEXT_GET_BP (ctx) >= jit_tls->end_of_stack) {
if (!test_only) {
jit_tls->abort_func (obj);
g_assert_not_reached ();
} else {
- ((MonoException*)obj)->trace_ips = glist_to_array (trace_ips);
+ if (mono_ex) {
+ trace_ips = g_list_reverse (trace_ips);
+ mono_ex->trace_ips = glist_to_array (trace_ips);
+ }
g_list_free (trace_ips);
+ if (trace_str)
+ g_string_free (trace_str, TRUE);
return FALSE;
}
}
g_assert_not_reached ();
}
+gboolean
+mono_arch_has_unwind_info (gconstpointer addr)
+{
+ return FALSE;
+}
+
projects / mono.git / blobdiff