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 static guint8* nullified_class_init_trampoline;
  22
  23 /*
  24  * Return the instruction to jump from code to target, 0 if not
  25  * reachable with a single instruction
  26  */
  27 static guint32
  28 branch_for_target_reachable (guint8 *branch, guint8 *target)
  29 {
  30         gint diff = target - branch - 8;
  31         g_assert ((diff & 3) == 0);
  32         if (diff >= 0) {
  33                 if (diff <= 33554431)
  34                         return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | (diff >> 2);
  35         } else {
  36                 /* diff between 0 and -33554432 */
  37                 if (diff >= -33554432)
  38                         return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | ((diff >> 2) & ~0xff000000);
  39         }
  40         return 0;
  41 }
  42
  43 /*
  44  * mono_arch_get_unbox_trampoline:
  45  * @gsctx: the generic sharing context
  46  * @m: method pointer
  47  * @addr: pointer to native code for @m
  48  *
  49  * when value type methods are called through the vtable we need to unbox the
  50  * this argument. This method returns a pointer to a trampoline which does
  51  * unboxing before calling the method
  52  */
  53 gpointer
  54 mono_arch_get_unbox_trampoline (MonoGenericSharingContext *gsctx, MonoMethod *m, gpointer addr)
  55 {
  56         guint8 *code, *start;
  57         int this_pos = 0;
  58         MonoDomain *domain = mono_domain_get ();
  59
  60         if (MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret))
  61                 this_pos = 1;
  62
  63         mono_domain_lock (domain);
  64         start = code = mono_code_manager_reserve (domain->code_mp, 16);
  65         mono_domain_unlock (domain);
  66
  67         ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 4);
  68         ARM_ADD_REG_IMM8 (code, this_pos, this_pos, sizeof (MonoObject));
  69         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP);
  70         *(guint32*)code = (guint32)addr;
  71         code += 4;
  72         mono_arch_flush_icache (start, code - start);
  73         g_assert ((code - start) <= 16);
  74         /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name);
  75         g_print ("unbox code is at %p for method at %p\n", start, addr);*/
  76
  77         return start;
  78 }
  79
  80 void
  81 mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr)
  82 {
  83         guint32 *code = (guint32*)code_ptr;
  84
  85         /* This is the 'bl' or the 'mov pc' instruction */
  86         --code;
  87
  88         /*
  89          * Note that methods are called also with the bl opcode.
  90          */
  91         if ((((*code) >> 25)  & 7) == 5) {
  92                 /*g_print ("direct patching\n");*/
  93                 arm_patch ((guint8*)code, addr);
  94                 mono_arch_flush_icache ((guint8*)code, 4);
  95                 return;
  96         }
  97
  98         if ((((*code) >> 20) & 0xFF) == 0x12) {
  99                 /*g_print ("patching bx\n");*/
 100                 arm_patch ((guint8*)code, addr);
 101                 mono_arch_flush_icache ((guint8*)(code - 2), 4);
 102                 return;
 103         }
 104
 105         g_assert_not_reached ();
 106 }
 107
 108 void
 109 mono_arch_patch_plt_entry (guint8 *code, guint8 *addr)
 110 {
 111         /* Patch the jump table entry used by the plt entry */
 112         guint32 offset = ((guint32*)code)[3];
 113         guint8 *jump_entry = code + offset + 12;
 114
 115         *(guint8**)jump_entry = addr;
 116 }
 117
 118 void
 119 mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs)
 120 {
 121         mono_arch_patch_callsite (NULL, code, nullified_class_init_trampoline);
 122 }
 123
 124 void
 125 mono_arch_nullify_plt_entry (guint8 *code)
 126 {
 127         if (mono_aot_only && !nullified_class_init_trampoline)
 128                 nullified_class_init_trampoline = mono_aot_get_named_code ("nullified_class_init_trampoline");
 129
 130         mono_arch_patch_plt_entry (code, nullified_class_init_trampoline);
 131 }
 132
 133 /* Stack size for trampoline function
 134  */
 135 #define STACK (sizeof (MonoLMF))
 136
 137 /* Method-specific trampoline code fragment size */
 138 #define METHOD_TRAMPOLINE_SIZE 64
 139
 140 /* Jump-specific trampoline code fragment size */
 141 #define JUMP_TRAMPOLINE_SIZE   64
 142
 143 #define GEN_TRAMP_SIZE 192
 144
 145 /*
 146  * Stack frame description when the generic trampoline is called.
 147  * caller frame
 148  * ------------------- old sp
 149  *  MonoLMF
 150  * ------------------- sp
 151  */
 152 guchar*
 153 mono_arch_create_trampoline_code (MonoTrampolineType tramp_type)
 154 {
 155         MonoJumpInfo *ji;
 156         guint32 code_size;
 157
 158         return mono_arch_create_trampoline_code_full (tramp_type, &code_size, &ji, FALSE);
 159 }
 160
 161 guchar*
 162 mono_arch_create_trampoline_code_full (MonoTrampolineType tramp_type, guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
 163 {
 164         guint8 *buf, *code = NULL;
 165         guint8 *load_get_lmf_addr, *load_trampoline;
 166         gpointer *constants;
 167
 168         *ji = NULL;
 169
 170         /* Now we'll create in 'buf' the ARM trampoline code. This
 171          is the trampoline code common to all methods  */
 172
 173         code = buf = mono_global_codeman_reserve (GEN_TRAMP_SIZE);
 174
 175         /*
 176          * At this point lr points to the specific arg and sp points to the saved
 177          * regs on the stack (all but PC and SP). The original LR value has been
 178          * saved as sp + LR_OFFSET by the push in the specific trampoline
 179          */
 180 #define LR_OFFSET (sizeof (gpointer) * 13)
 181         ARM_MOV_REG_REG (code, ARMREG_V1, ARMREG_SP);
 182         if (aot && tramp_type != MONO_TRAMPOLINE_GENERIC_CLASS_INIT) {
 183                 /*
 184                  * The trampoline contains a pc-relative offset to the got slot where the
 185                  * value is stored. The offset can be found at [lr + 4].
 186                  */
 187                 ARM_LDR_IMM (code, ARMREG_V2, ARMREG_LR, 4);
 188                 ARM_LDR_REG_REG (code, ARMREG_V2, ARMREG_V2, ARMREG_LR);
 189         } else {
 190                 if (tramp_type != MONO_TRAMPOLINE_GENERIC_CLASS_INIT)
 191                         ARM_LDR_IMM (code, ARMREG_V2, ARMREG_LR, 0);
 192                 else
 193                         ARM_MOV_REG_REG (code, ARMREG_V2, MONO_ARCH_VTABLE_REG);
 194         }
 195         ARM_LDR_IMM (code, ARMREG_V3, ARMREG_SP, LR_OFFSET);
 196
 197         /* ok, now we can continue with the MonoLMF setup, mostly untouched
 198          * from emit_prolog in mini-arm.c
 199          * This is a synthetized call to mono_get_lmf_addr ()
 200          */
 201         if (aot) {
 202                 *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr");
 203                 ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0);
 204                 ARM_B (code, 0);
 205                 *(gpointer*)code = NULL;
 206                 code += 4;
 207                 ARM_LDR_REG_REG (code, ARMREG_R0, ARMREG_PC, ARMREG_R0);
 208         } else {
 209                 load_get_lmf_addr = code;
 210                 code += 4;
 211         }
 212         ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC);
 213         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_R0);
 214
 215         /* we build the MonoLMF structure on the stack - see mini-arm.h
 216          * The pointer to the struct is put in r1.
 217          * the iregs array is already allocated on the stack by push.
 218          */
 219         ARM_SUB_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14);
 220         ARM_ADD_REG_IMM8 (code, ARMREG_R1, ARMREG_SP, STACK - sizeof (MonoLMF));
 221         /* r0 is the result from mono_get_lmf_addr () */
 222         ARM_STR_IMM (code, ARMREG_R0, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, lmf_addr));
 223         /* new_lmf->previous_lmf = *lmf_addr */
 224         ARM_LDR_IMM (code, ARMREG_R2, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 225         ARM_STR_IMM (code, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 226         /* *(lmf_addr) = r1 */
 227         ARM_STR_IMM (code, ARMREG_R1, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 228         /* save method info (it's in v2) */
 229         if ((tramp_type == MONO_TRAMPOLINE_JIT) || (tramp_type == MONO_TRAMPOLINE_JUMP))
 230                 ARM_STR_IMM (code, ARMREG_V2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, method));
 231         ARM_STR_IMM (code, ARMREG_SP, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, ebp));
 232         /* save the IP (caller ip) */
 233         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 234                 ARM_MOV_REG_IMM8 (code, ARMREG_R2, 0);
 235         } else {
 236                 /* assumes STACK == sizeof (MonoLMF) */
 237                 ARM_LDR_IMM (code, ARMREG_R2, ARMREG_SP, (G_STRUCT_OFFSET (MonoLMF, iregs) + 13*4));
 238         }
 239         ARM_STR_IMM (code, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, eip));
 240
 241         /*
 242          * Now we're ready to call xxx_trampoline ().
 243          */
 244         /* Arg 1: the saved registers. It was put in v1 */
 245         ARM_MOV_REG_REG (code, ARMREG_R0, ARMREG_V1);
 246
 247         /* Arg 2: code (next address to the instruction that called us) */
 248         if (tramp_type == MONO_TRAMPOLINE_JUMP) {
 249                 ARM_MOV_REG_IMM8 (code, ARMREG_R1, 0);
 250         } else {
 251                 ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_V3);
 252         }
 253
 254         /* Arg 3: the specific argument, stored in v2
 255          */
 256         ARM_MOV_REG_REG (code, ARMREG_R2, ARMREG_V2);
 257
 258         if (aot) {
 259                 char *icall_name = g_strdup_printf ("trampoline_func_%d", tramp_type);
 260                 *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name);
 261                 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0);
 262                 ARM_B (code, 0);
 263                 *(gpointer*)code = NULL;
 264                 code += 4;
 265                 ARM_LDR_REG_REG (code, ARMREG_IP, ARMREG_PC, ARMREG_IP);
 266         } else {
 267                 load_trampoline = code;
 268                 code += 4;
 269         }
 270
 271         ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC);
 272         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP);
 273
 274         /* OK, code address is now on r0. Move it to the place on the stack
 275          * where IP was saved (it is now no more useful to us and it can be
 276          * clobbered). This way we can just restore all the regs in one inst
 277          * and branch to IP.
 278          */
 279         ARM_STR_IMM (code, ARMREG_R0, ARMREG_V1, (ARMREG_R12 * 4));
 280
 281         /* Check for thread interruption */
 282         /* This is not perf critical code so no need to check the interrupt flag */
 283         /*
 284          * Have to call the _force_ variant, since there could be a protected wrapper on the top of the stack.
 285          */
 286         if (aot) {
 287                 *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_thread_force_interruption_checkpoint");
 288                 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0);
 289                 ARM_B (code, 0);
 290                 *(gpointer*)code = NULL;
 291                 code += 4;
 292                 ARM_LDR_REG_REG (code, ARMREG_IP, ARMREG_PC, ARMREG_IP);
 293         } else {
 294                 ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0);
 295                 ARM_B (code, 0);
 296                 *(gpointer*)code = mono_thread_force_interruption_checkpoint;
 297                 code += 4;
 298         }
 299         ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC);
 300         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP);
 301
 302         /*
 303          * Now we restore the MonoLMF (see emit_epilogue in mini-arm.c)
 304          * and the rest of the registers, so the method called will see
 305          * the same state as before we executed.
 306          * The pointer to MonoLMF is in r2.
 307          */
 308         ARM_MOV_REG_REG (code, ARMREG_R2, ARMREG_SP);
 309         /* ip = previous_lmf */
 310         ARM_LDR_IMM (code, ARMREG_IP, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 311         /* lr = lmf_addr */
 312         ARM_LDR_IMM (code, ARMREG_LR, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, lmf_addr));
 313         /* *(lmf_addr) = previous_lmf */
 314         ARM_STR_IMM (code, ARMREG_IP, ARMREG_LR, G_STRUCT_OFFSET (MonoLMF, previous_lmf));
 315
 316         /* Non-standard function epilogue. Instead of doing a proper
 317          * return, we just jump to the compiled code.
 318          */
 319         /* Restore the registers and jump to the code:
 320          * Note that IP has been conveniently set to the method addr.
 321          */
 322         ARM_ADD_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14);
 323         ARM_POP_NWB (code, 0x5fff);
 324         if (tramp_type == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH)
 325                 ARM_MOV_REG_REG (code, ARMREG_R0, ARMREG_IP);
 326         /* do we need to set sp? */
 327         ARM_ADD_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, (14 * 4));
 328         if ((tramp_type == MONO_TRAMPOLINE_CLASS_INIT) || (tramp_type == MONO_TRAMPOLINE_GENERIC_CLASS_INIT) || (tramp_type == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH))
 329                 ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_LR);
 330         else
 331                 ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP);
 332
 333         constants = (gpointer*)code;
 334         constants [0] = mono_get_lmf_addr;
 335         constants [1] = (gpointer)mono_get_trampoline_func (tramp_type);
 336
 337         if (!aot) {
 338                 /* backpatch by emitting the missing instructions skipped above */
 339                 ARM_LDR_IMM (load_get_lmf_addr, ARMREG_R0, ARMREG_PC, (code - load_get_lmf_addr - 8));
 340                 ARM_LDR_IMM (load_trampoline, ARMREG_IP, ARMREG_PC, (code + 4 - load_trampoline - 8));
 341         }
 342
 343         code += 8;
 344
 345         /* Flush instruction cache, since we've generated code */
 346         mono_arch_flush_icache (code, code - buf);
 347
 348         /* Sanity check */
 349         g_assert ((code - buf) <= GEN_TRAMP_SIZE);
 350
 351         *code_size = code - buf;
 352
 353         if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) {
 354                 guint32 code_len;
 355
 356                 /* Initialize the nullified class init trampoline used in the AOT case */
 357                 nullified_class_init_trampoline = mono_arch_get_nullified_class_init_trampoline (&code_len);
 358         }
 359
 360         return buf;
 361 }
 362
 363 gpointer
 364 mono_arch_get_nullified_class_init_trampoline (guint32 *code_len)
 365 {
 366         guint8 *buf, *code;
 367
 368         code = buf = mono_global_codeman_reserve (16);
 369
 370         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_LR);
 371
 372         mono_arch_flush_icache (code, code - buf);
 373
 374         *code_len = code - buf;
 375
 376         return buf;
 377 }
 378
 379 #define SPEC_TRAMP_SIZE 24
 380
 381 gpointer
 382 mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len)
 383 {
 384         guint8 *code, *buf, *tramp;
 385         gpointer *constants;
 386         guint32 short_branch, size = SPEC_TRAMP_SIZE;
 387
 388         tramp = mono_get_trampoline_code (tramp_type);
 389
 390         mono_domain_lock (domain);
 391         code = buf = mono_code_manager_reserve_align (domain->code_mp, size, 4);
 392         if ((short_branch = branch_for_target_reachable (code + 8, tramp))) {
 393                 size = 12;
 394                 mono_code_manager_commit (domain->code_mp, code, SPEC_TRAMP_SIZE, size);
 395         }
 396         mono_domain_unlock (domain);
 397
 398         /* we could reduce this to 12 bytes if tramp is within reach:
 399          * ARM_PUSH ()
 400          * ARM_BL ()
 401          * method-literal
 402          * The called code can access method using the lr register
 403          * A 20 byte sequence could be:
 404          * ARM_PUSH ()
 405          * ARM_MOV_REG_REG (lr, pc)
 406          * ARM_LDR_IMM (pc, pc, 0)
 407          * method-literal
 408          * tramp-literal
 409          */
 410         /* We save all the registers, except PC and SP */
 411         ARM_PUSH (code, 0x5fff);
 412         if (short_branch) {
 413                 constants = (gpointer*)code;
 414                 constants [0] = GUINT_TO_POINTER (short_branch | (1 << 24));
 415                 constants [1] = arg1;
 416                 code += 8;
 417         } else {
 418                 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 8); /* temp reg */
 419                 ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC);
 420                 ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_R1);
 421
 422                 constants = (gpointer*)code;
 423                 constants [0] = arg1;
 424                 constants [1] = tramp;
 425                 code += 8;
 426         }
 427
 428         /* Flush instruction cache, since we've generated code */
 429         mono_arch_flush_icache (code, code - buf);
 430
 431         g_assert ((code - buf) <= size);
 432
 433         if (code_len)
 434                 *code_len = code - buf;
 435
 436         return buf;
 437 }
 438
 439 #define arm_is_imm12(v) ((int)(v) > -4096 && (int)(v) < 4096)
 440
 441 gpointer
 442 mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot)
 443 {
 444         guint32 code_size;
 445         MonoJumpInfo *ji;
 446
 447         return mono_arch_create_rgctx_lazy_fetch_trampoline_full (slot, &code_size, &ji, FALSE);
 448 }
 449
 450 gpointer
 451 mono_arch_create_rgctx_lazy_fetch_trampoline_full (guint32 slot, guint32 *code_size, MonoJumpInfo **ji, gboolean aot)
 452 {
 453         guint8 *tramp;
 454         guint8 *code, *buf;
 455         int tramp_size;
 456         guint32 code_len;
 457         guint8 **rgctx_null_jumps;
 458         int depth, index;
 459         int i, njumps;
 460         gboolean mrgctx;
 461
 462         *ji = NULL;
 463
 464         mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot);
 465         index = MONO_RGCTX_SLOT_INDEX (slot);
 466         if (mrgctx)
 467                 index += sizeof (MonoMethodRuntimeGenericContext) / sizeof (gpointer);
 468         for (depth = 0; ; ++depth) {
 469                 int size = mono_class_rgctx_get_array_size (depth, mrgctx);
 470
 471                 if (index < size - 1)
 472                         break;
 473                 index -= size - 1;
 474         }
 475
 476         tramp_size = 64 + 16 * depth;
 477
 478         code = buf = mono_global_codeman_reserve (tramp_size);
 479
 480         rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2));
 481         njumps = 0;
 482
 483         /* The vtable/mrgctx is in R0 */
 484         g_assert (MONO_ARCH_VTABLE_REG == ARMREG_R0);
 485
 486         if (mrgctx) {
 487                 /* get mrgctx ptr */
 488                 ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_R0);
 489         } else {
 490                 /* load rgctx ptr from vtable */
 491                 g_assert (arm_is_imm12 (G_STRUCT_OFFSET (MonoVTable, runtime_generic_context)));
 492                 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R0, G_STRUCT_OFFSET (MonoVTable, runtime_generic_context));
 493                 /* is the rgctx ptr null? */
 494                 ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0);
 495                 /* if yes, jump to actual trampoline */
 496                 rgctx_null_jumps [njumps ++] = code;
 497                 ARM_B_COND (code, ARMCOND_EQ, 0);
 498         }
 499
 500         for (i = 0; i < depth; ++i) {
 501                 /* load ptr to next array */
 502                 if (mrgctx && i == 0) {
 503                         g_assert (arm_is_imm12 (sizeof (MonoMethodRuntimeGenericContext)));
 504                         ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R1, sizeof (MonoMethodRuntimeGenericContext));
 505                 } else {
 506                         ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R1, 0);
 507                 }
 508                 /* is the ptr null? */
 509                 ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0);
 510                 /* if yes, jump to actual trampoline */
 511                 rgctx_null_jumps [njumps ++] = code;
 512                 ARM_B_COND (code, ARMCOND_EQ, 0);
 513         }
 514
 515         /* fetch slot */
 516         code = mono_arm_emit_load_imm (code, ARMREG_R2, sizeof (gpointer) * (index + 1));
 517         ARM_LDR_REG_REG (code, ARMREG_R1, ARMREG_R1, ARMREG_R2);
 518         /* is the slot null? */
 519         ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0);
 520         /* if yes, jump to actual trampoline */
 521         rgctx_null_jumps [njumps ++] = code;
 522         ARM_B_COND (code, ARMCOND_EQ, 0);
 523         /* otherwise return, result is in R1 */
 524         ARM_MOV_REG_REG (code, ARMREG_R0, ARMREG_R1);
 525         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_LR);
 526
 527         g_assert (njumps <= depth + 2);
 528         for (i = 0; i < njumps; ++i)
 529                 arm_patch (rgctx_null_jumps [i], code);
 530
 531         g_free (rgctx_null_jumps);
 532
 533         /* Slowpath */
 534
 535         /* The vtable/mrgctx is still in R0 */
 536
 537         if (aot) {
 538                 *ji = mono_patch_info_list_prepend (*ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot));
 539                 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0);
 540                 ARM_B (code, 0);
 541                 *(gpointer*)code = NULL;
 542                 code += 4;
 543                 ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_R1);
 544         } else {
 545                 tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), &code_len);
 546
 547                 /* Jump to the actual trampoline */
 548                 ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); /* temp reg */
 549                 ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_R1);
 550                 *(guint32*)code = tramp;
 551                 code += 4;
 552         }
 553
 554         mono_arch_flush_icache (buf, code - buf);
 555
 556         g_assert (code - buf <= tramp_size);
 557
 558         *code_size = code - buf;
 559
 560         return buf;
 561 }
 562
 563 #define arm_is_imm8(v) ((v) > -256 && (v) < 256)
 564
 565 gpointer
 566 mono_arch_create_generic_class_init_trampoline (void)
 567 {
 568         guint8 *tramp;
 569         guint8 *code, *buf;
 570         static int byte_offset = -1;
 571         static guint8 bitmask;
 572         guint8 *jump;
 573         int tramp_size;
 574         guint32 code_len, imm8;
 575         gint rot_amount;
 576
 577         tramp_size = 64;
 578
 579         code = buf = mono_global_codeman_reserve (tramp_size);
 580
 581         if (byte_offset < 0)
 582                 mono_marshal_find_bitfield_offset (MonoVTable, initialized, &byte_offset, &bitmask);
 583
 584         g_assert (arm_is_imm8 (byte_offset));
 585         ARM_LDRSB_IMM (code, ARMREG_IP, MONO_ARCH_VTABLE_REG, byte_offset);
 586         imm8 = mono_arm_is_rotated_imm8 (bitmask, &rot_amount);
 587         g_assert (imm8 >= 0);
 588         ARM_AND_REG_IMM (code, ARMREG_IP, ARMREG_IP, imm8, rot_amount);
 589         ARM_CMP_REG_IMM (code, ARMREG_IP, 0, 0);
 590         jump = code;
 591         ARM_B_COND (code, ARMCOND_EQ, 0);
 592
 593         /* Initialized case */
 594         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_LR);
 595
 596         /* Uninitialized case */
 597         arm_patch (jump, code);
 598
 599         tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_GENERIC_CLASS_INIT, mono_get_root_domain (), &code_len);
 600
 601         /* Jump to the actual trampoline */
 602         ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); /* temp reg */
 603         ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_R1);
 604         *(guint32*)code = tramp;
 605         code += 4;
 606
 607         mono_arch_flush_icache (buf, code - buf);
 608
 609         g_assert (code - buf <= tramp_size);
 610
 611         return buf;
 612 }