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);
}
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");
}
void CPipeServer::EnumFieldsInClass()
{
void *c=(void *)ReadQword();
void *iter=NULL;
void *field;
do
{
field=mono_class_get_fields(c, &iter);
WriteQword((UINT_PTR)field);
if (field)
{
char *name;
void *fieldtype=mono_field_get_type(field);
WriteQword((UINT_PTR)fieldtype);
WriteDword(mono_type_get_type(fieldtype));
WriteQword((UINT_PTR)mono_field_get_parent(field));
WriteDword((UINT_PTR)mono_field_get_offset(field));
WriteDword(mono_field_get_flags(field));
name=mono_field_get_name(field);
WriteWord(strlen(name));
Write(name, strlen(name));
name=mono_type_get_name(fieldtype);
if (name)
{
WriteWord(strlen(name));
Write(name, strlen(name));
g_free(name);
}
else
WriteWord(0);
}
} while (field);
}
jobject JniManager::toResponse(MonoObject* monoObject)
{
assert(monoObject);
JNIEnv* env = getEnv();
assert(env);
jobject response = env->NewObject(responseClazz, responseCtor);
MonoObject* exc = NULL;
MonoObject* result = mono_runtime_invoke(getResult, monoObject, NULL, &exc);
if (exc)
{
const char* message = mono_string_to_utf8(mono_object_to_string(exc, NULL));
throwException(message);
return NULL;
}
jobject jPayload = NULL;
if (result != NULL)
{
MonoClass* resultClass = mono_object_get_class(result);
MonoType* monoType = mono_class_get_type(resultClass);
string typeName = string(mono_type_get_name(monoType));
// If it's a string or byte[]
if (typeName == "System.String")
{
const char* convertedPayload = mono_string_to_utf8(mono_object_to_string(result, NULL));
jPayload = env->NewStringUTF(convertedPayload);
}
else
{
jPayload = typeConverter->convertToJavaArray<jbyteArray>(env, result);
}
env->CallVoidMethod(response, setPayloadMethod, jPayload);
env->DeleteLocalRef(jPayload);
}
// set Mule Message properties
//jobject jInvocationProperties = typeConverter->convertToJavaMap(env, request->InvocationProperties);
//jobject jSessionProperties = typeConverter->convertToJavaMap(env, request->SessionProperties);
//jobject jOutboundProperties = typeConverter->convertToJavaMap(env, request->OutboundProperties);
/*env->CallVoidMethod(response, setInvocationProperties, jInvocationProperties);
env->CallVoidMethod(response, setOutboundProperties, jOutboundProperties);
env->CallVoidMethod(response, setSessionProperties, jSessionProperties);
env->DeleteLocalRef(jInvocationProperties);
env->DeleteLocalRef(jOutboundProperties);
env->DeleteLocalRef(jSessionProperties);*/
return response;
}
const char* mioType::getName() const
{
if (!mtype) { return nullptr; }
return mono_type_get_name(mtype);
}
static gboolean
collect_coverage_for (MonoProfiler *prof, MonoMethod *method)
{
int i;
char *classname;
char *fqn;
MonoMethodHeader *header;
gboolean has_positive, found;
guint32 iflags, flags, code_size;
MonoClass *klass;
MonoImage *image;
flags = mono_method_get_flags (method, &iflags);
if ((iflags & 0x1000 /*METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL*/) ||
(flags & 0x2000 /*METHOD_ATTRIBUTE_PINVOKE_IMPL*/))
return FALSE;
//if (method->wrapper_type != MONO_WRAPPER_NONE)
// return FALSE;
klass = mono_method_get_class (method);
image = mono_class_get_image (klass);
/* Hacky way of determining the executing assembly */
if (! prof->outfile_name && (strcmp (mono_method_get_name (method), "Main") == 0)) {
prof->outfile_name = g_strdup_printf ("%s.cov", mono_image_get_filename (image));
}
/* Check filters */
if (prof->filters) {
/* Check already filtered classes first */
if (g_hash_table_lookup (prof->filtered_classes, klass))
return FALSE;
classname = mono_type_get_name (mono_class_get_type (klass));
fqn = g_strdup_printf ("[%s]%s", mono_image_get_name (image), classname);
// Check positive filters first
has_positive = FALSE;
found = FALSE;
for (i = 0; i < prof->filters->len; ++i) {
char *filter = g_ptr_array_index (prof->filters_as_str, i);
if (filter [0] == '+') {
filter = &filter [1];
if (strstr (fqn, filter) != NULL)
found = TRUE;
has_positive = TRUE;
}
}
if (has_positive && !found)
return FALSE;
for (i = 0; i < prof->filters->len; ++i) {
// Is substring search suffices ???
// GPatternSpec *spec = g_ptr_array_index (filters, i);
// if (g_pattern_match_string (spec, classname)) {
char *filter = g_ptr_array_index (prof->filters_as_str, i);
if (filter [0] == '+')
continue;
// Skip '-'
filter = &filter [1];
if (strstr (fqn, filter) != NULL) {
g_hash_table_insert (prof->filtered_classes, klass, klass);
return FALSE;
}
}
g_free (fqn);
g_free (classname);
}
header = mono_method_get_header (method);
mono_method_header_get_code (header, &code_size, NULL);
if (code_size > 20000) {
exit (1);
g_warning ("Unable to instrument method %s:%s since it is too complex.", mono_class_get_name (klass), mono_method_get_name (method));
return FALSE;
}
g_hash_table_insert (prof->methods, method, method);
g_hash_table_insert (prof->classes, klass, klass);
g_hash_table_insert (prof->assemblies, mono_image_get_assembly (image), mono_image_get_assembly (image));
return TRUE;
}
