#include <mono/metadata/threads.h>
#include <mono/metadata/profiler-private.h>
#include <mono/metadata/mono-debug.h>
+#include <mono/metadata/gc-internal.h>
#include <mono/utils/mono-math.h>
#include <mono/utils/mono-counters.h>
#include <mono/utils/mono-mmap.h>
MonoBreakpointInfo
mono_breakpoint_info [MONO_BREAKPOINT_ARRAY_SIZE];
+static gpointer
+mono_realloc_native_code (MonoCompile *cfg)
+{
+#ifdef __native_client_codegen__
+ guint old_padding;
+ gpointer native_code;
+ guint alignment_check;
+
+ /* Save the old alignment offset so we can re-align after the realloc. */
+ old_padding = (guint)(cfg->native_code - cfg->native_code_alloc);
+
+ cfg->native_code_alloc = g_realloc (cfg->native_code_alloc,
+ cfg->code_size + kNaClAlignment);
+
+ /* Align native_code to next nearest kNaClAlignment byte. */
+ native_code = (guint)cfg->native_code_alloc + kNaClAlignment;
+ native_code = (guint)native_code & ~kNaClAlignmentMask;
+
+ /* Shift the data to be 32-byte aligned again. */
+ memmove (native_code, cfg->native_code_alloc + old_padding, cfg->code_size);
+
+ alignment_check = (guint)native_code & kNaClAlignmentMask;
+ g_assert (alignment_check == 0);
+ return native_code;
+#else
+ return g_realloc (cfg->native_code, cfg->code_size);
+#endif
+}
+
+#ifdef __native_client_codegen__
+
+/* mono_arch_nacl_pad: Add pad bytes of alignment instructions at code, */
+/* Check that alignment doesn't cross an alignment boundary. */
+guint8 *
+mono_arch_nacl_pad (guint8 *code, int pad)
+{
+ const int kMaxPadding = 7; /* see x86-codegen.h: x86_padding() */
+
+ if (pad == 0) return code;
+ /* assertion: alignment cannot cross a block boundary */
+ g_assert(((uintptr_t)code & (~kNaClAlignmentMask)) ==
+ (((uintptr_t)code + pad - 1) & (~kNaClAlignmentMask)));
+ while (pad >= kMaxPadding) {
+ x86_padding (code, kMaxPadding);
+ pad -= kMaxPadding;
+ }
+ if (pad != 0) x86_padding (code, pad);
+ return code;
+}
+
+guint8 *
+mono_arch_nacl_skip_nops (guint8 *code)
+{
+ x86_skip_nops (code);
+ return code;
+}
+
+#endif /* __native_client_codegen__ */
+
/*
* The code generated for sequence points reads from this location, which is
* made read-only when single stepping is enabled.
}
}
+void
+mono_x86_patch (unsigned char* code, gpointer target)
+{
+ x86_patch (code, (unsigned char*)target);
+}
typedef enum {
ArgInIReg,
guint32 freg_usage;
gboolean need_stack_align;
guint32 stack_align_amount;
+ gboolean vtype_retaddr;
+ /* The index of the vret arg in the argument list */
+ int vret_arg_index;
ArgInfo ret;
ArgInfo sig_cookie;
ArgInfo args [1];
static CallInfo*
get_call_info_internal (MonoGenericSharingContext *gsctx, CallInfo *cinfo, MonoMethodSignature *sig, gboolean is_pinvoke)
{
- guint32 i, gr, fr;
+ guint32 i, gr, fr, pstart;
MonoType *ret_type;
int n = sig->hasthis + sig->param_count;
guint32 stack_size = 0;
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);
- if (cinfo->ret.storage == ArgOnStack)
+ if (cinfo->ret.storage == ArgOnStack) {
+ cinfo->vtype_retaddr = TRUE;
/* The caller passes the address where the value is stored */
- add_general (&gr, &stack_size, &cinfo->ret);
+ }
break;
}
case MONO_TYPE_TYPEDBYREF:
- /* Same as a valuetype with size 24 */
- add_general (&gr, &stack_size, &cinfo->ret);
- ;
+ /* Same as a valuetype with size 12 */
+ cinfo->vtype_retaddr = TRUE;
break;
case MONO_TYPE_VOID:
cinfo->ret.storage = ArgNone;
}
}
- /* this */
- if (sig->hasthis)
- add_general (&gr, &stack_size, cinfo->args + 0);
+ pstart = 0;
+ /*
+ * To simplify get_this_arg_reg () and LLVM integration, emit the vret arg after
+ * the first argument, allowing 'this' to be always passed in the first arg reg.
+ * Also do this if the first argument is a reference type, since virtual calls
+ * are sometimes made using calli without sig->hasthis set, like in the delegate
+ * invoke wrappers.
+ */
+ if (cinfo->vtype_retaddr && !is_pinvoke && (sig->hasthis || (sig->param_count > 0 && MONO_TYPE_IS_REFERENCE (mini_type_get_underlying_type (gsctx, sig->params [0]))))) {
+ if (sig->hasthis) {
+ add_general (&gr, &stack_size, cinfo->args + 0);
+ } else {
+ add_general (&gr, &stack_size, &cinfo->args [sig->hasthis + 0]);
+ pstart = 1;
+ }
+ add_general (&gr, &stack_size, &cinfo->ret);
+ cinfo->vret_arg_index = 1;
+ } else {
+ /* this */
+ if (sig->hasthis)
+ add_general (&gr, &stack_size, cinfo->args + 0);
+
+ if (cinfo->vtype_retaddr)
+ add_general (&gr, &stack_size, &cinfo->ret);
+ }
if (!sig->pinvoke && (sig->call_convention == MONO_CALL_VARARG) && (n == 0)) {
gr = PARAM_REGS;
add_general (&gr, &stack_size, &cinfo->sig_cookie);
}
- for (i = 0; i < sig->param_count; ++i) {
+ for (i = pstart; i < sig->param_count; ++i) {
ArgInfo *ainfo = &cinfo->args [sig->hasthis + i];
MonoType *ptype;
int
mono_arch_get_argument_info (MonoMethodSignature *csig, int param_count, MonoJitArgumentInfo *arg_info)
{
- int k, args_size = 0;
+ int len, k, args_size = 0;
int size, pad;
guint32 align;
int offset = 8;
CallInfo *cinfo;
/* Avoid g_malloc as it is not signal safe */
- cinfo = (CallInfo*)g_newa (guint8*, sizeof (CallInfo) + (sizeof (ArgInfo) * (csig->param_count + 1)));
+ len = sizeof (CallInfo) + (sizeof (ArgInfo) * (csig->param_count + 1));
+ cinfo = (CallInfo*)g_newa (guint8*, len);
+ memset (cinfo, 0, len);
cinfo = get_call_info_internal (NULL, cinfo, csig, FALSE);
- if (MONO_TYPE_ISSTRUCT (csig->ret) && (cinfo->ret.storage == ArgOnStack)) {
+ arg_info [0].offset = offset;
+
+ if (csig->hasthis) {
args_size += sizeof (gpointer);
offset += 4;
}
- arg_info [0].offset = offset;
-
- if (csig->hasthis) {
+ if (MONO_TYPE_ISSTRUCT (csig->ret) && (cinfo->ret.storage == ArgOnStack)) {
args_size += sizeof (gpointer);
offset += 4;
}
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;
+#else
int have_cpuid = 0;
#ifndef _MSC_VER
__asm__ __volatile__ (
return 1;
}
return 0;
+#endif
}
/*
ss_trigger_page = mono_valloc (NULL, mono_pagesize (), MONO_MMAP_READ);
bp_trigger_page = mono_valloc (NULL, mono_pagesize (), MONO_MMAP_READ|MONO_MMAP_32BIT);
mono_mprotect (bp_trigger_page, mono_pagesize (), 0);
+
+ 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);
}
/*
guint32
mono_arch_cpu_optimizazions (guint32 *exclude_mask)
{
+#if !defined(__native_client__)
int eax, ebx, ecx, edx;
guint32 opts = 0;
*exclude_mask = 0;
+
+ if (mono_aot_only)
+ /* The cpuid function allocates from the global codeman */
+ return opts;
+
/* Feature Flags function, flags returned in EDX. */
if (cpuid (1, &eax, &ebx, &ecx, &edx)) {
if (edx & (1 << 15)) {
#endif
}
return opts;
+#else
+ return MONO_OPT_CMOV | MONO_OPT_FCMOV | MONO_OPT_SSE2;
+#endif
}
/*
int eax, ebx, ecx, edx;
guint32 sse_opts = 0;
+ if (mono_aot_only)
+ /* The cpuid function allocates from the global codeman */
+ return sse_opts;
+
if (cpuid (1, &eax, &ebx, &ecx, &edx)) {
if (edx & (1 << 25))
sse_opts |= SIMD_VERSION_SSE1;
if (MONO_TYPE_ISSTRUCT (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) {
break;
case ArgOnStack:
if (MONO_TYPE_ISSTRUCT (t)) {
- linfo->args [i].storage = LLVMArgVtypeByVal;
+ 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;
+ else
+ linfo->args [i].storage = LLVMArgVtypeByVal;
} else {
linfo->args [i].storage = LLVMArgInIReg;
if (t->byref) {
ArgInfo *ainfo = cinfo->args + i;
MonoType *t;
+ if (cinfo->vtype_retaddr && cinfo->vret_arg_index == 1 && i == 0) {
+ /* Push the vret arg before the first argument */
+ MonoInst *vtarg;
+ MONO_INST_NEW (cfg, vtarg, OP_X86_PUSH);
+ vtarg->type = STACK_MP;
+ vtarg->sreg1 = call->vret_var->dreg;
+ MONO_ADD_INS (cfg->cbb, vtarg);
+ }
+
if (i >= sig->hasthis)
t = sig->params [i - sig->hasthis];
else
MONO_ADD_INS (cfg->cbb, vtarg);
mono_call_inst_add_outarg_reg (cfg, call, vtarg->dreg, cinfo->ret.reg, FALSE);
- } else {
+ } else if (cinfo->vtype_retaddr && cinfo->vret_arg_index == 0) {
MonoInst *vtarg;
MONO_INST_NEW (cfg, vtarg, OP_X86_PUSH);
vtarg->type = STACK_MP;
x86_pop_reg (code, X86_EDX); \
x86_pop_reg (code, X86_EAX);
+/* REAL_PRINT_REG does not appear to be used, and was not adapted to work with Native Client. */
+#ifdef __native__client_codegen__
+#define REAL_PRINT_REG(text, reg) g_assert_not_reached()
+#endif
+
/* benchmark and set based on cpu */
#define LOOP_ALIGNMENT 8
#define bb_is_loop_start(bb) ((bb)->loop_body_start && (bb)->nesting)
bb->native_offset = cfg->code_len;
}
}
-
+#ifdef __native_client_codegen__
+ {
+ /* For Native Client, all indirect call/jump targets must be */
+ /* 32-byte aligned. Exception handler blocks are jumped to */
+ /* indirectly as well. */
+ gboolean bb_needs_alignment = (bb->flags & BB_INDIRECT_JUMP_TARGET) ||
+ (bb->flags & BB_EXCEPTION_HANDLER);
+
+ /* if ((cfg->code_len & kNaClAlignmentMask) != 0) { */
+ if ( bb_needs_alignment && ((cfg->code_len & kNaClAlignmentMask) != 0)) {
+ int pad = kNaClAlignment - (cfg->code_len & kNaClAlignmentMask);
+ if (pad != kNaClAlignment) code = mono_arch_nacl_pad(code, pad);
+ cfg->code_len += pad;
+ bb->native_offset = cfg->code_len;
+ }
+ }
+#endif /* __native_client_codegen__ */
if (cfg->verbose_level > 2)
g_print ("Basic block %d starting at offset 0x%x\n", bb->block_num, bb->native_offset);
mono_debug_open_block (cfg, bb, offset);
+ if (mono_break_at_bb_method && mono_method_desc_full_match (mono_break_at_bb_method, cfg->method) && bb->block_num == mono_break_at_bb_bb_num)
+ x86_breakpoint (code);
+
MONO_BB_FOR_EACH_INS (bb, ins) {
offset = code - cfg->native_code;
max_len = ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
- if (G_UNLIKELY (offset > (cfg->code_size - max_len - 16))) {
+#define EXTRA_CODE_SPACE (NACL_SIZE (16, 16 + kNaClAlignment))
+
+ if (G_UNLIKELY (offset > (cfg->code_size - max_len - EXTRA_CODE_SPACE))) {
cfg->code_size *= 2;
- cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
+ cfg->native_code = mono_realloc_native_code(cfg);
code = cfg->native_code + offset;
mono_jit_stats.code_reallocs++;
}
x86_mov_reg_imm (code, ins->dreg, 0);
break;
case OP_LOAD_GOTADDR:
- x86_call_imm (code, 0);
- /*
- * The patch needs to point to the pop, since the GOT offset needs
- * to be added to that address.
- */
- mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_GOT_OFFSET, NULL);
- x86_pop_reg (code, ins->dreg);
- x86_alu_reg_imm (code, X86_ADD, ins->dreg, 0xf0f0f0f0);
+ g_assert (ins->dreg == MONO_ARCH_GOT_REG);
+ code = mono_arch_emit_load_got_addr (cfg->native_code, code, cfg, NULL);
break;
case OP_GOT_ENTRY:
mono_add_patch_info (cfg, offset, (MonoJumpInfoType)ins->inst_right->inst_i1, ins->inst_right->inst_p0);
case OP_CALL_MEMBASE:
call = (MonoCallInst*)ins;
- /*
- * Emit a few nops to simplify get_vcall_slot ().
- */
- x86_nop (code);
- x86_nop (code);
- x86_nop (code);
-
x86_call_membase (code, ins->sreg1, ins->inst_offset);
if (call->stack_usage && !CALLCONV_IS_STDCALL (call->signature)) {
if (call->stack_usage == 4)
break;
}
case OP_ATOMIC_CAS_I4: {
+ g_assert (ins->dreg == X86_EAX);
g_assert (ins->sreg3 == X86_EAX);
g_assert (ins->sreg1 != X86_EAX);
g_assert (ins->sreg1 != ins->sreg2);
x86_prefix (code, X86_LOCK_PREFIX);
x86_cmpxchg_membase_reg (code, ins->sreg1, ins->inst_offset, ins->sreg2);
+ break;
+ }
+#ifdef HAVE_SGEN_GC
+ case OP_CARD_TABLE_WBARRIER: {
+ int ptr = ins->sreg1;
+ int value = ins->sreg2;
+ guchar *br;
+ int nursery_shift, card_table_shift;
+ gpointer card_table_mask;
+ 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);
- if (ins->dreg != X86_EAX)
- x86_mov_reg_reg (code, ins->dreg, X86_EAX, 4);
+ /*
+ * We need one register we can clobber, we choose EDX and make sreg1
+ * fixed EAX to work around limitations in the local register allocator.
+ * sreg2 might get allocated to EDX, but that is not a problem since
+ * we use it before clobbering EDX.
+ */
+ g_assert (ins->sreg1 == X86_EAX);
+
+ /*
+ * This is the code we produce:
+ *
+ * edx = value
+ * edx >>= nursery_shift
+ * cmp edx, (nursery_start >> nursery_shift)
+ * jne done
+ * edx = ptr
+ * edx >>= card_table_shift
+ * card_table[edx] = 1
+ * 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);
+ x86_mov_reg_reg (code, X86_EDX, ptr, 4);
+ x86_shift_reg_imm (code, X86_SHR, X86_EDX, card_table_shift);
+ x86_mov_membase_imm (code, X86_EDX, card_table, 1, 1);
+ x86_patch (br, code);
break;
}
+#endif
#ifdef MONO_ARCH_SIMD_INTRINSICS
case OP_ADDPS:
x86_sse_alu_ps_reg_reg (code, X86_SSE_ADD, ins->sreg1, ins->sreg2);
}
if (G_UNLIKELY ((code - cfg->native_code - offset) > max_len)) {
+#ifndef __native_client_codegen__
g_warning ("wrong maximal instruction length of instruction %s (expected %d, got %d)",
- mono_inst_name (ins->opcode), max_len, code - cfg->native_code - offset);
+ mono_inst_name (ins->opcode), max_len, code - cfg->native_code - offset);
g_assert_not_reached ();
+#endif /* __native_client_codegen__ */
}
cpos += max_len;
int alloc_size, pos, max_offset, i, cfa_offset;
guint8 *code;
gboolean need_stack_frame;
+#ifdef __native_client_codegen__
+ guint alignment_check;
+#endif
cfg->code_size = MAX (cfg->header->code_size * 4, 10240);
if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
cfg->code_size += 512;
+#ifdef __native_client_codegen__
+ /* native_code_alloc is not 32-byte aligned, native_code is. */
+ cfg->native_code_alloc = g_malloc (cfg->code_size + kNaClAlignment);
+
+ /* Align native_code to next nearest kNaclAlignment byte. */
+ cfg->native_code = (guint)cfg->native_code_alloc + kNaClAlignment;
+ cfg->native_code = (guint)cfg->native_code & ~kNaClAlignmentMask;
+
+ code = cfg->native_code;
+
+ alignment_check = (guint)cfg->native_code & kNaClAlignmentMask;
+ g_assert(alignment_check == 0);
+#else
code = cfg->native_code = g_malloc (cfg->code_size);
+#endif
/* Offset between RSP and the CFA */
cfa_offset = 0;
#endif
}
else {
- g_assert (!cfg->compile_aot);
- x86_push_imm (code, cfg->domain);
+ if (cfg->compile_aot) {
+ /*
+ * This goes before the saving of callee saved regs, so save the got reg
+ * ourselves.
+ */
+ x86_push_reg (code, MONO_ARCH_GOT_REG);
+ code = mono_arch_emit_load_got_addr (cfg->native_code, code, cfg, NULL);
+ x86_push_imm (code, 0);
+ } else {
+ x86_push_imm (code, cfg->domain);
+ }
code = emit_call (cfg, code, MONO_PATCH_INFO_INTERNAL_METHOD, (gpointer)"mono_jit_thread_attach");
x86_alu_reg_imm (code, X86_ADD, X86_ESP, 4);
+ if (cfg->compile_aot)
+ x86_pop_reg (code, MONO_ARCH_GOT_REG);
}
}
if (method->save_lmf) {
pos += sizeof (MonoLMF);
- if (cfg->compile_aot)
- cfg->disable_aot = TRUE;
-
/* save the current IP */
- mono_add_patch_info (cfg, code + 1 - cfg->native_code, MONO_PATCH_INFO_IP, NULL);
- x86_push_imm_template (code);
+ if (cfg->compile_aot) {
+ /* This pushes the current ip */
+ x86_call_imm (code, 0);
+ } else {
+ mono_add_patch_info (cfg, code + 1 - cfg->native_code, MONO_PATCH_INFO_IP, NULL);
+ x86_push_imm_template (code);
+ }
cfa_offset += sizeof (gpointer);
/* save all caller saved regs */
x86_alu_reg_imm (code, X86_ADD, X86_EAX, G_STRUCT_OFFSET (MonoJitTlsData, lmf));
#endif
} else {
+ if (cfg->compile_aot)
+ code = mono_arch_emit_load_got_addr (cfg->native_code, code, cfg, NULL);
code = emit_call (cfg, code, MONO_PATCH_INFO_INTERNAL_METHOD, (gpointer)"mono_get_lmf_addr");
}
if (G_UNLIKELY (required_code_size >= (cfg->code_size - offset))) {
while (required_code_size >= (cfg->code_size - offset))
cfg->code_size *= 2;
- cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
+ cfg->native_code = mono_realloc_native_code(cfg);
code = cfg->native_code + offset;
mono_jit_stats.code_reallocs++;
}
/* max alignment for loops */
if ((cfg->opt & MONO_OPT_LOOP) && bb_is_loop_start (bb))
max_offset += LOOP_ALIGNMENT;
-
+#ifdef __native_client_codegen__
+ /* max alignment for native client */
+ 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__
+ {
+ 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;
+ }
+ }
+#endif /* __native_client_codegen__ */
max_offset += ((guint8 *)ins_get_spec (ins->opcode))[MONO_INST_LEN];
}
}
while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
cfg->code_size *= 2;
- cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
+ cfg->native_code = mono_realloc_native_code(cfg);
mono_jit_stats.code_reallocs++;
}
while (cfg->code_len + code_size > (cfg->code_size - 16)) {
cfg->code_size *= 2;
- cfg->native_code = g_realloc (cfg->native_code, cfg->code_size);
+ cfg->native_code = mono_realloc_native_code(cfg);
mono_jit_stats.code_reallocs++;
}
guint32 size;
/* Compute size of code following the push <OFFSET> */
+#ifdef __native_client_codegen__
+ code = mono_nacl_align (code);
+ size = kNaClAlignment;
+#else
size = 5 + 5;
-
+#endif
/*This is aligned to 16 bytes by the callee. This way we save a few bytes here.*/
if ((code - cfg->native_code) - throw_ip < 126 - size) {
//[1 + 5] x86_jump_mem(inst,mem)
#define CMP_SIZE 6
+#ifdef __native_client_codegen__
+/* These constants should be coming from cpu-x86.md */
+/* I suspect the size calculation below is actually incorrect. */
+/* TODO: fix the calculation that uses these sizes. */
+#define BR_SMALL_SIZE 16
+#define BR_LARGE_SIZE 12
+#else
#define BR_SMALL_SIZE 2
#define BR_LARGE_SIZE 5
+#endif /* __native_client_codegen__ */
#define JUMP_IMM_SIZE 6
#define ENABLE_WRONG_METHOD_CHECK 0
#define DEBUG_IMT 0
int size = 0;
guint8 *code, *start;
+#ifdef __native_client_codegen__
+ /* g_print("mono_arch_build_imt_thunk needs to be aligned.\n"); */
+#endif
for (i = 0; i < count; ++i) {
MonoIMTCheckItem *item = imt_entries [i];
if (item->is_equals) {
return (MonoVTable*) regs [MONO_ARCH_RGCTX_REG];
}
+GSList*
+mono_arch_get_cie_program (void)
+{
+ GSList *l = NULL;
+
+ mono_add_unwind_op_def_cfa (l, (guint8*)NULL, (guint8*)NULL, X86_ESP, 4);
+ mono_add_unwind_op_offset (l, (guint8*)NULL, (guint8*)NULL, X86_NREG, -4);
+
+ return l;
+}
+
MonoInst*
mono_arch_emit_inst_for_method (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fsig, MonoInst **args)
{
return can_write;
}
-gpointer
-mono_arch_get_vcall_slot (guint8 *code, mgreg_t *regs, int *displacement)
-{
- guint8 buf [8];
- guint8 reg = 0;
- gint32 disp = 0;
-
- mono_breakpoint_clean_code (NULL, code, 8, buf, sizeof (buf));
- code = buf + 8;
-
- *displacement = 0;
-
- code -= 6;
-
- /*
- * A given byte sequence can match more than case here, so we have to be
- * really careful about the ordering of the cases. Longer sequences
- * come first.
- * There are two types of calls:
- * - direct calls: 0xff address_byte 8/32 bits displacement
- * - indirect calls: nop nop nop <call>
- * The nops make sure we don't confuse the instruction preceeding an indirect
- * call with a direct call.
- */
- if ((code [1] != 0xe8) && (code [3] == 0xff) && ((code [4] & 0x18) == 0x10) && ((code [4] >> 6) == 1)) {
- reg = code [4] & 0x07;
- disp = (signed char)code [5];
- } else if ((code [0] == 0xff) && ((code [1] & 0x18) == 0x10) && ((code [1] >> 6) == 2)) {
- reg = code [1] & 0x07;
- disp = *((gint32*)(code + 2));
- } else if ((code [1] == 0xe8)) {
- return NULL;
- } else if ((code [4] == 0xff) && (((code [5] >> 6) & 0x3) == 0) && (((code [5] >> 3) & 0x7) == 2)) {
- /*
- * This is a interface call
- * 8b 40 30 mov 0x30(%eax),%eax
- * ff 10 call *(%eax)
- */
- disp = 0;
- reg = code [5] & 0x07;
- }
- else
- return NULL;
-
- *displacement = disp;
- return (gpointer)regs [reg];
-}
-
/*
* mono_x86_get_this_arg_offset:
*
guint32
mono_x86_get_this_arg_offset (MonoGenericSharingContext *gsctx, MonoMethodSignature *sig)
{
- CallInfo *cinfo = NULL;
- int offset;
-
- if (MONO_TYPE_ISSTRUCT (sig->ret)) {
- cinfo = get_call_info (gsctx, NULL, sig, FALSE);
-
- offset = cinfo->args [0].offset;
- } else {
- offset = 0;
- }
-
- return offset;
+ return 0;
}
gpointer
gpointer res;
int offset;
- /*
- * Avoid expensive calls to get_generic_context_from_code () + get_call_info
- * if possible.
- */
- if (MONO_TYPE_ISSTRUCT (sig->ret)) {
- if (!gsctx && code)
- gsctx = mono_get_generic_context_from_code (code);
- cinfo = get_call_info (gsctx, NULL, sig, FALSE);
-
- offset = cinfo->args [0].offset;
- } else {
- offset = 0;
- }
+ offset = 0;
/*
* The stack looks like:
* <other args>
* <this=delegate>
- * <possible vtype return address>
* <return addr>
* <4 pointers pushed by mono_arch_create_trampoline_code ()>
*/
#define MAX_ARCH_DELEGATE_PARAMS 10
-gpointer
-mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target)
+static gpointer
+get_delegate_invoke_impl (gboolean has_target, guint32 param_count, guint32 *code_len)
{
guint8 *code, *start;
- if (sig->param_count > MAX_ARCH_DELEGATE_PARAMS)
- return NULL;
-
- /* FIXME: Support more cases */
- if (MONO_TYPE_ISSTRUCT (sig->ret))
- return NULL;
-
/*
* The stack contains:
* <delegate>
*/
if (has_target) {
- static guint8* cached = NULL;
- if (cached)
- return cached;
-
start = code = mono_global_codeman_reserve (64);
/* Replace the this argument with the target */
x86_jump_membase (code, X86_EAX, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
g_assert ((code - start) < 64);
-
- mono_debug_add_delegate_trampoline (start, code - start);
-
- mono_memory_barrier ();
-
- cached = start;
} else {
- static guint8* cache [MAX_ARCH_DELEGATE_PARAMS + 1] = {NULL};
int i = 0;
/* 8 for mov_reg and jump, plus 8 for each parameter */
- int code_reserve = 8 + (sig->param_count * 8);
-
- for (i = 0; i < sig->param_count; ++i)
- if (!mono_is_regsize_var (sig->params [i]))
- return NULL;
-
- code = cache [sig->param_count];
- if (code)
- return code;
-
+#ifdef __native_client_codegen__
+ /* TODO: calculate this size correctly */
+ int code_reserve = 13 + (param_count * 8) + 2 * kNaClAlignment;
+#else
+ int code_reserve = 8 + (param_count * 8);
+#endif /* __native_client_codegen__ */
/*
* The stack contains:
* <args in reverse order>
x86_mov_reg_membase (code, X86_ECX, X86_ESP, 4, 4);
/* move args up */
- for (i = 0; i < sig->param_count; ++i) {
+ for (i = 0; i < param_count; ++i) {
x86_mov_reg_membase (code, X86_EAX, X86_ESP, (i+2)*4, 4);
x86_mov_membase_reg (code, X86_ESP, (i+1)*4, X86_EAX, 4);
}
x86_jump_membase (code, X86_ECX, G_STRUCT_OFFSET (MonoDelegate, method_ptr));
g_assert ((code - start) < code_reserve);
+ }
+
+ mono_debug_add_delegate_trampoline (start, code - start);
+
+ if (code_len)
+ *code_len = code - start;
+
+ return start;
+}
+
+GSList*
+mono_arch_get_delegate_invoke_impls (void)
+{
+ GSList *res = NULL;
+ guint8 *code;
+ guint32 code_len;
+ int i;
+
+ code = get_delegate_invoke_impl (TRUE, 0, &code_len);
+ res = g_slist_prepend (res, mono_tramp_info_create (g_strdup ("delegate_invoke_impl_has_target"), code, code_len, NULL, NULL));
+
+ for (i = 0; i < MAX_ARCH_DELEGATE_PARAMS; ++i) {
+ code = get_delegate_invoke_impl (FALSE, i, &code_len);
+ res = g_slist_prepend (res, mono_tramp_info_create (g_strdup_printf ("delegate_invoke_impl_target_%d", i), code, code_len, NULL, NULL));
+ }
- mono_debug_add_delegate_trampoline (start, code - start);
+ return res;
+}
+
+gpointer
+mono_arch_get_delegate_invoke_impl (MonoMethodSignature *sig, gboolean has_target)
+{
+ guint8 *code, *start;
+
+ if (sig->param_count > MAX_ARCH_DELEGATE_PARAMS)
+ return NULL;
+
+ /* FIXME: Support more cases */
+ if (MONO_TYPE_ISSTRUCT (sig->ret))
+ return NULL;
+
+ /*
+ * The stack contains:
+ * <delegate>
+ * <return addr>
+ */
+
+ if (has_target) {
+ static guint8* cached = NULL;
+ if (cached)
+ return cached;
+
+ if (mono_aot_only)
+ start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
+ else
+ start = get_delegate_invoke_impl (TRUE, 0, NULL);
+
+ mono_memory_barrier ();
+
+ cached = start;
+ } else {
+ static guint8* cache [MAX_ARCH_DELEGATE_PARAMS + 1] = {NULL};
+ int i = 0;
+
+ for (i = 0; i < sig->param_count; ++i)
+ if (!mono_is_regsize_var (sig->params [i]))
+ return NULL;
+
+ code = cache [sig->param_count];
+ if (code)
+ return code;
+
+ if (mono_aot_only) {
+ char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", sig->param_count);
+ start = mono_aot_get_trampoline (name);
+ g_free (name);
+ } else {
+ start = get_delegate_invoke_impl (FALSE, sig->param_count, NULL);
+ }
mono_memory_barrier ();
#endif /* MONO_ARCH_SIMD_INTRINSICS */
}
+/*MONO_ARCH_HAVE_HANDLER_BLOCK_GUARD*/
+gpointer
+mono_arch_install_handler_block_guard (MonoJitInfo *ji, MonoJitExceptionInfo *clause, MonoContext *ctx, gpointer new_value)
+{
+ int offset;
+ gpointer *sp, old_value;
+ char *bp;
+ const unsigned char *handler;
+
+ /*Decode the first instruction to figure out where did we store the spvar*/
+ /*Our jit MUST generate the following:
+ mov %esp, -?(%ebp)
+ Which is encoded as: 0x89 mod_rm.
+ mod_rm (esp, ebp, imm) which can be: (imm will never be zero)
+ mod (reg + imm8): 01 reg(esp): 100 rm(ebp): 101 -> 01100101 (0x65)
+ mod (reg + imm32): 10 reg(esp): 100 rm(ebp): 101 -> 10100101 (0xA5)
+ */
+ handler = clause->handler_start;
+
+ if (*handler != 0x89)
+ return NULL;
+
+ ++handler;
+
+ if (*handler == 0x65)
+ offset = *(signed char*)(handler + 1);
+ else if (*handler == 0xA5)
+ offset = *(int*)(handler + 1);
+ else
+ return NULL;
+
+ /*Load the spvar*/
+ bp = MONO_CONTEXT_GET_BP (ctx);
+ sp = *(gpointer*)(bp + offset);
+
+ old_value = *sp;
+ if (old_value < ji->code_start || (char*)old_value > ((char*)ji->code_start + ji->code_size))
+ return old_value;
+
+ *sp = new_value;
+
+ return old_value;
+}
+
+/*
+ * mono_aot_emit_load_got_addr:
+ *
+ * Emit code to load the got address.
+ * On x86, the result is placed into EBX.
+ */
+guint8*
+mono_arch_emit_load_got_addr (guint8 *start, guint8 *code, MonoCompile *cfg, MonoJumpInfo **ji)
+{
+ x86_call_imm (code, 0);
+ /*
+ * The patch needs to point to the pop, since the GOT offset needs
+ * to be added to that address.
+ */
+ if (cfg)
+ mono_add_patch_info (cfg, code - cfg->native_code, MONO_PATCH_INFO_GOT_OFFSET, NULL);
+ else
+ *ji = mono_patch_info_list_prepend (*ji, code - start, MONO_PATCH_INFO_GOT_OFFSET, NULL);
+ x86_pop_reg (code, MONO_ARCH_GOT_REG);
+ x86_alu_reg_imm (code, X86_ADD, MONO_ARCH_GOT_REG, 0xf0f0f0f0);
+
+ return code;
+}
+
+/*
+ * mono_ppc_emit_load_aotconst:
+ *
+ * Emit code to load the contents of the GOT slot identified by TRAMP_TYPE and
+ * TARGET from the mscorlib GOT in full-aot code.
+ * On x86, the GOT address is assumed to be in EBX, and the result is placed into
+ * EAX.
+ */
+guint8*
+mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target)
+{
+ /* Load the mscorlib got address */
+ x86_mov_reg_membase (code, X86_EAX, MONO_ARCH_GOT_REG, sizeof (gpointer), 4);
+ *ji = mono_patch_info_list_prepend (*ji, code - start, tramp_type, target);
+ /* arch_emit_got_access () patches this */
+ x86_mov_reg_membase (code, X86_EAX, X86_EAX, 0xf0f0f0f0, 4);
+
+ return code;
+}
+
+/* Can't put this into mini-x86.h */
+gpointer
+mono_x86_get_signal_exception_trampoline (MonoTrampInfo **info, gboolean aot);
+
+GSList *
+mono_arch_get_trampolines (gboolean aot)
+{
+ MonoTrampInfo *info;
+ GSList *tramps = NULL;
+
+ mono_x86_get_signal_exception_trampoline (&info, aot);
+
+ tramps = g_slist_append (tramps, info);
+
+ return tramps;
+}
+
+
#if __APPLE__
#define DBG_SIGNAL SIGBUS
#else