gboolean is_pinvoke = sig->pinvoke;
if (mp)
- cinfo = mono_mempool_alloc0 (mp, sizeof (CallInfo) + (sizeof (ArgInfo) * n));
+ cinfo = (CallInfo *)mono_mempool_alloc0 (mp, sizeof (CallInfo) + (sizeof (ArgInfo) * n));
else
- cinfo = g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
+ cinfo = (CallInfo *)g_malloc0 (sizeof (CallInfo) + (sizeof (ArgInfo) * n));
cinfo->nargs = n;
if (!cfg->arch.cinfo)
cfg->arch.cinfo = get_call_info (cfg->mempool, sig);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
/*
* FIXME: Remove some of the restrictions.
sig = mono_method_signature (cfg->method);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
sig_ret = mini_get_underlying_type (sig->ret);
/*
sig = mono_method_signature (cfg->method);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
sig_ret = mini_get_underlying_type (sig->ret);
mono_arch_compute_omit_fp (cfg);
if (!cfg->arch.cinfo)
cfg->arch.cinfo = get_call_info (cfg->mempool, sig);
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
if (cinfo->ret.storage == ArgValuetypeInReg)
cfg->ret_var_is_local = TRUE;
} while (0);
static guint8*
-emit_call_body (MonoCompile *cfg, guint8 *code, guint32 patch_type, gconstpointer data)
+emit_call_body (MonoCompile *cfg, guint8 *code, MonoJumpInfoType patch_type, gconstpointer data)
{
gboolean no_patch = FALSE;
* The call might go directly to a native function without
* the wrapper.
*/
- MonoJitICallInfo *mi = mono_find_jit_icall_by_name (data);
+ MonoJitICallInfo *mi = mono_find_jit_icall_by_name ((const char *)data);
if (mi) {
gconstpointer target = mono_icall_get_wrapper (mi);
if ((((guint64)target) >> 32) != 0)
MonoJumpInfo *jinfo = NULL;
if (cfg->abs_patches)
- jinfo = g_hash_table_lookup (cfg->abs_patches, data);
+ jinfo = (MonoJumpInfo *)g_hash_table_lookup (cfg->abs_patches, data);
if (jinfo) {
if (jinfo->type == MONO_PATCH_INFO_JIT_ICALL_ADDR) {
MonoJitICallInfo *mi = mono_find_jit_icall_by_name (jinfo->data.name);
}
static inline guint8*
-emit_call (MonoCompile *cfg, guint8 *code, guint32 patch_type, gconstpointer data, gboolean win64_adjust_stack)
+emit_call (MonoCompile *cfg, guint8 *code, MonoJumpInfoType patch_type, gconstpointer data, gboolean win64_adjust_stack)
{
#ifdef TARGET_WIN32
if (win64_adjust_stack)
case OP_VCALL2_MEMBASE:
cinfo = get_call_info (cfg->mempool, ((MonoCallInst*)ins)->signature);
if (cinfo->ret.storage == ArgValuetypeInReg) {
- MonoInst *loc = cfg->arch.vret_addr_loc;
+ MonoInst *loc = (MonoInst *)cfg->arch.vret_addr_loc;
/* Load the destination address */
g_assert (loc->opcode == OP_REGOFFSET);
if (G_UNLIKELY (offset > (cfg->code_size - max_len - EXTRA_CODE_SPACE))) {
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code(cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code(cfg);
code = cfg->native_code + offset;
cfg->stat_code_reallocs++;
}
break;
case OP_SEQ_POINT: {
if (ins->flags & MONO_INST_SINGLE_STEP_LOC) {
- MonoInst *var = cfg->arch.ss_tramp_var;
+ MonoInst *var = (MonoInst *)cfg->arch.ss_tramp_var;
guint8 *label;
/* Load ss_tramp_var */
if (cfg->compile_aot) {
guint32 offset = code - cfg->native_code;
guint32 val;
- MonoInst *info_var = cfg->arch.seq_point_info_var;
+ MonoInst *info_var = (MonoInst *)cfg->arch.seq_point_info_var;
guint8 *label;
/* Load info var */
amd64_call_reg (code, AMD64_R11);
amd64_patch (label, code);
} else {
- MonoInst *var = cfg->arch.bp_tramp_var;
+ MonoInst *var = (MonoInst *)cfg->arch.bp_tramp_var;
guint8 *label;
/*
case OP_COND_EXC_IGE_UN:
case OP_COND_EXC_ILE:
case OP_COND_EXC_ILE_UN:
- EMIT_COND_SYSTEM_EXCEPTION (cc_table [mono_opcode_to_cond (ins->opcode)], cc_signed_table [mono_opcode_to_cond (ins->opcode)], ins->inst_p1);
+ EMIT_COND_SYSTEM_EXCEPTION (cc_table [mono_opcode_to_cond (ins->opcode)], cc_signed_table [mono_opcode_to_cond (ins->opcode)], (const char *)ins->inst_p1);
break;
case OP_COND_EXC_OV:
case OP_COND_EXC_NO:
case OP_COND_EXC_C:
case OP_COND_EXC_NC:
EMIT_COND_SYSTEM_EXCEPTION (branch_cc_table [ins->opcode - OP_COND_EXC_EQ],
- (ins->opcode < OP_COND_EXC_NE_UN), ins->inst_p1);
+ (ins->opcode < OP_COND_EXC_NE_UN), (const char *)ins->inst_p1);
break;
case OP_COND_EXC_IOV:
case OP_COND_EXC_INO:
case OP_COND_EXC_IC:
case OP_COND_EXC_INC:
EMIT_COND_SYSTEM_EXCEPTION (branch_cc_table [ins->opcode - OP_COND_EXC_IEQ],
- (ins->opcode < OP_COND_EXC_INE_UN), ins->inst_p1);
+ (ins->opcode < OP_COND_EXC_INE_UN), (const char *)ins->inst_p1);
break;
/* floating point opcodes */
cfg->code_size = MAX (cfg->header->code_size * 4, 1024);
#if defined(__default_codegen__)
- code = cfg->native_code = g_malloc (cfg->code_size);
+ code = cfg->native_code = (unsigned char *)g_malloc (cfg->code_size);
#elif defined(__native_client_codegen__)
/* native_code_alloc is not 32-byte aligned, native_code is. */
cfg->native_code_alloc = g_malloc (cfg->code_size + kNaClAlignment);
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 = mono_realloc_native_code (cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code (cfg);
code = cfg->native_code + offset;
cfg->stat_code_reallocs++;
}
sig = mono_method_signature (method);
pos = 0;
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
if (sig->ret->type != MONO_TYPE_VOID) {
/* Save volatile arguments to the stack */
if (trace) {
args_clobbered = TRUE;
- code = mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
+ code = (guint8 *)mono_arch_instrument_prolog (cfg, mono_trace_enter_method, code, TRUE);
}
if (cfg->prof_options & MONO_PROFILE_ENTER_LEAVE)
}
if (cfg->gen_sdb_seq_points) {
- MonoInst *info_var = cfg->arch.seq_point_info_var;
+ MonoInst *info_var = (MonoInst *)cfg->arch.seq_point_info_var;
/* Initialize seq_point_info_var */
if (cfg->compile_aot) {
if (cfg->compile_aot) {
/* Initialize ss_tramp_var */
- ins = cfg->arch.ss_tramp_var;
+ ins = (MonoInst *)cfg->arch.ss_tramp_var;
g_assert (ins->opcode == OP_REGOFFSET);
amd64_mov_reg_membase (code, AMD64_R11, info_var->inst_basereg, info_var->inst_offset, 8);
amd64_mov_membase_reg (code, ins->inst_basereg, ins->inst_offset, AMD64_R11, 8);
} else {
/* Initialize ss_tramp_var */
- ins = cfg->arch.ss_tramp_var;
+ ins = (MonoInst *)cfg->arch.ss_tramp_var;
g_assert (ins->opcode == OP_REGOFFSET);
amd64_mov_reg_imm (code, AMD64_R11, (guint64)&ss_trampoline);
amd64_mov_membase_reg (code, ins->inst_basereg, ins->inst_offset, AMD64_R11, 8);
/* Initialize bp_tramp_var */
- ins = cfg->arch.bp_tramp_var;
+ ins = (MonoInst *)cfg->arch.bp_tramp_var;
g_assert (ins->opcode == OP_REGOFFSET);
amd64_mov_reg_imm (code, AMD64_R11, (guint64)&bp_trampoline);
while (cfg->code_len + max_epilog_size > (cfg->code_size - 16)) {
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code (cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code (cfg);
cfg->stat_code_reallocs++;
}
code = cfg->native_code + cfg->code_len;
mono_emit_unwind_op_remember_state (cfg, code);
if (mono_jit_trace_calls != NULL && mono_trace_eval (method))
- code = mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
+ code = (guint8 *)mono_arch_instrument_epilog (cfg, mono_trace_leave_method, code, TRUE);
/* the code restoring the registers must be kept in sync with OP_TAILCALL */
}
/* Load returned vtypes into registers if needed */
- cinfo = cfg->arch.cinfo;
+ cinfo = (CallInfo *)cfg->arch.cinfo;
if (cinfo->ret.storage == ArgValuetypeInReg) {
ArgInfo *ainfo = &cinfo->ret;
MonoInst *inst = cfg->ret;
while (cfg->code_len + code_size > (cfg->code_size - 16)) {
cfg->code_size *= 2;
- cfg->native_code = mono_realloc_native_code (cfg);
+ cfg->native_code = (unsigned char *)mono_realloc_native_code (cfg);
cfg->stat_code_reallocs++;
}
void*
mono_arch_instrument_prolog (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments)
{
- guchar *code = p;
+ guchar *code = (guchar *)p;
MonoMethodSignature *sig;
MonoInst *inst;
int i, n, stack_area = 0;
void*
mono_arch_instrument_epilog_full (MonoCompile *cfg, void *func, void *p, gboolean enable_arguments, gboolean preserve_argument_registers)
{
- guchar *code = p;
+ guchar *code = (guchar *)p;
int save_mode = SAVE_NONE;
MonoMethod *method = cfg->method;
MonoType *ret_type = mini_get_underlying_type (mono_method_signature (method)->ret);
unwind_ops = mono_arch_get_cie_program ();
if (has_target) {
- start = code = mono_global_codeman_reserve (64);
+ start = code = (guint8 *)mono_global_codeman_reserve (64);
/* Replace the this argument with the target */
amd64_mov_reg_reg (code, AMD64_RAX, AMD64_ARG_REG1, 8);
g_assert ((code - start) < 64);
} else {
- start = code = mono_global_codeman_reserve (64);
+ start = code = (guint8 *)mono_global_codeman_reserve (64);
if (param_count == 0) {
amd64_jump_membase (code, AMD64_ARG_REG1, MONO_STRUCT_OFFSET (MonoDelegate, method_ptr));
if (offset / (int)sizeof (gpointer) > MAX_VIRTUAL_DELEGATE_OFFSET)
return NULL;
- start = code = mono_global_codeman_reserve (size);
+ start = code = (guint8 *)mono_global_codeman_reserve (size);
unwind_ops = mono_arch_get_cie_program ();
return cached;
if (mono_aot_only) {
- start = mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
+ start = (guint8 *)mono_aot_get_trampoline ("delegate_invoke_impl_has_target");
} else {
MonoTrampInfo *info;
- start = get_delegate_invoke_impl (&info, TRUE, 0);
+ start = (guint8 *)get_delegate_invoke_impl (&info, TRUE, 0);
mono_tramp_info_register (info, NULL);
}
if (mono_aot_only) {
char *name = g_strdup_printf ("delegate_invoke_impl_target_%d", sig->param_count);
- start = mono_aot_get_trampoline (name);
+ start = (guint8 *)mono_aot_get_trampoline (name);
g_free (name);
} else {
MonoTrampInfo *info;
- start = get_delegate_invoke_impl (&info, FALSE, sig->param_count);
+ start = (guint8 *)get_delegate_invoke_impl (&info, FALSE, sig->param_count);
mono_tramp_info_register (info, NULL);
}
code = mono_domain_code_reserve (domain, size);
#else
if (fail_tramp)
- code = mono_method_alloc_generic_virtual_thunk (domain, size);
+ code = (guint8 *)mono_method_alloc_generic_virtual_thunk (domain, size);
else
- code = mono_domain_code_reserve (domain, size);
+ code = (guint8 *)mono_domain_code_reserve (domain, size);
#endif
start = code;
char *bp;
/*Load the spvar*/
- bp = MONO_CONTEXT_GET_BP (ctx);
- sp = *(gpointer*)(bp + clause->exvar_offset);
+ bp = (char *)MONO_CONTEXT_GET_BP (ctx);
+ sp = (gpointer *)*(gpointer*)(bp + clause->exvar_offset);
old_value = *sp;
if (old_value < ji->code_start || (char*)old_value > ((char*)ji->code_start + ji->code_size))
* On AMD64, the result is placed into R11.
*/
guint8*
-mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, int tramp_type, gconstpointer target)
+mono_arch_emit_load_aotconst (guint8 *start, guint8 *code, MonoJumpInfo **ji, MonoJumpInfoType tramp_type, gconstpointer target)
{
*ji = mono_patch_info_list_prepend (*ji, code - start, tramp_type, target);
amd64_mov_reg_membase (code, AMD64_R11, AMD64_RIP, 0, 8);
if (ji->from_aot) {
guint32 native_offset = ip - (guint8*)ji->code_start;
- SeqPointInfo *info = mono_arch_get_seq_point_info (mono_domain_get (), ji->code_start);
+ SeqPointInfo *info = (SeqPointInfo *)mono_arch_get_seq_point_info (mono_domain_get (), (guint8 *)ji->code_start);
g_assert (info->bp_addrs [native_offset] == 0);
info->bp_addrs [native_offset] = mini_get_breakpoint_trampoline ();
if (ji->from_aot) {
guint32 native_offset = ip - (guint8*)ji->code_start;
- SeqPointInfo *info = mono_arch_get_seq_point_info (mono_domain_get (), ji->code_start);
+ SeqPointInfo *info = (SeqPointInfo *)mono_arch_get_seq_point_info (mono_domain_get (), (guint8 *)ji->code_start);
info->bp_addrs [native_offset] = NULL;
} else {
// FIXME: Add a free function
mono_domain_lock (domain);
- info = g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
+ info = (SeqPointInfo *)g_hash_table_lookup (domain_jit_info (domain)->arch_seq_points,
code);
mono_domain_unlock (domain);
g_assert (ji);
// FIXME: Optimize the size
- info = g_malloc0 (sizeof (SeqPointInfo) + (ji->code_size * sizeof (gpointer)));
+ info = (SeqPointInfo *)g_malloc0 (sizeof (SeqPointInfo) + (ji->code_size * sizeof (gpointer)));
info->ss_tramp_addr = &ss_trampoline;
projects / mono.git / blobdiff