mono/mini/exceptions-sparc.c

   1 /*
   2  * exceptions-sparc.c: exception support for sparc
   3  *
   4  * Authors:
   5  *   Mark Crichton (crichton@gimp.org)
   6  *   Dietmar Maurer (dietmar@ximian.com)
   7  *
   8  * (C) 2003 Ximian, Inc.
   9  */
  10
  11 #include <config.h>
  12 #include <glib.h>
  13 #include <signal.h>
  14 #include <string.h>
  15 #include <sys/ucontext.h>
  16
  17 #include <mono/arch/sparc/sparc-codegen.h>
  18 #include <mono/metadata/appdomain.h>
  19 #include <mono/metadata/tabledefs.h>
  20 #include <mono/metadata/threads.h>
  21 #include <mono/metadata/debug-helpers.h>
  22 #include <mono/metadata/exception.h>
  23 #include <mono/metadata/mono-debug.h>
  24 #include <mono/metadata/gc-internal.h>
  25 #include <mono/metadata/tokentype.h>
  26
  27 #include "mini.h"
  28 #include "mini-sparc.h"
  29
  30 #ifndef REG_SP
  31 #define REG_SP REG_O6
  32 #endif
  33
  34 #define MONO_SPARC_WINDOW_ADDR(sp) ((gpointer*)(((guint8*)(sp)) + MONO_SPARC_STACK_BIAS))
  35
  36 /*
  37  * mono_arch_get_restore_context:
  38  *
  39  * Returns a pointer to a method which restores a previously saved sigcontext.
  40  */
  41 gpointer
  42 mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
  43 {
  44         static guint32 *start;
  45         static int inited = 0;
  46         guint32 *code;
  47
  48         g_assert (!aot);
  49         if (info)
  50                 *info = NULL;
  51
  52         if (inited)
  53                 return start;
  54
  55         code = start = mono_global_codeman_reserve (32 * sizeof (guint32));
  56
  57         sparc_ldi_imm (code, sparc_o0, G_STRUCT_OFFSET (MonoContext, ip), sparc_i7);
  58         sparc_ldi_imm (code, sparc_o0, G_STRUCT_OFFSET (MonoContext, sp), sparc_i6);
  59
  60         sparc_jmpl_imm (code, sparc_i7, 0, sparc_g0);
  61         /* FIXME: This does not return to the correct window */
  62         sparc_restore_imm (code, sparc_g0, 0, sparc_g0);
  63
  64         g_assert ((code - start) < 32);
  65
  66         mono_arch_flush_icache ((guint8*)start, (guint8*)code - (guint8*)start);
  67
  68         inited = 1;
  69
  70         return start;
  71 }
  72
  73 /*
  74  * mono_arch_get_call_filter:
  75  *
  76  * Returns a pointer to a method which calls an exception filter. We
  77  * also use this function to call finally handlers (we pass NULL as
  78  * @exc object in this case).
  79  *
  80  * call_filter (MonoContext *ctx, gpointer ip)
  81  */
  82 gpointer
  83 mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
  84 {
  85         static guint32 *start;
  86         static int inited = 0;
  87         guint32 *code;
  88         int i;
  89
  90         g_assert (!aot);
  91         if (info)
  92                 *info = NULL;
  93
  94         if (inited)
  95                 return start;
  96
  97         code = start = mono_global_codeman_reserve (64 * sizeof (guint32));
  98
  99         /*
 100          * There are two frames here:
 101          * - the first frame is used by call_filter
 102          * - the second frame is used to run the filter code
 103          */
 104
 105         /* Create first frame */
 106         sparc_save_imm (code, sparc_sp, -256, sparc_sp);
 107
 108         sparc_mov_reg_reg (code, sparc_i1, sparc_o0);
 109         sparc_ldi_imm (code, sparc_i0, G_STRUCT_OFFSET (MonoContext, sp), sparc_o1);
 110
 111         /* Create second frame */
 112         sparc_save_imm (code, sparc_sp, -256, sparc_sp);
 113
 114         sparc_mov_reg_reg (code, sparc_i0, sparc_o0);
 115         sparc_mov_reg_reg (code, sparc_i1, sparc_o1);
 116
 117         /*
 118          * We need to change %fp to point to the stack frame of the method
 119          * containing the filter. But changing %fp also changes the %sp of
 120          * the parent frame (the first frame), so if the OS saves the first frame,
 121          * it saves it to the stack frame of the method, which is not good.
 122          * So flush all register windows to memory before changing %fp.
 123          */
 124         sparc_flushw (code);
 125
 126         sparc_mov_reg_reg (code, sparc_fp, sparc_o7);
 127
 128         /*
 129          * Modify the second frame so it is identical to the one used in the
 130          * method containing the filter.
 131          */
 132         for (i = 0; i < 16; ++i)
 133                 sparc_ldi_imm (code, sparc_o1, MONO_SPARC_STACK_BIAS + i * sizeof (gpointer), sparc_l0 + i);
 134
 135         /* Save %fp to a location reserved in mono_arch_allocate_vars */
 136         sparc_sti_imm (code, sparc_o7, sparc_fp, MONO_SPARC_STACK_BIAS - sizeof (gpointer));
 137
 138         /* Call the filter code, after this returns, %o0 will hold the result */
 139         sparc_call_imm (code, sparc_o0, 0);
 140         sparc_nop (code);
 141
 142         /* Restore original %fp */
 143         sparc_ldi_imm (code, sparc_fp, MONO_SPARC_STACK_BIAS - sizeof (gpointer), sparc_fp);
 144
 145         sparc_mov_reg_reg (code, sparc_o0, sparc_i0);
 146
 147         /* Return to first frame */
 148         sparc_restore (code, sparc_g0, sparc_g0, sparc_g0);
 149
 150         /* FIXME: Save locals to the stack */
 151
 152         /* Return to caller */
 153         sparc_ret (code);
 154         /* Return result in delay slot */
 155         sparc_restore (code, sparc_o0, sparc_g0, sparc_o0);
 156
 157         g_assert ((code - start) < 64);
 158
 159         mono_arch_flush_icache ((guint8*)start, (guint8*)code - (guint8*)start);
 160
 161         inited = 1;
 162
 163         return start;
 164 }
 165
 166 static void
 167 throw_exception (MonoObject *exc, gpointer sp, gpointer ip, gboolean rethrow)
 168 {
 169         MonoContext ctx;
 170         static void (*restore_context) (MonoContext *);
 171         gpointer *window;
 172
 173         if (!restore_context)
 174                 restore_context = mono_get_restore_context ();
 175
 176         window = MONO_SPARC_WINDOW_ADDR (sp);
 177         ctx.sp = (gpointer*)sp;
 178         ctx.ip = ip;
 179         ctx.fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (sp) [sparc_i6 - 16]);
 180
 181         if (mono_object_isinst (exc, mono_defaults.exception_class)) {
 182                 MonoException *mono_ex = (MonoException*)exc;
 183                 if (!rethrow)
 184                         mono_ex->stack_trace = NULL;
 185         }
 186         mono_handle_exception (&ctx, exc);
 187         restore_context (&ctx);
 188
 189         g_assert_not_reached ();
 190 }
 191
 192 static gpointer
 193 get_throw_exception (gboolean rethrow)
 194 {
 195         guint32 *start, *code;
 196
 197         code = start = mono_global_codeman_reserve (16 * sizeof (guint32));
 198
 199         sparc_save_imm (code, sparc_sp, -512, sparc_sp);
 200
 201         sparc_flushw (code);
 202         sparc_mov_reg_reg (code, sparc_i0, sparc_o0);
 203         sparc_mov_reg_reg (code, sparc_fp, sparc_o1);
 204         sparc_mov_reg_reg (code, sparc_i7, sparc_o2);
 205         sparc_set (code, rethrow, sparc_o3);
 206         sparc_set (code, throw_exception, sparc_o7);
 207         sparc_jmpl (code, sparc_o7, sparc_g0, sparc_callsite);
 208         sparc_nop (code);
 209
 210         g_assert ((code - start) <= 16);
 211
 212         mono_arch_flush_icache ((guint8*)start, (guint8*)code - (guint8*)start);
 213
 214         return start;
 215 }
 216
 217 /**
 218  * mono_arch_get_throw_exception:
 219  *
 220  * Returns a function pointer which can be used to raise exceptions.
 221  * The returned function has the following
 222  * signature: void (*func) (MonoException *exc);
 223  */
 224 gpointer
 225 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
 226 {
 227         static guint32* start;
 228         static int inited = 0;
 229
 230         g_assert (!aot);
 231         if (info)
 232                 *info = NULL;
 233
 234         if (inited)
 235                 return start;
 236
 237         inited = 1;
 238
 239         start = get_throw_exception (FALSE);
 240
 241         return start;
 242 }
 243
 244 gpointer
 245 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
 246 {
 247         static guint32* start;
 248         static int inited = 0;
 249
 250         g_assert (!aot);
 251         if (info)
 252                 *info = NULL;
 253
 254         if (inited)
 255                 return start;
 256
 257         inited = 1;
 258
 259         start = get_throw_exception (TRUE);
 260
 261         return start;
 262 }
 263
 264 /**
 265  * mono_arch_get_throw_corlib_exception:
 266  *
 267  * Returns a function pointer which can be used to raise
 268  * corlib exceptions. The returned function has the following
 269  * signature: void (*func) (guint32 ex_token, guint32 offset);
 270  * Here, offset is the offset which needs to be substracted from the caller IP
 271  * to get the IP of the throw. Passing the offset has the advantage that it
 272  * needs no relocations in the caller.
 273  */
 274 gpointer
 275 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
 276 {
 277         static guint32 *start;
 278         static int inited = 0;
 279         guint32 *code;
 280         int reg;
 281
 282         g_assert (!aot);
 283         if (info)
 284                 *info = NULL;
 285
 286         if (inited)
 287                 return start;
 288
 289         inited = 1;
 290         code = start = mono_global_codeman_reserve (64 * sizeof (guint32));
 291
 292 #ifdef SPARCV9
 293         reg = sparc_g4;
 294 #else
 295         reg = sparc_g1;
 296 #endif
 297
 298         sparc_mov_reg_reg (code, sparc_o7, sparc_o2);
 299         sparc_save_imm (code, sparc_sp, -160, sparc_sp);
 300
 301         sparc_set (code, MONO_TOKEN_TYPE_DEF, sparc_o7);
 302         sparc_add (code, FALSE, sparc_i0, sparc_o7, sparc_o1);
 303         sparc_set (code, mono_defaults.exception_class->image, sparc_o0);
 304         sparc_set (code, mono_exception_from_token, sparc_o7);
 305         sparc_jmpl (code, sparc_o7, sparc_g0, sparc_callsite);
 306         sparc_nop (code);
 307
 308         /* Return to the caller, so exception handling does not see this frame */
 309         sparc_restore (code, sparc_o0, sparc_g0, sparc_o0);
 310
 311         /* Compute throw ip */
 312         sparc_sll_imm (code, sparc_o1, 2, sparc_o1);
 313         sparc_sub (code, 0, sparc_o2, sparc_o1, sparc_o7);
 314
 315         sparc_set (code, mono_arch_get_throw_exception (NULL, FALSE), reg);
 316         /* Use a jmp instead of a call so o7 is preserved */
 317         sparc_jmpl_imm (code, reg, 0, sparc_g0);
 318         sparc_nop (code);
 319
 320         g_assert ((code - start) < 32);
 321
 322         mono_arch_flush_icache ((guint8*)start, (guint8*)code - (guint8*)start);
 323
 324         return start;
 325 }
 326
 327 /* mono_arch_find_jit_info:
 328  *
 329  * This function is used to gather information from @ctx. It return the
 330  * MonoJitInfo of the corresponding function, unwinds one stack frame and
 331  * stores the resulting context into @new_ctx. It also stores a string
 332  * describing the stack location into @trace (if not NULL), and modifies
 333  * the @lmf if necessary. @native_offset return the IP offset from the
 334  * start of the function or -1 if that info is not available.
 335  */
 336 gboolean
 337 mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
 338                                                          MonoJitInfo *ji, MonoContext *ctx,
 339                                                          MonoContext *new_ctx, MonoLMF **lmf,
 340                                                          mgreg_t **save_locations,
 341                                                          StackFrameInfo *frame)
 342 {
 343         gpointer *window;
 344
 345         memset (frame, 0, sizeof (StackFrameInfo));
 346         frame->ji = ji;
 347
 348         *new_ctx = *ctx;
 349
 350         if (ji != NULL) {
 351                 frame->type = FRAME_TYPE_MANAGED;
 352
 353                 /* Restore ip and sp from the saved register window */
 354                 window = MONO_SPARC_WINDOW_ADDR (ctx->sp);
 355                 new_ctx->ip = window [sparc_i7 - 16];
 356                 new_ctx->sp = (gpointer*)(window [sparc_i6 - 16]);
 357                 new_ctx->fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (new_ctx->sp) [sparc_i6 - 16]);
 358
 359                 return TRUE;
 360         }
 361         else {
 362                 if (!(*lmf))
 363                         return FALSE;
 364
 365                 if (!(*lmf)->method)
 366                         return FALSE;
 367
 368                 ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->ip, NULL);
 369                 if (!ji)
 370                         return FALSE;
 371
 372                 frame->ji = ji;
 373                 frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
 374
 375                 new_ctx->ip = (*lmf)->ip;
 376                 new_ctx->sp = (*lmf)->sp;
 377                 new_ctx->fp = (*lmf)->ebp;
 378
 379                 *lmf = (*lmf)->previous_lmf;
 380
 381                 return TRUE;
 382         }
 383 }
 384
 385 #ifdef __linux__
 386
 387 gboolean
 388 mono_arch_handle_exception (void *sigctx, gpointer obj)
 389 {
 390        MonoContext mctx;
 391        struct sigcontext *sc = sigctx;
 392        gpointer *window;
 393
 394 #ifdef SPARCV9
 395        mctx.ip = (gpointer) sc->sigc_regs.tpc;
 396        mctx.sp = (gpointer) sc->sigc_regs.u_regs[14];
 397 #else
 398        mctx.ip = (gpointer) sc->si_regs.pc;
 399        mctx.sp = (gpointer) sc->si_regs.u_regs[14];
 400 #endif
 401
 402        window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 403        mctx.fp = window [sparc_fp - 16];
 404
 405        mono_handle_exception (&mctx, obj);
 406
 407 #ifdef SPARCV9
 408        sc->sigc_regs.tpc = (unsigned long) mctx.ip;
 409        sc->sigc_regs.tnpc = (unsigned long) (mctx.ip + 4);
 410        sc->sigc_regs.u_regs[14] = (unsigned long) mctx.sp;
 411 #else
 412        sc->si_regs.pc = (unsigned long) mctx.ip;
 413        sc->si_regs.npc = (unsigned long) (mctx.ip + 4);
 414        sc->si_regs.u_regs[14] = (unsigned long) mctx.sp;
 415 #endif
 416
 417        window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 418        window [sparc_fp - 16] = mctx.fp;
 419
 420        return TRUE;
 421 }
 422
 423 gpointer
 424 mono_arch_ip_from_context (void *sigctx)
 425 {
 426        struct sigcontext *sc = sigctx;
 427        gpointer *ret;
 428
 429 #ifdef SPARCV9
 430        ret = (gpointer) sc->sigc_regs.tpc;
 431 #else
 432        ret = (gpointer) sc->si_regs.pc;
 433 #endif
 434
 435        return ret;
 436 }
 437
 438 #else /* !__linux__ */
 439
 440 gboolean
 441 mono_arch_handle_exception (void *sigctx, gpointer obj)
 442 {
 443         MonoContext mctx;
 444         ucontext_t *ctx = (ucontext_t*)sigctx;
 445         gpointer *window;
 446
 447         /*
 448          * Access to the machine state using the ucontext_t parameter is somewhat
 449          * under documented under solaris. The code below seems to work under
 450          * Solaris 9.
 451          */
 452         g_assert (!ctx->uc_mcontext.gwins);
 453
 454         mctx.ip = ctx->uc_mcontext.gregs [REG_PC];
 455         mctx.sp = ctx->uc_mcontext.gregs [REG_SP];
 456         window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 457         mctx.fp = window [sparc_fp - 16];
 458
 459         mono_handle_exception (&mctx, obj);
 460
 461         /* We can't use restore_context to return from a signal handler */
 462         ctx->uc_mcontext.gregs [REG_PC] = mctx.ip;
 463         ctx->uc_mcontext.gregs [REG_nPC] = mctx.ip + 4;
 464         ctx->uc_mcontext.gregs [REG_SP] = mctx.sp;
 465         window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 466         window [sparc_fp - 16] = mctx.fp;
 467
 468         return TRUE;
 469 }
 470
 471 gpointer
 472 mono_arch_ip_from_context (void *sigctx)
 473 {
 474         ucontext_t *ctx = (ucontext_t*)sigctx;
 475         return (gpointer)ctx->uc_mcontext.gregs [REG_PC];
 476 }
 477
 478 #endif