gpointer
mono_amd64_start_gsharedvt_call (GSharedVtCallInfo *info, gpointer *caller, gpointer *callee, gpointer mrgctx_reg)
{
int i;
#ifdef DEBUG_AMD64_GSHAREDVT
printf ("mono_amd64_start_gsharedvt_call info %p caller %p callee %p ctx %p\n", info, caller, callee, mrgctx_reg);
for (i = 0; i < PARAM_REGS; ++i)
printf ("\treg [%d] -> %p\n", i, caller [i]);
#endif
/* Set vtype ret arg */
if (info->vret_slot != -1) {
DEBUG_AMD64_GSHAREDVT_PRINT ("vret handling\n[%d] < &%d (%p)\n", info->vret_arg_reg, info->vret_slot, &callee [info->vret_slot]);
g_assert (info->vret_slot);
callee [info->vret_arg_reg] = &callee [info->vret_slot];
}
for (i = 0; i < info->map_count; ++i) {
int src = info->map [i * 2];
int dst = info->map [(i * 2) + 1];
int arg_marshal = (src >> SRC_DESCRIPTOR_MARSHAL_SHIFT) & SRC_DESCRIPTOR_MARSHAL_MASK;
int source_reg = src & SRC_REG_MASK;
int dest_reg = dst & SRC_REG_MASK;
DEBUG_AMD64_GSHAREDVT_PRINT ("source %x dest %x marshal %d: ", src, dst, arg_marshal);
switch (arg_marshal) {
case GSHAREDVT_ARG_NONE:
callee [dest_reg] = caller [source_reg];
DEBUG_AMD64_GSHAREDVT_PRINT ("[%d] <- %d (%p) <- (%p)\n", dest_reg, source_reg, &callee [dest_reg], caller [source_reg]);
break;
case GSHAREDVT_ARG_BYVAL_TO_BYREF:
/* gsharedvt argument passed by addr in reg/stack slot */
callee [dest_reg] = &caller [source_reg];
DEBUG_AMD64_GSHAREDVT_PRINT ("[%d] <- &%d (%p) <- (%p)\n", dest_reg, source_reg, &callee [dest_reg], &caller [source_reg]);
break;
case GSHAREDVT_ARG_BYREF_TO_BYVAL: {
int slot_count = (src >> SLOT_COUNT_SHIFT) & SLOT_COUNT_MASK;
int j;
gpointer *addr = caller [source_reg];
for (j = 0; j < slot_count; ++j)
callee [dest_reg + j] = addr [j];
DEBUG_AMD64_GSHAREDVT_PRINT ("[%d] <- [%d] (%d words) (%p) <- (%p)\n", dest_reg, source_reg, slot_count, &callee [dest_reg], &caller [source_reg]);
break;
}
default:
g_error ("cant handle arg marshal %d\n", arg_marshal);
}
}
//Can't handle for now
if (info->vcall_offset != -1){
MonoObject *this_obj = caller [0];
DEBUG_AMD64_GSHAREDVT_PRINT ("target is a vcall at offset %d\n", info->vcall_offset / 8);
if (G_UNLIKELY (!this_obj))
return NULL;
if (info->vcall_offset == MONO_GSHAREDVT_DEL_INVOKE_VT_OFFSET)
/* delegate invoke */
return ((MonoDelegate*)this_obj)->invoke_impl;
else
return *(gpointer*)((char*)this_obj->vtable + info->vcall_offset);
} else if (info->calli) {
/* The address to call is passed in the mrgctx reg */
return mrgctx_reg;
} else {
DEBUG_AMD64_GSHAREDVT_PRINT ("target is %p\n", info->addr);
return info->addr;
}
}
gpointer
mono_arch_get_gsharedvt_call_info (gpointer addr, MonoMethodSignature *normal_sig, MonoMethodSignature *gsharedvt_sig, gboolean gsharedvt_in, gint32 vcall_offset, gboolean calli)
{
GSharedVtCallInfo *info;
CallInfo *caller_cinfo, *callee_cinfo;
MonoMethodSignature *caller_sig, *callee_sig;
int aindex, i;
gboolean var_ret = FALSE;
CallInfo *cinfo, *gcinfo;
MonoMethodSignature *sig, *gsig;
GPtrArray *map;
if (gsharedvt_in) {
caller_sig = normal_sig;
callee_sig = gsharedvt_sig;
caller_cinfo = mono_arch_get_call_info (NULL, caller_sig);
callee_cinfo = mono_arch_get_call_info (NULL, callee_sig);
} else {
callee_sig = normal_sig;
caller_sig = gsharedvt_sig;
callee_cinfo = mono_arch_get_call_info (NULL, callee_sig);
caller_cinfo = mono_arch_get_call_info (NULL, caller_sig);
}
/*
* If GSHAREDVT_IN is true, this means we are transitioning from normal to gsharedvt code. The caller uses the
* normal call signature, while the callee uses the gsharedvt signature.
* If GSHAREDVT_IN is false, its the other way around.
*/
/* sig/cinfo describes the normal call, while gsig/gcinfo describes the gsharedvt call */
if (gsharedvt_in) {
sig = caller_sig;
gsig = callee_sig;
cinfo = caller_cinfo;
gcinfo = callee_cinfo;
} else {
sig = callee_sig;
gsig = caller_sig;
cinfo = callee_cinfo;
gcinfo = caller_cinfo;
}
DEBUG_AMD64_GSHAREDVT_PRINT ("source sig: (%s) return (%s)\n", mono_signature_get_desc (caller_sig, FALSE), mono_type_full_name (mono_signature_get_return_type (caller_sig))); // Leak
DEBUG_AMD64_GSHAREDVT_PRINT ("dest sig: (%s) return (%s)\n", mono_signature_get_desc (callee_sig, FALSE), mono_type_full_name (mono_signature_get_return_type (callee_sig)));
if (gcinfo->ret.storage == ArgGsharedvtVariableInReg) {
/*
* The return type is gsharedvt
*/
var_ret = TRUE;
}
/*
* The stack looks like this:
* <arguments>
* <trampoline frame>
* <call area>
* We have to map the stack slots in <arguments> to the stack slots in <call area>.
*/
map = g_ptr_array_new ();
for (aindex = 0; aindex < cinfo->nargs; ++aindex) {
ArgInfo *src_info = &caller_cinfo->args [aindex];
ArgInfo *dst_info = &callee_cinfo->args [aindex];
int *src = NULL, *dst = NULL;
int nsrc = -1, ndst = -1, nslots = 0;
int arg_marshal = GSHAREDVT_ARG_NONE;
int arg_slots = 0; // Size in quadwords
DEBUG_AMD64_GSHAREDVT_PRINT ("-- arg %d in (%s) out (%s)\n", aindex, arg_info_desc (src_info), arg_info_desc (dst_info));
switch (src_info->storage) {
case ArgInIReg:
case ArgInDoubleSSEReg:
case ArgInFloatSSEReg:
case ArgValuetypeInReg:
case ArgOnStack:
nsrc = get_arg_slots (src_info, &src, TRUE);
break;
case ArgGSharedVtInReg:
handle_marshal_when_src_gsharedvt (dst_info, &arg_marshal, &arg_slots);
handle_map_when_gsharedvt_in_reg (src_info, &nsrc, &src);
break;
case ArgGSharedVtOnStack:
handle_marshal_when_src_gsharedvt (dst_info, &arg_marshal, &arg_slots);
handle_map_when_gsharedvt_on_stack (src_info, &nsrc, &src, TRUE);
break;
case ArgValuetypeAddrInIReg:
case ArgValuetypeAddrOnStack:
nsrc = get_arg_slots (src_info, &src, TRUE);
break;
default:
g_error ("Gsharedvt can't handle source arg type %d", (int)src_info->storage); // Inappropriate value: ArgValuetypeAddrInIReg is for returns only
}
switch (dst_info->storage) {
case ArgInIReg:
case ArgInDoubleSSEReg:
case ArgInFloatSSEReg:
case ArgOnStack:
case ArgValuetypeInReg:
ndst = get_arg_slots (dst_info, &dst, FALSE);
break;
case ArgGSharedVtInReg:
handle_marshal_when_dst_gsharedvt (src_info, &arg_marshal);
handle_map_when_gsharedvt_in_reg (dst_info, &ndst, &dst);
break;
case ArgGSharedVtOnStack:
handle_marshal_when_dst_gsharedvt (src_info, &arg_marshal);
handle_map_when_gsharedvt_on_stack (dst_info, &ndst, &dst, FALSE);
break;
case ArgValuetypeAddrInIReg:
case ArgValuetypeAddrOnStack:
ndst = get_arg_slots (dst_info, &dst, FALSE);
break;
default:
g_error ("Gsharedvt can't handle dest arg type %d", (int)dst_info->storage); // See above
}
if (nsrc)
src [0] |= (arg_marshal << SRC_DESCRIPTOR_MARSHAL_SHIFT) | (arg_slots << SLOT_COUNT_SHIFT);
/* Merge and add to the global list*/
nslots = MIN (nsrc, ndst);
DEBUG_AMD64_GSHAREDVT_PRINT ("nsrc %d ndst %d\n", nsrc, ndst);
for (i = 0; i < nslots; ++i)
add_to_map (map, src [i], dst [i]);
g_free (src);
g_free (dst);
}
DEBUG_AMD64_GSHAREDVT_PRINT ("-- return in (%s) out (%s) var_ret %d\n", arg_info_desc (&caller_cinfo->ret), arg_info_desc (&callee_cinfo->ret), var_ret);
if (cinfo->ret.storage == ArgValuetypeAddrInIReg) {
/* Both the caller and the callee pass the vtype ret address in r8 (System V) and RCX or RDX (Windows) */
g_assert (gcinfo->ret.storage == ArgValuetypeAddrInIReg || gcinfo->ret.storage == ArgGsharedvtVariableInReg);
add_to_map (map, map_reg (cinfo->ret.reg), map_reg (cinfo->ret.reg));
}
info = mono_domain_alloc0 (mono_domain_get (), sizeof (GSharedVtCallInfo) + (map->len * sizeof (int)));
info->addr = addr;
info->stack_usage = callee_cinfo->stack_usage;
info->ret_marshal = GSHAREDVT_RET_NONE;
info->gsharedvt_in = gsharedvt_in ? 1 : 0;
info->vret_slot = -1;
info->calli = calli;
if (var_ret) {
g_assert (gcinfo->ret.storage == ArgGsharedvtVariableInReg);
info->vret_arg_reg = map_reg (gcinfo->ret.reg);
DEBUG_AMD64_GSHAREDVT_PRINT ("mapping vreg_arg_reg to %d in reg %s\n", info->vret_arg_reg, mono_arch_regname (gcinfo->ret.reg));
} else {
info->vret_arg_reg = -1;
}
#ifdef DEBUG_AMD64_GSHAREDVT
printf ("final map:\n");
for (i = 0; i < map->len; i += 2) {
printf ("\t[%d] src %x dst %x\n ",
i / 2,
GPOINTER_TO_UINT (g_ptr_array_index (map, i)),
GPOINTER_TO_UINT (g_ptr_array_index (map, i + 1)));
}
#endif
info->vcall_offset = vcall_offset;
info->map_count = map->len / 2;
for (i = 0; i < map->len; ++i)
info->map [i] = GPOINTER_TO_UINT (g_ptr_array_index (map, i));
g_ptr_array_free (map, TRUE);
/* Compute return value marshalling */
if (var_ret) {
/* Compute return value marshalling */
switch (cinfo->ret.storage) {
case ArgInIReg:
if (!gsharedvt_in || sig->ret->byref) {
info->ret_marshal = GSHAREDVT_RET_IREGS_1;
} else {
MonoType *ret = sig->ret;
// Unwrap enums
if (ret->type == MONO_TYPE_VALUETYPE)
ret = mini_type_get_underlying_type (ret);
switch (ret->type) {
case MONO_TYPE_I1:
info->ret_marshal = GSHAREDVT_RET_I1;
break;
case MONO_TYPE_BOOLEAN:
case MONO_TYPE_U1:
info->ret_marshal = GSHAREDVT_RET_U1;
break;
case MONO_TYPE_I2:
info->ret_marshal = GSHAREDVT_RET_I2;
break;
case MONO_TYPE_CHAR:
case MONO_TYPE_U2:
info->ret_marshal = GSHAREDVT_RET_U2;
break;
case MONO_TYPE_I4:
info->ret_marshal = GSHAREDVT_RET_I4;
break;
case MONO_TYPE_U4:
info->ret_marshal = GSHAREDVT_RET_U4;
break;
case MONO_TYPE_I:
case MONO_TYPE_U:
case MONO_TYPE_PTR:
case MONO_TYPE_FNPTR:
case MONO_TYPE_CLASS:
case MONO_TYPE_OBJECT:
case MONO_TYPE_SZARRAY:
case MONO_TYPE_ARRAY:
case MONO_TYPE_STRING:
case MONO_TYPE_U8:
case MONO_TYPE_I8:
info->ret_marshal = GSHAREDVT_RET_I8;
break;
case MONO_TYPE_GENERICINST:
g_assert (!mono_type_generic_inst_is_valuetype (ret));
info->ret_marshal = GSHAREDVT_RET_I8;
break;
default:
g_error ("Gsharedvt can't handle dst type [%d]", (int)sig->ret->type);
}
}
break;
case ArgValuetypeInReg:
info->ret_marshal = GSHAREDVT_RET_IREGS_1 - 1 + cinfo->ret.nregs;
g_assert (cinfo->ret.nregs == 1); // ABI supports 2-register return but we do not implement this.
break;
case ArgInDoubleSSEReg:
case ArgInFloatSSEReg:
info->ret_marshal = GSHAREDVT_RET_R8;
break;
case ArgValuetypeAddrInIReg:
break;
default:
g_error ("Can't marshal return of storage [%d] %s", (int)cinfo->ret.storage, storage_name (cinfo->ret.storage));
}
if (gsharedvt_in && cinfo->ret.storage != ArgValuetypeAddrInIReg) {
/* Allocate stack space for the return value */
info->vret_slot = map_stack_slot (info->stack_usage / sizeof (gpointer));
info->stack_usage += mono_type_stack_size_internal (normal_sig->ret, NULL, FALSE) + sizeof (gpointer);
}
DEBUG_AMD64_GSHAREDVT_PRINT ("RET marshal is %s\n", ret_marshal_name [info->ret_marshal]);
}
info->stack_usage = ALIGN_TO (info->stack_usage, MONO_ARCH_FRAME_ALIGNMENT);
g_free (callee_cinfo);
g_free (caller_cinfo);
DEBUG_AMD64_GSHAREDVT_PRINT ("allocated an info at %p stack usage %d\n", info, info->stack_usage);
return info;
}
