mono/mini/tramp-arm.c

   1 /*
   2  * tramp-arm.c: JIT trampoline code for ARM
   3  *
   4  * Authors:
   5  *   Paolo Molaro (lupus@ximian.com)
   6  *
   7  * (C) 2001 Ximian, Inc.
   8  */
   9
  10 #include <config.h>
  11 #include <glib.h>
  12
  13 #include <mono/metadata/appdomain.h>
  14 #include <mono/metadata/marshal.h>
  15 #include <mono/metadata/tabledefs.h>
  16 #include <mono/arch/arm/arm-codegen.h>
  17
  18 #include "mini.h"
  19 #include "mini-arm.h"
  20
  21 /*
  22  * Return the instruction to jump from code to target, 0 if not
  23  * reachable with a single instruction
  24  */
  25 static guint32
  26 branch_for_target_reachable (guint8 *branch, guint8 *target)
  27 {
  28         gint diff = target - branch - 8;
  29         g_assert ((diff & 3) == 0);
  30         if (diff >= 0) {
  31                 if (diff <= 33554431)
  32                         return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | (diff >> 2);
  33         } else {
  34                 /* diff between 0 and -33554432 */
  35                 if (diff >= -33554432)
  36                         return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | ((diff >> 2) & ~0xff000000);
  37         }
  38         return 0;
  39 }
  40
  41 /*
  42  * mono_arch_get_unbox_trampoline:
  43  * @gsctx: the generic sharing context
  44  * @m: method pointer
  45  * @addr: pointer to native code for @m
  46  *
  47  * when value type methods are called through the vtable we need to unbox the
  48  * this argument. This method returns a pointer to a trampoline which does
  49  * unboxing before calling the method
  50  */
  51 gpointer
  52 mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr)
  53 {
  54         guint8 *code, *start;
  55         int this_pos = 0;
  56         MonoDomain *domain = mono_domain_get ();
  57
  58         if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
  59                 this_pos = 1;
  60
  61         mono_domain_lock (domain);
  62         start = code = mono_code_manager_reserve (domain->code_mp, 16);
  63         mono_domain_unlock (domain);
  64
  65         ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 4);
  66         ARM_ADD_REG_IMM8 (code, this_pos, this_pos, sizeof (MonoObject));
  67         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP);
  68         *(guint32*)code = (guint32)addr;
  69         code += 4;
  70         mono_arch_flush_icache (start, code - start);
  71         g_assert ((code - start) <= 16);
  72         /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name);
  73         g_print ("unbox code is at %p for method at %p\n", start, addr);*/
  74
  75         return start;
  76 }
  77
  78 void
  79 mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr)
  80 {
  81         guint32 *code = (guint32*)code_ptr;
  82
  83         /* This is the 'bl' or the 'mov pc' instruction */
  84         --code;
  85
  86         /*
  87          * Note that methods are called also with the bl opcode.
  88          */
  89         if ((((*code) >> 25)  & 7) == 5) {
  90                 /*g_print ("direct patching\n");*/
  91                 arm_patch ((guint8*)code, addr);
  92                 mono_arch_flush_icache ((guint8*)code, 4);
  93                 return;
  94         }
  95
  96         if ((((*code) >> 20) & 0xFF) == 0x12) {
  97                 /*g_print ("patching bx\n");*/
  98                 arm_patch ((guint8*)code, addr);
  99                 mono_arch_flush_icache ((guint8*)(code - 2), 4);
 100                 return;
 101         }
 102
 103         g_assert_not_reached ();
 104 }
 105
 106 void
 107 mono_arch_patch_plt_entry (guint8 *code, guint8 *addr)
 108 {
 109         guint32 ins = branch_for_target_reachable (code, addr);
 110
 111         if (ins)
 112                 /* Patch the branch */
 113                 ((guint32*)code) [0] = ins;
 114         else
 115                 /* Patch the jump address */
 116                 ((guint32*)code) [1] = (guint32)addr;
 117         mono_arch_flush_icache ((guint8*)code, 4);
 118 }
 119
 120 void
 121 mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
 122 {
 123         return;
 124 }
 125
 126 void
 127 mono_arch_nullify_plt_entry (guint8 *code)
 128 {
 129         guint8 buf [4];
 130         guint8 *p;
 131
 132         p = buf;
 133         ARM_MOV_REG_REG (p, ARMREG_PC, ARMREG_LR);
 134
 135         ((guint32*)code) [0] = ((guint32*)buf) [0];
 136         mono_arch_flush_icache ((guint8*)code, 4);
 137 }
 138
 139
 140 /* Stack size for trampoline function
 141  */
 142 #define STACK (sizeof (MonoLMF))
 143
 144 /* Method-specific trampoline code fragment size */
 145 #define METHOD_TRAMPOLINE_SIZE 64
 146
 147 /* Jump-specific trampoline code fragment size */
 148 #define JUMP_TRAMPOLINE_SIZE   64
 149
 150 #define GEN_TRAMP_SIZE 192
 151
 152 /*
 153  * Stack frame description when the generic trampoline is called.
 154  * caller frame
 155  * ------------------- old sp
 156  *  MonoLMF
 157  * ------------------- sp
 158  */
 159 guchar*
 160 mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
 161 {
 162         guint8 *buf, *code = NULL;
 163         guint8 *load_get_lmf_addr, *load_trampoline;
 164         gpointer *constants;
 165
 166         /* Now we'll create in 'buf' the ARM trampoline code. This
 167          is the trampoline code common to all methods  */
 168
 169         code = buf = mono_global_codeman_reserve (GEN_TRAMP_SIZE);
 170
 171         /*
 172          * At this point lr points to the specific arg and sp points to the saved
 173          * regs on the stack (all but PC and SP). The original LR value has been
 174          * saved as sp + LR_OFFSET by the push in the specific trampoline
 175          */
 176 #define LR_OFFSET (sizeof (gpointer) * 13)
 177         ARM_MOV_REG_REG (buf, ARMREG_V1, ARMREG_SP);
 178         ARM_LDR_IMM (buf, ARMREG_V2, ARMREG_LR, 0);
 179         ARM_LDR_IMM (buf, ARMREG_V3, ARMREG_SP, LR_OFFSET);
 180
 181         /* ok, now we can continue with the MonoLMF setup, mostly untouched
 182          * from emit_prolog in mini-arm.c
 183          * This is a sinthetized call to mono_get_lmf_addr ()
 184          */
 185         load_get_lmf_addr = buf;
 186         buf += 4;
 187         ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC);
 188         ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_R0);
 189
 190         /* we build the MonoLMF structure on the stack - see mini-arm.h
 191          * The pointer to the struct is put in r1.
 192          * the iregs array is already allocated on the stack by push.
 193          */
 194         ARM_SUB_REG_IMM8 (buf, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14);
 195         ARM_ADD_REG_IMM8 (buf, ARMREG_R1, ARMREG_SP, STACK - sizeof (MonoLMF));
 196         /* r0 is the result from mono_get_lmf_addr () */
 197         ARM_STR_IMM (buf, ARMREG_R0, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, lmf_addr));
 198         /* new_lmf->previous_lmf = *lmf_addr */
 199         ARM_LDR_IMM (buf, ARMREG_R2, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 200         ARM_STR_IMM (buf, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 201         /* *(lmf_addr) = r1 */
 202         ARM_STR_IMM (buf, ARMREG_R1, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 203         /* save method info (it's in v2) */
 204         if ((tramp_type == MONO_TRAMPOLINE_GENERIC) || (tramp_type == MONO_TRAMPOLINE_JUMP))
 205                 ARM_STR_IMM (buf, ARMREG_V2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, method));
 206         ARM_STR_IMM (buf, ARMREG_SP, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, ebp));
 207         /* save the IP (caller ip) */
 208         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 209                 ARM_MOV_REG_IMM8 (buf, ARMREG_R2, 0);
 210         } else {
 211                 /* assumes STACK == sizeof (MonoLMF) */
 212                 ARM_LDR_IMM (buf, ARMREG_R2, ARMREG_SP, (G_STRUCT_OFFSET (MonoLMF, iregs) + 13*4));
 213         }
 214         ARM_STR_IMM (buf, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, eip));
 215
 216         /*
 217          * Now we're ready to call xxx_trampoline ().
 218          */
 219         /* Arg 1: the saved registers. It was put in v1 */
 220         ARM_MOV_REG_REG (buf, ARMREG_R0, ARMREG_V1);
 221
 222         /* Arg 2: code (next address to the instruction that called us) */
 223         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 224                 ARM_MOV_REG_IMM8 (buf, ARMREG_R1, 0);
 225         } else {
 226                 ARM_MOV_REG_REG (buf, ARMREG_R1, ARMREG_V3);
 227         }
 228
 229         /* Arg 3: the specific argument, stored in v2
 230          */
 231         ARM_MOV_REG_REG (buf, ARMREG_R2, ARMREG_V2);
 232
 233         load_trampoline = buf;
 234         buf += 4;
 235
 236         ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC);
 237         ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_IP);
 238
 239         /* OK, code address is now on r0. Move it to the place on the stack
 240          * where IP was saved (it is now no more useful to us and it can be
 241          * clobbered). This way we can just restore all the regs in one inst
 242          * and branch to IP.
 243          */
 244         ARM_STR_IMM (buf, ARMREG_R0, ARMREG_V1, (ARMREG_R12 * 4));
 245
 246         /* Check for thread interruption */
 247         /* This is not perf critical code so no need to check the interrupt flag */
 248         /*
 249          * Have to call the _force_ variant, since there could be a protected wrapper on the top of the stack.
 250          */
 251         ARM_LDR_IMM (buf, ARMREG_IP, ARMREG_PC, 0);
 252         ARM_B (buf, 0);
 253         *(gpointer*)buf = mono_thread_force_interruption_checkpoint;
 254         buf += 4;
 255         ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC);
 256         ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_IP);
 257
 258         /*
 259          * Now we restore the MonoLMF (see emit_epilogue in mini-arm.c)
 260          * and the rest of the registers, so the method called will see
 261          * the same state as before we executed.
 262          * The pointer to MonoLMF is in r2.
 263          */
 264         ARM_MOV_REG_REG (buf, ARMREG_R2, ARMREG_SP);
 265         /* ip = previous_lmf */
 266         ARM_LDR_IMM (buf, ARMREG_IP, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 267         /* lr = lmf_addr */
 268         ARM_LDR_IMM (buf, ARMREG_LR, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, lmf_addr));
 269         /* *(lmf_addr) = previous_lmf */
 270         ARM_STR_IMM (buf, ARMREG_IP, ARMREG_LR, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 271
 272         /* Non-standard function epilogue. Instead of doing a proper
 273          * return, we just jump to the compiled code.
 274          */
 275         /* Restore the registers and jump to the code:
 276          * Note that IP has been conveniently set to the method addr.
 277          */
 278         ARM_ADD_REG_IMM8 (buf, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14);
 279         ARM_POP_NWB (buf, 0x5fff);
 280         /* do we need to set sp? */
 281         ARM_ADD_REG_IMM8 (buf, ARMREG_SP, ARMREG_SP, (14 * 4));
 282         if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT)
 283                 ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_LR);
 284         else
 285                 ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_IP);
 286
 287         constants = (gpointer*)buf;
 288         constants [0] = mono_get_lmf_addr;
 289         constants [1] = (gpointer)mono_get_trampoline_func (tramp_type);
 290
 291         /* backpatch by emitting the missing instructions skipped above */
 292         ARM_LDR_IMM (load_get_lmf_addr, ARMREG_R0, ARMREG_PC, (buf - load_get_lmf_addr - 8));
 293         ARM_LDR_IMM (load_trampoline, ARMREG_IP, ARMREG_PC, (buf + 4 - load_trampoline - 8));
 294
 295         buf += 8;
 296
 297         /* Flush instruction cache, since we've generated code */
 298         mono_arch_flush_icache (code, buf - code);
 299
 300         /* Sanity check */
 301         g_assert ((buf - code) <= GEN_TRAMP_SIZE);
 302
 303         return code;
 304 }
 305
 306 #define SPEC_TRAMP_SIZE 24
 307
 308 gpointer
 309 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
 310 {
 311         guint8 *code, *buf, *tramp;
 312         gpointer *constants;
 313         guint32 short_branch, size = SPEC_TRAMP_SIZE;
 314
 315         tramp = mono_get_trampoline_code (tramp_type);
 316
 317         mono_domain_lock (domain);
 318         code = buf = mono_code_manager_reserve_align (domain->code_mp, size, 4);
 319         if ((short_branch = branch_for_target_reachable (code + 8, tramp))) {
 320                 size = 12;
 321                 mono_code_manager_commit (domain->code_mp, code, SPEC_TRAMP_SIZE, size);
 322         }
 323         mono_domain_unlock (domain);
 324
 325         /* we could reduce this to 12 bytes if tramp is within reach:
 326          * ARM_PUSH ()
 327          * ARM_BL ()
 328          * method-literal
 329          * The called code can access method using the lr register
 330          * A 20 byte sequence could be:
 331          * ARM_PUSH ()
 332          * ARM_MOV_REG_REG (lr, pc)
 333          * ARM_LDR_IMM (pc, pc, 0)
 334          * method-literal
 335          * tramp-literal
 336          */
 337         /* We save all the registers, except PC and SP */
 338         ARM_PUSH (buf, 0x5fff);
 339         if (short_branch) {
 340                 constants = (gpointer*)buf;
 341                 constants [0] = GUINT_TO_POINTER (short_branch | (1 << 24));
 342                 constants [1] = arg1;
 343                 buf += 8;
 344         } else {
 345                 ARM_LDR_IMM (buf, ARMREG_R1, ARMREG_PC, 8); /* temp reg */
 346                 ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC);
 347                 ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_R1);
 348
 349                 constants = (gpointer*)buf;
 350                 constants [0] = arg1;
 351                 constants [1] = tramp;
 352                 buf += 8;
 353         }
 354
 355         /* Flush instruction cache, since we've generated code */
 356         mono_arch_flush_icache (code, buf - code);
 357
 358         g_assert ((buf - code) <= size);
 359
 360         if (code_len)
 361                 *code_len = buf - code;
 362
 363         return code;
 364 }
 365
 366 gpointer
 367 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 encoded_offset)
 368 {
 369         /* FIXME: implement! */
 370         g_assert_not_reached ();
 371         return NULL;
 372 }
 373
 374 guint32
 375 mono_arch_get_rgctx_lazy_fetch_offset (gpointer *regs)
 376 {
 377         /* FIXME: implement! */
 378         g_assert_not_reached ();
 379         return 0;
 380 }