mono/mini/tramp-mips.c

   1 /**
   2  * \file
   3  * JIT trampoline code for MIPS
   4  *
   5  * Authors:
   6  *    Mark Mason (mason@broadcom.com)
   7  *
   8  * Based on tramp-ppc.c by:
   9  *   Dietmar Maurer (dietmar@ximian.com)
  10  *   Paolo Molaro (lupus@ximian.com)
  11  *   Carlos Valiente <yo@virutass.net>
  12  *
  13  * (C) 2006 Broadcom
  14  * (C) 2001 Ximian, Inc.
  15  */
  16
  17 #include <config.h>
  18 #include <glib.h>
  19
  20 #include <mono/metadata/abi-details.h>
  21 #include <mono/metadata/appdomain.h>
  22 #include <mono/metadata/marshal.h>
  23 #include <mono/metadata/tabledefs.h>
  24 #include <mono/arch/mips/mips-codegen.h>
  25
  26 #include "mini.h"
  27 #include "mini-mips.h"
  28 #include "mini-runtime.h"
  29
  30 /*
  31  * get_unbox_trampoline:
  32  * @m: method pointer
  33  * @addr: pointer to native code for @m
  34  *
  35  * when value type methods are called through the vtable we need to unbox the
  36  * this argument. This method returns a pointer to a trampoline which does
  37  * unboxing before calling the method
  38  */
  39 gpointer
  40 mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr)
  41 {
  42         guint8 *code, *start;
  43         MonoDomain *domain = mono_domain_get ();
  44
  45         start = code = mono_domain_code_reserve (domain, 20);
  46
  47         mips_load (code, mips_t9, addr);
  48         /* The this pointer is kept in a0 */
  49         mips_addiu (code, mips_a0, mips_a0, MONO_ABI_SIZEOF (MonoObject));
  50         mips_jr (code, mips_t9);
  51         mips_nop (code);
  52
  53         mono_arch_flush_icache (start, code - start);
  54         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_UNBOX_TRAMPOLINE, m));
  55
  56         g_assert ((code - start) <= 20);
  57         /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name);
  58         g_print ("unbox code is at %p for method at %p\n", start, addr);*/
  59
  60         mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, NULL), domain);
  61
  62         return start;
  63 }
  64
  65 void
  66 mono_arch_patch_callsite (guint8 *method_start, guint8 *orig_code, guint8 *addr)
  67 {
  68         guint32 *code = (guint32*)orig_code;
  69
  70         /* Locate the address of the method-specific trampoline.
  71         The call using the vtable slot that took the processing flow to
  72         'arch_create_jit_trampoline' looks something like one of these:
  73
  74                 jal     XXXXYYYY
  75                 nop
  76
  77                 lui     t9, XXXX
  78                 addiu   t9, YYYY
  79                 jalr    t9
  80                 nop
  81
  82         On entry, 'code' points just after one of the above sequences.
  83         */
  84
  85         /* The jal case */
  86         if ((code[-2] >> 26) == 0x03) {
  87                 //g_print ("direct patching\n");
  88                 mips_patch ((code-2), (gsize)addr);
  89                 return;
  90         }
  91         /* Look for the jalr */
  92         if ((code[-2] & 0xfc1f003f) == 0x00000009) {
  93                 /* The lui / addiu / jalr case */
  94                 if ((code [-4] >> 26) == 0x0f && (code [-3] >> 26) == 0x09
  95                     && (code [-2] >> 26) == 0) {
  96                         mips_patch ((code-4), (gsize)addr);
  97                         return;
  98                 }
  99         }
 100         g_print("error: bad patch at 0x%08x\n", code);
 101         g_assert_not_reached ();
 102 }
 103
 104 void
 105 mono_arch_patch_plt_entry (guint8 *code, gpointer *got, host_mgreg_t *regs, guint8 *addr)
 106 {
 107         g_assert_not_reached ();
 108 }
 109
 110 /* Stack size for trampoline function
 111  * MIPS_MINIMAL_STACK_SIZE + 16 (args + alignment to mips_magic_trampoline)
 112  * + MonoLMF + 14 fp regs + 13 gregs + alignment
 113  * #define STACK (MIPS_MINIMAL_STACK_SIZE + 4 * sizeof (gulong) + sizeof (MonoLMF) + 14 * sizeof (double) + 13 * (sizeof (gulong)))
 114  * STACK would be 444 for 32 bit darwin
 115  */
 116
 117 #define STACK (int)(ALIGN_TO(4*IREG_SIZE + 8 + sizeof(MonoLMF) + 32, 8))
 118
 119 /*
 120  * Stack frame description when the generic trampoline is called.
 121  * caller frame
 122  * --------------------
 123  *  MonoLMF
 124  *  -------------------
 125  *  Saved FP registers 0-13
 126  *  -------------------
 127  *  Saved general registers 0-12
 128  *  -------------------
 129  *  param area for 3 args to mips_magic_trampoline
 130  *  -------------------
 131  *  linkage area
 132  *  -------------------
 133  */
 134 guchar*
 135 mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot)
 136 {
 137         const char *tramp_name;
 138         guint8 *buf, *tramp, *code = NULL;
 139         int i, lmf;
 140         GSList *unwind_ops = NULL;
 141         MonoJumpInfo *ji = NULL;
 142         int max_code_len = 768;
 143
 144         /* AOT not supported on MIPS yet */
 145         g_assert (!aot);
 146
 147         /* Now we'll create in 'buf' the MIPS trampoline code. This
 148            is the trampoline code common to all methods  */
 149
 150         code = buf = mono_global_codeman_reserve (max_code_len);
 151
 152         /* Allocate the stack frame, and save the return address */
 153         mips_addiu (code, mips_sp, mips_sp, -STACK);
 154         mips_sw (code, mips_ra, mips_sp, STACK + MIPS_RET_ADDR_OFFSET);
 155
 156         /* we build the MonoLMF structure on the stack - see mini-mips.h */
 157         /* offset of MonoLMF from sp */
 158         lmf = STACK - sizeof (MonoLMF) - 8;
 159
 160         for (i = 0; i < MONO_MAX_IREGS; i++)
 161                 MIPS_SW (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, iregs[i]));
 162         for (i = 0; i < MONO_MAX_FREGS; i++)
 163                 MIPS_SWC1 (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, fregs[i]));
 164
 165         /* Set the magic number */
 166         mips_load_const (code, mips_at, MIPS_LMF_MAGIC2);
 167         mips_sw (code, mips_at, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, magic));
 168
 169         /* Save caller sp */
 170         mips_addiu (code, mips_at, mips_sp, STACK);
 171         MIPS_SW (code, mips_at, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, iregs[mips_sp]));
 172
 173         /* save method info (it was in t8) */
 174         mips_sw (code, mips_t8, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, method));
 175
 176         /* save the IP (caller ip) */
 177         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 178                 mips_sw (code, mips_zero, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, eip));
 179         } else {
 180                 mips_sw (code, mips_ra, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, eip));
 181         }
 182
 183         /* jump to mono_get_lmf_addr here */
 184         mips_load (code, mips_t9, mono_get_lmf_addr);
 185         mips_jalr (code, mips_t9, mips_ra);
 186         mips_nop (code);
 187
 188         /* v0 now points at the (MonoLMF **) for the current thread */
 189
 190         /* new_lmf->lmf_addr = lmf_addr -- useful when unwinding */
 191         mips_sw (code, mips_v0, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, lmf_addr));
 192
 193         /* new_lmf->previous_lmf = *lmf_addr */
 194         mips_lw (code, mips_at, mips_v0, 0);
 195         mips_sw (code, mips_at, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, previous_lmf));
 196
 197         /* *(lmf_addr) = new_lmf */
 198         mips_addiu (code, mips_at, mips_sp, lmf);
 199         mips_sw (code, mips_at, mips_v0, 0);
 200
 201         /*
 202          * Now we're ready to call mips_magic_trampoline ().
 203          */
 204
 205         /* Arg 1: pointer to registers so that the magic trampoline can
 206          * access what we saved above
 207          */
 208         mips_addiu (code, mips_a0, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, iregs[0]));
 209
 210         /* Arg 2: code (next address to the instruction that called us) */
 211         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 212                 mips_move (code, mips_a1, mips_zero);
 213         } else {
 214                 mips_lw (code, mips_a1, mips_sp, STACK + MIPS_RET_ADDR_OFFSET);
 215         }
 216
 217         /* Arg 3: MonoMethod *method. */
 218         mips_lw (code, mips_a2, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, method));
 219
 220         /* Arg 4: Trampoline */
 221         mips_move (code, mips_a3, mips_zero);
 222
 223         /* Now go to the trampoline */
 224         tramp = (guint8*)mono_get_trampoline_func (tramp_type);
 225         mips_load (code, mips_t9, (guint32)tramp);
 226         mips_jalr (code, mips_t9, mips_ra);
 227         mips_nop (code);
 228
 229         /* Code address is now in v0, move it to at */
 230         mips_move (code, mips_at, mips_v0);
 231
 232         /*
 233          * Now unwind the MonoLMF
 234          */
 235
 236         /* t0 = current_lmf->previous_lmf */
 237         mips_lw (code, mips_t0, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, previous_lmf));
 238         /* t1 = lmf_addr */
 239         mips_lw (code, mips_t1, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, lmf_addr));
 240         /* (*lmf_addr) = previous_lmf */
 241         mips_sw (code, mips_t0, mips_t1, 0);
 242
 243         /* Restore the callee-saved & argument registers */
 244         for (i = 0; i < MONO_MAX_IREGS; i++) {
 245                 if ((MONO_ARCH_CALLEE_SAVED_REGS | MONO_ARCH_CALLEE_REGS | MIPS_ARG_REGS) & (1 << i))
 246                     MIPS_LW (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, iregs[i]));
 247         }
 248         for (i = 0; i < MONO_MAX_FREGS; i++)
 249                 MIPS_LWC1 (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, fregs[i]));
 250
 251         /* Non-standard function epilogue. Instead of doing a proper
 252          * return, we just jump to the compiled code.
 253          */
 254         /* Restore ra & stack pointer, and jump to the code */
 255
 256         if (tramp_type == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH)
 257                 mips_move (code, mips_v0, mips_at);
 258         mips_lw (code, mips_ra, mips_sp, STACK + MIPS_RET_ADDR_OFFSET);
 259         mips_addiu (code, mips_sp, mips_sp, STACK);
 260         if (MONO_TRAMPOLINE_TYPE_MUST_RETURN (tramp_type))
 261                 mips_jr (code, mips_ra);
 262         else
 263                 mips_jr (code, mips_at);
 264         mips_nop (code);
 265
 266         /* Flush instruction cache, since we've generated code */
 267         mono_arch_flush_icache (buf, code - buf);
 268         MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_HELPER, NULL));
 269
 270         /* Sanity check */
 271         g_assert ((code - buf) <= max_code_len);
 272
 273         g_assert (info);
 274         tramp_name = mono_get_generic_trampoline_name (tramp_type);
 275         *info = mono_tramp_info_create (tramp_name, buf, code - buf, ji, unwind_ops);
 276
 277         return buf;
 278 }
 279
 280 gpointer
 281 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
 282 {
 283         guint8 *code, *buf, *tramp;
 284
 285         tramp = mono_get_trampoline_code (tramp_type);
 286
 287         code = buf = mono_domain_code_reserve (domain, 32);
 288
 289         /* Prepare the jump to the generic trampoline code
 290          * mono_arch_create_trampoline_code() knows we're putting this in t8
 291          */
 292         mips_load (code, mips_t8, arg1);
 293
 294         /* Now jump to the generic trampoline code */
 295         mips_load (code, mips_at, tramp);
 296         mips_jr (code, mips_at);
 297         mips_nop (code);
 298
 299         /* Flush instruction cache, since we've generated code */
 300         mono_arch_flush_icache (buf, code - buf);
 301         MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_SPECIFIC_TRAMPOLINE, mono_get_generic_trampoline_simple_name (tramp_type)));
 302
 303         g_assert ((code - buf) <= 32);
 304
 305         if (code_len)
 306                 *code_len = code - buf;
 307
 308         return buf;
 309 }
 310
 311 gpointer
 312 mono_arch_get_static_rgctx_trampoline (gpointer arg, gpointer addr)
 313 {
 314         guint8 *code, *start;
 315         int buf_len;
 316
 317         MonoDomain *domain = mono_domain_get ();
 318
 319         buf_len = 24;
 320
 321         start = code = mono_domain_code_reserve (domain, buf_len);
 322
 323         mips_load (code, MONO_ARCH_RGCTX_REG, arg);
 324         mips_load (code, mips_at, addr);
 325         mips_jr (code, mips_at);
 326         mips_nop (code);
 327
 328         g_assert ((code - start) <= buf_len);
 329
 330         mono_arch_flush_icache (start, code - start);
 331         MONO_PROFILER_RAISE (jit_code_buffer, (start, code - start, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL));
 332
 333         mono_tramp_info_register (mono_tramp_info_create (NULL, start, code - start, NULL, NULL), domain);
 334
 335         return start;
 336 }
 337
 338 gpointer
 339 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot)
 340 {
 341         guint8 *tramp;
 342         guint8 *code, *buf;
 343         int tramp_size;
 344         guint32 code_len;
 345         guint8 **rgctx_null_jumps;
 346         int depth, index;
 347         int i, njumps;
 348         gboolean mrgctx;
 349         MonoJumpInfo *ji = NULL;
 350         GSList *unwind_ops = NULL;
 351
 352         mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
 353         index = MONO_RGCTX_SLOT_INDEX (slot);
 354         if (mrgctx)
 355                 index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (target_mgreg_t);
 356         for (depth = 0; ; ++depth) {
 357                 int size = mono_class_rgctx_get_array_size (depth, mrgctx);
 358
 359                 if (index < size - 1)
 360                         break;
 361                 index -= size - 1;
 362         }
 363
 364         tramp_size = 64 + 16 * depth;
 365
 366         code = buf = mono_global_codeman_reserve (tramp_size);
 367
 368         mono_add_unwind_op_def_cfa (unwind_ops, code, buf, mips_sp, 0);
 369
 370         rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
 371         njumps = 0;
 372
 373         /* The vtable/mrgctx is in a0 */
 374         g_assert (MONO_ARCH_VTABLE_REG == mips_a0);
 375         if (mrgctx) {
 376                 /* get mrgctx ptr */
 377                 mips_move (code, mips_a1, mips_a0);
 378         } else {
 379                 /* load rgctx ptr from vtable */
 380                 g_assert (mips_is_imm16 (MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context)));
 381                 mips_lw (code, mips_a1, mips_a0, MONO_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
 382                 /* is the rgctx ptr null? */
 383                 /* if yes, jump to actual trampoline */
 384                 rgctx_null_jumps [njumps ++] = code;
 385                 mips_beq (code, mips_a1, mips_zero, 0);
 386                 mips_nop (code);
 387         }
 388
 389         for (i = 0; i < depth; ++i) {
 390                 /* load ptr to next array */
 391                 if (mrgctx && i == 0) {
 392                         g_assert (mips_is_imm16 (MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT));
 393                         mips_lw (code, mips_a1, mips_a1, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT);
 394                 } else {
 395                         mips_lw (code, mips_a1, mips_a1, 0);
 396                 }
 397                 /* is the ptr null? */
 398                 /* if yes, jump to actual trampoline */
 399                 rgctx_null_jumps [njumps ++] = code;
 400                 mips_beq (code, mips_a1, mips_zero, 0);
 401                 mips_nop (code);
 402         }
 403
 404         /* fetch slot */
 405         g_assert (mips_is_imm16 (sizeof (target_mgreg_t) * (index + 1)));
 406         mips_lw (code, mips_a1, mips_a1, sizeof (target_mgreg_t) * (index + 1));
 407         /* is the slot null? */
 408         /* if yes, jump to actual trampoline */
 409         rgctx_null_jumps [njumps ++] = code;
 410         mips_beq (code, mips_a1, mips_zero, 0);
 411         mips_nop (code);
 412         /* otherwise return, result is in R1 */
 413         mips_move (code, mips_v0, mips_a1);
 414         mips_jr (code, mips_ra);
 415         mips_nop (code);
 416
 417         g_assert (njumps <= depth + 2);
 418         for (i = 0; i < njumps; ++i)
 419                 mips_patch ((guint32*)rgctx_null_jumps [i], (guint32)code);
 420
 421         g_free (rgctx_null_jumps);
 422
 423         /* Slowpath */
 424
 425         /* The vtable/mrgctx is still in a0 */
 426
 427         if (aot) {
 428                 ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_SPECIFIC_TRAMPOLINE_LAZY_FETCH_ADDR, GUINT_TO_POINTER (slot));
 429                 mips_load (code, mips_at, 0);
 430                 mips_jr (code, mips_at);
 431                 mips_nop (code);
 432         } else {
 433                 tramp = (guint8*)mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), &code_len);
 434                 mips_load (code, mips_at, tramp);
 435                 mips_jr (code, mips_at);
 436                 mips_nop (code);
 437         }
 438
 439         mono_arch_flush_icache (buf, code - buf);
 440         MONO_PROFILER_RAISE (jit_code_buffer, (buf, code - buf, MONO_PROFILER_CODE_BUFFER_GENERICS_TRAMPOLINE, NULL));
 441
 442         g_assert (code - buf <= tramp_size);
 443
 444         if (info) {
 445                 char *name = mono_get_rgctx_fetch_trampoline_name (slot);
 446                 *info = mono_tramp_info_create (name, buf, code - buf, ji, unwind_ops);
 447                 g_free (name);
 448         }
 449
 450         return buf;
 451 }