2017-10-02 23:24:00 +02:00
|
|
|
/*************************************************************************/
|
|
|
|
/* gd_mono.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
|
|
|
/* https://godotengine.org */
|
|
|
|
/*************************************************************************/
|
2021-01-01 20:13:46 +01:00
|
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
|
2017-10-02 23:24:00 +02:00
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
#include "gd_mono.h"
|
|
|
|
|
2019-04-18 13:58:55 +02:00
|
|
|
#include <mono/metadata/environment.h>
|
2017-10-23 00:35:04 +02:00
|
|
|
#include <mono/metadata/exception.h>
|
2017-10-02 23:24:00 +02:00
|
|
|
#include <mono/metadata/mono-config.h>
|
|
|
|
#include <mono/metadata/mono-debug.h>
|
2017-10-05 00:12:36 +02:00
|
|
|
#include <mono/metadata/mono-gc.h>
|
2019-03-03 01:57:35 +01:00
|
|
|
#include <mono/metadata/profiler.h>
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-11-07 23:33:38 +01:00
|
|
|
#include "core/config/project_settings.h"
|
2020-02-27 03:30:20 +01:00
|
|
|
#include "core/debugger/engine_debugger.h"
|
2021-06-11 14:51:48 +02:00
|
|
|
#include "core/io/dir_access.h"
|
|
|
|
#include "core/io/file_access.h"
|
2018-09-11 18:13:45 +02:00
|
|
|
#include "core/os/os.h"
|
|
|
|
#include "core/os/thread.h"
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
#include "../csharp_script.h"
|
2018-02-22 13:13:51 +01:00
|
|
|
#include "../godotsharp_dirs.h"
|
2017-10-02 23:24:00 +02:00
|
|
|
#include "../utils/path_utils.h"
|
2019-11-10 17:10:38 +01:00
|
|
|
#include "gd_mono_cache.h"
|
2017-10-02 23:24:00 +02:00
|
|
|
#include "gd_mono_utils.h"
|
|
|
|
|
|
|
|
#ifdef TOOLS_ENABLED
|
2018-02-16 16:00:54 +01:00
|
|
|
#include "main/main.h"
|
2017-10-02 23:24:00 +02:00
|
|
|
#endif
|
|
|
|
|
2019-07-03 17:41:07 +02:00
|
|
|
#ifdef ANDROID_ENABLED
|
2019-08-26 17:46:57 +02:00
|
|
|
#include "android_mono_config.h"
|
2020-03-18 17:40:04 +01:00
|
|
|
#include "support/android_support.h"
|
|
|
|
#elif defined(IPHONE_ENABLED)
|
|
|
|
#include "support/ios_support.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(TOOL_ENABLED) && defined(GD_MONO_SINGLE_APPDOMAIN)
|
|
|
|
// This will no longer be the case if we replace appdomains with AssemblyLoadContext
|
|
|
|
#error "Editor build requires support for multiple appdomains"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(GD_MONO_HOT_RELOAD) && defined(GD_MONO_SINGLE_APPDOMAIN)
|
|
|
|
#error "Hot reloading requires multiple appdomains"
|
2019-07-03 17:41:07 +02:00
|
|
|
#endif
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
// TODO:
|
2021-08-13 16:46:14 +02:00
|
|
|
// This has turned into a gigantic mess. There's too much going on here. Too much #ifdef as well.
|
2019-11-10 17:10:38 +01:00
|
|
|
// It's just painful to read... It needs to be re-structured. Please, clean this up, future me.
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
GDMono *GDMono::singleton = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2018-03-18 23:02:06 +01:00
|
|
|
namespace {
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
#if defined(JAVASCRIPT_ENABLED)
|
|
|
|
extern "C" {
|
|
|
|
void mono_wasm_load_runtime(const char *managed_path, int enable_debugging);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if !defined(JAVASCRIPT_ENABLED)
|
|
|
|
|
|
|
|
void gd_mono_setup_runtime_main_args() {
|
2018-03-18 23:02:06 +01:00
|
|
|
CharString execpath = OS::get_singleton()->get_executable_path().utf8();
|
|
|
|
|
|
|
|
List<String> cmdline_args = OS::get_singleton()->get_cmdline_args();
|
|
|
|
|
|
|
|
List<CharString> cmdline_args_utf8;
|
|
|
|
Vector<char *> main_args;
|
|
|
|
main_args.resize(cmdline_args.size() + 1);
|
|
|
|
|
2018-07-25 03:11:03 +02:00
|
|
|
main_args.write[0] = execpath.ptrw();
|
2018-03-18 23:02:06 +01:00
|
|
|
|
|
|
|
int i = 1;
|
2021-07-24 15:46:25 +02:00
|
|
|
for (const String &E : cmdline_args) {
|
2021-07-16 05:45:57 +02:00
|
|
|
CharString &stored = cmdline_args_utf8.push_back(E.utf8())->get();
|
2018-07-25 03:11:03 +02:00
|
|
|
main_args.write[i] = stored.ptrw();
|
2018-03-18 23:02:06 +01:00
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
mono_runtime_set_main_args(main_args.size(), main_args.ptrw());
|
|
|
|
}
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
void gd_mono_profiler_init() {
|
2019-03-03 01:57:35 +01:00
|
|
|
String profiler_args = GLOBAL_DEF("mono/profiler/args", "log:calls,alloc,sample,output=output.mlpd");
|
|
|
|
bool profiler_enabled = GLOBAL_DEF("mono/profiler/enabled", false);
|
|
|
|
if (profiler_enabled) {
|
|
|
|
mono_profiler_load(profiler_args.utf8());
|
2019-12-16 20:34:30 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const String env_var_name = "MONO_ENV_OPTIONS";
|
|
|
|
if (OS::get_singleton()->has_environment(env_var_name)) {
|
2021-04-25 16:40:58 +02:00
|
|
|
const String mono_env_ops = OS::get_singleton()->get_environment(env_var_name);
|
2019-12-16 20:34:30 +01:00
|
|
|
// Usually MONO_ENV_OPTIONS looks like: --profile=jb:prof=timeline,ctl=remote,host=127.0.0.1:55467
|
|
|
|
const String prefix = "--profile=";
|
|
|
|
if (mono_env_ops.begins_with(prefix)) {
|
2021-04-25 16:40:58 +02:00
|
|
|
const String ops = mono_env_ops.substr(prefix.length(), mono_env_ops.length());
|
2019-12-16 20:34:30 +01:00
|
|
|
mono_profiler_load(ops.utf8());
|
|
|
|
}
|
2019-03-03 01:57:35 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
void gd_mono_debug_init() {
|
2019-09-25 22:02:24 +02:00
|
|
|
CharString da_args = OS::get_singleton()->get_environment("GODOT_MONO_DEBUGGER_AGENT").utf8();
|
|
|
|
|
2020-05-09 20:45:43 +02:00
|
|
|
if (da_args.length()) {
|
|
|
|
OS::get_singleton()->set_environment("GODOT_MONO_DEBUGGER_AGENT", String());
|
|
|
|
}
|
|
|
|
|
2019-09-25 22:02:24 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2017-10-02 23:24:00 +02:00
|
|
|
int da_port = GLOBAL_DEF("mono/debugger_agent/port", 23685);
|
|
|
|
bool da_suspend = GLOBAL_DEF("mono/debugger_agent/wait_for_debugger", false);
|
|
|
|
int da_timeout = GLOBAL_DEF("mono/debugger_agent/wait_timeout", 3000);
|
|
|
|
|
|
|
|
if (Engine::get_singleton()->is_editor_hint() ||
|
2020-12-15 13:04:21 +01:00
|
|
|
ProjectSettings::get_singleton()->get_resource_path().is_empty() ||
|
2018-02-16 16:00:54 +01:00
|
|
|
Main::is_project_manager()) {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (da_args.size() == 0) {
|
2019-07-03 09:44:53 +02:00
|
|
|
return;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2019-02-03 06:51:07 +01:00
|
|
|
if (da_args.length() == 0) {
|
2019-01-21 22:44:05 +01:00
|
|
|
da_args = String("--debugger-agent=transport=dt_socket,address=127.0.0.1:" + itos(da_port) +
|
|
|
|
",embedding=1,server=y,suspend=" + (da_suspend ? "y,timeout=" + itos(da_timeout) : "n"))
|
|
|
|
.utf8();
|
|
|
|
}
|
2019-09-25 22:02:24 +02:00
|
|
|
#else
|
|
|
|
if (da_args.length() == 0)
|
|
|
|
return; // Exported games don't use the project settings to setup the debugger agent
|
|
|
|
#endif
|
2019-01-21 22:44:05 +01:00
|
|
|
|
2020-04-22 16:44:03 +02:00
|
|
|
// Debugging enabled
|
|
|
|
|
|
|
|
mono_debug_init(MONO_DEBUG_FORMAT_MONO);
|
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
// --debugger-agent=help
|
|
|
|
const char *options[] = {
|
|
|
|
"--soft-breakpoints",
|
|
|
|
da_args.get_data()
|
|
|
|
};
|
|
|
|
mono_jit_parse_options(2, (char **)options);
|
|
|
|
}
|
2018-03-18 23:02:06 +01:00
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
#endif // !defined(JAVASCRIPT_ENABLED)
|
|
|
|
|
|
|
|
#if defined(JAVASCRIPT_ENABLED)
|
|
|
|
MonoDomain *gd_initialize_mono_runtime() {
|
|
|
|
const char *vfs_prefix = "managed";
|
|
|
|
int enable_debugging = 0;
|
|
|
|
|
2020-04-22 16:44:03 +02:00
|
|
|
// TODO: Provide a way to enable debugging on WASM release builds.
|
2019-11-10 17:10:38 +01:00
|
|
|
#ifdef DEBUG_ENABLED
|
|
|
|
enable_debugging = 1;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
mono_wasm_load_runtime(vfs_prefix, enable_debugging);
|
|
|
|
|
|
|
|
return mono_get_root_domain();
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
MonoDomain *gd_initialize_mono_runtime() {
|
|
|
|
gd_mono_debug_init();
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
#if defined(IPHONE_ENABLED) || defined(ANDROID_ENABLED)
|
|
|
|
// I don't know whether this actually matters or not
|
|
|
|
const char *runtime_version = "mobile";
|
|
|
|
#else
|
|
|
|
const char *runtime_version = "v4.0.30319";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return mono_jit_init_version("GodotEngine.RootDomain", runtime_version);
|
2019-11-10 17:10:38 +01:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
#endif
|
2018-03-18 23:02:06 +01:00
|
|
|
} // namespace
|
|
|
|
|
2019-01-29 23:00:30 +01:00
|
|
|
void GDMono::add_mono_shared_libs_dir_to_path() {
|
2019-11-10 17:10:38 +01:00
|
|
|
// TODO: Replace this with a mono_dl_fallback
|
|
|
|
|
2019-01-29 23:00:30 +01:00
|
|
|
// By default Mono seems to search shared libraries in the following directories:
|
|
|
|
// Current working directory, @executable_path@ and PATH
|
|
|
|
// The parent directory of the image file (assembly where the dllimport method is declared)
|
|
|
|
// @executable_path@/../lib
|
|
|
|
// @executable_path@/../Libraries (__MACH__ only)
|
|
|
|
|
|
|
|
// This does not work when embedding Mono unless we use the same directory structure.
|
|
|
|
// To fix this we append the directory containing our shared libraries to PATH.
|
|
|
|
|
|
|
|
#if defined(WINDOWS_ENABLED) || defined(UNIX_ENABLED)
|
|
|
|
String path_var("PATH");
|
|
|
|
String path_value = OS::get_singleton()->get_environment(path_var);
|
|
|
|
|
|
|
|
#ifdef WINDOWS_ENABLED
|
|
|
|
path_value += ';';
|
|
|
|
|
|
|
|
String bundled_bin_dir = GodotSharpDirs::get_data_mono_bin_dir();
|
2019-02-15 18:49:04 +01:00
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
if (DirAccess::exists(bundled_bin_dir)) {
|
|
|
|
path_value += bundled_bin_dir;
|
|
|
|
} else {
|
|
|
|
path_value += mono_reg_info.bin_dir;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (DirAccess::exists(bundled_bin_dir))
|
|
|
|
path_value += bundled_bin_dir;
|
|
|
|
#endif // TOOLS_ENABLED
|
|
|
|
|
2019-01-29 23:00:30 +01:00
|
|
|
#else
|
|
|
|
path_value += ':';
|
|
|
|
|
|
|
|
String bundled_lib_dir = GodotSharpDirs::get_data_mono_lib_dir();
|
|
|
|
if (DirAccess::exists(bundled_lib_dir)) {
|
|
|
|
path_value += bundled_lib_dir;
|
|
|
|
} else {
|
|
|
|
// TODO: Do we need to add the lib dir when using the system installed Mono on Unix platforms?
|
|
|
|
}
|
2019-02-15 18:49:04 +01:00
|
|
|
#endif // WINDOWS_ENABLED
|
2019-01-29 23:00:30 +01:00
|
|
|
|
|
|
|
OS::get_singleton()->set_environment(path_var, path_value);
|
2019-02-15 18:49:04 +01:00
|
|
|
#endif // WINDOWS_ENABLED || UNIX_ENABLED
|
2019-01-29 23:00:30 +01:00
|
|
|
}
|
|
|
|
|
2019-11-28 23:42:37 +01:00
|
|
|
void GDMono::determine_mono_dirs(String &r_assembly_rootdir, String &r_config_dir) {
|
|
|
|
String bundled_assembly_rootdir = GodotSharpDirs::get_data_mono_lib_dir();
|
|
|
|
String bundled_config_dir = GodotSharpDirs::get_data_mono_etc_dir();
|
2018-10-03 19:01:57 +02:00
|
|
|
|
|
|
|
#ifdef TOOLS_ENABLED
|
2019-11-28 23:42:37 +01:00
|
|
|
|
2019-04-05 23:20:20 +02:00
|
|
|
#if defined(WINDOWS_ENABLED)
|
2017-10-02 23:24:00 +02:00
|
|
|
mono_reg_info = MonoRegUtils::find_mono();
|
|
|
|
|
|
|
|
if (mono_reg_info.assembly_dir.length() && DirAccess::exists(mono_reg_info.assembly_dir)) {
|
2019-11-28 23:42:37 +01:00
|
|
|
r_assembly_rootdir = mono_reg_info.assembly_dir;
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (mono_reg_info.config_dir.length() && DirAccess::exists(mono_reg_info.config_dir)) {
|
2019-11-28 23:42:37 +01:00
|
|
|
r_config_dir = mono_reg_info.config_dir;
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
2019-04-05 23:20:20 +02:00
|
|
|
#elif defined(OSX_ENABLED)
|
2018-10-03 19:01:57 +02:00
|
|
|
const char *c_assembly_rootdir = mono_assembly_getrootdir();
|
|
|
|
const char *c_config_dir = mono_get_config_dir();
|
|
|
|
|
|
|
|
if (!c_assembly_rootdir || !c_config_dir || !DirAccess::exists(c_assembly_rootdir) || !DirAccess::exists(c_config_dir)) {
|
|
|
|
Vector<const char *> locations;
|
|
|
|
locations.push_back("/Library/Frameworks/Mono.framework/Versions/Current/");
|
|
|
|
locations.push_back("/usr/local/var/homebrew/linked/mono/");
|
|
|
|
|
|
|
|
for (int i = 0; i < locations.size(); i++) {
|
2019-07-08 15:16:35 +02:00
|
|
|
String hint_assembly_rootdir = path::join(locations[i], "lib");
|
|
|
|
String hint_mscorlib_path = path::join(hint_assembly_rootdir, "mono", "4.5", "mscorlib.dll");
|
|
|
|
String hint_config_dir = path::join(locations[i], "etc");
|
2018-10-03 19:01:57 +02:00
|
|
|
|
|
|
|
if (FileAccess::exists(hint_mscorlib_path) && DirAccess::exists(hint_config_dir)) {
|
2019-11-28 23:42:37 +01:00
|
|
|
r_assembly_rootdir = hint_assembly_rootdir;
|
|
|
|
r_config_dir = hint_config_dir;
|
2018-10-03 19:01:57 +02:00
|
|
|
break;
|
2018-09-06 19:38:24 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-10-03 19:01:57 +02:00
|
|
|
#endif
|
|
|
|
|
2019-05-20 18:34:35 +02:00
|
|
|
if (DirAccess::exists(bundled_assembly_rootdir)) {
|
2019-11-28 23:42:37 +01:00
|
|
|
r_assembly_rootdir = bundled_assembly_rootdir;
|
2019-05-20 18:34:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (DirAccess::exists(bundled_config_dir)) {
|
2019-11-28 23:42:37 +01:00
|
|
|
r_config_dir = bundled_config_dir;
|
2018-10-03 19:01:57 +02:00
|
|
|
}
|
2019-02-15 19:04:45 +01:00
|
|
|
|
|
|
|
#ifdef WINDOWS_ENABLED
|
2020-12-15 13:04:21 +01:00
|
|
|
if (r_assembly_rootdir.is_empty() || r_config_dir.is_empty()) {
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_PRINT("Cannot find Mono in the registry.");
|
2019-02-15 19:04:45 +01:00
|
|
|
// Assertion: if they are not set, then they weren't found in the registry
|
|
|
|
CRASH_COND(mono_reg_info.assembly_dir.length() > 0 || mono_reg_info.config_dir.length() > 0);
|
|
|
|
}
|
|
|
|
#endif // WINDOWS_ENABLED
|
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
#else
|
2019-11-28 23:42:37 +01:00
|
|
|
// Export templates always use the bundled directories
|
|
|
|
r_assembly_rootdir = bundled_assembly_rootdir;
|
|
|
|
r_config_dir = bundled_config_dir;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void GDMono::initialize() {
|
|
|
|
ERR_FAIL_NULL(Engine::get_singleton());
|
|
|
|
|
|
|
|
print_verbose("Mono: Initializing module...");
|
|
|
|
|
|
|
|
char *runtime_build_info = mono_get_runtime_build_info();
|
|
|
|
print_verbose("Mono JIT compiler version " + String(runtime_build_info));
|
|
|
|
mono_free(runtime_build_info);
|
|
|
|
|
|
|
|
_init_godot_api_hashes();
|
|
|
|
_init_exception_policy();
|
|
|
|
|
|
|
|
GDMonoLog::get_singleton()->initialize();
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
#if !defined(JAVASCRIPT_ENABLED)
|
2019-11-28 23:42:37 +01:00
|
|
|
String assembly_rootdir;
|
|
|
|
String config_dir;
|
|
|
|
determine_mono_dirs(assembly_rootdir, config_dir);
|
|
|
|
|
2018-10-03 19:01:57 +02:00
|
|
|
// Leak if we call mono_set_dirs more than once
|
2020-04-02 01:20:12 +02:00
|
|
|
mono_set_dirs(assembly_rootdir.length() ? assembly_rootdir.utf8().get_data() : nullptr,
|
|
|
|
config_dir.length() ? config_dir.utf8().get_data() : nullptr);
|
2018-10-03 19:01:57 +02:00
|
|
|
|
2019-01-29 23:00:30 +01:00
|
|
|
add_mono_shared_libs_dir_to_path();
|
2019-11-10 17:10:38 +01:00
|
|
|
#endif
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
#ifdef ANDROID_ENABLED
|
|
|
|
mono_config_parse_memory(get_godot_android_mono_config().utf8().get_data());
|
|
|
|
#else
|
2020-04-02 01:20:12 +02:00
|
|
|
mono_config_parse(nullptr);
|
2020-03-18 17:40:04 +01:00
|
|
|
#endif
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
#if defined(ANDROID_ENABLED)
|
2020-03-18 17:40:04 +01:00
|
|
|
gdmono::android::support::initialize();
|
|
|
|
#elif defined(IPHONE_ENABLED)
|
|
|
|
gdmono::ios::support::initialize();
|
2019-11-10 17:10:38 +01:00
|
|
|
#endif
|
2019-01-29 23:00:30 +01:00
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
GDMonoAssembly::initialize();
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
#if !defined(JAVASCRIPT_ENABLED)
|
|
|
|
gd_mono_profiler_init();
|
2017-10-02 23:24:00 +02:00
|
|
|
#endif
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
mono_install_unhandled_exception_hook(&unhandled_exception_hook, nullptr);
|
2018-06-26 21:03:42 +02:00
|
|
|
|
2019-03-09 22:55:44 +01:00
|
|
|
#ifndef TOOLS_ENABLED
|
2019-11-28 23:42:37 +01:00
|
|
|
// Exported games that don't use C# must still work. They likely don't ship with mscorlib.
|
|
|
|
// We only initialize the Mono runtime if we can find mscorlib. Otherwise it would crash.
|
2020-12-15 13:04:21 +01:00
|
|
|
if (GDMonoAssembly::find_assembly("mscorlib.dll").is_empty()) {
|
2019-11-28 23:42:37 +01:00
|
|
|
print_verbose("Mono: Skipping runtime initialization because 'mscorlib.dll' could not be found");
|
2019-07-11 14:01:25 +02:00
|
|
|
return;
|
2019-11-28 23:42:37 +01:00
|
|
|
}
|
2019-02-10 18:34:34 +01:00
|
|
|
#endif
|
|
|
|
|
2019-12-16 15:40:26 +01:00
|
|
|
#if !defined(NO_MONO_THREADS_SUSPEND_WORKAROUND)
|
2019-08-30 01:33:50 +02:00
|
|
|
// FIXME: Temporary workaround. See: https://github.com/godotengine/godot/issues/29812
|
|
|
|
if (!OS::get_singleton()->has_environment("MONO_THREADS_SUSPEND")) {
|
|
|
|
OS::get_singleton()->set_environment("MONO_THREADS_SUSPEND", "preemptive");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2019-12-04 15:07:00 +01:00
|
|
|
// NOTE: Internal calls must be registered after the Mono runtime initialization.
|
2020-04-02 01:20:12 +02:00
|
|
|
// Otherwise registration fails with the error: 'assertion 'hash != nullptr' failed'.
|
2019-12-04 15:07:00 +01:00
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
root_domain = gd_initialize_mono_runtime();
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_FAIL_NULL_MSG(root_domain, "Mono: Failed to initialize runtime.");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
GDMonoUtils::set_main_thread(GDMonoUtils::get_current_thread());
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
#if !defined(JAVASCRIPT_ENABLED)
|
|
|
|
gd_mono_setup_runtime_main_args(); // Required for System.Environment.GetCommandLineArgs
|
|
|
|
#endif
|
2018-03-18 23:02:06 +01:00
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
runtime_initialized = true;
|
|
|
|
|
2018-08-24 08:47:34 +02:00
|
|
|
print_verbose("Mono: Runtime initialized");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-12-04 15:07:00 +01:00
|
|
|
#if defined(ANDROID_ENABLED)
|
2020-03-18 17:40:04 +01:00
|
|
|
gdmono::android::support::register_internal_calls();
|
2019-12-04 15:07:00 +01:00
|
|
|
#endif
|
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
// mscorlib assembly MUST be present at initialization
|
2019-08-09 03:39:45 +02:00
|
|
|
bool corlib_loaded = _load_corlib_assembly();
|
|
|
|
ERR_FAIL_COND_MSG(!corlib_loaded, "Mono: Failed to load mscorlib assembly.");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
#ifndef GD_MONO_SINGLE_APPDOMAIN
|
2019-08-09 03:39:45 +02:00
|
|
|
Error domain_load_err = _load_scripts_domain();
|
|
|
|
ERR_FAIL_COND_MSG(domain_load_err != OK, "Mono: Failed to load scripts domain.");
|
2020-03-18 17:40:04 +01:00
|
|
|
#else
|
|
|
|
scripts_domain = root_domain;
|
|
|
|
#endif
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
_register_internal_calls();
|
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
print_verbose("Mono: INITIALIZED");
|
|
|
|
}
|
2019-07-03 09:44:53 +02:00
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
void GDMono::initialize_load_assemblies() {
|
|
|
|
// Load assemblies. The API and tools assemblies are required,
|
|
|
|
// the application is aborted if these assemblies cannot be loaded.
|
2018-02-22 13:13:51 +01:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
if (!_try_load_api_assemblies()) {
|
|
|
|
CRASH_NOW_MSG("Failed to load one of the API assemblies.");
|
|
|
|
}
|
2018-02-22 13:13:51 +01:00
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
#if defined(TOOLS_ENABLED)
|
2019-08-09 03:39:45 +02:00
|
|
|
bool tool_assemblies_loaded = _load_tools_assemblies();
|
|
|
|
CRASH_COND_MSG(!tool_assemblies_loaded, "Mono: Failed to load '" TOOLS_ASM_NAME "' assemblies.");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (Main::is_project_manager()) {
|
2020-05-22 02:17:06 +02:00
|
|
|
return;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2020-05-30 07:21:24 +02:00
|
|
|
#endif
|
2020-05-22 02:17:06 +02:00
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
// Load the project's main assembly. This doesn't necessarily need to succeed.
|
|
|
|
// The game may not be using .NET at all, or if the project does use .NET and
|
|
|
|
// we're running in the editor, it may just happen to be it wasn't built yet.
|
|
|
|
if (!_load_project_assembly()) {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (OS::get_singleton()->is_stdout_verbose()) {
|
2019-07-11 14:01:25 +02:00
|
|
|
print_error("Mono: Failed to load project assembly");
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2019-07-11 14:01:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
C#: Move marshaling logic and generated glue to C#
We will be progressively moving most code to C#.
The plan is to only use Mono's embedding APIs to set things at launch.
This will make it much easier to later support CoreCLR too which
doesn't have rich embedding APIs.
Additionally the code in C# is more maintainable and makes it easier
to implement new features, e.g.: runtime codegen which we could use to
avoid using reflection for marshaling everytime a field, property or
method is accessed.
SOME NOTES ON INTEROP
We make the same assumptions as GDNative about the size of the Godot
structures we use. We take it a bit further by also assuming the layout
of fields in some cases, which is riskier but let's us squeeze out some
performance by avoiding unnecessary managed to native calls.
Code that deals with native structs is less safe than before as there's
no RAII and copy constructors in C#. It's like using the GDNative C API
directly. One has to take special care to free values they own.
Perhaps we could use roslyn analyzers to check this, but I don't know
any that uses attributes to determine what's owned or borrowed.
As to why we maily use pointers for native structs instead of ref/out:
- AFAIK (and confirmed with a benchmark) ref/out are pinned
during P/Invoke calls and that has a cost.
- Native struct fields can't be ref/out in the first place.
- A `using` local can't be passed as ref/out, only `in`. Calling a
method or property on an `in` value makes a silent copy, so we want
to avoid `in`.
REGARDING THE BUILD SYSTEM
There's no longer a `mono_glue=yes/no` SCons options. We no longer
need to build with `mono_glue=no`, generate the glue and then build
again with `mono_glue=yes`. We build only once and generate the glue
(which is in C# now).
However, SCons no longer builds the C# projects for us. Instead one
must run `build_assemblies.py`, e.g.:
```sh
%godot_src_root%/modules/mono/build_scripts/build_assemblies.py \
--godot-output-dir=%godot_src_root%/bin \
--godot-target=release_debug`
```
We could turn this into a custom build target, but I don't know how
to do that with SCons (it's possible with Meson).
OTHER NOTES
Most of the moved code doesn't follow the C# naming convention and
still has the word Mono in the names despite no longer dealing with
Mono's embedding APIs. This is just temporary while transitioning,
to make it easier to understand what was moved where.
2021-05-03 15:21:06 +02:00
|
|
|
void godot_register_object_icalls();
|
|
|
|
void godot_register_placeholder_icalls();
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
void GDMono::_register_internal_calls() {
|
C#: Move marshaling logic and generated glue to C#
We will be progressively moving most code to C#.
The plan is to only use Mono's embedding APIs to set things at launch.
This will make it much easier to later support CoreCLR too which
doesn't have rich embedding APIs.
Additionally the code in C# is more maintainable and makes it easier
to implement new features, e.g.: runtime codegen which we could use to
avoid using reflection for marshaling everytime a field, property or
method is accessed.
SOME NOTES ON INTEROP
We make the same assumptions as GDNative about the size of the Godot
structures we use. We take it a bit further by also assuming the layout
of fields in some cases, which is riskier but let's us squeeze out some
performance by avoiding unnecessary managed to native calls.
Code that deals with native structs is less safe than before as there's
no RAII and copy constructors in C#. It's like using the GDNative C API
directly. One has to take special care to free values they own.
Perhaps we could use roslyn analyzers to check this, but I don't know
any that uses attributes to determine what's owned or borrowed.
As to why we maily use pointers for native structs instead of ref/out:
- AFAIK (and confirmed with a benchmark) ref/out are pinned
during P/Invoke calls and that has a cost.
- Native struct fields can't be ref/out in the first place.
- A `using` local can't be passed as ref/out, only `in`. Calling a
method or property on an `in` value makes a silent copy, so we want
to avoid `in`.
REGARDING THE BUILD SYSTEM
There's no longer a `mono_glue=yes/no` SCons options. We no longer
need to build with `mono_glue=no`, generate the glue and then build
again with `mono_glue=yes`. We build only once and generate the glue
(which is in C# now).
However, SCons no longer builds the C# projects for us. Instead one
must run `build_assemblies.py`, e.g.:
```sh
%godot_src_root%/modules/mono/build_scripts/build_assemblies.py \
--godot-output-dir=%godot_src_root%/bin \
--godot-target=release_debug`
```
We could turn this into a custom build target, but I don't know how
to do that with SCons (it's possible with Meson).
OTHER NOTES
Most of the moved code doesn't follow the C# naming convention and
still has the word Mono in the names despite no longer dealing with
Mono's embedding APIs. This is just temporary while transitioning,
to make it easier to understand what was moved where.
2021-05-03 15:21:06 +02:00
|
|
|
// Registers internal calls that were not generated.
|
|
|
|
godot_register_object_icalls();
|
|
|
|
godot_register_placeholder_icalls();
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2019-11-28 23:42:37 +01:00
|
|
|
void GDMono::_init_godot_api_hashes() {
|
C#: Move marshaling logic and generated glue to C#
We will be progressively moving most code to C#.
The plan is to only use Mono's embedding APIs to set things at launch.
This will make it much easier to later support CoreCLR too which
doesn't have rich embedding APIs.
Additionally the code in C# is more maintainable and makes it easier
to implement new features, e.g.: runtime codegen which we could use to
avoid using reflection for marshaling everytime a field, property or
method is accessed.
SOME NOTES ON INTEROP
We make the same assumptions as GDNative about the size of the Godot
structures we use. We take it a bit further by also assuming the layout
of fields in some cases, which is riskier but let's us squeeze out some
performance by avoiding unnecessary managed to native calls.
Code that deals with native structs is less safe than before as there's
no RAII and copy constructors in C#. It's like using the GDNative C API
directly. One has to take special care to free values they own.
Perhaps we could use roslyn analyzers to check this, but I don't know
any that uses attributes to determine what's owned or borrowed.
As to why we maily use pointers for native structs instead of ref/out:
- AFAIK (and confirmed with a benchmark) ref/out are pinned
during P/Invoke calls and that has a cost.
- Native struct fields can't be ref/out in the first place.
- A `using` local can't be passed as ref/out, only `in`. Calling a
method or property on an `in` value makes a silent copy, so we want
to avoid `in`.
REGARDING THE BUILD SYSTEM
There's no longer a `mono_glue=yes/no` SCons options. We no longer
need to build with `mono_glue=no`, generate the glue and then build
again with `mono_glue=yes`. We build only once and generate the glue
(which is in C# now).
However, SCons no longer builds the C# projects for us. Instead one
must run `build_assemblies.py`, e.g.:
```sh
%godot_src_root%/modules/mono/build_scripts/build_assemblies.py \
--godot-output-dir=%godot_src_root%/bin \
--godot-target=release_debug`
```
We could turn this into a custom build target, but I don't know how
to do that with SCons (it's possible with Meson).
OTHER NOTES
Most of the moved code doesn't follow the C# naming convention and
still has the word Mono in the names despite no longer dealing with
Mono's embedding APIs. This is just temporary while transitioning,
to make it easier to understand what was moved where.
2021-05-03 15:21:06 +02:00
|
|
|
#ifdef DEBUG_METHODS_ENABLED
|
|
|
|
get_api_core_hash();
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
#ifdef TOOLS_ENABLED
|
C#: Move marshaling logic and generated glue to C#
We will be progressively moving most code to C#.
The plan is to only use Mono's embedding APIs to set things at launch.
This will make it much easier to later support CoreCLR too which
doesn't have rich embedding APIs.
Additionally the code in C# is more maintainable and makes it easier
to implement new features, e.g.: runtime codegen which we could use to
avoid using reflection for marshaling everytime a field, property or
method is accessed.
SOME NOTES ON INTEROP
We make the same assumptions as GDNative about the size of the Godot
structures we use. We take it a bit further by also assuming the layout
of fields in some cases, which is riskier but let's us squeeze out some
performance by avoiding unnecessary managed to native calls.
Code that deals with native structs is less safe than before as there's
no RAII and copy constructors in C#. It's like using the GDNative C API
directly. One has to take special care to free values they own.
Perhaps we could use roslyn analyzers to check this, but I don't know
any that uses attributes to determine what's owned or borrowed.
As to why we maily use pointers for native structs instead of ref/out:
- AFAIK (and confirmed with a benchmark) ref/out are pinned
during P/Invoke calls and that has a cost.
- Native struct fields can't be ref/out in the first place.
- A `using` local can't be passed as ref/out, only `in`. Calling a
method or property on an `in` value makes a silent copy, so we want
to avoid `in`.
REGARDING THE BUILD SYSTEM
There's no longer a `mono_glue=yes/no` SCons options. We no longer
need to build with `mono_glue=no`, generate the glue and then build
again with `mono_glue=yes`. We build only once and generate the glue
(which is in C# now).
However, SCons no longer builds the C# projects for us. Instead one
must run `build_assemblies.py`, e.g.:
```sh
%godot_src_root%/modules/mono/build_scripts/build_assemblies.py \
--godot-output-dir=%godot_src_root%/bin \
--godot-target=release_debug`
```
We could turn this into a custom build target, but I don't know how
to do that with SCons (it's possible with Meson).
OTHER NOTES
Most of the moved code doesn't follow the C# naming convention and
still has the word Mono in the names despite no longer dealing with
Mono's embedding APIs. This is just temporary while transitioning,
to make it easier to understand what was moved where.
2021-05-03 15:21:06 +02:00
|
|
|
get_api_editor_hash();
|
2017-10-02 23:24:00 +02:00
|
|
|
#endif // TOOLS_ENABLED
|
C#: Move marshaling logic and generated glue to C#
We will be progressively moving most code to C#.
The plan is to only use Mono's embedding APIs to set things at launch.
This will make it much easier to later support CoreCLR too which
doesn't have rich embedding APIs.
Additionally the code in C# is more maintainable and makes it easier
to implement new features, e.g.: runtime codegen which we could use to
avoid using reflection for marshaling everytime a field, property or
method is accessed.
SOME NOTES ON INTEROP
We make the same assumptions as GDNative about the size of the Godot
structures we use. We take it a bit further by also assuming the layout
of fields in some cases, which is riskier but let's us squeeze out some
performance by avoiding unnecessary managed to native calls.
Code that deals with native structs is less safe than before as there's
no RAII and copy constructors in C#. It's like using the GDNative C API
directly. One has to take special care to free values they own.
Perhaps we could use roslyn analyzers to check this, but I don't know
any that uses attributes to determine what's owned or borrowed.
As to why we maily use pointers for native structs instead of ref/out:
- AFAIK (and confirmed with a benchmark) ref/out are pinned
during P/Invoke calls and that has a cost.
- Native struct fields can't be ref/out in the first place.
- A `using` local can't be passed as ref/out, only `in`. Calling a
method or property on an `in` value makes a silent copy, so we want
to avoid `in`.
REGARDING THE BUILD SYSTEM
There's no longer a `mono_glue=yes/no` SCons options. We no longer
need to build with `mono_glue=no`, generate the glue and then build
again with `mono_glue=yes`. We build only once and generate the glue
(which is in C# now).
However, SCons no longer builds the C# projects for us. Instead one
must run `build_assemblies.py`, e.g.:
```sh
%godot_src_root%/modules/mono/build_scripts/build_assemblies.py \
--godot-output-dir=%godot_src_root%/bin \
--godot-target=release_debug`
```
We could turn this into a custom build target, but I don't know how
to do that with SCons (it's possible with Meson).
OTHER NOTES
Most of the moved code doesn't follow the C# naming convention and
still has the word Mono in the names despite no longer dealing with
Mono's embedding APIs. This is just temporary while transitioning,
to make it easier to understand what was moved where.
2021-05-03 15:21:06 +02:00
|
|
|
#endif // DEBUG_METHODS_ENABLED
|
2019-11-28 23:42:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void GDMono::_init_exception_policy() {
|
|
|
|
PropertyInfo exc_policy_prop = PropertyInfo(Variant::INT, "mono/unhandled_exception_policy", PROPERTY_HINT_ENUM,
|
|
|
|
vformat("Terminate Application:%s,Log Error:%s", (int)POLICY_TERMINATE_APP, (int)POLICY_LOG_ERROR));
|
|
|
|
unhandled_exception_policy = (UnhandledExceptionPolicy)(int)GLOBAL_DEF(exc_policy_prop.name, (int)POLICY_TERMINATE_APP);
|
|
|
|
ProjectSettings::get_singleton()->set_custom_property_info(exc_policy_prop.name, exc_policy_prop);
|
|
|
|
|
|
|
|
if (Engine::get_singleton()->is_editor_hint()) {
|
|
|
|
// Unhandled exceptions should not terminate the editor
|
|
|
|
unhandled_exception_policy = POLICY_LOG_ERROR;
|
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
void GDMono::add_assembly(int32_t p_domain_id, GDMonoAssembly *p_assembly) {
|
2017-10-02 23:24:00 +02:00
|
|
|
assemblies[p_domain_id][p_assembly->get_name()] = p_assembly;
|
|
|
|
}
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
GDMonoAssembly *GDMono::get_loaded_assembly(const String &p_name) {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (p_name == "mscorlib" && corlib_assembly) {
|
2020-05-09 20:54:07 +02:00
|
|
|
return corlib_assembly;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-07 04:21:55 +02:00
|
|
|
|
|
|
|
MonoDomain *domain = mono_domain_get();
|
2020-07-05 19:19:36 +02:00
|
|
|
int32_t domain_id = domain ? mono_domain_get_id(domain) : 0;
|
2020-03-18 17:40:04 +01:00
|
|
|
GDMonoAssembly **result = assemblies[domain_id].getptr(p_name);
|
2020-04-02 01:20:12 +02:00
|
|
|
return result ? *result : nullptr;
|
2017-10-07 04:21:55 +02:00
|
|
|
}
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::load_assembly(const String &p_name, GDMonoAssembly **r_assembly) {
|
2020-05-09 20:54:07 +02:00
|
|
|
#ifdef DEBUG_ENABLED
|
2018-02-22 13:39:41 +01:00
|
|
|
CRASH_COND(!r_assembly);
|
2020-05-09 20:54:07 +02:00
|
|
|
#endif
|
2018-02-22 13:39:41 +01:00
|
|
|
|
|
|
|
MonoAssemblyName *aname = mono_assembly_name_new(p_name.utf8());
|
2021-09-12 20:21:15 +02:00
|
|
|
bool result = load_assembly(p_name, aname, r_assembly);
|
2018-02-22 13:39:41 +01:00
|
|
|
mono_assembly_name_free(aname);
|
|
|
|
mono_free(aname);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::load_assembly(const String &p_name, MonoAssemblyName *p_aname, GDMonoAssembly **r_assembly) {
|
2020-05-09 20:54:07 +02:00
|
|
|
#ifdef DEBUG_ENABLED
|
2017-10-02 23:24:00 +02:00
|
|
|
CRASH_COND(!r_assembly);
|
2020-05-09 20:54:07 +02:00
|
|
|
#endif
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
return load_assembly(p_name, p_aname, r_assembly, GDMonoAssembly::get_default_search_dirs());
|
2020-05-09 20:54:07 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::load_assembly(const String &p_name, MonoAssemblyName *p_aname, GDMonoAssembly **r_assembly, const Vector<String> &p_search_dirs) {
|
2020-05-09 20:54:07 +02:00
|
|
|
#ifdef DEBUG_ENABLED
|
|
|
|
CRASH_COND(!r_assembly);
|
|
|
|
#endif
|
2018-02-22 13:39:41 +01:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
print_verbose("Mono: Loading assembly " + p_name + "...");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
GDMonoAssembly *assembly = GDMonoAssembly::load(p_name, p_aname, /* refonly: */ false, p_search_dirs);
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (!assembly) {
|
2020-05-09 20:54:07 +02:00
|
|
|
return false;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2018-02-22 13:39:41 +01:00
|
|
|
|
2020-05-09 20:54:07 +02:00
|
|
|
*r_assembly = assembly;
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
print_verbose("Mono: Assembly " + p_name + " loaded from path: " + (*r_assembly)->get_path());
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::load_assembly_from(const String &p_name, const String &p_path, GDMonoAssembly **r_assembly) {
|
2018-10-19 19:02:52 +02:00
|
|
|
CRASH_COND(!r_assembly);
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
print_verbose("Mono: Loading assembly " + p_name + "...");
|
2018-10-19 19:02:52 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
GDMonoAssembly *assembly = GDMonoAssembly::load_from(p_name, p_path, /* refonly: */ false);
|
2018-10-19 19:02:52 +02:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (!assembly) {
|
2018-10-19 19:02:52 +02:00
|
|
|
return false;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2018-10-19 19:02:52 +02:00
|
|
|
|
|
|
|
*r_assembly = assembly;
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
print_verbose("Mono: Assembly " + p_name + " loaded from path: " + (*r_assembly)->get_path());
|
2018-10-19 19:02:52 +02:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
bool GDMono::_load_corlib_assembly() {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (corlib_assembly) {
|
2017-10-02 23:24:00 +02:00
|
|
|
return true;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
return load_assembly("mscorlib", &corlib_assembly);
|
2019-07-11 14:01:25 +02:00
|
|
|
}
|
2019-07-03 09:44:53 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::_load_core_api_assembly(GDMonoAssembly **r_loaded_api_assembly, const String &p_config) {
|
|
|
|
if (*r_loaded_api_assembly) {
|
2017-10-02 23:24:00 +02:00
|
|
|
return true;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
return load_assembly(CORE_API_ASSEMBLY_NAME, r_loaded_api_assembly);
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TOOLS_ENABLED
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::_load_editor_api_assembly(GDMonoAssembly **r_loaded_api_assembly, const String &p_config) {
|
|
|
|
if (*r_loaded_api_assembly) {
|
2017-10-02 23:24:00 +02:00
|
|
|
return true;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
return load_assembly(EDITOR_API_ASSEMBLY_NAME, r_loaded_api_assembly);
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
bool GDMono::_try_load_api_assemblies() {
|
|
|
|
String config = get_expected_api_build_config();
|
|
|
|
|
|
|
|
if (!_load_core_api_assembly(&core_api_assembly, config)) {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (OS::get_singleton()->is_stdout_verbose()) {
|
2019-07-11 14:01:25 +02:00
|
|
|
print_error("Mono: Failed to load Core API assembly");
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2019-07-11 14:01:25 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef TOOLS_ENABLED
|
2021-09-12 20:21:15 +02:00
|
|
|
if (!_load_editor_api_assembly(&editor_api_assembly, config)) {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (OS::get_singleton()->is_stdout_verbose()) {
|
2019-07-11 14:01:25 +02:00
|
|
|
print_error("Mono: Failed to load Editor API assembly");
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2019-07-11 14:01:25 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
return _on_core_api_assembly_loaded();
|
2019-07-11 14:01:25 +02:00
|
|
|
}
|
|
|
|
|
2019-10-11 01:23:35 +02:00
|
|
|
bool GDMono::_on_core_api_assembly_loaded() {
|
2019-11-10 17:10:38 +01:00
|
|
|
GDMonoCache::update_godot_api_cache();
|
2019-10-11 01:23:35 +02:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (!GDMonoCache::cached_data.godot_api_cache_updated) {
|
2019-10-11 01:23:35 +02:00
|
|
|
return false;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2019-10-11 01:23:35 +02:00
|
|
|
|
|
|
|
get_singleton()->_install_trace_listener();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2019-07-03 09:44:53 +02:00
|
|
|
bool GDMono::_load_tools_assemblies() {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (tools_assembly && tools_project_editor_assembly) {
|
2017-10-02 23:24:00 +02:00
|
|
|
return true;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
return load_assembly(TOOLS_ASM_NAME, &tools_assembly) &&
|
|
|
|
load_assembly(TOOLS_PROJECT_EDITOR_ASM_NAME, &tools_project_editor_assembly);
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool GDMono::_load_project_assembly() {
|
2020-07-05 19:19:36 +02:00
|
|
|
if (project_assembly) {
|
2017-10-02 23:24:00 +02:00
|
|
|
return true;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-07-03 17:41:07 +02:00
|
|
|
String appname = ProjectSettings::get_singleton()->get("application/config/name");
|
|
|
|
String appname_safe = OS::get_singleton()->get_safe_dir_name(appname);
|
2020-12-15 13:04:21 +01:00
|
|
|
if (appname_safe.is_empty()) {
|
2019-07-03 17:41:07 +02:00
|
|
|
appname_safe = "UnnamedProject";
|
2017-10-27 21:22:54 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-07-03 17:41:07 +02:00
|
|
|
bool success = load_assembly(appname_safe, &project_assembly);
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2018-02-22 13:13:51 +01:00
|
|
|
if (success) {
|
2017-10-02 23:24:00 +02:00
|
|
|
mono_assembly_set_main(project_assembly->get_assembly());
|
2021-09-12 20:21:15 +02:00
|
|
|
MonoException *exc = nullptr;
|
|
|
|
GDMonoCache::cached_data.methodthunk_ScriptManagerBridge_LookupScriptsInAssembly.invoke(
|
|
|
|
mono_assembly_get_object(mono_domain_get(), project_assembly->get_assembly()), &exc);
|
|
|
|
if (exc) {
|
|
|
|
GDMonoUtils::debug_print_unhandled_exception(exc);
|
|
|
|
}
|
2018-02-22 13:13:51 +01:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
2019-03-07 12:17:56 +01:00
|
|
|
void GDMono::_install_trace_listener() {
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
|
|
// Install the trace listener now before the project assembly is loaded
|
2020-04-02 01:20:12 +02:00
|
|
|
MonoException *exc = nullptr;
|
2021-09-12 20:21:15 +02:00
|
|
|
GDMonoCache::cached_data.methodthunk_DebuggingUtils_InstallTraceListener.invoke(&exc);
|
2019-03-07 12:17:56 +01:00
|
|
|
if (exc) {
|
|
|
|
GDMonoUtils::debug_print_unhandled_exception(exc);
|
2019-10-11 01:23:35 +02:00
|
|
|
ERR_PRINT("Failed to install 'System.Diagnostics.Trace' listener.");
|
2019-03-07 12:17:56 +01:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
#ifndef GD_MONO_SINGLE_APPDOMAIN
|
2017-10-02 23:24:00 +02:00
|
|
|
Error GDMono::_load_scripts_domain() {
|
2020-04-02 01:20:12 +02:00
|
|
|
ERR_FAIL_COND_V(scripts_domain != nullptr, ERR_BUG);
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2018-08-24 08:47:34 +02:00
|
|
|
print_verbose("Mono: Loading scripts domain...");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-10-11 01:23:35 +02:00
|
|
|
scripts_domain = GDMonoUtils::create_domain("GodotEngine.Domain.Scripts");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_FAIL_NULL_V_MSG(scripts_domain, ERR_CANT_CREATE, "Mono: Could not create scripts app domain.");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
mono_domain_set(scripts_domain, true);
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
Error GDMono::_unload_scripts_domain() {
|
|
|
|
ERR_FAIL_NULL_V(scripts_domain, ERR_BUG);
|
|
|
|
|
2021-09-12 19:50:13 +02:00
|
|
|
CSharpLanguage::get_singleton()->_on_scripts_domain_about_to_unload();
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
print_verbose("Mono: Finalizing scripts domain...");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (mono_domain_get() != root_domain) {
|
2017-10-02 23:24:00 +02:00
|
|
|
mono_domain_set(root_domain, true);
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2018-10-06 23:00:18 +02:00
|
|
|
finalizing_scripts_domain = true;
|
|
|
|
|
|
|
|
if (!mono_domain_finalize(scripts_domain, 2000)) {
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_PRINT("Mono: Domain finalization timeout.");
|
2018-10-06 23:00:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
finalizing_scripts_domain = false;
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2017-10-05 00:12:36 +02:00
|
|
|
mono_gc_collect(mono_gc_max_generation());
|
|
|
|
|
2019-11-10 17:10:38 +01:00
|
|
|
GDMonoCache::clear_godot_api_cache();
|
2019-05-20 18:34:35 +02:00
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
_domain_assemblies_cleanup(mono_domain_get_id(scripts_domain));
|
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
core_api_assembly = nullptr;
|
2019-10-12 21:27:56 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2021-09-12 20:21:15 +02:00
|
|
|
editor_api_assembly = nullptr;
|
2019-10-12 21:27:56 +02:00
|
|
|
#endif
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
project_assembly = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2020-04-02 01:20:12 +02:00
|
|
|
tools_assembly = nullptr;
|
|
|
|
tools_project_editor_assembly = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
MonoDomain *domain = scripts_domain;
|
2020-04-02 01:20:12 +02:00
|
|
|
scripts_domain = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
print_verbose("Mono: Unloading scripts domain...");
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
MonoException *exc = nullptr;
|
2018-06-26 21:03:42 +02:00
|
|
|
mono_domain_try_unload(domain, (MonoObject **)&exc);
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2018-06-26 21:03:42 +02:00
|
|
|
if (exc) {
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_PRINT("Exception thrown when unloading scripts domain.");
|
2018-06-26 21:03:42 +02:00
|
|
|
GDMonoUtils::debug_unhandled_exception(exc);
|
2017-10-02 23:24:00 +02:00
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
2020-03-18 17:40:04 +01:00
|
|
|
#endif
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-01-22 18:33:36 +01:00
|
|
|
#ifdef GD_MONO_HOT_RELOAD
|
2017-10-02 23:24:00 +02:00
|
|
|
Error GDMono::reload_scripts_domain() {
|
|
|
|
ERR_FAIL_COND_V(!runtime_initialized, ERR_BUG);
|
|
|
|
|
|
|
|
if (scripts_domain) {
|
2019-08-09 03:39:45 +02:00
|
|
|
Error domain_unload_err = _unload_scripts_domain();
|
|
|
|
ERR_FAIL_COND_V_MSG(domain_unload_err != OK, domain_unload_err, "Mono: Failed to unload scripts domain.");
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2019-08-09 03:39:45 +02:00
|
|
|
Error domain_load_err = _load_scripts_domain();
|
|
|
|
ERR_FAIL_COND_V_MSG(domain_load_err != OK, domain_load_err, "Mono: Failed to load scripts domain.");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
// Load assemblies. The API and tools assemblies are required,
|
|
|
|
// the application is aborted if these assemblies cannot be loaded.
|
2018-02-22 13:13:51 +01:00
|
|
|
|
2021-09-12 20:21:15 +02:00
|
|
|
if (!_try_load_api_assemblies()) {
|
|
|
|
CRASH_NOW_MSG("Failed to load one of the API assemblies.");
|
|
|
|
}
|
2018-02-22 13:13:51 +01:00
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
#if defined(TOOLS_ENABLED)
|
2019-08-09 03:39:45 +02:00
|
|
|
bool tools_assemblies_loaded = _load_tools_assemblies();
|
|
|
|
CRASH_COND_MSG(!tools_assemblies_loaded, "Mono: Failed to load '" TOOLS_ASM_NAME "' assemblies.");
|
2019-07-03 09:44:53 +02:00
|
|
|
#endif
|
|
|
|
|
2019-07-11 14:01:25 +02:00
|
|
|
// Load the project's main assembly. Here, during hot-reloading, we do
|
|
|
|
// consider failing to load the project's main assembly to be an error.
|
|
|
|
// However, unlike the API and tools assemblies, the application can continue working.
|
2018-09-26 23:59:38 +02:00
|
|
|
if (!_load_project_assembly()) {
|
2019-07-11 14:01:25 +02:00
|
|
|
print_error("Mono: Failed to load project assembly");
|
2018-02-22 13:13:51 +01:00
|
|
|
return ERR_CANT_OPEN;
|
2018-09-26 23:59:38 +02:00
|
|
|
}
|
2018-02-22 13:13:51 +01:00
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
return OK;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
#ifndef GD_MONO_SINGLE_APPDOMAIN
|
2018-02-22 13:39:41 +01:00
|
|
|
Error GDMono::finalize_and_unload_domain(MonoDomain *p_domain) {
|
2020-04-02 01:20:12 +02:00
|
|
|
CRASH_COND(p_domain == nullptr);
|
2019-07-03 09:44:53 +02:00
|
|
|
CRASH_COND(p_domain == GDMono::get_singleton()->get_scripts_domain()); // Should use _unload_scripts_domain() instead
|
2018-02-22 13:39:41 +01:00
|
|
|
|
|
|
|
String domain_name = mono_domain_get_friendly_name(p_domain);
|
|
|
|
|
2019-08-09 03:39:45 +02:00
|
|
|
print_verbose("Mono: Unloading domain '" + domain_name + "'...");
|
2018-02-22 13:39:41 +01:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (mono_domain_get() == p_domain) {
|
2018-02-22 13:39:41 +01:00
|
|
|
mono_domain_set(root_domain, true);
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2018-02-22 13:39:41 +01:00
|
|
|
|
2018-10-06 23:00:18 +02:00
|
|
|
if (!mono_domain_finalize(p_domain, 2000)) {
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_PRINT("Mono: Domain finalization timeout.");
|
2018-10-06 23:00:18 +02:00
|
|
|
}
|
2019-03-10 18:54:07 +01:00
|
|
|
|
2018-02-22 13:39:41 +01:00
|
|
|
mono_gc_collect(mono_gc_max_generation());
|
|
|
|
|
|
|
|
_domain_assemblies_cleanup(mono_domain_get_id(p_domain));
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
MonoException *exc = nullptr;
|
2018-06-26 21:03:42 +02:00
|
|
|
mono_domain_try_unload(p_domain, (MonoObject **)&exc);
|
2018-02-22 13:39:41 +01:00
|
|
|
|
2018-06-26 21:03:42 +02:00
|
|
|
if (exc) {
|
2019-11-06 17:03:04 +01:00
|
|
|
ERR_PRINT("Exception thrown when unloading domain '" + domain_name + "'.");
|
2019-07-03 09:44:53 +02:00
|
|
|
GDMonoUtils::debug_print_unhandled_exception(exc);
|
2018-02-22 13:39:41 +01:00
|
|
|
return FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return OK;
|
|
|
|
}
|
2020-03-18 17:40:04 +01:00
|
|
|
#endif
|
2018-02-22 13:39:41 +01:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
void GDMono::_domain_assemblies_cleanup(int32_t p_domain_id) {
|
2017-10-02 23:24:00 +02:00
|
|
|
HashMap<String, GDMonoAssembly *> &domain_assemblies = assemblies[p_domain_id];
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
const String *k = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
while ((k = domain_assemblies.next(k))) {
|
|
|
|
memdelete(domain_assemblies.get(*k));
|
|
|
|
}
|
|
|
|
|
|
|
|
assemblies.erase(p_domain_id);
|
|
|
|
}
|
|
|
|
|
2018-06-26 21:03:42 +02:00
|
|
|
void GDMono::unhandled_exception_hook(MonoObject *p_exc, void *) {
|
2018-07-18 16:24:33 +02:00
|
|
|
// This method will be called by the runtime when a thrown exception is not handled.
|
|
|
|
// It won't be called when we manually treat a thrown exception as unhandled.
|
|
|
|
// We assume the exception was already printed before calling this hook.
|
2018-06-26 21:03:42 +02:00
|
|
|
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
|
|
GDMonoUtils::debug_send_unhandled_exception_error((MonoException *)p_exc);
|
2020-07-05 19:19:36 +02:00
|
|
|
if (EngineDebugger::is_active()) {
|
2020-02-27 03:30:20 +01:00
|
|
|
EngineDebugger::get_singleton()->poll_events(false);
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2018-06-26 21:03:42 +02:00
|
|
|
#endif
|
2019-04-18 13:58:55 +02:00
|
|
|
|
|
|
|
exit(mono_environment_exitcode_get());
|
|
|
|
|
2019-01-29 00:02:35 +01:00
|
|
|
GD_UNREACHABLE();
|
2018-06-26 21:03:42 +02:00
|
|
|
}
|
|
|
|
|
2017-10-02 23:24:00 +02:00
|
|
|
GDMono::GDMono() {
|
|
|
|
singleton = this;
|
|
|
|
|
|
|
|
gdmono_log = memnew(GDMonoLog);
|
|
|
|
|
|
|
|
runtime_initialized = false;
|
2018-10-06 23:00:18 +02:00
|
|
|
finalizing_scripts_domain = false;
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
root_domain = nullptr;
|
|
|
|
scripts_domain = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
corlib_assembly = nullptr;
|
|
|
|
project_assembly = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
#ifdef TOOLS_ENABLED
|
2020-04-02 01:20:12 +02:00
|
|
|
tools_assembly = nullptr;
|
|
|
|
tools_project_editor_assembly = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
api_core_hash = 0;
|
|
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
api_editor_hash = 0;
|
|
|
|
#endif
|
2019-07-24 23:13:24 +02:00
|
|
|
|
|
|
|
unhandled_exception_policy = POLICY_TERMINATE_APP;
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
GDMono::~GDMono() {
|
2018-09-12 02:41:54 +02:00
|
|
|
if (is_runtime_initialized()) {
|
2020-03-18 17:40:04 +01:00
|
|
|
#ifndef GD_MONO_SINGLE_APPDOMAIN
|
2019-03-10 18:54:07 +01:00
|
|
|
if (scripts_domain) {
|
2017-10-02 23:24:00 +02:00
|
|
|
Error err = _unload_scripts_domain();
|
|
|
|
if (err != OK) {
|
2019-08-09 03:39:45 +02:00
|
|
|
ERR_PRINT("Mono: Failed to unload scripts domain.");
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
}
|
2020-03-18 17:40:04 +01:00
|
|
|
#else
|
|
|
|
CRASH_COND(scripts_domain != root_domain);
|
|
|
|
|
|
|
|
print_verbose("Mono: Finalizing scripts domain...");
|
|
|
|
|
|
|
|
if (mono_domain_get() != root_domain)
|
|
|
|
mono_domain_set(root_domain, true);
|
|
|
|
|
|
|
|
finalizing_scripts_domain = true;
|
|
|
|
|
|
|
|
if (!mono_domain_finalize(root_domain, 2000)) {
|
|
|
|
ERR_PRINT("Mono: Domain finalization timeout.");
|
|
|
|
}
|
|
|
|
|
|
|
|
finalizing_scripts_domain = false;
|
|
|
|
|
|
|
|
mono_gc_collect(mono_gc_max_generation());
|
|
|
|
|
|
|
|
GDMonoCache::clear_godot_api_cache();
|
|
|
|
|
|
|
|
_domain_assemblies_cleanup(mono_domain_get_id(root_domain));
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
core_api_assembly.assembly = nullptr;
|
2020-03-18 17:40:04 +01:00
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
project_assembly = nullptr;
|
2020-03-18 17:40:04 +01:00
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
root_domain = nullptr;
|
|
|
|
scripts_domain = nullptr;
|
2020-03-18 17:40:04 +01:00
|
|
|
|
|
|
|
// Leave the rest to 'mono_jit_cleanup'
|
|
|
|
#endif
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
const int32_t *k = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
while ((k = assemblies.next(k))) {
|
|
|
|
HashMap<String, GDMonoAssembly *> &domain_assemblies = assemblies.get(*k);
|
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
const String *kk = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
while ((kk = domain_assemblies.next(kk))) {
|
|
|
|
memdelete(domain_assemblies.get(*kk));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assemblies.clear();
|
|
|
|
|
2018-08-24 08:47:34 +02:00
|
|
|
print_verbose("Mono: Runtime cleanup...");
|
2017-10-02 23:24:00 +02:00
|
|
|
|
|
|
|
mono_jit_cleanup(root_domain);
|
2018-09-12 02:41:54 +02:00
|
|
|
|
2019-03-10 18:54:07 +01:00
|
|
|
print_verbose("Mono: Finalized");
|
|
|
|
|
2018-09-12 02:41:54 +02:00
|
|
|
runtime_initialized = false;
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2020-03-18 17:40:04 +01:00
|
|
|
#if defined(ANDROID_ENABLED)
|
|
|
|
gdmono::android::support::cleanup();
|
|
|
|
#endif
|
|
|
|
|
2020-07-05 19:19:36 +02:00
|
|
|
if (gdmono_log) {
|
2017-10-02 23:24:00 +02:00
|
|
|
memdelete(gdmono_log);
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2017-10-29 05:57:20 +01:00
|
|
|
|
2020-04-02 01:20:12 +02:00
|
|
|
singleton = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
namespace mono_bind {
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
GodotSharp *GodotSharp::singleton = nullptr;
|
|
|
|
|
|
|
|
void GodotSharp::attach_thread() {
|
2017-10-02 23:24:00 +02:00
|
|
|
GDMonoUtils::attach_current_thread();
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
void GodotSharp::detach_thread() {
|
2017-10-02 23:24:00 +02:00
|
|
|
GDMonoUtils::detach_current_thread();
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
int32_t GodotSharp::get_domain_id() {
|
2018-09-12 02:41:54 +02:00
|
|
|
MonoDomain *domain = mono_domain_get();
|
2020-07-05 19:19:36 +02:00
|
|
|
ERR_FAIL_NULL_V(domain, -1);
|
2018-09-12 02:41:54 +02:00
|
|
|
return mono_domain_get_id(domain);
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
int32_t GodotSharp::get_scripts_domain_id() {
|
2020-07-05 19:19:36 +02:00
|
|
|
ERR_FAIL_NULL_V_MSG(GDMono::get_singleton(),
|
|
|
|
-1, "The Mono runtime is not initialized");
|
2019-07-03 09:44:53 +02:00
|
|
|
MonoDomain *domain = GDMono::get_singleton()->get_scripts_domain();
|
2020-07-05 19:19:36 +02:00
|
|
|
ERR_FAIL_NULL_V(domain, -1);
|
2018-09-12 02:41:54 +02:00
|
|
|
return mono_domain_get_id(domain);
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
bool GodotSharp::is_scripts_domain_loaded() {
|
2020-07-05 19:19:36 +02:00
|
|
|
return GDMono::get_singleton() != nullptr &&
|
|
|
|
GDMono::get_singleton()->is_runtime_initialized() &&
|
|
|
|
GDMono::get_singleton()->get_scripts_domain() != nullptr;
|
2018-09-12 02:41:54 +02:00
|
|
|
}
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
bool GodotSharp::_is_domain_finalizing_for_unload(int32_t p_domain_id) {
|
2018-09-12 02:41:54 +02:00
|
|
|
return is_domain_finalizing_for_unload(p_domain_id);
|
|
|
|
}
|
2017-12-31 22:37:57 +01:00
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
bool GodotSharp::is_domain_finalizing_for_unload(int32_t p_domain_id) {
|
2018-09-12 02:41:54 +02:00
|
|
|
return is_domain_finalizing_for_unload(mono_domain_get_by_id(p_domain_id));
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
bool GodotSharp::is_domain_finalizing_for_unload(MonoDomain *p_domain) {
|
2020-07-05 19:19:36 +02:00
|
|
|
GDMono *gd_mono = GDMono::get_singleton();
|
|
|
|
|
|
|
|
ERR_FAIL_COND_V_MSG(!gd_mono || !gd_mono->is_runtime_initialized(),
|
|
|
|
false, "The Mono runtime is not initialized");
|
|
|
|
|
|
|
|
ERR_FAIL_NULL_V(p_domain, true);
|
|
|
|
|
|
|
|
if (p_domain == gd_mono->get_scripts_domain() && gd_mono->is_finalizing_scripts_domain()) {
|
2018-10-06 23:00:18 +02:00
|
|
|
return true;
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
|
|
|
|
2018-09-12 02:41:54 +02:00
|
|
|
return mono_domain_is_unloading(p_domain);
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
bool GodotSharp::is_runtime_shutting_down() {
|
2018-09-12 02:41:54 +02:00
|
|
|
return mono_runtime_is_shutting_down();
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
bool GodotSharp::is_runtime_initialized() {
|
2020-07-05 19:19:36 +02:00
|
|
|
return GDMono::get_singleton() != nullptr && GDMono::get_singleton()->is_runtime_initialized();
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
void GodotSharp::_reload_assemblies(bool p_soft_reload) {
|
2019-07-03 09:44:53 +02:00
|
|
|
#ifdef GD_MONO_HOT_RELOAD
|
2020-07-05 19:19:36 +02:00
|
|
|
CRASH_COND(CSharpLanguage::get_singleton() == nullptr);
|
2020-04-23 02:23:25 +02:00
|
|
|
// This method may be called more than once with `call_deferred`, so we need to check
|
|
|
|
// again if reloading is needed to avoid reloading multiple times unnecessarily.
|
2020-07-05 19:19:36 +02:00
|
|
|
if (CSharpLanguage::get_singleton()->is_assembly_reloading_needed()) {
|
2020-04-23 02:23:25 +02:00
|
|
|
CSharpLanguage::get_singleton()->reload_assemblies(p_soft_reload);
|
2020-07-05 19:19:36 +02:00
|
|
|
}
|
2019-07-03 09:44:53 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
void GodotSharp::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("attach_thread"), &GodotSharp::attach_thread);
|
|
|
|
ClassDB::bind_method(D_METHOD("detach_thread"), &GodotSharp::detach_thread);
|
2017-10-02 23:24:00 +02:00
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("get_domain_id"), &GodotSharp::get_domain_id);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_scripts_domain_id"), &GodotSharp::get_scripts_domain_id);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_scripts_domain_loaded"), &GodotSharp::is_scripts_domain_loaded);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_domain_finalizing_for_unload", "domain_id"), &GodotSharp::_is_domain_finalizing_for_unload);
|
2018-09-12 02:41:54 +02:00
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
ClassDB::bind_method(D_METHOD("is_runtime_shutting_down"), &GodotSharp::is_runtime_shutting_down);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_runtime_initialized"), &GodotSharp::is_runtime_initialized);
|
|
|
|
ClassDB::bind_method(D_METHOD("_reload_assemblies"), &GodotSharp::_reload_assemblies);
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
GodotSharp::GodotSharp() {
|
2017-10-02 23:24:00 +02:00
|
|
|
singleton = this;
|
|
|
|
}
|
|
|
|
|
2021-08-13 16:46:14 +02:00
|
|
|
GodotSharp::~GodotSharp() {
|
2020-04-02 01:20:12 +02:00
|
|
|
singleton = nullptr;
|
2017-10-02 23:24:00 +02:00
|
|
|
}
|
2021-08-13 16:46:14 +02:00
|
|
|
|
|
|
|
} // namespace mono_bind
|