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);
}
}
const Vector<GDMonoClass *> &GDMonoClass::get_all_delegates() {
if (delegates_fetched)
return delegates_list;
void *iter = NULL;
MonoClass *raw_class = NULL;
while ((raw_class = mono_class_get_nested_types(mono_class, &iter)) != NULL) {
if (mono_class_is_delegate(raw_class)) {
StringName name = mono_class_get_name(raw_class);
Map<StringName, GDMonoClass *>::Element *match = delegates.find(name);
if (match) {
delegates_list.push_back(match->get());
} else {
GDMonoClass *delegate = memnew(GDMonoClass(mono_class_get_namespace(raw_class), mono_class_get_name(raw_class), raw_class, assembly));
delegates.insert(name, delegate);
delegates_list.push_back(delegate);
}
}
}
delegates_fetched = true;
return delegates_list;
}
bool CScriptClass::ImplementsInterface(const char *interfaceName, const char *nameSpace, bool bSearchDerivedClasses)
{
void *pIterator = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
while (pClass != nullptr)
{
MonoClass *pCurInterface = mono_class_get_interfaces(pClass, &pIterator);
if(pCurInterface == nullptr)
{
if(!bSearchDerivedClasses)
return false;
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
if(!strcmp(mono_class_get_name(pCurInterface), interfaceName)
&& (nameSpace == nullptr || !strcmp(mono_class_get_namespace(pCurInterface), nameSpace)))
return true;
}
return false;
}
static void
output_type_edge (MonoClass *first, MonoClass *second) {
if (include_namespace)
fprintf (output, "\t\"%s.%s\" -> \"%s.%s\"\n", mono_class_get_namespace (first), mono_class_get_name (first), mono_class_get_namespace (second), mono_class_get_name (second));
else
fprintf (output, "\t\"%s\" -> \"%s\"\n", mono_class_get_name (first), mono_class_get_name (second));
}
void CPipeServer::EnumClassesInImage()
{
int i;
void *image=(void *)ReadQword();
void *tdef=mono_image_get_table_info (image, MONO_TABLE_TYPEDEF);
int tdefcount=mono_table_info_get_rows(tdef);
WriteDword(tdefcount);
for (i = 0; i < tdefcount; i++)
{
void *c = mono_class_get(image, MONO_TOKEN_TYPE_DEF | i+1);
char *name=mono_class_get_name(c);
WriteQword((UINT_PTR)c);
WriteWord(strlen(name));
Write(name, strlen(name));
name=mono_class_get_namespace(c);
WriteWord(strlen(name));
Write(name, strlen(name));
}
}
void CPipeServer::GetClassNamespace()
{
void *klass=(void *)ReadQword();
char *methodname=mono_class_get_namespace(klass);
WriteWord(strlen(methodname));
Write(methodname, strlen(methodname));
}
CScriptClass::CScriptClass(MonoClass *pClass, CScriptAssembly *pDeclaringAssembly)
: m_pDeclaringAssembly(pDeclaringAssembly)
, m_refs(0)
{
CRY_ASSERT(pClass);
m_pObject = (MonoObject *)pClass;
m_objectHandle = -1;
m_pClass = NULL;
m_name = string(mono_class_get_name(pClass));
m_namespace = string(mono_class_get_namespace(pClass));
}
static int gc_find_big(MonoObject *obj, MonoClass *klass, uintptr_t size, uintptr_t num,
MonoObject **refs, uintptr_t *offsets, void *data) {
// account for object alignment in the heap
size += 7; size &= ~7;
if (size < 1000 * 1000) return 0;
big[big_count] = obj; big_count++;
puts(" ## BIG OBJECT DETECTED ##");
const char *name = mono_class_get_name (klass);
const char *nspace = mono_class_get_namespace (klass);
printf("%s.%s of %i bytes\n", nspace, name, size);
return 0;
}
gboolean ml_is_api_dll(MonoImage *image)
{
MonoClass *klass;
int i, total;
total = mono_image_get_table_rows (image, MONO_TABLE_TYPEDEF);
for (i = 1; i <= total; ++i) {
klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF | i);
if (strcmp(mono_class_get_name(klass), "Debug") == 0)
if (strcmp(mono_class_get_namespace(klass), "Purple") == 0) {
ml_set_api_image(image);
return TRUE;
}
}
return FALSE;
}
GDMonoClass *GDMonoAssembly::get_class(MonoClass *p_mono_class) {
ERR_FAIL_COND_V(!loaded, NULL);
Map<MonoClass *, GDMonoClass *>::Element *match = cached_raw.find(p_mono_class);
if (match)
return match->value();
StringName namespace_name = mono_class_get_namespace(p_mono_class);
StringName class_name = mono_class_get_name(p_mono_class);
GDMonoClass *wrapped_class = memnew(GDMonoClass(namespace_name, class_name, p_mono_class, this));
cached_classes[ClassKey(namespace_name, class_name)] = wrapped_class;
cached_raw[p_mono_class] = wrapped_class;
return wrapped_class;
}
bool CScriptClass::ImplementsClass(const char *className, const char *nameSpace)
{
MonoClass *pClass = (MonoClass *)m_pObject;
while (pClass != nullptr)
{
if(!strcmp(mono_class_get_name(pClass), className)
&& (nameSpace == nullptr || !strcmp(mono_class_get_namespace(pClass), nameSpace)))
return true;
else
CryLogAlways("%s did not match pattern %s", mono_class_get_name(pClass), className);
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
}
return false;
}
static int gc_dump_big_refs(MonoObject *obj, MonoClass *klass, uintptr_t size, uintptr_t num,
MonoObject **refs, uintptr_t *offsets, void *data) {
if (num == 0) return 0;
int i, j;
for (i = 0; i < num; i++) {
for (j = 0; j < big_count; j++) {
if (refs[i] == big[j]) { goto found; }
}
}
return 0;
found:
puts(" ## REFERENCING BIG OBJECT DETECTED ##");
const char *name = mono_class_get_name (klass);
const char *nspace = mono_class_get_namespace (klass);
printf(" %s.%s\n", nspace, name);
return 0;
}
IMonoMethod *CScriptClass::GetMethod(const char *name, IMonoArray *pArgs, bool throwOnFail)
{
MonoMethodSignature *pSignature = nullptr;
void *pIterator = 0;
MonoClass *pClass = (MonoClass *)m_pObject;
MonoType *pClassType = mono_class_get_type(pClass);
MonoMethod *pCurMethod = nullptr;
int suppliedArgsCount = pArgs ? pArgs->GetSize() : 0;
while (pClass != nullptr)
{
pCurMethod = mono_class_get_methods(pClass, &pIterator);
if(pCurMethod == nullptr)
{
pClass = mono_class_get_parent(pClass);
if(pClass == mono_get_object_class())
break;
pIterator = 0;
continue;
}
pSignature = mono_method_signature(pCurMethod);
int signatureParamCount = mono_signature_get_param_count(pSignature);
bool bCorrectName = !strcmp(mono_method_get_name(pCurMethod), name);
if(bCorrectName && signatureParamCount == 0 && suppliedArgsCount == 0)
return new CScriptMethod(pCurMethod);
else if(bCorrectName && signatureParamCount >= suppliedArgsCount && suppliedArgsCount != 0)
{
//if(bStatic != (mono_method_get_flags(pCurMethod, nullptr) & METHOD_ATTRIBUTE_STATIC) > 0)
//continue;
void *pIter = nullptr;
MonoType *pType = nullptr;
for(int i = 0; i < signatureParamCount; i++)
{
pType = mono_signature_get_params(pSignature, &pIter);
if(mono::object item = pArgs->GetItem(i))
{
MonoClass *pItemClass = mono_object_get_class((MonoObject *)item);
MonoType *pItemType = mono_class_get_type(pItemClass);
MonoTypeEnum itemMonoType = (MonoTypeEnum)mono_type_get_type(pItemType);
MonoTypeEnum monoType = (MonoTypeEnum)mono_type_get_type(pType);
if(itemMonoType != monoType)
{
// exceptions:
// Anything can be treated as object.
if(monoType == MONO_TYPE_OBJECT) {}
// The runtime confuses things with value types a lot, so ignore parameters that appear with that type.
else if(itemMonoType == MONO_TYPE_VALUETYPE || monoType == MONO_TYPE_VALUETYPE) {}
else
{
if(MonoClass *pMethodParameterClass = mono_type_get_class(pType))
{
MonoWarning("Parameter mismatch when searching for method %s in class %s.%s, on parameter %i: Provided type %s.%s does not match expected parameter type %s.%s.",
name, mono_class_get_namespace(pClass), mono_class_get_name(pClass), i + 1, mono_class_get_namespace(pItemClass), mono_class_get_name(pItemClass), mono_class_get_namespace(pMethodParameterClass), mono_class_get_name(pMethodParameterClass));
}
else
{
MonoWarning("Parameter mismatch when searching for method %s in class %s.%s, on parameter %i: Provided type %s.%s does not match parameter type.",
name, mono_class_get_namespace(pClass), mono_class_get_name(pClass), i + 1, mono_class_get_namespace(pItemClass), mono_class_get_name(pItemClass));
}
break;
}
}
}
if(i + 1 == suppliedArgsCount)
return new CScriptMethod(pCurMethod);
}
}
}
if(throwOnFail)
{
if(IMonoException *pException = GetMonoScriptSystem()->GetCorlibAssembly()->GetException("System", "MissingMethodException", "Failed to locate method %s in class %s", name, GetName()))
pException->Throw();
}
return nullptr;
}
