X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Ftramp-arm.c;h=de25b412c7df96ec244a80d0f18f6a14289de3cc;hb=e98d5e33453448134f34f5d85c9e9a470a6bf007;hp=d7b2d1e3dcab6a6ae2b282dbdcd1cf9f203d712d;hpb=eac934155e3a0d36f6c3da15027a6cee59a96409;p=mono.git diff --git a/mono/mini/tramp-arm.c b/mono/mini/tramp-arm.c index d7b2d1e3dca..de25b412c7d 100644 --- a/mono/mini/tramp-arm.c +++ b/mono/mini/tramp-arm.c @@ -18,61 +18,7 @@ #include "mini.h" #include "mini-arm.h" -/* - * Return the instruction to jump from code to target, 0 if not - * reachable with a single instruction - */ -static guint32 -branch_for_target_reachable (guint8 *branch, guint8 *target) -{ - gint diff = target - branch - 8; - g_assert ((diff & 3) == 0); - if (diff >= 0) { - if (diff <= 33554431) - return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | (diff >> 2); - } else { - /* diff between 0 and -33554432 */ - if (diff >= -33554432) - return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | ((diff >> 2) & ~0xff000000); - } - return 0; -} - -/* - * mono_arch_get_unbox_trampoline: - * @m: method pointer - * @addr: pointer to native code for @m - * - * when value type methods are called through the vtable we need to unbox the - * this argument. This method returns a pointer to a trampoline which does - * unboxing before calling the method - */ -gpointer -mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) -{ - guint8 *code, *start; - int this_pos = 0; - MonoDomain *domain = mono_domain_get (); - - if (!mono_method_signature (m)->ret->byref && MONO_TYPE_ISSTRUCT (mono_method_signature (m)->ret)) - this_pos = 1; - - mono_domain_lock (domain); - start = code = mono_code_manager_reserve (domain->code_mp, 16); - mono_domain_unlock (domain); - - ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 4); - ARM_ADD_REG_IMM8 (code, this_pos, this_pos, sizeof (MonoObject)); - ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_IP); - *(guint32*)code = (guint32)addr; - code += 4; - mono_arch_flush_icache (start, code - start); - g_assert ((code - start) <= 16); - /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name); - g_print ("unbox code is at %p for method at %p\n", start, addr);*/ - - return start; -} +static guint8* nullified_class_init_trampoline; void mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr) @@ -87,15 +33,15 @@ mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr) */ if ((((*code) >> 25) & 7) == 5) { /*g_print ("direct patching\n");*/ - arm_patch ((char*)code, addr); - mono_arch_flush_icache ((char*)code, 4); + arm_patch ((guint8*)code, addr); + mono_arch_flush_icache ((guint8*)code, 4); return; } if ((((*code) >> 20) & 0xFF) == 0x12) { /*g_print ("patching bx\n");*/ - arm_patch ((char*)code, addr); - mono_arch_flush_icache ((char*)(code - 2), 4); + arm_patch ((guint8*)code, addr); + mono_arch_flush_icache ((guint8*)(code - 2), 4); return; } @@ -103,38 +49,71 @@ mono_arch_patch_callsite (guint8 *method_start, guint8 *code_ptr, guint8 *addr) } void -mono_arch_patch_plt_entry (guint8 *code, guint8 *addr) +mono_arch_patch_plt_entry (guint8 *code, gpointer *got, mgreg_t *regs, guint8 *addr) { - guint32 ins = branch_for_target_reachable (code, addr); + guint8 *jump_entry; + + /* Patch the jump table entry used by the plt entry */ + if (*(guint32*)code == 0xe59fc000) { + /* ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); */ + guint32 offset = ((guint32*)code)[2]; + + jump_entry = code + offset + 12; + } else { + g_assert_not_reached (); + } - if (ins) - /* Patch the branch */ - ((guint32*)code) [0] = ins; - else - /* Patch the jump address */ - ((guint32*)code) [1] = addr; - mono_arch_flush_icache ((char*)code, 4); + *(guint8**)jump_entry = addr; } void -mono_arch_nullify_class_init_trampoline (guint8 *code, gssize *regs) +mono_arch_nullify_class_init_trampoline (guint8 *code, mgreg_t *regs) { - return; + mono_arch_patch_callsite (NULL, code, nullified_class_init_trampoline); } void -mono_arch_nullify_plt_entry (guint8 *code) +mono_arch_nullify_plt_entry (guint8 *code, mgreg_t *regs) { - guint8 buf [4]; - guint8 *p; + if (mono_aot_only && !nullified_class_init_trampoline) + nullified_class_init_trampoline = mono_aot_get_trampoline ("nullified_class_init_trampoline"); - p = buf; - ARM_MOV_REG_REG (p, ARMREG_PC, ARMREG_LR); + mono_arch_patch_plt_entry (code, NULL, regs, nullified_class_init_trampoline); +} + +#ifndef DISABLE_JIT - ((guint32*)code) [0] = ((guint32*)buf) [0]; - mono_arch_flush_icache ((char*)code, 4); +#define arm_is_imm12(v) ((int)(v) > -4096 && (int)(v) < 4096) + +/* + * Return the instruction to jump from code to target, 0 if not + * reachable with a single instruction + */ +static guint32 +branch_for_target_reachable (guint8 *branch, guint8 *target) +{ + gint diff = target - branch - 8; + g_assert ((diff & 3) == 0); + if (diff >= 0) { + if (diff <= 33554431) + return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | (diff >> 2); + } else { + /* diff between 0 and -33554432 */ + if (diff >= -33554432) + return (ARMCOND_AL << ARMCOND_SHIFT) | (ARM_BR_TAG) | ((diff >> 2) & ~0xff000000); + } + return 0; } +static inline guint8* +emit_bx (guint8* code, int reg) +{ + if (mono_arm_thumb_supported ()) + ARM_BX (code, reg); + else + ARM_MOV_REG_REG (code, ARMREG_PC, reg); + return code; +} /* Stack size for trampoline function */ @@ -146,27 +125,22 @@ mono_arch_nullify_plt_entry (guint8 *code) /* Jump-specific trampoline code fragment size */ #define JUMP_TRAMPOLINE_SIZE 64 -#define GEN_TRAMP_SIZE 148 - -/* - * Stack frame description when the generic trampoline is called. - * caller frame - * ------------------- old sp - * MonoLMF - * ------------------- sp - */ guchar* -mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) +mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot) { guint8 *buf, *code = NULL; - int i, offset; guint8 *load_get_lmf_addr, *load_trampoline; gpointer *constants; + int cfa_offset; + GSList *unwind_ops = NULL; + MonoJumpInfo *ji = NULL; + int buf_len; /* Now we'll create in 'buf' the ARM trampoline code. This is the trampoline code common to all methods */ - - code = buf = mono_global_codeman_reserve (GEN_TRAMP_SIZE); + + buf_len = 212; + code = buf = mono_global_codeman_reserve (buf_len); /* * At this point lr points to the specific arg and sp points to the saved @@ -174,74 +148,147 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) * saved as sp + LR_OFFSET by the push in the specific trampoline */ #define LR_OFFSET (sizeof (gpointer) * 13) - ARM_MOV_REG_REG (buf, ARMREG_V1, ARMREG_SP); - ARM_LDR_IMM (buf, ARMREG_V2, ARMREG_LR, 0); - ARM_LDR_IMM (buf, ARMREG_V3, ARMREG_SP, LR_OFFSET); + + // FIXME: Finish the unwind info, the current info allows us to unwind + // when the trampoline is not in the epilog + + // CFA = SP + (num registers pushed) * 4 + cfa_offset = 14 * sizeof (gpointer); + mono_add_unwind_op_def_cfa (unwind_ops, code, buf, ARMREG_SP, cfa_offset); + // PC saved at sp+LR_OFFSET + mono_add_unwind_op_offset (unwind_ops, code, buf, ARMREG_LR, -4); + + ARM_MOV_REG_REG (code, ARMREG_V1, ARMREG_SP); + if (aot && tramp_type != MONO_TRAMPOLINE_GENERIC_CLASS_INIT) { + /* + * The trampoline contains a pc-relative offset to the got slot + * preceeding the got slot where the value is stored. The offset can be + * found at [lr + 0]. + */ + ARM_LDR_IMM (code, ARMREG_V2, ARMREG_LR, 0); + ARM_ADD_REG_IMM (code, ARMREG_V2, ARMREG_V2, 4, 0); + ARM_LDR_REG_REG (code, ARMREG_V2, ARMREG_V2, ARMREG_LR); + } else { + if (tramp_type != MONO_TRAMPOLINE_GENERIC_CLASS_INIT) + ARM_LDR_IMM (code, ARMREG_V2, ARMREG_LR, 0); + else + ARM_MOV_REG_REG (code, ARMREG_V2, MONO_ARCH_VTABLE_REG); + } + ARM_LDR_IMM (code, ARMREG_V3, ARMREG_SP, LR_OFFSET); /* ok, now we can continue with the MonoLMF setup, mostly untouched * from emit_prolog in mini-arm.c - * This is a sinthetized call to mono_get_lmf_addr () + * This is a synthetized call to mono_get_lmf_addr () */ - load_get_lmf_addr = buf; - buf += 4; - ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC); - ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_R0); + if (aot) { + ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_get_lmf_addr"); + ARM_LDR_IMM (code, ARMREG_R0, ARMREG_PC, 0); + ARM_B (code, 0); + *(gpointer*)code = NULL; + code += 4; + ARM_LDR_REG_REG (code, ARMREG_R0, ARMREG_PC, ARMREG_R0); + } else { + load_get_lmf_addr = code; + code += 4; + } + ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC); + code = emit_bx (code, ARMREG_R0); /* we build the MonoLMF structure on the stack - see mini-arm.h * The pointer to the struct is put in r1. * the iregs array is already allocated on the stack by push. */ - ARM_SUB_REG_IMM8 (buf, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14); - ARM_ADD_REG_IMM8 (buf, ARMREG_R1, ARMREG_SP, STACK - sizeof (MonoLMF)); + ARM_SUB_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14); + cfa_offset += sizeof (MonoLMF) - sizeof (guint) * 14; + mono_add_unwind_op_def_cfa_offset (unwind_ops, code, buf, cfa_offset); + ARM_ADD_REG_IMM8 (code, ARMREG_R1, ARMREG_SP, STACK - sizeof (MonoLMF)); /* r0 is the result from mono_get_lmf_addr () */ - ARM_STR_IMM (buf, ARMREG_R0, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, lmf_addr)); + ARM_STR_IMM (code, ARMREG_R0, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, lmf_addr)); /* new_lmf->previous_lmf = *lmf_addr */ - ARM_LDR_IMM (buf, ARMREG_R2, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); - ARM_STR_IMM (buf, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); + ARM_LDR_IMM (code, ARMREG_R2, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); + ARM_STR_IMM (code, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); /* *(lmf_addr) = r1 */ - ARM_STR_IMM (buf, ARMREG_R1, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); + ARM_STR_IMM (code, ARMREG_R1, ARMREG_R0, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); /* save method info (it's in v2) */ - if ((tramp_type == MONO_TRAMPOLINE_GENERIC) || (tramp_type == MONO_TRAMPOLINE_JUMP)) - ARM_STR_IMM (buf, ARMREG_V2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, method)); - ARM_STR_IMM (buf, ARMREG_SP, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, ebp)); + if ((tramp_type == MONO_TRAMPOLINE_JIT) || (tramp_type == MONO_TRAMPOLINE_JUMP)) + ARM_STR_IMM (code, ARMREG_V2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, method)); + else { + ARM_MOV_REG_IMM8 (code, ARMREG_R2, 0); + ARM_STR_IMM (code, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, method)); + } + /* Save sp into lmf->iregs, the eh code expects it to be at IP */ + ARM_ADD_REG_IMM8 (code, ARMREG_R2, ARMREG_SP, cfa_offset); + ARM_STR_IMM (code, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, iregs) + (ARMREG_IP * 4)); + ARM_STR_IMM (code, ARMREG_SP, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, esp)); /* save the IP (caller ip) */ if (tramp_type == MONO_TRAMPOLINE_JUMP) { - ARM_MOV_REG_IMM8 (buf, ARMREG_R2, 0); + ARM_MOV_REG_IMM8 (code, ARMREG_R2, 0); } else { /* assumes STACK == sizeof (MonoLMF) */ - ARM_LDR_IMM (buf, ARMREG_R2, ARMREG_SP, (G_STRUCT_OFFSET (MonoLMF, iregs) + 13*4)); + ARM_LDR_IMM (code, ARMREG_R2, ARMREG_SP, (G_STRUCT_OFFSET (MonoLMF, iregs) + 13*4)); } - ARM_STR_IMM (buf, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, eip)); + ARM_STR_IMM (code, ARMREG_R2, ARMREG_R1, G_STRUCT_OFFSET (MonoLMF, eip)); /* * Now we're ready to call xxx_trampoline (). */ /* Arg 1: the saved registers. It was put in v1 */ - ARM_MOV_REG_REG (buf, ARMREG_R0, ARMREG_V1); + ARM_MOV_REG_REG (code, ARMREG_R0, ARMREG_V1); /* Arg 2: code (next address to the instruction that called us) */ if (tramp_type == MONO_TRAMPOLINE_JUMP) { - ARM_MOV_REG_IMM8 (buf, ARMREG_R1, 0); + ARM_MOV_REG_IMM8 (code, ARMREG_R1, 0); } else { - ARM_MOV_REG_REG (buf, ARMREG_R1, ARMREG_V3); + ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_V3); } /* Arg 3: the specific argument, stored in v2 */ - ARM_MOV_REG_REG (buf, ARMREG_R2, ARMREG_V2); - - load_trampoline = buf; - buf += 4; + ARM_MOV_REG_REG (code, ARMREG_R2, ARMREG_V2); + + if (aot) { + char *icall_name = g_strdup_printf ("trampoline_func_%d", tramp_type); + ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, icall_name); + ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); + ARM_B (code, 0); + *(gpointer*)code = NULL; + code += 4; + ARM_LDR_REG_REG (code, ARMREG_IP, ARMREG_PC, ARMREG_IP); + } else { + load_trampoline = code; + code += 4; + } - ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC); - ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_IP); + ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC); + code = emit_bx (code, ARMREG_IP); /* OK, code address is now on r0. Move it to the place on the stack * where IP was saved (it is now no more useful to us and it can be * clobbered). This way we can just restore all the regs in one inst * and branch to IP. */ - ARM_STR_IMM (buf, ARMREG_R0, ARMREG_V1, (ARMREG_R12 * 4)); + ARM_STR_IMM (code, ARMREG_R0, ARMREG_V1, (ARMREG_R12 * 4)); + + /* Check for thread interruption */ + /* This is not perf critical code so no need to check the interrupt flag */ + /* + * Have to call the _force_ variant, since there could be a protected wrapper on the top of the stack. + */ + if (aot) { + ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_thread_force_interruption_checkpoint"); + ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); + ARM_B (code, 0); + *(gpointer*)code = NULL; + code += 4; + ARM_LDR_REG_REG (code, ARMREG_IP, ARMREG_PC, ARMREG_IP); + } else { + ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 0); + ARM_B (code, 0); + *(gpointer*)code = mono_thread_force_interruption_checkpoint; + code += 4; + } + ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC); + code = emit_bx (code, ARMREG_IP); /* * Now we restore the MonoLMF (see emit_epilogue in mini-arm.c) @@ -249,13 +296,13 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) * the same state as before we executed. * The pointer to MonoLMF is in r2. */ - ARM_MOV_REG_REG (buf, ARMREG_R2, ARMREG_SP); + ARM_MOV_REG_REG (code, ARMREG_R2, ARMREG_SP); /* ip = previous_lmf */ - ARM_LDR_IMM (buf, ARMREG_IP, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); + ARM_LDR_IMM (code, ARMREG_IP, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); /* lr = lmf_addr */ - ARM_LDR_IMM (buf, ARMREG_LR, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, lmf_addr)); + ARM_LDR_IMM (code, ARMREG_LR, ARMREG_R2, G_STRUCT_OFFSET (MonoLMF, lmf_addr)); /* *(lmf_addr) = previous_lmf */ - ARM_STR_IMM (buf, ARMREG_IP, ARMREG_LR, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); + ARM_STR_IMM (code, ARMREG_IP, ARMREG_LR, G_STRUCT_OFFSET (MonoLMF, previous_lmf)); /* Non-standard function epilogue. Instead of doing a proper * return, we just jump to the compiled code. @@ -263,32 +310,60 @@ mono_arch_create_trampoline_code (MonoTrampolineType tramp_type) /* Restore the registers and jump to the code: * Note that IP has been conveniently set to the method addr. */ - ARM_ADD_REG_IMM8 (buf, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14); - ARM_POP_NWB (buf, 0x5fff); + ARM_ADD_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, sizeof (MonoLMF) - sizeof (guint) * 14); + ARM_POP_NWB (code, 0x5fff); + if (tramp_type == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH) + ARM_MOV_REG_REG (code, ARMREG_R0, ARMREG_IP); /* do we need to set sp? */ - ARM_ADD_REG_IMM8 (buf, ARMREG_SP, ARMREG_SP, (14 * 4)); - if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) - ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_LR); + ARM_ADD_REG_IMM8 (code, ARMREG_SP, ARMREG_SP, (14 * 4)); + if ((tramp_type == MONO_TRAMPOLINE_CLASS_INIT) || (tramp_type == MONO_TRAMPOLINE_GENERIC_CLASS_INIT) || (tramp_type == MONO_TRAMPOLINE_RGCTX_LAZY_FETCH)) + code = emit_bx (code, ARMREG_LR); else - ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_IP); + code = emit_bx (code, ARMREG_IP); - constants = (gpointer*)buf; + constants = (gpointer*)code; constants [0] = mono_get_lmf_addr; - constants [1] = mono_get_trampoline_func (tramp_type); + constants [1] = (gpointer)mono_get_trampoline_func (tramp_type); - /* backpatch by emitting the missing instructions skipped above */ - ARM_LDR_IMM (load_get_lmf_addr, ARMREG_R0, ARMREG_PC, (buf - load_get_lmf_addr - 8)); - ARM_LDR_IMM (load_trampoline, ARMREG_IP, ARMREG_PC, (buf + 4 - load_trampoline - 8)); + if (!aot) { + /* backpatch by emitting the missing instructions skipped above */ + ARM_LDR_IMM (load_get_lmf_addr, ARMREG_R0, ARMREG_PC, (code - load_get_lmf_addr - 8)); + ARM_LDR_IMM (load_trampoline, ARMREG_IP, ARMREG_PC, (code + 4 - load_trampoline - 8)); + } - buf += 8; + code += 8; /* Flush instruction cache, since we've generated code */ - mono_arch_flush_icache (code, buf - code); + mono_arch_flush_icache (buf, code - buf); /* Sanity check */ - g_assert ((buf - code) <= GEN_TRAMP_SIZE); + g_assert ((code - buf) <= buf_len); - return code; + if (tramp_type == MONO_TRAMPOLINE_CLASS_INIT) + /* Initialize the nullified class init trampoline used in the AOT case */ + nullified_class_init_trampoline = mono_arch_get_nullified_class_init_trampoline (NULL); + + if (info) + *info = mono_tramp_info_create (mono_get_generic_trampoline_name (tramp_type), buf, code - buf, ji, unwind_ops); + + return buf; +} + +gpointer +mono_arch_get_nullified_class_init_trampoline (MonoTrampInfo **info) +{ + guint8 *buf, *code; + + code = buf = mono_global_codeman_reserve (16); + + code = emit_bx (code, ARMREG_LR); + + mono_arch_flush_icache (buf, code - buf); + + if (info) + *info = mono_tramp_info_create (g_strdup_printf ("nullified_class_init_trampoline"), buf, code - buf, NULL, NULL); + + return buf; } #define SPEC_TRAMP_SIZE 24 @@ -303,10 +378,10 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty tramp = mono_get_trampoline_code (tramp_type); mono_domain_lock (domain); - code = buf = mono_code_manager_reserve_align (domain->code_mp, size, 4); + code = buf = mono_domain_code_reserve_align (domain, size, 4); if ((short_branch = branch_for_target_reachable (code + 8, tramp))) { size = 12; - mono_code_manager_commit (domain->code_mp, code, SPEC_TRAMP_SIZE, size); + mono_domain_code_commit (domain, code, SPEC_TRAMP_SIZE, size); } mono_domain_unlock (domain); @@ -323,46 +398,337 @@ mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_ty * tramp-literal */ /* We save all the registers, except PC and SP */ - ARM_PUSH (buf, 0x5fff); + ARM_PUSH (code, 0x5fff); if (short_branch) { - constants = (gpointer*)buf; + constants = (gpointer*)code; constants [0] = GUINT_TO_POINTER (short_branch | (1 << 24)); constants [1] = arg1; - buf += 8; + code += 8; } else { - ARM_LDR_IMM (buf, ARMREG_R1, ARMREG_PC, 8); /* temp reg */ - ARM_MOV_REG_REG (buf, ARMREG_LR, ARMREG_PC); - ARM_MOV_REG_REG (buf, ARMREG_PC, ARMREG_R1); + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 8); /* temp reg */ + ARM_MOV_REG_REG (code, ARMREG_LR, ARMREG_PC); + code = emit_bx (code, ARMREG_R1); - constants = (gpointer*)buf; + constants = (gpointer*)code; constants [0] = arg1; constants [1] = tramp; - buf += 8; + code += 8; } /* Flush instruction cache, since we've generated code */ - mono_arch_flush_icache (code, buf - code); + mono_arch_flush_icache (buf, code - buf); - g_assert ((buf - code) <= size); + g_assert ((code - buf) <= size); if (code_len) - *code_len = buf - code; + *code_len = code - buf; - return code; + return buf; } +/* + * mono_arch_get_unbox_trampoline: + * @m: method pointer + * @addr: pointer to native code for @m + * + * when value type methods are called through the vtable we need to unbox the + * this argument. This method returns a pointer to a trampoline which does + * unboxing before calling the method + */ +gpointer +mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) +{ + guint8 *code, *start; + MonoDomain *domain = mono_domain_get (); + + start = code = mono_domain_code_reserve (domain, 16); + + ARM_LDR_IMM (code, ARMREG_IP, ARMREG_PC, 4); + ARM_ADD_REG_IMM8 (code, ARMREG_R0, ARMREG_R0, sizeof (MonoObject)); + code = emit_bx (code, ARMREG_IP); + *(guint32*)code = (guint32)addr; + code += 4; + mono_arch_flush_icache (start, code - start); + g_assert ((code - start) <= 16); + /*g_print ("unbox trampoline at %d for %s:%s\n", this_pos, m->klass->name, m->name); + g_print ("unbox code is at %p for method at %p\n", start, addr);*/ + + return start; +} + +gpointer +mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr) +{ + guint8 *code, *start; + int buf_len; + + MonoDomain *domain = mono_domain_get (); + + buf_len = 16; + + start = code = mono_domain_code_reserve (domain, buf_len); + + ARM_LDR_IMM (code, MONO_ARCH_RGCTX_REG, ARMREG_PC, 0); + ARM_LDR_IMM (code, ARMREG_PC, ARMREG_PC, 0); + *(guint32*)code = (guint32)mrgctx; + code += 4; + *(guint32*)code = (guint32)addr; + code += 4; + + g_assert ((code - start) <= buf_len); + + mono_arch_flush_icache (start, code - start); + + return start; +} + +gpointer +mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot) +{ + guint8 *tramp; + guint8 *code, *buf; + int tramp_size; + guint32 code_len; + guint8 **rgctx_null_jumps; + int depth, index; + int i, njumps; + gboolean mrgctx; + MonoJumpInfo *ji = NULL; + GSList *unwind_ops = NULL; + char *name; + + mrgctx = MONO_RGCTX_SLOT_IS_MRGCTX (slot); + index = MONO_RGCTX_SLOT_INDEX (slot); + if (mrgctx) + index += MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT / sizeof (gpointer); + for (depth = 0; ; ++depth) { + int size = mono_class_rgctx_get_array_size (depth, mrgctx); + + if (index < size - 1) + break; + index -= size - 1; + } + + tramp_size = 64 + 16 * depth; + + code = buf = mono_global_codeman_reserve (tramp_size); + + mono_add_unwind_op_def_cfa (unwind_ops, code, buf, ARMREG_SP, 0); + + rgctx_null_jumps = g_malloc (sizeof (guint8*) * (depth + 2)); + njumps = 0; + + /* The vtable/mrgctx is in R0 */ + g_assert (MONO_ARCH_VTABLE_REG == ARMREG_R0); + + if (mrgctx) { + /* get mrgctx ptr */ + ARM_MOV_REG_REG (code, ARMREG_R1, ARMREG_R0); + } else { + /* load rgctx ptr from vtable */ + g_assert (arm_is_imm12 (G_STRUCT_OFFSET (MonoVTable, runtime_generic_context))); + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R0, G_STRUCT_OFFSET (MonoVTable, runtime_generic_context)); + /* is the rgctx ptr null? */ + ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0); + /* if yes, jump to actual trampoline */ + rgctx_null_jumps [njumps ++] = code; + ARM_B_COND (code, ARMCOND_EQ, 0); + } + + for (i = 0; i < depth; ++i) { + /* load ptr to next array */ + if (mrgctx && i == 0) { + g_assert (arm_is_imm12 (MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT)); + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R1, MONO_SIZEOF_METHOD_RUNTIME_GENERIC_CONTEXT); + } else { + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_R1, 0); + } + /* is the ptr null? */ + ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0); + /* if yes, jump to actual trampoline */ + rgctx_null_jumps [njumps ++] = code; + ARM_B_COND (code, ARMCOND_EQ, 0); + } + + /* fetch slot */ + code = mono_arm_emit_load_imm (code, ARMREG_R2, sizeof (gpointer) * (index + 1)); + ARM_LDR_REG_REG (code, ARMREG_R1, ARMREG_R1, ARMREG_R2); + /* is the slot null? */ + ARM_CMP_REG_IMM (code, ARMREG_R1, 0, 0); + /* if yes, jump to actual trampoline */ + rgctx_null_jumps [njumps ++] = code; + ARM_B_COND (code, ARMCOND_EQ, 0); + /* otherwise return, result is in R1 */ + ARM_MOV_REG_REG (code, ARMREG_R0, ARMREG_R1); + code = emit_bx (code, ARMREG_LR); + + g_assert (njumps <= depth + 2); + for (i = 0; i < njumps; ++i) + arm_patch (rgctx_null_jumps [i], code); + + g_free (rgctx_null_jumps); + + /* Slowpath */ + + /* The vtable/mrgctx is still in R0 */ + + if (aot) { + ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, g_strdup_printf ("specific_trampoline_lazy_fetch_%u", slot)); + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); + ARM_B (code, 0); + *(gpointer*)code = NULL; + code += 4; + ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_R1); + } else { + tramp = mono_arch_create_specific_trampoline (GUINT_TO_POINTER (slot), MONO_TRAMPOLINE_RGCTX_LAZY_FETCH, mono_get_root_domain (), &code_len); + + /* Jump to the actual trampoline */ + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); /* temp reg */ + code = emit_bx (code, ARMREG_R1); + *(gpointer*)code = tramp; + code += 4; + } + + mono_arch_flush_icache (buf, code - buf); + + g_assert (code - buf <= tramp_size); + + if (info) + *info = mono_tramp_info_create (mono_get_rgctx_fetch_trampoline_name (slot), buf, code - buf, ji, unwind_ops); + + return buf; +} + +#define arm_is_imm8(v) ((v) > -256 && (v) < 256) + gpointer -mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 encoded_offset) +mono_arch_create_generic_class_init_trampoline (MonoTrampInfo **info, gboolean aot) +{ + guint8 *tramp; + guint8 *code, *buf; + static int byte_offset = -1; + static guint8 bitmask; + guint8 *jump; + int tramp_size; + guint32 code_len, imm8; + gint rot_amount; + GSList *unwind_ops = NULL; + MonoJumpInfo *ji = NULL; + + tramp_size = 64; + + code = buf = mono_global_codeman_reserve (tramp_size); + + if (byte_offset < 0) + mono_marshal_find_bitfield_offset (MonoVTable, initialized, &byte_offset, &bitmask); + + g_assert (arm_is_imm8 (byte_offset)); + ARM_LDRSB_IMM (code, ARMREG_IP, MONO_ARCH_VTABLE_REG, byte_offset); + imm8 = mono_arm_is_rotated_imm8 (bitmask, &rot_amount); + g_assert (imm8 >= 0); + ARM_AND_REG_IMM (code, ARMREG_IP, ARMREG_IP, imm8, rot_amount); + ARM_CMP_REG_IMM (code, ARMREG_IP, 0, 0); + jump = code; + ARM_B_COND (code, ARMCOND_EQ, 0); + + /* Initialized case */ + ARM_MOV_REG_REG (code, ARMREG_PC, ARMREG_LR); + + /* Uninitialized case */ + arm_patch (jump, code); + + if (aot) { + ji = mono_patch_info_list_prepend (ji, code - buf, MONO_PATCH_INFO_JIT_ICALL_ADDR, "specific_trampoline_generic_class_init"); + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); + ARM_B (code, 0); + *(gpointer*)code = NULL; + code += 4; + ARM_LDR_REG_REG (code, ARMREG_PC, ARMREG_PC, ARMREG_R1); + } else { + tramp = mono_arch_create_specific_trampoline (NULL, MONO_TRAMPOLINE_GENERIC_CLASS_INIT, mono_get_root_domain (), &code_len); + + /* Jump to the actual trampoline */ + ARM_LDR_IMM (code, ARMREG_R1, ARMREG_PC, 0); /* temp reg */ + code = emit_bx (code, ARMREG_R1); + *(gpointer*)code = tramp; + code += 4; + } + + mono_arch_flush_icache (buf, code - buf); + + g_assert (code - buf <= tramp_size); + + if (info) + *info = mono_tramp_info_create (g_strdup_printf ("generic_class_init_trampoline"), buf, code - buf, ji, unwind_ops); + + return buf; +} + +#else + +guchar* +mono_arch_create_generic_trampoline (MonoTrampolineType tramp_type, MonoTrampInfo **info, gboolean aot) { - /* FIXME: implement! */ g_assert_not_reached (); return NULL; } -guint32 -mono_arch_get_rgctx_lazy_fetch_offset (gpointer *regs) +gpointer +mono_arch_create_specific_trampoline (gpointer arg1, MonoTrampolineType tramp_type, MonoDomain *domain, guint32 *code_len) { - /* FIXME: implement! */ g_assert_not_reached (); - return 0; + return NULL; +} + +gpointer +mono_arch_get_unbox_trampoline (MonoMethod *m, gpointer addr) +{ + g_assert_not_reached (); + return NULL; +} + +gpointer +mono_arch_get_static_rgctx_trampoline (MonoMethod *m, MonoMethodRuntimeGenericContext *mrgctx, gpointer addr) +{ + g_assert_not_reached (); + return NULL; +} + +gpointer +mono_arch_create_rgctx_lazy_fetch_trampoline (guint32 slot, MonoTrampInfo **info, gboolean aot) +{ + g_assert_not_reached (); + return NULL; +} + +gpointer +mono_arch_create_generic_class_init_trampoline (MonoTrampInfo **info, gboolean aot) +{ + g_assert_not_reached (); + return NULL; +} + +#endif /* DISABLE_JIT */ + +guint8* +mono_arch_get_call_target (guint8 *code) +{ + guint32 ins = ((guint32*)(gpointer)code) [-1]; + + /* Should be a 'bl' */ + if ((((ins >> 25) & 0x7) == 0x5) && (((ins >> 24) & 0x1) == 0x1)) { + gint32 disp = ((gint32)ins) & 0xffffff; + guint8 *target = code - 4 + 8 + (disp * 4); + + return target; + } else { + return NULL; + } +} + +guint32 +mono_arch_get_plt_info_offset (guint8 *plt_entry, mgreg_t *regs, guint8 *code) +{ + /* The offset is stored as the 4th word of the plt entry */ + return ((guint32*)plt_entry) [3]; }