X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;ds=sidebyside;f=mono%2Fmini%2Fmini-x86.c;h=4809ae935bd8d98854070c2abf7c463bea840056;hb=4ffdf1cd94dbe94b46977db1c954a92d9351c141;hp=936d1e55a45ebd901f8c0af3675a6c8ece519d22;hpb=4d84028bd8d48b06a1858854715145e44378e6bd;p=mono.git diff --git a/mono/mini/mini-x86.c b/mono/mini/mini-x86.c index 936d1e55a45..4809ae935bd 100644 --- a/mono/mini/mini-x86.c +++ b/mono/mini/mini-x86.c @@ -74,8 +74,6 @@ mono_breakpoint_info [MONO_BREAKPOINT_ARRAY_SIZE]; #ifdef __native_client_codegen__ -const guint kNaClAlignment = kNaClAlignmentX86; -const guint kNaClAlignmentMask = kNaClAlignmentMaskX86; /* Default alignment for Native Client is 32-byte. */ gint8 nacl_align_byte = -32; /* signed version of 0xe0 */ @@ -204,6 +202,8 @@ typedef struct { gint16 offset; gint8 reg; ArgStorage storage; + int nslots; + gboolean is_pair; /* Only if storage == ArgValuetypeInReg */ ArgStorage pair_storage [2]; @@ -220,6 +220,7 @@ typedef struct { gboolean vtype_retaddr; /* The index of the vret arg in the argument list */ int vret_arg_index; + int vret_arg_offset; ArgInfo ret; ArgInfo sig_cookie; ArgInfo args [1]; @@ -261,6 +262,7 @@ add_general_pair (guint32 *gr, guint32 *stack_size, ArgInfo *ainfo) ainfo->storage = ArgOnStack; (*stack_size) += sizeof (gpointer) * 2; + ainfo->nslots = 2; } static void inline @@ -271,6 +273,7 @@ add_float (guint32 *gr, guint32 *stack_size, ArgInfo *ainfo, gboolean is_double) if (*gr >= FLOAT_PARAM_REGS) { ainfo->storage = ArgOnStack; (*stack_size) += is_double ? 8 : 4; + ainfo->nslots = is_double ? 2 : 1; } else { /* A double register */ @@ -335,6 +338,7 @@ add_valuetype (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig, ArgIn ainfo->offset = *stack_size; ainfo->storage = ArgOnStack; *stack_size += ALIGN_TO (size, sizeof (gpointer)); + ainfo->nslots = ALIGN_TO (size, sizeof (gpointer)) / sizeof (gpointer); } /* @@ -357,6 +361,7 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM gr = 0; fr = 0; + cinfo->nargs = n; /* return value */ { @@ -386,6 +391,7 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM case MONO_TYPE_I8: cinfo->ret.storage = ArgInIReg; cinfo->ret.reg = X86_EAX; + cinfo->ret.is_pair = TRUE; break; case MONO_TYPE_R4: cinfo->ret.storage = ArgOnFloatFpStack; @@ -400,7 +406,8 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM break; } /* Fall through */ - case MONO_TYPE_VALUETYPE: { + case MONO_TYPE_VALUETYPE: + case MONO_TYPE_TYPEDBYREF: { guint32 tmp_gr = 0, tmp_fr = 0, tmp_stacksize = 0; add_valuetype (gsctx, sig, &cinfo->ret, sig->ret, TRUE, &tmp_gr, &tmp_fr, &tmp_stacksize); @@ -410,10 +417,6 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM } break; } - case MONO_TYPE_TYPEDBYREF: - /* Same as a valuetype with size 12 */ - cinfo->vtype_retaddr = TRUE; - break; case MONO_TYPE_VOID: cinfo->ret.storage = ArgNone; break; @@ -437,6 +440,7 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM add_general (&gr, &stack_size, &cinfo->args [sig->hasthis + 0]); pstart = 1; } + cinfo->vret_arg_offset = stack_size; add_general (&gr, &stack_size, &cinfo->ret); cinfo->vret_arg_index = 1; } else { @@ -511,11 +515,8 @@ get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoM } /* Fall through */ case MONO_TYPE_VALUETYPE: - add_valuetype (gsctx, sig, ainfo, sig->params [i], FALSE, &gr, &fr, &stack_size); - break; case MONO_TYPE_TYPEDBYREF: - stack_size += sizeof (MonoTypedRef); - ainfo->storage = ArgOnStack; + add_valuetype (gsctx, sig, ainfo, ptype, FALSE, &gr, &fr, &stack_size); break; case MONO_TYPE_U8: case MONO_TYPE_I8: @@ -582,7 +583,7 @@ get_call_info (MonoGenericSharingContext *gsctx, MonoMemPool *mp, MonoMethodSign * FIXME: The metadata calls might not be signal safe. */ int -mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info) +mono_arch_get_argument_info (MonoGenericSharingContext *gsctx, MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info) { int len, k, args_size = 0; int size, pad; @@ -595,7 +596,7 @@ mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJit cinfo = (CallInfo*)g_newa (guint8*, len); memset (cinfo, 0, len); - cinfo = get_call_info_internal (NULL, cinfo, csig); + cinfo = get_call_info_internal (gsctx, cinfo, csig); arg_info [0].offset = offset; @@ -668,6 +669,7 @@ mono_x86_tail_call_supported (MonoMethodSignature *caller_sig, MonoMethodSignatu return res; } +#if !defined(__native_client__) static const guchar cpuid_impl [] = { 0x55, /* push %ebp */ 0x89, 0xe5, /* mov %esp,%ebp */ @@ -688,6 +690,33 @@ static const guchar cpuid_impl [] = { 0xc9, /* leave */ 0xc3, /* ret */ }; +#else +static const guchar cpuid_impl [] = { + 0x55, /* push %ebp */ + 0x89, 0xe5, /* mov %esp,%ebp */ + 0x53, /* push %ebx */ + 0x8b, 0x45, 0x08, /* mov 0x8(%ebp),%eax */ + 0x0f, 0xa2, /* cpuid */ + 0x50, /* push %eax */ + 0x8b, 0x45, 0x10, /* mov 0x10(%ebp),%eax */ + 0x89, 0x18, /* mov %ebx,(%eax) */ + 0x8b, 0x45, 0x14, /* mov 0x14(%ebp),%eax */ + 0x89, 0x08, /* mov %ecx,(%eax) */ + 0x8b, 0x45, 0x18, /* mov 0x18(%ebp),%eax */ + 0x89, 0x10, /* mov %edx,(%eax) */ + 0x58, /* pop %eax */ + 0x8b, 0x55, 0x0c, /* mov 0xc(%ebp),%edx */ + 0x89, 0x02, /* mov %eax,(%edx) */ + 0x5b, /* pop %ebx */ + 0xc9, /* leave */ + 0x59, 0x83, 0xe1, 0xe0, 0xff, 0xe1, /* naclret */ + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, /* padding, to provide bundle aligned version */ + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, 0xf4, + 0xf4 +}; +#endif typedef void (*CpuidFunc) (int id, int* p_eax, int* p_ebx, int* p_ecx, int* p_edx); @@ -695,12 +724,16 @@ static int cpuid (int id, int* p_eax, int* p_ebx, int* p_ecx, int* p_edx) { #if defined(__native_client__) - /* Taken from below, the bug listed in the comment is */ - /* only valid for non-static cases. */ - __asm__ __volatile__ ("cpuid" - : "=a" (*p_eax), "=b" (*p_ebx), "=c" (*p_ecx), "=d" (*p_edx) - : "a" (id)); - return 1; + static CpuidFunc func = NULL; + void *ptr, *end_ptr; + if (!func) { + ptr = mono_global_codeman_reserve (sizeof (cpuid_impl)); + memcpy(ptr, cpuid_impl, sizeof(cpuid_impl)); + end_ptr = ptr + sizeof(cpuid_impl); + nacl_global_codeman_validate (&ptr, sizeof(cpuid_impl), &end_ptr); + func = (CpuidFunc)ptr; + } + func (id, p_eax, p_ebx, p_ecx, p_edx); #else int have_cpuid = 0; #ifndef _MSC_VER @@ -793,6 +826,9 @@ mono_arch_init (void) mono_aot_register_jit_icall ("mono_x86_throw_exception", mono_x86_throw_exception); mono_aot_register_jit_icall ("mono_x86_throw_corlib_exception", mono_x86_throw_corlib_exception); +#if defined(MONOTOUCH) || defined(MONO_EXTENSIONS) + mono_aot_register_jit_icall ("mono_x86_start_gsharedvt_call", mono_x86_start_gsharedvt_call); +#endif } /* @@ -1183,7 +1219,7 @@ mono_arch_allocate_vars (MonoCompile *cfg) switch (cinfo->ret.storage) { case ArgOnStack: - if (MONO_TYPE_ISSTRUCT (sig->ret)) { + if (cfg->vret_addr) { /* * In the new IR, the cfg->vret_addr variable represents the * vtype return value. @@ -1246,7 +1282,7 @@ mono_arch_create_vars (MonoCompile *cfg) if (cinfo->ret.storage == ArgValuetypeInReg) cfg->ret_var_is_local = TRUE; - if ((cinfo->ret.storage != ArgValuetypeInReg) && MONO_TYPE_ISSTRUCT (sig->ret)) { + if ((cinfo->ret.storage != ArgValuetypeInReg) && (MONO_TYPE_ISSTRUCT (sig->ret) || mini_is_gsharedvt_variable_type (cfg, sig->ret))) { cfg->vret_addr = mono_compile_create_var (cfg, &mono_defaults.int_class->byval_arg, OP_ARG); } @@ -1344,13 +1380,13 @@ mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) */ } - if (MONO_TYPE_ISSTRUCT (sig->ret) && cinfo->ret.storage == ArgInIReg) { + if (mini_type_is_vtype (cfg, sig->ret) && cinfo->ret.storage == ArgInIReg) { /* Vtype returned using a hidden argument */ linfo->ret.storage = LLVMArgVtypeRetAddr; linfo->vret_arg_index = cinfo->vret_arg_index; } - if (MONO_TYPE_ISSTRUCT (sig->ret) && cinfo->ret.storage != ArgInIReg) { + if (mini_type_is_vtype (cfg, sig->ret) && cinfo->ret.storage != ArgInIReg) { // FIXME: cfg->exception_message = g_strdup ("vtype ret in call"); cfg->disable_llvm = TRUE; @@ -1375,7 +1411,7 @@ mono_arch_get_llvm_call_info (MonoCompile *cfg, MonoMethodSignature *sig) linfo->args [i].storage = LLVMArgInFPReg; break; case ArgOnStack: - if (MONO_TYPE_ISSTRUCT (t)) { + if (mini_type_is_vtype (cfg, t)) { if (mono_class_value_size (mono_class_from_mono_type (t), NULL) == 0) /* LLVM seems to allocate argument space for empty structures too */ linfo->args [i].storage = LLVMArgNone; @@ -1485,7 +1521,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) /* Arguments are pushed in the reverse order */ for (i = n - 1; i >= 0; i --) { ArgInfo *ainfo = cinfo->args + i; - MonoType *t; + MonoType *orig_type, *t; int argsize; if (cinfo->vtype_retaddr && cinfo->vret_arg_index == 1 && i == 0) { @@ -1503,6 +1539,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) t = sig->params [i - sig->hasthis]; else t = &mono_defaults.int_class->byval_arg; + orig_type = t; t = mini_type_get_underlying_type (cfg->generic_sharing_context, t); MONO_INST_NEW (cfg, arg, OP_X86_PUSH); @@ -1536,7 +1573,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) MONO_ADD_INS (cfg->cbb, arg); sp_offset += size; - emit_gc_param_slot_def (cfg, sp_offset, t); + emit_gc_param_slot_def (cfg, sp_offset, orig_type); } } else { argsize = 4; @@ -1575,11 +1612,16 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) if (cfg->compute_gc_maps) { if (argsize == 4) { /* FIXME: The == STACK_OBJ check might be fragile ? */ - if (sig->hasthis && i == 0 && call->args [i]->type == STACK_OBJ) + if (sig->hasthis && i == 0 && call->args [i]->type == STACK_OBJ) { /* this */ - emit_gc_param_slot_def (cfg, sp_offset, &mono_defaults.object_class->byval_arg); - else - emit_gc_param_slot_def (cfg, sp_offset, t); + if (call->need_unbox_trampoline) + /* The unbox trampoline transforms this into a managed pointer */ + emit_gc_param_slot_def (cfg, sp_offset, &mono_defaults.int_class->this_arg); + else + emit_gc_param_slot_def (cfg, sp_offset, &mono_defaults.object_class->byval_arg); + } else { + emit_gc_param_slot_def (cfg, sp_offset, orig_type); + } } else { /* i8/r8 */ for (j = 0; j < argsize; j += 4) @@ -1596,7 +1638,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) } } - if (sig->ret && MONO_TYPE_ISSTRUCT (sig->ret)) { + if (sig->ret && (MONO_TYPE_ISSTRUCT (sig->ret) || cinfo->vtype_retaddr)) { MonoInst *vtarg; if (cinfo->ret.storage == ArgValuetypeInReg) { @@ -1627,6 +1669,7 @@ mono_arch_emit_call (MonoCompile *cfg, MonoCallInst *call) } call->stack_usage = cinfo->stack_usage; + call->stack_align_amount = cinfo->stack_align_amount; cfg->arch.param_area_size = MAX (cfg->arch.param_area_size, sp_offset); } @@ -1879,14 +1922,12 @@ emit_call (MonoCompile *cfg, guint8 *code, guint32 patch_type, gconstpointer dat { gboolean needs_paddings = TRUE; guint32 pad_size; + MonoJumpInfo *jinfo = NULL; - if (cfg->abs_patches && g_hash_table_lookup (cfg->abs_patches, data)) { - } else { - MonoJitICallInfo *info = mono_find_jit_icall_by_addr (data); - if (info) { - if ((cfg->method->wrapper_type == MONO_WRAPPER_MANAGED_TO_NATIVE) && strstr (cfg->method->name, info->name)) - needs_paddings = FALSE; /* A call to the wrapped function */ - } + if (cfg->abs_patches) { + jinfo = g_hash_table_lookup (cfg->abs_patches, data); + if (jinfo && jinfo->type == MONO_PATCH_INFO_JIT_ICALL_ADDR) + needs_paddings = FALSE; } if (cfg->compile_aot) @@ -2439,17 +2480,6 @@ x86_pop_reg (code, X86_EAX); #define bb_is_loop_start(bb) ((bb)->loop_body_start && (bb)->nesting) #ifndef DISABLE_JIT - -#if defined(__native_client__) || defined(__native_client_codegen__) -void -mono_nacl_gc() -{ -#ifdef __native_client_gc__ - __nacl_suspend_thread_if_needed(); -#endif -} -#endif - void mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) { @@ -2783,6 +2813,10 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; case OP_IDIV: case OP_IREM: +#if defined( __native_client_codegen__ ) + x86_alu_reg_imm (code, X86_CMP, ins->sreg2, 0); + EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, TRUE, "DivideByZeroException"); +#endif /* * The code is the same for div/rem, the allocator will allocate dreg * to RAX/RDX as appropriate. @@ -2800,6 +2834,10 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; case OP_IDIV_UN: case OP_IREM_UN: +#if defined( __native_client_codegen__ ) + x86_alu_reg_imm (code, X86_CMP, ins->sreg2, 0); + EMIT_COND_SYSTEM_EXCEPTION (X86_CC_EQ, TRUE, "DivideByZeroException"); +#endif if (ins->sreg2 == X86_EDX) { x86_push_reg (code, ins->sreg2); x86_alu_reg_reg (code, X86_XOR, X86_EDX, X86_EDX); @@ -2811,6 +2849,13 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } break; case OP_DIV_IMM: +#if defined( __native_client_codegen__ ) + if (ins->inst_imm == 0) { + mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_EXC, "DivideByZeroException"); + x86_jump32 (code, 0); + break; + } +#endif x86_mov_reg_imm (code, ins->sreg2, ins->inst_imm); x86_cdq (code); x86_div_reg (code, ins->sreg2, TRUE); @@ -3151,6 +3196,9 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) MonoCallInst *call = (MonoCallInst*)ins; int pos = 0, i; + ins->flags |= MONO_INST_GC_CALLSITE; + ins->backend.pc_offset = code - cfg->native_code; + /* FIXME: no tracing support... */ if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE) code = mono_arch_instrument_epilog (cfg, mono_profiler_method_leave, code, FALSE); @@ -3179,7 +3227,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) } /* Copy arguments on the stack to our argument area */ - for (i = 0; i < call->stack_usage; i += 4) { + for (i = 0; i < call->stack_usage - call->stack_align_amount; i += 4) { x86_mov_reg_membase (code, X86_EAX, X86_ESP, i, 4); x86_mov_membase_reg (code, X86_EBP, 8 + i, X86_EAX, 4); } @@ -3630,7 +3678,15 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) br = code; x86_branch8 (code, X86_CC_GEZ, 0, TRUE); /* add correction constant mn */ - x86_fld80_mem (code, mn); + if (cfg->compile_aot) { + x86_push_imm (code, (((guint32)mn [9]) << 24) | ((guint32)mn [8] << 16) | ((guint32)mn [7] << 8) | ((guint32)mn [6])); + x86_push_imm (code, (((guint32)mn [5]) << 24) | ((guint32)mn [4] << 16) | ((guint32)mn [3] << 8) | ((guint32)mn [2])); + x86_push_imm (code, (((guint32)mn [1]) << 24) | ((guint32)mn [0] << 16)); + x86_fld80_membase (code, X86_ESP, 2); + x86_alu_reg_imm (code, X86_ADD, X86_ESP, 12); + } else { + x86_fld80_mem (code, mn); + } x86_fp_op_reg (code, X86_FADD, 1, TRUE); x86_patch (br, code); @@ -3810,8 +3866,9 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) x86_fprem (code); x86_fnstsw (code); x86_alu_reg_imm (code, X86_AND, X86_EAX, X86_FP_C2); - l2 = code + 2; - x86_branch8 (code, X86_CC_NE, l1 - l2, FALSE); + l2 = code; + x86_branch8 (code, X86_CC_NE, 0, FALSE); + x86_patch (l2, l1); /* pop result */ x86_fstp (code, 1); @@ -4235,6 +4292,7 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) size_t nursery_size; gulong card_table = (gulong)mono_gc_get_card_table (&card_table_shift, &card_table_mask); gulong nursery_start = (gulong)mono_gc_get_nursery (&nursery_shift, &nursery_size); + gboolean card_table_nursery_check = mono_gc_card_table_nursery_check (); /* * We need one register we can clobber, we choose EDX and make sreg1 @@ -4257,17 +4315,20 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) * done: */ - if (value != X86_EDX) - x86_mov_reg_reg (code, X86_EDX, value, 4); - x86_shift_reg_imm (code, X86_SHR, X86_EDX, nursery_shift); - x86_alu_reg_imm (code, X86_CMP, X86_EDX, nursery_start >> nursery_shift); - br = code; x86_branch8 (code, X86_CC_NE, -1, FALSE); + if (card_table_nursery_check) { + if (value != X86_EDX) + x86_mov_reg_reg (code, X86_EDX, value, 4); + x86_shift_reg_imm (code, X86_SHR, X86_EDX, nursery_shift); + x86_alu_reg_imm (code, X86_CMP, X86_EDX, nursery_start >> nursery_shift); + br = code; x86_branch8 (code, X86_CC_NE, -1, FALSE); + } x86_mov_reg_reg (code, X86_EDX, ptr, 4); x86_shift_reg_imm (code, X86_SHR, X86_EDX, card_table_shift); if (card_table_mask) x86_alu_reg_imm (code, X86_AND, X86_EDX, (int)card_table_mask); x86_mov_membase_imm (code, X86_EDX, card_table, 1, 1); - x86_patch (br, code); + if (card_table_nursery_check) + x86_patch (br, code); break; } #ifdef MONO_ARCH_SIMD_INTRINSICS @@ -4860,8 +4921,17 @@ mono_arch_output_basic_block (MonoCompile *cfg, MonoBasicBlock *bb) break; } case OP_NACL_GC_SAFE_POINT: { -#if defined(__native_client_codegen__) - code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)mono_nacl_gc); +#if defined(__native_client_codegen__) && defined(__native_client_gc__) + if (cfg->compile_aot) + code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)mono_nacl_gc); + else { + guint8 *br [1]; + + x86_test_mem_imm8 (code, (gpointer)&__nacl_thread_suspension_needed, 0xFFFFFFFF); + br[0] = code; x86_branch8 (code, X86_CC_EQ, 0, FALSE); + code = emit_call (cfg, code, MONO_PATCH_INFO_ABS, (gpointer)mono_nacl_gc); + x86_patch (br[0], code); + } #endif break; } @@ -4944,6 +5014,7 @@ mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, Mono case MONO_PATCH_INFO_GENERIC_CLASS_INIT: case MONO_PATCH_INFO_MONITOR_ENTER: case MONO_PATCH_INFO_MONITOR_EXIT: + case MONO_PATCH_INFO_JIT_ICALL_ADDR: #if defined(__native_client_codegen__) && defined(__native_client__) if (nacl_is_code_address (code)) { /* For tail calls, code is patched after being installed */ @@ -4990,6 +5061,13 @@ mono_arch_patch_code (MonoMethod *method, MonoDomain *domain, guint8 *code, Mono } } +static G_GNUC_UNUSED void +stack_unaligned (MonoMethod *m, gpointer caller) +{ + printf ("%s\n", mono_method_full_name (m, TRUE)); + g_assert_not_reached (); +} + guint8 * mono_arch_emit_prolog (MonoCompile *cfg) { @@ -5013,6 +5091,7 @@ mono_arch_emit_prolog (MonoCompile *cfg) code = cfg->native_code = g_malloc (cfg->code_size); #elif defined(__native_client_codegen__) /* native_code_alloc is not 32-byte aligned, native_code is. */ + cfg->code_size = NACL_BUNDLE_ALIGN_UP (cfg->code_size); cfg->native_code_alloc = g_malloc (cfg->code_size + kNaClAlignment); /* Align native_code to next nearest kNaclAlignment byte. */ @@ -5025,6 +5104,24 @@ mono_arch_emit_prolog (MonoCompile *cfg) g_assert(alignment_check == 0); #endif +#if 0 + { + guint8 *br [16]; + + /* Check that the stack is aligned on osx */ + x86_mov_reg_reg (code, X86_EAX, X86_ESP, sizeof (mgreg_t)); + x86_alu_reg_imm (code, X86_AND, X86_EAX, 15); + x86_alu_reg_imm (code, X86_CMP, X86_EAX, 0xc); + br [0] = code; + x86_branch_disp (code, X86_CC_Z, 0, FALSE); + x86_push_membase (code, X86_ESP, 0); + x86_push_imm (code, cfg->method); + x86_mov_reg_imm (code, X86_EAX, stack_unaligned); + x86_call_reg (code, X86_EAX); + x86_patch (br [0], code); + } +#endif + /* Offset between RSP and the CFA */ cfa_offset = 0; @@ -5238,19 +5335,38 @@ mono_arch_emit_prolog (MonoCompile *cfg) max_offset += LOOP_ALIGNMENT; #ifdef __native_client_codegen__ /* max alignment for native client */ - max_offset += kNaClAlignment; + if (bb->flags & BB_INDIRECT_JUMP_TARGET || bb->flags & BB_EXCEPTION_HANDLER) + max_offset += kNaClAlignment; #endif MONO_BB_FOR_EACH_INS (bb, ins) { if (ins->opcode == OP_LABEL) ins->inst_c1 = max_offset; #ifdef __native_client_codegen__ + switch (ins->opcode) { - int space_in_block = kNaClAlignment - - ((max_offset + cfg->code_len) & kNaClAlignmentMask); - int max_len = ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN]; - if (space_in_block < max_len && max_len < kNaClAlignment) { - max_offset += space_in_block; - } + case OP_FCALL: + case OP_LCALL: + case OP_VCALL: + case OP_VCALL2: + case OP_VOIDCALL: + case OP_CALL: + case OP_FCALL_REG: + case OP_LCALL_REG: + case OP_VCALL_REG: + case OP_VCALL2_REG: + case OP_VOIDCALL_REG: + case OP_CALL_REG: + case OP_FCALL_MEMBASE: + case OP_LCALL_MEMBASE: + case OP_VCALL_MEMBASE: + case OP_VCALL2_MEMBASE: + case OP_VOIDCALL_MEMBASE: + case OP_CALL_MEMBASE: + max_offset += kNaClAlignment; + break; + default: + max_offset += ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN] - 1; + break; } #endif /* __native_client_codegen__ */ max_offset += ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN]; @@ -5441,8 +5557,8 @@ mono_arch_emit_epilog (MonoCompile *cfg) if (CALLCONV_IS_STDCALL (sig)) { MonoJitArgumentInfo *arg_info = alloca (sizeof (MonoJitArgumentInfo) * (sig->param_count + 1)); - stack_to_pop = mono_arch_get_argument_info (sig, sig->param_count, arg_info); - } else if (MONO_TYPE_ISSTRUCT (mono_method_signature (cfg->method)->ret) && (cinfo->ret.storage == ArgOnStack)) + stack_to_pop = mono_arch_get_argument_info (NULL, sig, sig->param_count, arg_info); + } else if (cinfo->vtype_retaddr) stack_to_pop = 4; else stack_to_pop = 0; @@ -5689,6 +5805,7 @@ mono_arch_build_imt_thunk (MonoVTable *vtable, MonoDomain *domain, MonoIMTCheckI #if defined(__native_client__) && defined(__native_client_codegen__) /* In Native Client, we don't re-use thunks, allocate from the */ /* normal code manager paths. */ + size = NACL_BUNDLE_ALIGN_UP (size); code = mono_domain_code_reserve (domain, size); #else if (fail_tramp) @@ -5899,9 +6016,9 @@ mono_arch_get_patch_offset (guint8 *code) { if ((code [0] == 0x8b) && (x86_modrm_mod (code [1]) == 0x2)) return 2; - else if ((code [0] == 0xba)) + else if (code [0] == 0xba) return 1; - else if ((code [0] == 0x68)) + else if (code [0] == 0x68) /* push IMM */ return 1; else if ((code [0] == 0xff) && (x86_modrm_reg (code [1]) == 0x6)) @@ -6641,3 +6758,8 @@ mono_arch_get_seq_point_info (MonoDomain *domain, guint8 *code) #endif +#if defined(MONOTOUCH) || defined(MONO_EXTENSIONS) + +#include "../../../mono-extensions/mono/mini/mini-x86-gsharedvt.c" + +#endif /* !MONOTOUCH */