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; }