mono/mini/tramp-mips.c

   1 /*
   2  * tramp-mips.c: JIT trampoline code for MIPS
   3  *
   4  * Authors:
   5  *    Mark Mason (mason@broadcom.com)
   6  *
   7  * Based on tramp-ppc.c by:
   8  *   Dietmar Maurer (dietmar@ximian.com)
   9  *   Paolo Molaro (lupus@ximian.com)
  10  *   Carlos Valiente <yo@virutass.net>
  11  *
  12  * (C) 2006 Broadcom
  13  * (C) 2001 Ximian, Inc.
  14  */
  15
  16 #include <config.h>
  17 #include <glib.h>
  18
  19 #include <mono/metadata/appdomain.h>
  20 #include <mono/metadata/marshal.h>
  21 #include <mono/metadata/tabledefs.h>
  22 #include <mono/arch/mips/mips-codegen.h>
  23
  24 #include "mini.h"
  25 #include "mini-mips.h"
  26
  27 /*
  28  * get_unbox_trampoline:
  29  * @gsctx: the generic sharing context
  30  * @m: method pointer
  31  * @addr: pointer to native code for @m
  32  *
  33  * when value type methods are called through the vtable we need to unbox the
  34  * this argument. This method returns a pointer to a trampoline which does
  35  * unboxing before calling the method
  36  */
  37 gpointer
  38 mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr)
  39 {
  40         guint8 *code, *start;
  41         int this_pos = mips_a0;
  42         MonoDomain *domain = mono_domain_get ();
  43
  44         if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
  45                 this_pos = mips_a1;
  46
  47         start = code = mono_domain_code_reserve (domain, 20);
  48
  49         mips_load (code, mips_t9, addr);
  50         mips_addiu (code, this_pos, this_pos, sizeof (MonoObject));
  51         mips_jr (code, mips_t9);
  52         mips_nop (code);
  53
  54         mono_arch_flush_icache (start, code - start);
  55         g_assert ((code - start) <= 20);
  56         /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name);
  57         g_print ("unbox code is at %p for method at %p\n", start, addr);*/
  58
  59         return start;
  60 }
  61
  62 void
  63 mono_arch_patch_callsite (guint8 *method_start, guint8 *orig_code, guint8 *addr)
  64 {
  65         guint32 *code = (guint32*)orig_code;
  66
  67         /* Locate the address of the method-specific trampoline. The call using
  68         the vtable slot that took the processing flow to 'arch_create_jit_trampoline'
  69         looks something like this:
  70
  71                 jal     XXXXYYYY
  72                 nop
  73
  74                 lui     t9, XXXX
  75                 addiu   t9, YYYY
  76                 jalr    t9
  77                 nop
  78
  79         On entry, 'code' points just after one of the above sequences.
  80         */
  81
  82         /* The jal case */
  83         if ((code[-2] >> 26) == 0x03) {
  84                 //g_print ("direct patching\n");
  85                 mips_patch ((code-2), (gsize)addr);
  86         } else {
  87                 /* Sanity check: look for the jalr */
  88                 g_assert((code[-2] & 0xfc1f003f) == 0x00000009);
  89
  90                 //printf ("mips_magic_trampoline: jalr @ 0x%0x, w/ reg %d\n", code-2, reg);
  91
  92                 /* The lui / addiu / jalr case */
  93                 if ((code [-4] >> 26) == 0x0f && (code [-3] >> 26) == 0x09 && (code [-2] >> 26) == 0) {
  94                         mips_patch ((code-4), (gsize)addr);
  95                 } else {
  96                         g_assert_not_reached ();
  97                 }
  98         }
  99 }
 100
 101 void
 102 mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr)
 103 {
 104         g_assert_not_reached ();
 105 }
 106
 107 /* Stack size for trampoline function
 108  * MIPS_MINIMAL_STACK_SIZE + 16 (args + alignment to mips_magic_trampoline)
 109  * + MonoLMF + 14 fp regs + 13 gregs + alignment
 110  * #define STACK (MIPS_MINIMAL_STACK_SIZE + 4 * sizeof (gulong) + sizeof (MonoLMF) + 14 * sizeof (double) + 13 * (sizeof (gulong)))
 111  * STACK would be 444 for 32 bit darwin
 112  */
 113
 114 #define STACK (4*IREG_SIZE + 8 + sizeof(MonoLMF) + 32)
 115
 116
 117 gpointer
 118 mono_arch_get_vcall_slot (guint8 *code_ptr, mgreg_t *regs, int *displacement)
 119 {
 120         char *o = NULL;
 121         char *vtable = NULL;
 122         int reg, offset = 0;
 123         guint32 base = 0;
 124         guint32 *code = (guint32*)code_ptr;
 125         char *sp;
 126
 127         /* On MIPS, we are passed sp instead of the register array */
 128         sp = (char*)regs;
 129
 130         //printf ("mips_magic_trampoline: 0x%08x @ 0x%0x\n", *(code-2), code-2);
 131
 132         /* The jal case */
 133         if ((code[-2] >> 26) == 0x03)
 134                 return NULL;
 135
 136         /* Sanity check: look for the jalr */
 137         g_assert((code[-2] & 0xfc1f003f) == 0x00000009);
 138
 139         reg = (code[-2] >> 21) & 0x1f;
 140
 141         //printf ("mips_magic_trampoline: jalr @ 0x%0x, w/ reg %d\n", code-2, reg);
 142
 143         /* The lui / addiu / jalr case */
 144         if ((code [-4] >> 26) == 0x0f && (code [-3] >> 26) == 0x09 && (code [-2] >> 26) == 0) {
 145                 return NULL;
 146         }
 147
 148         /* Probably a vtable lookup */
 149
 150         /* Walk backwards to find 'lw reg,XX(base)' */
 151         for(; --code;) {
 152                 guint32 mask = (0x3f << 26) | (0x1f << 16);
 153                 guint32 match = (0x23 << 26) | (reg << 16);
 154                 if((*code & mask) == match) {
 155                         gint16 soff;
 156                         gint reg_offset;
 157
 158                         /* lw reg,XX(base) */
 159                         base = (*code >> 21) & 0x1f;
 160                         soff = (*code & 0xffff);
 161                         if (soff & 0x8000)
 162                                 soff |= 0xffff0000;
 163                         offset = soff;
 164                         if (1) {
 165                                 MonoLMF *lmf = (MonoLMF*)((char *)regs + 12*IREG_SIZE);
 166                                 g_assert (lmf->magic == MIPS_LMF_MAGIC2);
 167                                 o = (gpointer)lmf->iregs [base];
 168                         }
 169                         else {
 170                                 o = regs [base];
 171                         }
 172                         break;
 173                 }
 174         }
 175         *displacement = offset;
 176         return o;
 177 }
 178
 179 void
 180 mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs)
 181 {
 182         g_assert_not_reached ();
 183 }
 184
 185 void
 186 mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs)
 187 {
 188         guint32 *code32 = (guint32*)code;
 189
 190         /* back up to the jal/jalr instruction */
 191         code32 -= 2;
 192
 193         /* Check for jal/jalr -- and NOP it out */
 194         if ((((*code32)&0xfc000000) == 0x0c000000)
 195             || (((*code32)&0xfc1f003f) == 0x00000009)) {
 196                 mips_nop (code32);
 197                 mono_arch_flush_icache ((gpointer)(code32 - 1), 4);
 198                 return;
 199         } else {
 200                 g_assert_not_reached ();
 201         }
 202 }
 203
 204 /*
 205  * Stack frame description when the generic trampoline is called.
 206  * caller frame
 207  * --------------------
 208  *  MonoLMF
 209  *  -------------------
 210  *  Saved FP registers 0-13
 211  *  -------------------
 212  *  Saved general registers 0-12
 213  *  -------------------
 214  *  param area for 3 args to mips_magic_trampoline
 215  *  -------------------
 216  *  linkage area
 217  *  -------------------
 218  */
 219 guchar*
 220 mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
 221 {
 222         guint8 *buf, *tramp, *code = NULL;
 223         int i, lmf;
 224         int max_code_len = 768;
 225
 226         /* Now we'll create in 'buf' the MIPS trampoline code. This
 227            is the trampoline code common to all methods  */
 228
 229         code = buf = mono_global_codeman_reserve (max_code_len);
 230
 231         /* Allocate the stack frame, and save the return address */
 232         mips_addiu (code, mips_sp, mips_sp, -STACK);
 233         mips_sw (code, mips_ra, mips_sp, STACK + MIPS_RET_ADDR_OFFSET);
 234
 235         /* we build the MonoLMF structure on the stack - see mini-mips.h */
 236         /* offset of MonoLMF from sp */
 237         lmf = STACK - sizeof (MonoLMF) - 8;
 238
 239         for (i = 0; i < MONO_MAX_IREGS; i++)
 240                 MIPS_SW (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, iregs[i]));
 241         for (i = 0; i < MONO_MAX_FREGS; i++)
 242                 MIPS_SWC1 (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, fregs[i]));
 243
 244         /* Set the magic number */
 245         mips_load_const (code, mips_at, MIPS_LMF_MAGIC2);
 246         mips_sw (code, mips_at, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, magic));
 247
 248         /* save method info (it was in t8) */
 249         mips_sw (code, mips_t8, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, method));
 250
 251         /* save frame pointer (caller fp) */
 252         MIPS_SW (code, mips_fp, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, ebp));
 253
 254         /* save the IP (caller ip) */
 255         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 256                 mips_sw (code, mips_zero, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, eip));
 257         } else {
 258                 mips_sw (code, mips_ra, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, eip));
 259         }
 260
 261         /* jump to mono_get_lmf_addr here */
 262         mips_load (code, mips_t9, mono_get_lmf_addr);
 263         mips_jalr (code, mips_t9, mips_ra);
 264         mips_nop (code);
 265
 266         /* v0 now points at the (MonoLMF **) for the current thread */
 267
 268         /* new_lmf->lmf_addr = lmf_addr -- useful when unwinding */
 269         mips_sw (code, mips_v0, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, lmf_addr));
 270
 271         /* new_lmf->previous_lmf = *lmf_addr */
 272         mips_lw (code, mips_at, mips_v0, 0);
 273         mips_sw (code, mips_at, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, previous_lmf));
 274
 275         /* *(lmf_addr) = new_lmf */
 276         mips_addiu (code, mips_at, mips_sp, lmf);
 277         mips_sw (code, mips_at, mips_v0, 0);
 278
 279         /*
 280          * Now we're ready to call mips_magic_trampoline ().
 281          */
 282
 283         /* Arg 1: stack pointer so that the magic trampoline can access the
 284          * registers we saved above
 285          */
 286         mips_move (code, mips_a0, mips_sp);
 287
 288         /* Arg 2: code (next address to the instruction that called us) */
 289         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 290                 mips_move (code, mips_a1, mips_zero);
 291         } else {
 292                 mips_lw (code, mips_a1, mips_sp, STACK + MIPS_RET_ADDR_OFFSET);
 293         }
 294
 295         /* Arg 3: MonoMethod *method. */
 296         mips_lw (code, mips_a2, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, method));
 297
 298         /* Arg 4: Trampoline */
 299         mips_move (code, mips_a3, mips_zero);
 300
 301         /* Now go to the trampoline */
 302         tramp = (guint8*)mono_get_trampoline_func (tramp_type);
 303         mips_load (code, mips_t9, (guint32)tramp);
 304         mips_jalr (code, mips_t9, mips_ra);
 305         mips_nop (code);
 306
 307         /* Code address is now in v0, move it to at */
 308         mips_move (code, mips_at, mips_v0);
 309
 310         /*
 311          * Now unwind the MonoLMF
 312          */
 313
 314         /* t0 = current_lmf->previous_lmf */
 315         mips_lw (code, mips_t0, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, previous_lmf));
 316         /* t1 = lmf_addr */
 317         mips_lw (code, mips_t1, mips_sp, lmf + G_STRUCT_OFFSET(MonoLMF, lmf_addr));
 318         /* (*lmf_addr) = previous_lmf */
 319         mips_sw (code, mips_t0, mips_t1, 0);
 320
 321         /* Restore the callee-saved & argument registers */
 322         for (i = 0; i < MONO_MAX_IREGS; i++) {
 323                 if ((MONO_ARCH_CALLEE_SAVED_REGS | MONO_ARCH_CALLEE_REGS | MIPS_ARG_REGS) & (1 << i))
 324                     MIPS_LW (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, iregs[i]));
 325         }
 326         for (i = 0; i < MONO_MAX_FREGS; i++)
 327                 MIPS_LWC1 (code, i, mips_sp, lmf + G_STRUCT_OFFSET (MonoLMF, fregs[i]));
 328
 329         /* Non-standard function epilogue. Instead of doing a proper
 330          * return, we just jump to the compiled code.
 331          */
 332         /* Restore ra & stack pointer, and jump to the code */
 333
 334         mips_lw (code, mips_ra, mips_sp, STACK + MIPS_RET_ADDR_OFFSET);
 335         mips_addiu (code, mips_sp, mips_sp, STACK);
 336         if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT)
 337                 mips_jr (code, mips_ra);
 338         else
 339                 mips_jr (code, mips_at);
 340         mips_nop (code);
 341
 342         /* Flush instruction cache, since we've generated code */
 343         mono_arch_flush_icache (buf, code - buf);
 344
 345         /* Sanity check */
 346         g_assert ((code - buf) <= max_code_len);
 347
 348         return buf;
 349 }
 350
 351 gpointer
 352 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
 353 {
 354         guint8 *code, *buf, *tramp;
 355
 356         tramp = mono_get_trampoline_code (tramp_type);
 357
 358         code = buf = mono_domain_code_reserve (domain, 32);
 359
 360         /* Prepare the jump to the generic trampoline code
 361          * mono_arch_create_trampoline_code() knows we're putting this in t8
 362          */
 363         mips_load (code, mips_t8, arg1);
 364
 365         /* Now jump to the generic trampoline code */
 366         mips_load (code, mips_at, tramp);
 367         mips_jr (code, mips_at);
 368         mips_nop (code);
 369
 370         /* Flush instruction cache, since we've generated code */
 371         mono_arch_flush_icache (buf, code - buf);
 372
 373         g_assert ((code - buf) <= 32);
 374
 375         if (code_len)
 376                 *code_len = code - buf;
 377
 378         return buf;
 379 }
 380
 381 gpointer
 382 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 encoded_offset)
 383 {
 384         /* FIXME: implement! */
 385         g_assert_not_reached ();
 386         return NULL;
 387 }
 388
 389 gpointer
 390 mono_arch_create_generic_class_init_trampoline (void)
 391 {
 392         /* FIXME: implement! */
 393         g_assert_not_reached ();
 394         return NULL;
 395 }