void mono_debug_domain_unload (MonoDomain *domain) { MonoDebugDataTable *table; if (!mono_debug_initialized) return; mono_debugger_lock (); table = g_hash_table_lookup (data_table_hash, domain); if (!table) { g_warning (G_STRLOC ": unloading unknown domain %p / %d", domain, mono_domain_get_id (domain)); mono_debugger_unlock (); return; } mono_debugger_event (MONO_DEBUGGER_EVENT_DOMAIN_UNLOAD, (guint64) (gsize) table, mono_domain_get_id (domain)); g_hash_table_remove (data_table_hash, domain); mono_debugger_unlock (); }
Error GDMono::finalize_and_unload_domain(MonoDomain *p_domain) { CRASH_COND(p_domain == NULL); String domain_name = mono_domain_get_friendly_name(p_domain); print_verbose("Mono: Unloading domain `" + domain_name + "`..."); if (mono_domain_get() != root_domain) mono_domain_set(root_domain, true); mono_gc_collect(mono_gc_max_generation()); mono_domain_finalize(p_domain, 2000); mono_gc_collect(mono_gc_max_generation()); _domain_assemblies_cleanup(mono_domain_get_id(p_domain)); MonoException *exc = NULL; mono_domain_try_unload(p_domain, (MonoObject **)&exc); if (exc) { ERR_PRINTS("Exception thrown when unloading domain `" + domain_name + "`"); GDMonoUtils::debug_unhandled_exception(exc); return FAILED; } return OK; }
bool GDMono::_load_assembly(const String &p_name, GDMonoAssembly **r_assembly) { CRASH_COND(!r_assembly); if (OS::get_singleton()->is_stdout_verbose()) OS::get_singleton()->print((String() + "Mono: Loading assembly " + p_name + "...\n").utf8()); MonoImageOpenStatus status = MONO_IMAGE_OK; MonoAssemblyName *aname = mono_assembly_name_new(p_name.utf8()); MonoAssembly *assembly = mono_assembly_load_full(aname, NULL, &status, false); mono_assembly_name_free(aname); if (!assembly) return false; uint32_t domain_id = mono_domain_get_id(mono_domain_get()); GDMonoAssembly **stored_assembly = assemblies[domain_id].getptr(p_name); ERR_FAIL_COND_V(status != MONO_IMAGE_OK, false); ERR_FAIL_COND_V(stored_assembly == NULL, false); ERR_FAIL_COND_V((*stored_assembly)->get_assembly() != assembly, false); *r_assembly = *stored_assembly; if (OS::get_singleton()->is_stdout_verbose()) OS::get_singleton()->print(String("Mono: Assembly " + p_name + " loaded from path: " + (*r_assembly)->get_path() + "\n").utf8()); return true; }
bool GDMono::load_assembly(const String &p_name, MonoAssemblyName *p_aname, GDMonoAssembly **r_assembly, bool p_refonly) { CRASH_COND(!r_assembly); print_verbose("Mono: Loading assembly " + p_name + (p_refonly ? " (refonly)" : "") + "..."); MonoImageOpenStatus status = MONO_IMAGE_OK; MonoAssembly *assembly = mono_assembly_load_full(p_aname, NULL, &status, p_refonly); if (!assembly) return false; ERR_FAIL_COND_V(status != MONO_IMAGE_OK, false); uint32_t domain_id = mono_domain_get_id(mono_domain_get()); GDMonoAssembly **stored_assembly = assemblies[domain_id].getptr(p_name); ERR_FAIL_COND_V(stored_assembly == NULL, false); ERR_FAIL_COND_V((*stored_assembly)->get_assembly() != assembly, false); *r_assembly = *stored_assembly; print_verbose("Mono: Assembly " + p_name + (p_refonly ? " (refonly)" : "") + " loaded from path: " + (*r_assembly)->get_path()); return true; }
MonoAssembly *gdmono_load_assembly_from(const String &p_name, const String &p_path) { MonoDomain *domain = mono_domain_get(); GDMonoAssembly *assembly = memnew(GDMonoAssembly(p_name, p_path)); Error err = assembly->load(domain); ERR_FAIL_COND_V(err != OK, NULL); GDMono::get_singleton()->add_assembly(mono_domain_get_id(domain), assembly); return assembly->get_assembly(); }
void mono_debugger_event_create_appdomain (MonoDomain *domain, gchar *shadow_path) { AppDomainSetupInfo info; info.id = mono_domain_get_id (domain); info.shadow_path_len = shadow_path ? strlen (shadow_path) : 0; info.shadow_path = shadow_path; info.domain = domain; info.setup = domain->setup; mono_debugger_event (MONO_DEBUGGER_EVENT_CREATE_APPDOMAIN, (guint64) (gsize) &info, 0); }
void mono_debug_domain_create (MonoDomain *domain) { MonoDebugDataTable *table; if (!mono_debug_initialized) return; mono_debugger_lock (); table = create_data_table (domain); mono_debugger_event (MONO_DEBUGGER_EVENT_DOMAIN_CREATE, (guint64) (gsize) table, mono_domain_get_id (domain)); mono_debugger_unlock (); }
MonoAssembly *GDMonoAssembly::_load_assembly_from(const String &p_name, const String &p_path) { GDMonoAssembly *assembly = memnew(GDMonoAssembly(p_name, p_path)); MonoDomain *domain = mono_domain_get(); Error err = assembly->load(domain); if (err != OK) { memdelete(assembly); ERR_FAIL_V(NULL); } GDMono::get_singleton()->add_assembly(domain ? mono_domain_get_id(domain) : 0, assembly); return assembly->get_assembly(); }
Error GDMono::_unload_scripts_domain() { ERR_FAIL_NULL_V(scripts_domain, ERR_BUG); if (OS::get_singleton()->is_stdout_verbose()) { OS::get_singleton()->print("Mono: Unloading scripts domain...\n"); } _GodotSharp::get_singleton()->_dispose_callback(); if (mono_domain_get() != root_domain) mono_domain_set(root_domain, true); mono_gc_collect(mono_gc_max_generation()); finalizing_scripts_domain = true; mono_domain_finalize(scripts_domain, 2000); finalizing_scripts_domain = false; mono_gc_collect(mono_gc_max_generation()); _domain_assemblies_cleanup(mono_domain_get_id(scripts_domain)); api_assembly = NULL; project_assembly = NULL; #ifdef TOOLS_ENABLED editor_api_assembly = NULL; #endif MonoDomain *domain = scripts_domain; scripts_domain = NULL; _GodotSharp::get_singleton()->_dispose_callback(); MonoObject *ex = NULL; mono_domain_try_unload(domain, &ex); if (ex) { ERR_PRINT("Exception thrown when unloading scripts domain:"); mono_print_unhandled_exception(ex); return FAILED; } return OK; }
Error GDMono::_unload_scripts_domain() { ERR_FAIL_NULL_V(scripts_domain, ERR_BUG); print_verbose("Mono: Unloading scripts domain..."); _GodotSharp::get_singleton()->_dispose_callback(); if (mono_domain_get() != root_domain) mono_domain_set(root_domain, true); mono_gc_collect(mono_gc_max_generation()); mono_domain_finalize(scripts_domain, 2000); mono_gc_collect(mono_gc_max_generation()); _domain_assemblies_cleanup(mono_domain_get_id(scripts_domain)); core_api_assembly = NULL; project_assembly = NULL; #ifdef TOOLS_ENABLED editor_api_assembly = NULL; #endif core_api_assembly_out_of_sync = false; editor_api_assembly_out_of_sync = false; MonoDomain *domain = scripts_domain; scripts_domain = NULL; _GodotSharp::get_singleton()->_dispose_callback(); MonoException *exc = NULL; mono_domain_try_unload(domain, (MonoObject **)&exc); if (exc) { ERR_PRINT("Exception thrown when unloading scripts domain"); GDMonoUtils::debug_unhandled_exception(exc); return FAILED; } return OK; }
void mono_debug_domain_unload (MonoDomain *domain) { MonoDebugDataTable *table; if (!mono_debug_initialized) return; mono_debugger_lock (); table = (MonoDebugDataTable *)g_hash_table_lookup (data_table_hash, domain); if (!table) { g_warning (G_STRLOC ": unloading unknown domain %p / %d", domain, mono_domain_get_id (domain)); mono_debugger_unlock (); return; } g_hash_table_remove (data_table_hash, domain); mono_debugger_unlock (); }
GDMonoClass *GDMono::get_class(MonoClass *p_raw_class) { MonoImage *image = mono_class_get_image(p_raw_class); if (image == corlib_assembly->get_image()) return corlib_assembly->get_class(p_raw_class); uint32_t domain_id = mono_domain_get_id(mono_domain_get()); HashMap<String, GDMonoAssembly *> &domain_assemblies = assemblies[domain_id]; const String *k = NULL; while ((k = domain_assemblies.next(k))) { GDMonoAssembly *assembly = domain_assemblies.get(*k); if (assembly->get_image() == image) { GDMonoClass *klass = assembly->get_class(p_raw_class); if (klass) return klass; } } return NULL; }
static MonoDebugDataTable * create_data_table (MonoDomain *domain) { MonoDebugDataTable *table; MonoDebugDataChunk *chunk; table = g_new0 (MonoDebugDataTable, 1); table->domain = domain ? mono_domain_get_id (domain) : -1; table->method_address_hash = g_hash_table_new (NULL, NULL); table->method_hash = g_hash_table_new (NULL, NULL); chunk = g_malloc0 (sizeof (MonoDebugDataChunk) + DATA_TABLE_CHUNK_SIZE); chunk->total_size = DATA_TABLE_CHUNK_SIZE; table->first_chunk = table->current_chunk = chunk; if (domain) { mono_debug_list_add (&mono_symbol_table->data_tables, table); g_hash_table_insert (data_table_hash, domain, table); } return table; }
MonoDebugMethodAddress * mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain) { MonoMethod *declaring; MonoDebugDataTable *table; MonoDebugMethodHeader *header; MonoDebugMethodAddress *address; MonoDebugMethodInfo *minfo; MonoDebugHandle *handle; guint8 buffer [BUFSIZ]; guint8 *ptr, *oldptr; guint32 i, size, total_size, max_size; gboolean is_wrapper = FALSE; mono_debugger_lock (); table = lookup_data_table (domain); handle = _mono_debug_get_image (method->klass->image); minfo = _mono_debug_lookup_method (method); if (!minfo || (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) || (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) || (method->flags & METHOD_ATTRIBUTE_ABSTRACT) || (method->wrapper_type != MONO_WRAPPER_NONE)) { is_wrapper = TRUE; } max_size = (5 * 5) + 1 + (10 * jit->num_line_numbers) + (25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals); if (max_size > BUFSIZ) ptr = oldptr = g_malloc (max_size); else ptr = oldptr = buffer; write_leb128 (jit->prologue_end, ptr, &ptr); write_leb128 (jit->epilogue_begin, ptr, &ptr); write_leb128 (jit->num_line_numbers, ptr, &ptr); for (i = 0; i < jit->num_line_numbers; i++) { MonoDebugLineNumberEntry *lne = &jit->line_numbers [i]; write_sleb128 (lne->il_offset, ptr, &ptr); write_sleb128 (lne->native_offset, ptr, &ptr); } *ptr++ = jit->this_var ? 1 : 0; if (jit->this_var) write_variable (jit->this_var, ptr, &ptr); write_leb128 (jit->num_params, ptr, &ptr); for (i = 0; i < jit->num_params; i++) write_variable (&jit->params [i], ptr, &ptr); write_leb128 (jit->num_locals, ptr, &ptr); for (i = 0; i < jit->num_locals; i++) write_variable (&jit->locals [i], ptr, &ptr); size = ptr - oldptr; g_assert (size < max_size); total_size = size + sizeof (MonoDebugMethodAddress); address = (MonoDebugMethodAddress *) allocate_data_item ( table, MONO_DEBUG_DATA_ITEM_METHOD, total_size); address->header.size = total_size; address->header.symfile_id = handle ? handle->index : 0; address->header.domain_id = mono_domain_get_id (domain); address->header.method_id = is_wrapper ? 0 : minfo->index; address->header.method = method; address->code_start = jit->code_start; address->code_size = jit->code_size; memcpy (&address->data, oldptr, size); if (max_size > BUFSIZ) g_free (oldptr); declaring = method->is_inflated ? ((MonoMethodInflated *) method)->declaring : method; header = g_hash_table_lookup (table->method_hash, declaring); if (!header) { header = &address->header; g_hash_table_insert (table->method_hash, declaring, header); if (is_wrapper) { MonoDebugWrapperData *wrapper; header->wrapper_data = wrapper = g_new0 (MonoDebugWrapperData, 1); wrapper->wrapper_type = method->wrapper_type; wrapper->method_name = mono_method_full_name (declaring, TRUE); wrapper->obsolete_cil_code = ""; } } else { address->header.wrapper_data = header->wrapper_data; header->address_list = g_slist_prepend (header->address_list, address); } g_hash_table_insert (table->method_address_hash, method, address); write_data_item (table, (guint8 *) address); mono_debugger_unlock (); return address; }
static void foreach_domain_callback (MonoDomain *domain, void *user_data) { std::vector<int> *v = (std::vector<int>*)user_data; v->push_back (mono_domain_get_id (domain)); }
int32_t _GodotSharp::get_scripts_domain_id() { MonoDomain *domain = SCRIPTS_DOMAIN; CRASH_COND(!domain); // User must check if scripts domain is loaded before calling this method return mono_domain_get_id(domain); }
int32_t _GodotSharp::get_domain_id() { MonoDomain *domain = mono_domain_get(); CRASH_COND(!domain); // User must check if runtime is initialized before calling this method return mono_domain_get_id(domain); }
void mono_debugger_event_unload_appdomain (MonoDomain *domain) { mono_debugger_event (MONO_DEBUGGER_EVENT_UNLOAD_APPDOMAIN, (guint64) (gsize) domain, (guint64) mono_domain_get_id (domain)); }