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-internals.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         MonoError error;
 170         MonoContext ctx;
 171         static void (*restore_context) (MonoContext *);
 172         gpointer *window;
 173
 174         if (!restore_context)
 175                 restore_context = mono_get_restore_context ();
 176
 177         window = MONO_SPARC_WINDOW_ADDR (sp);
 178         ctx.sp = (gpointer*)sp;
 179         ctx.ip = ip;
 180         ctx.fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (sp) [sparc_i6 - 16]);
 181
 182         if (mono_object_isinst_checked (exc, mono_defaults.exception_class, &error)) {
 183                 MonoException *mono_ex = (MonoException*)exc;
 184                 if (!rethrow) {
 185                         mono_ex->stack_trace = NULL;
 186                         mono_ex->trace_ips = NULL;
 187                 }
 188         }
 189         mono_error_assert_ok (&error);
 190         mono_handle_exception (&ctx, exc);
 191         restore_context (&ctx);
 192
 193         g_assert_not_reached ();
 194 }
 195
 196 static gpointer
 197 get_throw_exception (gboolean rethrow)
 198 {
 199         guint32 *start, *code;
 200
 201         code = start = mono_global_codeman_reserve (16 * sizeof (guint32));
 202
 203         sparc_save_imm (code, sparc_sp, -512, sparc_sp);
 204
 205         sparc_flushw (code);
 206         sparc_mov_reg_reg (code, sparc_i0, sparc_o0);
 207         sparc_mov_reg_reg (code, sparc_fp, sparc_o1);
 208         sparc_mov_reg_reg (code, sparc_i7, sparc_o2);
 209         sparc_set (code, rethrow, sparc_o3);
 210         sparc_set (code, throw_exception, sparc_o7);
 211         sparc_jmpl (code, sparc_o7, sparc_g0, sparc_callsite);
 212         sparc_nop (code);
 213
 214         g_assert ((code - start) <= 16);
 215
 216         mono_arch_flush_icache ((guint8*)start, (guint8*)code - (guint8*)start);
 217
 218         return start;
 219 }
 220
 221 /**
 222  * mono_arch_get_throw_exception:
 223  *
 224  * Returns a function pointer which can be used to raise exceptions.
 225  * The returned function has the following
 226  * signature: void (*func) (MonoException *exc);
 227  */
 228 gpointer
 229 mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
 230 {
 231         static guint32* start;
 232         static int inited = 0;
 233
 234         g_assert (!aot);
 235         if (info)
 236                 *info = NULL;
 237
 238         if (inited)
 239                 return start;
 240
 241         inited = 1;
 242
 243         start = get_throw_exception (FALSE);
 244
 245         return start;
 246 }
 247
 248 gpointer
 249 mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
 250 {
 251         static guint32* start;
 252         static int inited = 0;
 253
 254         g_assert (!aot);
 255         if (info)
 256                 *info = NULL;
 257
 258         if (inited)
 259                 return start;
 260
 261         inited = 1;
 262
 263         start = get_throw_exception (TRUE);
 264
 265         return start;
 266 }
 267
 268 /**
 269  * mono_arch_get_throw_corlib_exception:
 270  *
 271  * Returns a function pointer which can be used to raise
 272  * corlib exceptions. The returned function has the following
 273  * signature: void (*func) (guint32 ex_token, guint32 offset);
 274  * Here, offset is the offset which needs to be substracted from the caller IP
 275  * to get the IP of the throw. Passing the offset has the advantage that it
 276  * needs no relocations in the caller.
 277  */
 278 gpointer
 279 mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
 280 {
 281         static guint32 *start;
 282         static int inited = 0;
 283         guint32 *code;
 284         int reg;
 285
 286         g_assert (!aot);
 287         if (info)
 288                 *info = NULL;
 289
 290         if (inited)
 291                 return start;
 292
 293         inited = 1;
 294         code = start = mono_global_codeman_reserve (64 * sizeof (guint32));
 295
 296 #ifdef SPARCV9
 297         reg = sparc_g4;
 298 #else
 299         reg = sparc_g1;
 300 #endif
 301
 302         sparc_mov_reg_reg (code, sparc_o7, sparc_o2);
 303         sparc_save_imm (code, sparc_sp, -160, sparc_sp);
 304
 305         sparc_set (code, MONO_TOKEN_TYPE_DEF, sparc_o7);
 306         sparc_add (code, FALSE, sparc_i0, sparc_o7, sparc_o1);
 307         sparc_set (code, mono_defaults.exception_class->image, sparc_o0);
 308         sparc_set (code, mono_exception_from_token, sparc_o7);
 309         sparc_jmpl (code, sparc_o7, sparc_g0, sparc_callsite);
 310         sparc_nop (code);
 311
 312         /* Return to the caller, so exception handling does not see this frame */
 313         sparc_restore (code, sparc_o0, sparc_g0, sparc_o0);
 314
 315         /* Compute throw ip */
 316         sparc_sll_imm (code, sparc_o1, 2, sparc_o1);
 317         sparc_sub (code, 0, sparc_o2, sparc_o1, sparc_o7);
 318
 319         sparc_set (code, mono_arch_get_throw_exception (NULL, FALSE), reg);
 320         /* Use a jmp instead of a call so o7 is preserved */
 321         sparc_jmpl_imm (code, reg, 0, sparc_g0);
 322         sparc_nop (code);
 323
 324         g_assert ((code - start) < 32);
 325
 326         mono_arch_flush_icache ((guint8*)start, (guint8*)code - (guint8*)start);
 327
 328         return start;
 329 }
 330
 331 /* mono_arch_unwind_frame:
 332  *
 333  * This function is used to gather information from @ctx. It return the
 334  * MonoJitInfo of the corresponding function, unwinds one stack frame and
 335  * stores the resulting context into @new_ctx. It also stores a string
 336  * describing the stack location into @trace (if not NULL), and modifies
 337  * the @lmf if necessary. @native_offset return the IP offset from the
 338  * start of the function or -1 if that info is not available.
 339  */
 340 gboolean
 341 mono_arch_unwind_frame (MonoDomain *domain, MonoJitTlsData *jit_tls,
 342                                                          MonoJitInfo *ji, MonoContext *ctx,
 343                                                          MonoContext *new_ctx, MonoLMF **lmf,
 344                                                          mgreg_t **save_locations,
 345                                                          StackFrameInfo *frame)
 346 {
 347         gpointer *window;
 348
 349         memset (frame, 0, sizeof (StackFrameInfo));
 350         frame->ji = ji;
 351
 352         *new_ctx = *ctx;
 353
 354         if (ji != NULL) {
 355                 if (ji->is_trampoline)
 356                         frame->type = FRAME_TYPE_TRAMPOLINE;
 357                 else
 358                         frame->type = FRAME_TYPE_MANAGED;
 359
 360                 /* Restore ip and sp from the saved register window */
 361                 window = MONO_SPARC_WINDOW_ADDR (ctx->sp);
 362                 new_ctx->ip = window [sparc_i7 - 16];
 363                 new_ctx->sp = (gpointer*)(window [sparc_i6 - 16]);
 364                 new_ctx->fp = (gpointer*)(MONO_SPARC_WINDOW_ADDR (new_ctx->sp) [sparc_i6 - 16]);
 365
 366                 return TRUE;
 367         }
 368         else {
 369                 if (!(*lmf))
 370                         return FALSE;
 371
 372                 if (!(*lmf)->method)
 373                         return FALSE;
 374
 375                 ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->ip, NULL);
 376                 if (!ji)
 377                         return FALSE;
 378
 379                 frame->ji = ji;
 380                 frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;
 381
 382                 new_ctx->ip = (*lmf)->ip;
 383                 new_ctx->sp = (*lmf)->sp;
 384                 new_ctx->fp = (*lmf)->ebp;
 385
 386                 *lmf = (*lmf)->previous_lmf;
 387
 388                 return TRUE;
 389         }
 390 }
 391
 392 #ifdef __linux__
 393
 394 gboolean
 395 mono_arch_handle_exception (void *sigctx, gpointer obj)
 396 {
 397        MonoContext mctx;
 398        struct sigcontext *sc = sigctx;
 399        gpointer *window;
 400
 401 #ifdef SPARCV9
 402        mctx.ip = (gpointer) sc->sigc_regs.tpc;
 403        mctx.sp = (gpointer) sc->sigc_regs.u_regs[14];
 404 #else
 405        mctx.ip = (gpointer) sc->si_regs.pc;
 406        mctx.sp = (gpointer) sc->si_regs.u_regs[14];
 407 #endif
 408
 409        window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 410        mctx.fp = window [sparc_fp - 16];
 411
 412        mono_handle_exception (&mctx, obj);
 413
 414 #ifdef SPARCV9
 415        sc->sigc_regs.tpc = (unsigned long) mctx.ip;
 416        sc->sigc_regs.tnpc = (unsigned long) (mctx.ip + 4);
 417        sc->sigc_regs.u_regs[14] = (unsigned long) mctx.sp;
 418 #else
 419        sc->si_regs.pc = (unsigned long) mctx.ip;
 420        sc->si_regs.npc = (unsigned long) (mctx.ip + 4);
 421        sc->si_regs.u_regs[14] = (unsigned long) mctx.sp;
 422 #endif
 423
 424        window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 425        window [sparc_fp - 16] = mctx.fp;
 426
 427        return TRUE;
 428 }
 429
 430 gpointer
 431 mono_arch_ip_from_context (void *sigctx)
 432 {
 433        struct sigcontext *sc = sigctx;
 434        gpointer *ret;
 435
 436 #ifdef SPARCV9
 437        ret = (gpointer) sc->sigc_regs.tpc;
 438 #else
 439        ret = (gpointer) sc->si_regs.pc;
 440 #endif
 441
 442        return ret;
 443 }
 444
 445 #else /* !__linux__ */
 446
 447 gboolean
 448 mono_arch_handle_exception (void *sigctx, gpointer obj)
 449 {
 450         MonoContext mctx;
 451         ucontext_t *ctx = (ucontext_t*)sigctx;
 452         gpointer *window;
 453
 454         /*
 455          * Access to the machine state using the ucontext_t parameter is somewhat
 456          * under documented under solaris. The code below seems to work under
 457          * Solaris 9.
 458          */
 459         g_assert (!ctx->uc_mcontext.gwins);
 460
 461         mctx.ip = ctx->uc_mcontext.gregs [REG_PC];
 462         mctx.sp = ctx->uc_mcontext.gregs [REG_SP];
 463         window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 464         mctx.fp = window [sparc_fp - 16];
 465
 466         mono_handle_exception (&mctx, obj);
 467
 468         /* We can't use restore_context to return from a signal handler */
 469         ctx->uc_mcontext.gregs [REG_PC] = mctx.ip;
 470         ctx->uc_mcontext.gregs [REG_nPC] = mctx.ip + 4;
 471         ctx->uc_mcontext.gregs [REG_SP] = mctx.sp;
 472         window = (gpointer*)(((guint8*)mctx.sp) + MONO_SPARC_STACK_BIAS);
 473         window [sparc_fp - 16] = mctx.fp;
 474
 475         return TRUE;
 476 }
 477
 478 gpointer
 479 mono_arch_ip_from_context (void *sigctx)
 480 {
 481         ucontext_t *ctx = (ucontext_t*)sigctx;
 482         return (gpointer)ctx->uc_mcontext.gregs [REG_PC];
 483 }
 484
 485 #endif