/*
* namespace and class are supposed to match already if this function is used.
*/
gboolean
mono_method_desc_match (MonoMethodDesc *desc, MonoMethod *method)
{
char *sig;
gboolean name_match;
name_match = strcmp (desc->name, method->name) == 0;
#ifndef _EGLIB_MAJOR
if (!name_match && desc->name_glob)
name_match = g_pattern_match_simple (desc->name, method->name);
#endif
if (!name_match)
return FALSE;
if (!desc->args)
return TRUE;
if (desc->num_args != mono_method_signature (method)->param_count)
return FALSE;
sig = mono_signature_get_desc (mono_method_signature (method), desc->include_namespace);
if (strcmp (sig, desc->args)) {
g_free (sig);
return FALSE;
}
g_free (sig);
return TRUE;
}
static void
method_jit_result (MonoProfiler *prof, MonoMethod *method, MonoJitInfo* jinfo, int result) {
if (result == MONO_PROFILE_OK) {
int i;
MonoDebugSourceLocation *sourceLoc;
MonoDebugMethodJitInfo *dmji;
MonoClass *klass = mono_method_get_class (method);
char *signature = mono_signature_get_desc (mono_method_signature (method), TRUE);
char *name = g_strdup_printf ("%s(%s)", mono_method_get_name (method), signature);
char *classname = g_strdup_printf ("%s%s%s", mono_class_get_namespace (klass), mono_class_get_namespace (klass)[0] != 0 ? "::" : "", mono_class_get_name (klass));
gpointer code_start = mono_jit_info_get_code_start (jinfo);
int code_size = mono_jit_info_get_code_size (jinfo);
iJIT_Method_Load vtuneMethod;
memset(&vtuneMethod, 0, sizeof(vtuneMethod));
vtuneMethod.method_id = iJIT_GetNewMethodID();
vtuneMethod.method_name = name;
vtuneMethod.method_load_address = code_start;
vtuneMethod.method_size = code_size;
vtuneMethod.class_file_name = classname;
dmji = mono_debug_find_method (method, mono_domain_get());
if (dmji != NULL)
{
vtuneMethod.line_number_size = dmji->num_line_numbers;
vtuneMethod.line_number_table = (vtuneMethod.line_number_size != 0) ?
(LineNumberInfo*)malloc(sizeof(LineNumberInfo) * vtuneMethod.line_number_size) : NULL;
for (i = 0; i < dmji->num_line_numbers; ++i)
{
sourceLoc = mono_debug_lookup_source_location (method, dmji->line_numbers[i].native_offset, mono_domain_get());
if (sourceLoc == NULL)
{
g_free (vtuneMethod.line_number_table);
vtuneMethod.line_number_table = NULL;
vtuneMethod.line_number_size = 0;
break;
}
if (i == 0)
vtuneMethod.source_file_name = strdup(sourceLoc->source_file);
vtuneMethod.line_number_table[i].Offset = dmji->line_numbers[i].native_offset;
vtuneMethod.line_number_table[i].LineNumber = sourceLoc->row;
mono_debug_free_source_location (sourceLoc);
}
mono_debug_free_method_jit_info (dmji);
}
iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, &vtuneMethod);
if (vtuneMethod.source_file_name != NULL)
g_free (vtuneMethod.source_file_name);
if (vtuneMethod.line_number_table != NULL)
g_free (vtuneMethod.line_number_table);
g_free (signature);
g_free (name);
g_free (classname);
}
}
String GDMonoMethod::get_signature_desc(bool p_namespaces) const {
MonoMethodSignature *method_sig = mono_method_signature(mono_method);
char *sig_desc = mono_signature_get_desc(method_sig, p_namespaces);
String res = sig_desc;
mono_free(sig_desc);
return res;
}
static int
dump_verify_info (MonoImage *image, int flags)
{
GSList *errors, *tmp;
int count = 0, verifiable = 0;
const char* desc [] = {
"Ok", "Error", "Warning", NULL, "CLS", NULL, NULL, NULL, "Not Verifiable"
};
if (verify_code) { /* verify code */
int i;
MonoTableInfo *m = &image->tables [MONO_TABLE_METHOD];
for (i = 0; i < m->rows; ++i) {
MonoMethod *method;
MonoError error;
method = mono_get_method_checked (image, MONO_TOKEN_METHOD_DEF | (i+1), NULL, NULL, &error);
if (!method) {
g_print ("Warning: Cannot lookup method with token 0x%08x due to %s\n", i + 1, mono_error_get_message (&error));
mono_error_cleanup (&error);
continue;
}
errors = mono_method_verify (method, flags);
if (errors) {
MonoClass *klass = mono_method_get_class (method);
char *name = mono_type_full_name (&klass->byval_arg);
if (mono_method_signature (method) == NULL) {
g_print ("In method: %s::%s(ERROR)\n", name, mono_method_get_name (method));
} else {
char *sig;
sig = mono_signature_get_desc (mono_method_signature (method), FALSE);
g_print ("In method: %s::%s(%s)\n", name, mono_method_get_name (method), sig);
g_free (sig);
}
g_free (name);
}
for (tmp = errors; tmp; tmp = tmp->next) {
MonoVerifyInfo *info = (MonoVerifyInfo *)tmp->data;
g_print ("%s: %s\n", desc [info->status], info->message);
if (info->status == MONO_VERIFY_ERROR) {
count++;
verifiable = 3;
}
if(info->status == MONO_VERIFY_NOT_VERIFIABLE) {
if (verifiable < 2)
verifiable = 2;
}
}
mono_free_verify_list (errors);
}
}
if (count)
g_print ("Error count: %d\n", count);
return verifiable;
}
void CPipeServer::GetMethodSignature()
{
void *method = (void *)ReadQword();
void *methodsignature = mono_method_signature(method);
char *sig = mono_signature_get_desc(methodsignature, TRUE);
int paramcount = mono_signature_get_param_count(methodsignature);
char **names=(char **)calloc(sizeof(char *), paramcount);
int i;
mono_method_get_param_names(method, (const char **)names);
WriteByte(paramcount);
for (i = 0; i < paramcount; i++)
{
if (names[i])
{
WriteByte(strlen(names[i]));
Write(names[i], strlen(names[i]));
}
else
WriteByte(0);
}
free(names);
WriteWord(strlen(sig));
Write(sig, strlen(sig));
g_free(sig);
//12/5/2014:send the returntype as well
void *returntype = mono_signature_get_return_type(methodsignature);
if (returntype)
{
char *tname = mono_type_get_name(returntype);
if (tname)
{
WriteByte(strlen(tname));
Write(tname, strlen(tname));
g_free(tname);
}
else
WriteByte(0);
}
else
WriteByte(0);
}
String GDMonoMethod::get_full_name_no_class() const {
String res;
MonoMethodSignature *method_sig = mono_method_signature(mono_method);
char *ret_str = mono_type_full_name(mono_signature_get_return_type(method_sig));
res += ret_str;
mono_free(ret_str);
res += " ";
res += name;
res += "(";
char *sig_desc = mono_signature_get_desc(method_sig, true);
res += sig_desc;
mono_free(sig_desc);
res += ")";
return res;
}
static void
output_method (MonoMethod *method, gpointer dummy, MonoProfiler *prof)
{
MonoMethodHeader *header;
char *classname;
char *tmpsig;
char *tmpname;
FILE *outfile;
MonoClass *klass;
MonoImage *image;
outfile = prof->outfile;
header = mono_method_get_header (method);
tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE);
tmpsig = g_markup_escape_text (tmpsig, strlen (tmpsig));
klass = mono_method_get_class (method);
classname = mono_type_get_name (mono_class_get_type (klass));
image = mono_class_get_image (klass);
tmpname = mono_method_get_name (method);
tmpname = g_markup_escape_text (tmpname, strlen (tmpname));
fprintf (outfile, "\t<method assembly=\"%s\" class=\"%s\" name=\"%s (%s)\" token=\"%d\">\n",
mono_image_get_name (image),
classname, tmpname,
tmpsig, mono_method_get_token (method));
g_free (tmpsig);
g_free (tmpname);
fprintf (outfile, "\t\t");
count = 0;
prev_offset = 0;
mono_profiler_coverage_get (prof, method, output_entry);
fprintf (outfile, "\n");
fprintf (outfile, "\t</method>\n");
}
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;
}
