#include <glib.h>
#include <string.h>
-#if HAVE_BOEHM_GC
-#include <gc/gc.h>
-#endif
+#include <mono/os/gc_wrapper.h>
#include <mono/metadata/object.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/assembly.h>
#include <mono/metadata/exception.h>
-#include <mono/metadata/cil-coff.h>
+#include <mono/metadata/threads.h>
+#include <mono/metadata/socket-io.h>
+#include <mono/metadata/tabledefs.h>
+#include <mono/metadata/gc.h>
-static guint32 appdomain_thread_id = 0;
+HANDLE mono_delegate_semaphore = NULL;
+CRITICAL_SECTION mono_delegate_section;
-static int
-ldstr_hash (const char* str)
-{
- guint len, h;
- const char *end;
- len = mono_metadata_decode_blob_size (str, &str);
- end = str + len;
- h = *str;
- /*
- * FIXME: The distribution may not be so nice with lots of
- * null chars in the string.
- */
- for (str += 1; str < end; str++)
- h = (h << 5) - h + *str;
- return h;
-}
-
-static gboolean
-ldstr_equal (const char *str1, const char *str2) {
- int len, len2;
- len = mono_metadata_decode_blob_size (str1, NULL);
- len2 = mono_metadata_decode_blob_size (str2, NULL);
- if (len != len2)
- return 0;
- return memcmp (str1, str2, len) == 0;
-}
-
-static MonoDomain *
-mono_create_domain ()
-{
- MonoDomain *domain;
+static MonoObject *
+mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj);
-#if HAVE_BOEHM_GC
- domain = GC_malloc (sizeof (MonoDomain));
-#else
- domain = g_new0 (MonoDomain, 1);
-#endif
- domain->domain = NULL;
- domain->setup = NULL;
- domain->friendly_name = NULL;
-
- domain->mp = mono_mempool_new ();
- domain->env = g_hash_table_new (g_str_hash, g_str_equal);
- domain->assemblies = g_hash_table_new (g_str_hash, g_str_equal);
- domain->class_vtable_hash = g_hash_table_new (NULL, NULL);
- domain->jit_code_hash = g_hash_table_new (NULL, NULL);
- domain->ldstr_table = g_hash_table_new ((GHashFunc)ldstr_hash, (GCompareFunc)ldstr_equal);
-
- return domain;
-}
+static MonoAssembly *
+mono_domain_assembly_preload (MonoAssemblyName *aname,
+ gchar **assemblies_path,
+ gpointer user_data);
-MonoDomain *mono_root_domain = NULL;
+static void
+mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data);
-/**
- * mono_init:
- *
- * Creates the initial application domain and initializes the mono_defaults
- * structure.
+/*
+ * mono_runtime_init:
+ * @domain: domain returned by mono_init ()
+ *
+ * Initialize the core AppDomain: this function will run also some
+ * IL initialization code, so it needs the execution engine to be fully
+ * operational.
+ *
+ * AppDomain.SetupInformation is set up in mono_runtime_exec_main, where
+ * we know the entry_assembly.
*
- * Returns: the initial domain.
*/
-MonoDomain *
-mono_init (const char *filename)
+void
+mono_runtime_init (MonoDomain *domain, MonoThreadStartCB start_cb,
+ MonoThreadStartCB attach_cb)
{
- static MonoDomain *domain = NULL;
MonoAppDomainSetup *setup;
MonoAppDomain *ad;
- MonoAssembly *ass;
MonoClass *class;
- MonoString *name;
- enum MonoImageOpenStatus status = MONO_IMAGE_OK;
-
- if (domain)
- g_assert_not_reached ();
-
- appdomain_thread_id = TlsAlloc ();
-
- domain = mono_create_domain ();
- mono_root_domain = domain;
-
- TlsSetValue (appdomain_thread_id, domain);
-
- /* find the corlib */
- ass = mono_assembly_open (CORLIB_NAME, NULL, &status);
- if ((status != MONO_IMAGE_OK) || (ass == NULL)) {
- switch (status){
- case MONO_IMAGE_ERROR_ERRNO:
- g_print ("The assembly corlib.dll was not found or could not be loaded.\n");
- g_print ("It should have been installed in the `%s' directory.\n", MONO_ASSEMBLIES);
- break;
-
- case MONO_IMAGE_IMAGE_INVALID:
- g_print ("The file %s/corlib.dll is an invalid CIL image", MONO_ASSEMBLIES);
- break;
- }
-
- exit (1);
- }
- mono_defaults.corlib = ass->image;
-
- mono_defaults.object_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Object");
- g_assert (mono_defaults.object_class != 0);
-
- mono_defaults.void_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Void");
- g_assert (mono_defaults.void_class != 0);
-
- mono_defaults.boolean_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Boolean");
- g_assert (mono_defaults.boolean_class != 0);
-
- mono_defaults.byte_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Byte");
- g_assert (mono_defaults.byte_class != 0);
-
- mono_defaults.sbyte_class = mono_class_from_name (
- mono_defaults.corlib, "System", "SByte");
- g_assert (mono_defaults.sbyte_class != 0);
-
- mono_defaults.int16_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Int16");
- g_assert (mono_defaults.int16_class != 0);
-
- mono_defaults.uint16_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UInt16");
- g_assert (mono_defaults.uint16_class != 0);
-
- mono_defaults.int32_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Int32");
- g_assert (mono_defaults.int32_class != 0);
-
- mono_defaults.uint32_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UInt32");
- g_assert (mono_defaults.uint32_class != 0);
-
- mono_defaults.uint_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UIntPtr");
- g_assert (mono_defaults.uint_class != 0);
+
+ mono_install_assembly_preload_hook (mono_domain_assembly_preload, NULL);
+ mono_install_assembly_load_hook (mono_domain_fire_assembly_load, NULL);
- mono_defaults.int_class = mono_class_from_name (
- mono_defaults.corlib, "System", "IntPtr");
- g_assert (mono_defaults.int_class != 0);
+ class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
+ setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
- mono_defaults.int64_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Int64");
- g_assert (mono_defaults.int64_class != 0);
+ class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
+ ad = (MonoAppDomain *) mono_object_new (domain, class);
+ ad->data = domain;
+ domain->domain = ad;
+ domain->setup = setup;
- mono_defaults.uint64_class = mono_class_from_name (
- mono_defaults.corlib, "System", "UInt64");
- g_assert (mono_defaults.uint64_class != 0);
+ mono_delegate_semaphore = CreateSemaphore (NULL, 0, 0x7fffffff, NULL);
+ g_assert (mono_delegate_semaphore != INVALID_HANDLE_VALUE);
+ InitializeCriticalSection (&mono_delegate_section);
- mono_defaults.single_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Single");
- g_assert (mono_defaults.single_class != 0);
+ mono_thread_init (domain, start_cb, attach_cb);
+
+ /* GC init has to happen after thread init */
+ mono_gc_init ();
- mono_defaults.double_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Double");
- g_assert (mono_defaults.double_class != 0);
+ mono_network_init ();
- mono_defaults.char_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Char");
- g_assert (mono_defaults.char_class != 0);
+ return;
+}
- mono_defaults.string_class = mono_class_from_name (
- mono_defaults.corlib, "System", "String");
- g_assert (mono_defaults.string_class != 0);
+void
+mono_runtime_cleanup (MonoDomain *domain)
+{
+ mono_thread_cleanup ();
- mono_defaults.enum_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Enum");
- g_assert (mono_defaults.enum_class != 0);
+ /* Do this after the thread cleanup, because subthreads might
+ * still be doing socket calls.
+ */
+ mono_network_cleanup ();
+}
- mono_defaults.array_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Array");
- g_assert (mono_defaults.array_class != 0);
+void
+ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
+{
+ MonoDomain* domain = mono_domain_get ();
+ MonoAssembly *assembly;
+ gchar *str;
- mono_defaults.delegate_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Delegate");
- g_assert (mono_defaults.delegate_class != 0);
+ MONO_ARCH_SAVE_REGS;
- mono_defaults.typehandle_class = mono_class_from_name (
- mono_defaults.corlib, "System", "RuntimeTypeHandle");
- g_assert (mono_defaults.typehandle_class != 0);
+ assembly = domain->entry_assembly;
+ g_assert (assembly);
- mono_defaults.methodhandle_class = mono_class_from_name (
- mono_defaults.corlib, "System", "RuntimeMethodHandle");
- g_assert (mono_defaults.methodhandle_class != 0);
+ setup->application_base = mono_string_new (domain, assembly->basedir);
+ str = g_strconcat (assembly->basedir, assembly->aname.name,
+ ".exe.config", NULL);
+ setup->configuration_file = mono_string_new (domain, str);
+ g_free (str);
+}
- mono_defaults.fieldhandle_class = mono_class_from_name (
- mono_defaults.corlib, "System", "RuntimeFieldHandle");
- g_assert (mono_defaults.fieldhandle_class != 0);
+/*
+ * invokes a method in a specific domain.
+ */
+static MonoObject*
+mono_runtime_invoke_in_domain (MonoDomain *domain, MonoMethod *method, void *obj,
+ void **params, MonoObject **exc)
+{
+ MonoDomain *cur = mono_domain_get ();
+ MonoObject **real_exc, *default_exc;
+ MonoObject *res;
- mono_defaults.monotype_class = mono_class_from_name (
- mono_defaults.corlib, "System", "MonoType");
- g_assert (mono_defaults.monotype_class != 0);
+ if (domain == cur)
+ return mono_runtime_invoke (method, obj, params, exc);
- mono_defaults.exception_class = mono_class_from_name (
- mono_defaults.corlib, "System", "Exception");
- g_assert (mono_defaults.exception_class != 0);
+ if (!exc)
+ real_exc = &default_exc;
+ else
+ real_exc = exc;
+ *real_exc = NULL;
+ mono_domain_set (domain);
+ res = mono_runtime_invoke (method, obj, params, real_exc);
+ mono_domain_set (cur);
- class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomainSetup");
- setup = (MonoAppDomainSetup *) mono_object_new (domain, class);
- ves_icall_System_AppDomainSetup_InitAppDomainSetup (setup);
+ if (*real_exc) {
+ /* transfer Exception to the right domain */
+ *real_exc = mono_domain_transfer_object (domain, cur, *real_exc);
- name = mono_string_new (domain, g_path_get_basename (filename));
+ if (!exc)
+ mono_raise_exception ((MonoException *)*real_exc);
- class = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
- ad = (MonoAppDomain *) mono_object_new (domain, class);
- ad->data = domain;
- domain->domain = ad;
- domain->setup = setup;
- domain->friendly_name = name;
+ }
- return domain;
+ return res;
}
-void
-ves_icall_System_AppDomainSetup_InitAppDomainSetup (MonoAppDomainSetup *setup)
+static MonoObject *
+mono_domain_transfer_array (MonoDomain *src, MonoDomain *dst, MonoArray *ao)
{
- // fixme: implement me
+ MonoObject *res = NULL;
+ MonoClass *klass;
+ int esize, ecount, i;
+ guint32 *sizes;
+
+ klass = ao->obj.vtable->klass;
+
+ esize = mono_array_element_size (klass);
+ if (ao->bounds == NULL) {
+ ecount = mono_array_length (ao);
+ res = (MonoObject *)mono_array_new_full (dst, klass, &ecount, NULL);
+ } else {
+ sizes = alloca (klass->rank * sizeof(guint32) * 2);
+ ecount = 1;
+ for (i = 0; i < klass->rank; ++i) {
+ sizes [i] = ao->bounds [i].length;
+ ecount *= ao->bounds [i].length;
+ sizes [i + klass->rank] = ao->bounds [i].lower_bound;
+ }
+ res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
+ }
+ if (klass->element_class->valuetype) {
+ if (klass->element_class->blittable) {
+ memcpy (((MonoArray *)res)->vector, ao->vector, esize * ecount);
+ } else {
+ for (i = 0; i < ecount; i++) {
+ MonoObject *s, *d;
+ gpointer *src_ea = (gpointer *)mono_array_addr_with_size (ao, esize, i);
+ gpointer *dst_ea = (gpointer *)mono_array_addr_with_size ((MonoArray *)res, esize, i);
+ s = mono_value_box (src, klass->element_class, src_ea);
+ d = mono_domain_transfer_object (src, dst, s);
+ memcpy (dst_ea, (char *)d + sizeof(MonoObject), esize);
+ }
+ }
+ } else {
+ g_assert (esize == sizeof (gpointer));
+ for (i = 0; i < ecount; i++) {
+ gpointer *src_ea = (gpointer *)mono_array_addr_with_size (ao, esize, i);
+ gpointer *dst_ea = (gpointer *)mono_array_addr_with_size ((MonoArray *)res, esize, i);
+ *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
+ }
+ }
+ return res;
}
/**
static MonoObject *
mono_domain_transfer_object (MonoDomain *src, MonoDomain *dst, MonoObject *obj)
{
+ MonoClass *sic = mono_defaults.serializationinfo_class;
MonoClass *klass;
- MonoObject *res;
+ MonoObject *res = NULL;
+ int i;
if (!obj)
return NULL;
g_assert (obj->vtable->domain == src);
- /* fixme: transfer an object from one domain into another */
-
klass = obj->vtable->klass;
- if (MONO_CLASS_IS_ARRAY (klass)) {
- MonoArray *ao = (MonoArray *)obj;
- int esize, ecount, i;
- guint32 *sizes;
+ /* some special cases */
+ if (klass == mono_defaults.string_class) {
+ MonoString *str = (MonoString *)obj;
+ return (MonoObject *)mono_string_new_utf16 (dst,
+ (const guint16 *)mono_string_chars (str), str->length);
+ }
+
+ if (klass == mono_defaults.monotype_class)
+ return (MonoObject *) mono_type_get_object (dst, ((MonoReflectionType *)obj)->type);
+
+ if (MONO_CLASS_IS_ARRAY (klass))
+ return mono_domain_transfer_array (src, dst, (MonoArray *)obj);
+
+ if (mono_object_isinst (obj, mono_defaults.iserializeable_class)) {
+ static MonoMethod *serinfo_ctor1 = NULL, *serinfo_ctor2 = NULL, *get_entries = NULL;
+ MonoMethod *get_object_data, *ser_ctor;
+ MonoObject *src_serinfo, *dst_serinfo;
+ void *pa [2];
+ MonoStreamingContext ctx;
+ MonoArray *entries, *trans_entries;
+ int len;
+
+ /* get a pointer to the GetObjectData method */
+ get_object_data = klass->vtable [klass->interface_offsets [mono_defaults.iserializeable_class->interface_id]];
+ g_assert (get_object_data);
+
+ src_serinfo = mono_object_new (src, sic);
+
+ if (!serinfo_ctor1) {
+ for (i = 0; i < sic->method.count; ++i) {
+ if (!strcmp (".ctor", sic->methods [i]->name) &&
+ sic->methods [i]->signature->param_count == 1) {
+ serinfo_ctor1 = sic->methods [i];
+ break;
+ }
+ }
+ g_assert (serinfo_ctor1);
+ }
- sizes = alloca (klass->rank * sizeof(guint32) * 2);
- esize = mono_array_element_size (klass);
- ecount = 1;
- for (i = 0; i < klass->rank; ++i) {
- sizes [i] = ao->bounds [i].length;
- ecount *= ao->bounds [i].length;
- sizes [i + klass->rank] = ao->bounds [i].lower_bound;
+ if (!serinfo_ctor2) {
+ for (i = 0; i < sic->method.count; ++i) {
+ if (!strcmp (".ctor", sic->methods [i]->name) &&
+ sic->methods [i]->signature->param_count == 2 &&
+ sic->methods [i]->signature->params [1]->type == MONO_TYPE_SZARRAY) {
+ serinfo_ctor2 = sic->methods [i];
+ break;
+ }
+ }
+ g_assert (serinfo_ctor2);
}
- res = (MonoObject *)mono_array_new_full (dst, klass, sizes, sizes + klass->rank);
- if (klass->element_class->valuetype) {
- memcpy (res, (char *)ao + sizeof(MonoArray), esize * ecount);
- } else {
- g_assert (esize == sizeof (gpointer));
- for (i = 0; i < ecount; i++) {
- int offset = sizeof (MonoArray) + esize * i;
- gpointer *src_ea = (gpointer *)((char *)ao + offset);
- gpointer *dst_ea = (gpointer *)((char *)res + offset);
+
+ if (!get_entries) {
+ for (i = 0; i < sic->method.count; ++i) {
+ if (!strcmp ("get_entries", sic->methods [i]->name) &&
+ sic->methods [i]->signature->param_count == 0) {
+ get_entries = sic->methods [i];
+ break;
+ }
+ }
+ g_assert (get_entries);
+ }
+
+ pa [0] = mono_type_get_object (src, &klass->byval_arg);
+ mono_runtime_invoke_in_domain (src, serinfo_ctor1, src_serinfo, pa, NULL);
+
+ ctx.additional = NULL;
+ ctx.state = 128; /* CrossAppDomain */
+ pa [0] = src_serinfo;
+ pa [1] = &ctx;
+ mono_runtime_invoke_in_domain (src, get_object_data, obj, pa, NULL);
+
+ entries = (MonoArray *)mono_runtime_invoke_in_domain (src, get_entries, src_serinfo, NULL, NULL);
+
+ g_assert (src_serinfo->vtable->domain == src);
+ g_assert (entries->obj.vtable->domain == src);
+
+ /* transfer all SerializationEntry objects */
+ len = mono_array_length ((MonoArray*)entries);
+ trans_entries = mono_array_new (dst, entries->obj.vtable->klass->element_class, len);
+
+ for (i = 0; i < len; i++) {
+ MonoSerializationEntry *s, *d;
+ s = (MonoSerializationEntry *)mono_array_addr_with_size (entries,
+ sizeof (MonoSerializationEntry), i);
+ d = (MonoSerializationEntry *)mono_array_addr_with_size (trans_entries,
+ sizeof (MonoSerializationEntry), i);
+ d->name = (MonoString *)mono_domain_transfer_object (src, dst, (MonoObject *)s->name);
+ d->value = mono_domain_transfer_object (src, dst, s->value);
+ d->type = (MonoReflectionType *)mono_domain_transfer_object (src, dst, (MonoObject *)s->type);
+ }
+
+ dst_serinfo = mono_object_new (dst, sic);
+
+ pa [0] = mono_type_get_object (dst, &klass->byval_arg);
+ pa [1] = trans_entries;
+ mono_runtime_invoke_in_domain (dst, serinfo_ctor2, dst_serinfo, pa, NULL);
+
+ ser_ctor = NULL;
+ for (i = 0; i < klass->method.count; i++) {
+ MonoMethod *t = klass->methods [i];
+ if (!strcmp (t->name, ".ctor") && t->signature->param_count == 2 &&
+ mono_metadata_type_equal (t->signature->params [0],
+ &mono_defaults.serializationinfo_class->byval_arg) &&
+ mono_metadata_type_equal (t->signature->params [1],
+ &mono_defaults.streamingcontext_class->byval_arg))
+ ser_ctor = t;
+ }
+ g_assert (ser_ctor);
+
+ res = mono_object_new (dst, klass);
+
+ ctx.additional = NULL;
+ ctx.state = 128; /* CrossAppDomain */
+ pa [0] = dst_serinfo;
+ pa [1] = &ctx;
+ mono_runtime_invoke_in_domain (dst, ser_ctor, res, pa, NULL);
- *dst_ea = mono_domain_transfer_object (src, dst, *src_ea);
+ return res;
+ }
+
+ if (!(klass->flags & TYPE_ATTRIBUTE_SERIALIZABLE)) {
+ MonoException *exc = NULL;
+ char *msg;
+
+ msg = g_strdup_printf ("klass \"%s.%s\" is not serializable",
+ klass->name_space, klass->name);
+ exc = mono_get_exception_serialization (msg);
+ g_free (msg);
+
+ mono_raise_exception (exc);
+ }
+
+ res = mono_object_new (dst, klass);
+
+ for (i = 0; i < klass->field.count; i++) {
+ MonoClassField *field = &klass->fields [i];
+ MonoType *type = field->type;
+ int size, align;
+ char *src_ptr, *dst_ptr;
+ int simple_type;
+
+ if (type->attrs & FIELD_ATTRIBUTE_STATIC ||
+ type->attrs & FIELD_ATTRIBUTE_NOT_SERIALIZED)
+ continue;
+
+ size = mono_type_size (type, &align);
+
+ dst_ptr = (char*)res + field->offset;
+ src_ptr = (char *)obj + field->offset;
+
+ g_assert (!type->byref);
+
+ simple_type = type->type;
+ handle_enum:
+ switch (simple_type) {
+ case MONO_TYPE_BOOLEAN:
+ case MONO_TYPE_CHAR:
+ case MONO_TYPE_I1:
+ case MONO_TYPE_U1:
+ case MONO_TYPE_I2:
+ case MONO_TYPE_U2:
+ case MONO_TYPE_I4:
+ case MONO_TYPE_U4:
+ case MONO_TYPE_I:
+ case MONO_TYPE_U:
+ case MONO_TYPE_I8:
+ case MONO_TYPE_U8:
+ case MONO_TYPE_R4:
+ case MONO_TYPE_R8:
+ memcpy (dst_ptr, src_ptr, size);
+ break;
+ case MONO_TYPE_OBJECT:
+ case MONO_TYPE_ARRAY:
+ case MONO_TYPE_SZARRAY:
+ case MONO_TYPE_CLASS:
+ case MONO_TYPE_STRING: {
+ *(MonoObject **)dst_ptr = mono_domain_transfer_object (src, dst, *(MonoObject **)src_ptr);
+ break;
+ }
+ case MONO_TYPE_VALUETYPE: {
+ MonoObject *boxed_src, *tmp;
+
+ if (type->data.klass->enumtype) {
+ simple_type = type->data.klass->enum_basetype->type;
+ goto handle_enum;
}
+ boxed_src = mono_value_box (src, type->data.klass, src_ptr);
+ tmp = mono_domain_transfer_object (src, dst, boxed_src);
+ memcpy (dst_ptr, (char *)tmp + sizeof (MonoObject), size);
+ break;
+ }
+ default:
+ g_assert_not_reached ();
}
- } else if (klass == mono_defaults.string_class) {
- MonoString *str = (MonoString *)obj;
- res = (MonoObject *)mono_string_new_utf16 (dst,
- (const guint16 *)str->c_str->vector, str->length);
- } else {
- // fixme: we need generic marshalling code here */
- g_assert_not_reached ();
}
-
+
return res;
}
MonoObject *o;
char *str;
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (name != NULL);
str = mono_string_to_utf8 (name);
+ mono_domain_lock (add);
if (!strcmp (str, "APPBASE"))
o = (MonoObject *)add->setup->application_base;
else if (!strcmp (str, "APP_CONFIG_FILE"))
else if (!strcmp (str, "FORCE_CACHE_INSTALL"))
o = (MonoObject *)add->setup->shadow_copy_files;
else
- o = g_hash_table_lookup (add->env, str);
+ o = mono_g_hash_table_lookup (add->env, name);
+ mono_domain_unlock (add);
g_free (str);
if (!o)
MonoDomain *add = ad->data;
MonoDomain *cur = mono_domain_get ();
MonoObject *o;
- char *str;
+
+ MONO_ARCH_SAVE_REGS;
g_assert (ad != NULL);
g_assert (name != NULL);
o = mono_domain_transfer_object (cur, add, data);
- /* fixme: need a hash func for MonoString */
- str = mono_string_to_utf8 (name);
- g_hash_table_insert (add->env, str, o);
- g_free (str);
+ mono_domain_lock (add);
+ mono_g_hash_table_insert (add->env, name, o);
+
+ mono_domain_unlock (add);
}
MonoAppDomainSetup *
ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (ad->data != NULL);
MonoString *
ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad)
{
+ MONO_ARCH_SAVE_REGS;
+
g_assert (ad != NULL);
g_assert (ad->data != NULL);
- return ad->data->friendly_name;
-}
-
-/**
- * mono_domain_get:
- *
- * Returns the current domain.
- */
-inline MonoDomain *
-mono_domain_get ()
-{
- return ((MonoDomain *)TlsGetValue (appdomain_thread_id));
-}
-
-/**
- * mono_domain_set:
- * @domain: the new domain
- *
- * Sets the current domain to @domain.
- */
-inline void
-mono_domain_set (MonoDomain *domain)
-{
- TlsSetValue (appdomain_thread_id, domain);
+ return mono_string_new (ad->data, ad->data->friendly_name);
}
MonoAppDomain *
ves_icall_System_AppDomain_getCurDomain ()
{
MonoDomain *add = mono_domain_get ();
+
+ MONO_ARCH_SAVE_REGS;
+
return add->domain;
}
MonoAppDomain *ad;
MonoDomain *data;
+ MONO_ARCH_SAVE_REGS;
+
adclass = mono_class_from_name (mono_defaults.corlib, "System", "AppDomain");
- // fixme: pin all those objects
+ /* FIXME: pin all those objects */
ad = (MonoAppDomain *) mono_object_new (domain, adclass);
- ad->data = data = mono_create_domain ();
+ ad->data = data = mono_domain_create ();
data->domain = ad;
data->setup = setup;
- data->friendly_name = friendly_name;
+ data->friendly_name = mono_string_to_utf8 (friendly_name);
- // fixme: what to do next ?
+ /* FIXME: what to do next ? */
return ad;
}
MonoArray *res;
add_assembly_helper_t ah;
+ MONO_ARCH_SAVE_REGS;
+
if (!System_Reflection_Assembly)
System_Reflection_Assembly = mono_class_from_name (
mono_defaults.corlib, "System.Reflection", "Assembly");
ah.domain = domain;
ah.res = res;
ah.idx = 0;
+ mono_domain_lock (domain);
g_hash_table_foreach (domain->assemblies, add_assembly, &ah);
+ mono_domain_unlock (domain);
return res;
}
+/*
+ * Used to find methods in AppDomain class.
+ * It only works if there are no multiple signatures for any given method name
+ */
+static MonoMethod *
+look_for_method_by_name (MonoClass *klass, const gchar *name)
+{
+ gint i;
+ MonoMethod *method;
+
+ for (i = 0; i < klass->method.count; i++) {
+ method = klass->methods [i];
+ if (!strcmp (method->name, name))
+ return method;
+ }
-MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoReflectionAssemblyName *assRef, MonoObject *evidence)
+ return NULL;
+}
+
+static MonoReflectionAssembly *
+try_assembly_resolve (MonoDomain *domain, MonoString *fname)
{
- MonoDomain *domain = ad->data;
- char *name, *filename;
- enum MonoImageOpenStatus status = MONO_IMAGE_OK;
- MonoAssembly *ass;
+ MonoClass *klass;
+ MonoMethod *method;
+ void *params [1];
- /* FIXME : examine evidence? */
+ g_assert (domain != NULL && fname != NULL);
- g_assert (assRef != NULL);
- g_assert (assRef->name != NULL);
+ klass = domain->domain->object.vtable->klass;
+ g_assert (klass);
+
+ method = look_for_method_by_name (klass, "DoAssemblyResolve");
+ if (method == NULL) {
+ g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
+ return NULL;
+ }
+
+ *params = fname;
+ return (MonoReflectionAssembly *) mono_runtime_invoke (method, domain->domain, params, NULL);
+}
+
+static void
+add_assemblies_to_domain (MonoDomain *domain, MonoAssembly *ass)
+{
+ gint i;
- /* FIXME : examine version, culture info */
+ if (g_hash_table_lookup (domain->assemblies, ass->aname.name))
+ return; /* This is ok while no lazy loading of assemblies */
- name = filename = mono_string_to_utf8 (assRef->name);
+ mono_domain_lock (domain);
+ g_hash_table_insert (domain->assemblies, (gpointer) ass->aname.name, ass);
+ mono_domain_unlock (domain);
- if (strncmp (filename, "file://", 7) == 0)
- filename += 7;
+ for (i = 0; ass->image->references [i] != NULL; i++)
+ add_assemblies_to_domain (domain, ass->image->references [i]);
+}
+
+static void
+mono_domain_fire_assembly_load (MonoAssembly *assembly, gpointer user_data)
+{
+ MonoDomain *domain = mono_domain_get ();
+ MonoReflectionAssembly *ref_assembly;
+ MonoClass *klass;
+ MonoMethod *method;
+ void *params [1];
- ass = mono_assembly_open (filename, NULL, &status);
+ klass = domain->domain->object.vtable->klass;
- g_free (name);
+ method = look_for_method_by_name (klass, "DoAssemblyLoad");
+ if (method == NULL) {
+ g_warning ("Method AppDomain.DoAssemblyLoad not found.\n");
+ return;
+ }
- if (!ass)
- mono_raise_exception ((MonoException *)mono_exception_from_name (mono_defaults.corlib, "System.IO", "FileNotFoundException"));
+ add_assemblies_to_domain (domain, assembly);
- return mono_assembly_get_object (domain, ass);
+ ref_assembly = mono_assembly_get_object (domain, assembly);
+ g_assert (ref_assembly);
+
+ *params = ref_assembly;
+ mono_runtime_invoke (method, domain->domain, params, NULL);
}
-void
-ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
+static void
+set_domain_search_path (MonoDomain *domain)
{
- mono_domain_unload (ad->data, FALSE);
+ MonoAppDomainSetup *setup;
+ gchar **tmp;
+ gchar *utf8;
+ gint i;
+ gint npaths = 0;
+ gchar **pvt_split = NULL;
+
+ if (domain->search_path != NULL)
+ return;
+
+ setup = domain->setup;
+ if (setup->application_base)
+ npaths++;
+
+ if (setup->private_bin_path) {
+ utf8 = mono_string_to_utf8 (setup->private_bin_path);
+ pvt_split = g_strsplit (utf8, G_SEARCHPATH_SEPARATOR_S, 1000);
+ g_free (utf8);
+ for (tmp = pvt_split; *tmp; tmp++, npaths++);
+ }
+
+ if (!npaths) {
+ if (pvt_split)
+ g_strfreev (pvt_split);
+ /*
+ * Don't do this because the first time is called, the domain
+ * setup is not finished.
+ *
+ * domain->search_path = g_malloc (sizeof (char *));
+ * domain->search_path [0] = NULL;
+ */
+ return;
+ }
+
+ domain->search_path = tmp = g_malloc ((npaths + 1) * sizeof (gchar *));
+ tmp [npaths] = NULL;
+ if (setup->application_base) {
+ *tmp = mono_string_to_utf8 (setup->application_base);
+ } else {
+ *tmp = g_strdup ("");
+ }
+
+ tmp++;
+ npaths--;
+ for (i = 0; i < npaths; i++)
+ tmp [i] = pvt_split [i];
+
+ g_strfreev (pvt_split);
}
-/**
- * mono_domain_assembly_open:
- * @domain: the application domain
- * @name: file name of the assembly
- *
- * fixme: maybe we should integrate this with mono_assembly_open ??
+static MonoAssembly *
+real_load (gchar **search_path, gchar *filename)
+{
+ MonoAssembly *result;
+ gchar **path;
+ gchar *fullpath;
+
+ for (path = search_path; *path; path++) {
+ if (**path == '\0')
+ continue; /* Ignore empty ApplicationBase */
+ fullpath = g_build_filename (*path, filename, NULL);
+ result = mono_assembly_open (fullpath, NULL);
+ g_free (fullpath);
+ if (result)
+ return result;
+ }
+
+ return NULL;
+}
+
+/*
+ * Try loading the assembly from ApplicationBase and PrivateBinPath
+ * and then from assemblies_path if any.
*/
-MonoAssembly *
-mono_domain_assembly_open (MonoDomain *domain, char *name)
+static MonoAssembly *
+mono_domain_assembly_preload (MonoAssemblyName *aname,
+ gchar **assemblies_path,
+ gpointer user_data)
{
- MonoAssembly *ass, *tmp;
- int i;
+ MonoDomain *domain = mono_domain_get ();
+ MonoAssembly *result;
+ gchar *dll, *exe;
+
+ set_domain_search_path (domain);
+
+ dll = g_strconcat (aname->name, ".dll", NULL);
+ exe = g_strdup (dll);
+ strcpy (exe + strlen (exe) - 4, ".exe");
+
+ if (domain->search_path && domain->search_path [0] != NULL) {
+ /* TODO: should also search in name/name.dll and name/name.exe from appbase */
+ result = real_load (domain->search_path, dll);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+
+ result = real_load (domain->search_path, exe);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+ }
- if ((ass = g_hash_table_lookup (domain->assemblies, name)))
- return ass;
+ if (assemblies_path && assemblies_path [0] != NULL) {
+ result = real_load (assemblies_path, dll);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
- if (!(ass = mono_assembly_open (name, NULL, NULL)))
- return NULL;
+ result = real_load (assemblies_path, exe);
+ if (result) {
+ g_free (dll);
+ g_free (exe);
+ return result;
+ }
+ }
+
+ g_free (dll);
+ g_free (exe);
+ return NULL;
+}
+
+MonoReflectionAssembly *
+ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname)
+{
+ MonoDomain *domain = mono_domain_get ();
+ char *name, *filename;
+ MonoImageOpenStatus status = MONO_IMAGE_OK;
+ MonoAssembly *ass;
+
+ MONO_ARCH_SAVE_REGS;
+
+ if (fname == NULL) {
+ MonoException *exc = mono_get_exception_argument_null ("assemblyFile");
+ mono_raise_exception (exc);
+ }
+
+ name = filename = mono_string_to_utf8 (fname);
- g_hash_table_insert (domain->assemblies, ass->name, ass);
+ /* FIXME: move uri handling to mono_assembly_open */
+ if (strncmp (filename, "file://", 7) == 0)
+ filename += 7;
+
+ ass = mono_assembly_open (filename, &status);
+
+ g_free (name);
- // fixme: maybe this must be recursive ?
- for (i = 0; (tmp = ass->image->references [i]) != NULL; i++) {
- if (!g_hash_table_lookup (domain->assemblies, tmp->name))
- g_hash_table_insert (domain->assemblies, tmp->name, tmp);
+ if (!ass){
+ MonoException *exc = mono_get_exception_file_not_found (fname);
+ mono_raise_exception (exc);
}
- return ass;
+ return mono_assembly_get_object (domain, ass);
}
static void
-remove_assembly (gpointer key, gpointer value, gpointer user_data)
+free_assembly_name (MonoAssemblyName *aname)
{
- mono_assembly_close ((MonoAssembly *)value);
+ if (aname == NULL)
+ return;
+
+ g_free ((void *) aname->name);
+ g_free ((void *) aname->culture);
+ g_free ((void *) aname->hash_value);
}
-void
-mono_domain_unload (MonoDomain *domain, gboolean force)
+static gboolean
+get_info_from_assembly_name (MonoReflectionAssemblyName *assRef, MonoAssemblyName *aname)
{
- if ((domain == mono_root_domain) && !force) {
- g_warning ("cant unload root domain");
- return;
+ gchar *name;
+ gchar *value;
+ gchar **parts;
+ gchar **tmp;
+ gint major, minor, build, revision;
+
+ memset (aname, 0, sizeof (MonoAssemblyName));
+
+ name = mono_string_to_utf8 (assRef->name);
+ parts = tmp = g_strsplit (name, ",", 4);
+ g_free (name);
+ if (!tmp || !*tmp) {
+ g_strfreev (tmp);
+ return FALSE;
}
- g_hash_table_foreach (domain->assemblies, remove_assembly, NULL);
+ value = g_strstrip (*tmp);
+ /* g_print ("Assembly name: %s\n", value); */
+ aname->name = g_strdup (value);
+ tmp++;
+ if (!*tmp) {
+ g_strfreev (parts);
+ return TRUE;
+ }
- g_hash_table_destroy (domain->env);
- g_hash_table_destroy (domain->assemblies);
- g_hash_table_destroy (domain->class_vtable_hash);
- g_hash_table_destroy (domain->jit_code_hash);
- g_hash_table_destroy (domain->ldstr_table);
- mono_mempool_destroy (domain->mp);
+ value = g_strstrip (*tmp);
+ if (strncmp (value, "Version=", 8)) {
+ g_strfreev (parts);
+ return FALSE;
+ }
- // fixme: anything else required ? */
+ if (sscanf (value + 8, "%u.%u.%u.%u", &major, &minor, &build, &revision) != 4) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ /* g_print ("Version: %u.%u.%u.%u\n", major, minor, build, revision); */
+ aname->major = major;
+ aname->minor = minor;
+ aname->build = build;
+ aname->revision = revision;
+ tmp++;
+
+ if (!*tmp) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ value = g_strstrip (*tmp);
+ if (strncmp (value, "Culture=", 8)) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ /* g_print ("Culture: %s\n", aname->culture); */
+ aname->culture = g_strstrip (g_strdup (value + 8));
+ tmp++;
+
+ if (!*tmp) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ value = g_strstrip (*tmp);
+ if (strncmp (value, "PublicKeyToken=", 15)) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ value += 15;
+ if (*value && strcmp (value, "null")) {
+ gint i, len;
+ gchar h, l;
+ gchar *result;
+
+ value = g_strstrip (g_strdup (value));
+ len = strlen (value);
+ if (len % 2) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+
+ aname->hash_len = len / 2;
+ aname->hash_value = g_malloc0 (aname->hash_len);
+ result = (gchar *) aname->hash_value;
+
+ for (i = 0; i < len; i++) {
+ if (i % 2) {
+ l = g_ascii_xdigit_value (value [i]);
+ if (l == -1) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+ result [i / 2] = (h * 16) + l;
+ } else {
+ h = g_ascii_xdigit_value (value [i]);
+ if (h == -1) {
+ g_strfreev (parts);
+ return FALSE;
+ }
+ }
+ }
+
+ /*
+ g_print ("PublicKeyToken: ");
+ for (i = 0; i < aname->hash_len; i++) {
+ g_print ("%x", 0x00FF & aname->hash_value [i]);
+ }
+ g_print ("\n");
+ */
+ }
+
+ g_strfreev (parts);
+ return TRUE;
+}
+
+MonoReflectionAssembly *
+ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoReflectionAssemblyName *assRef, MonoObject *evidence)
+{
+ MonoDomain *domain = ad->data;
+ MonoImageOpenStatus status = MONO_IMAGE_OK;
+ MonoAssembly *ass;
+ MonoAssemblyName aname;
+ MonoReflectionAssembly *refass = NULL;
+
+ MONO_ARCH_SAVE_REGS;
+
+ memset (&aname, 0, sizeof (aname));
+
+ /* FIXME : examine evidence? */
-#if HAVE_BOEHM_GC
-#else
- g_free (domain);
-#endif
+ g_assert (assRef != NULL);
+ g_assert (assRef->name != NULL);
+
+ if (!get_info_from_assembly_name (assRef, &aname)) {
+ MonoException *exc;
+
+ free_assembly_name (&aname);
+ /* This is a parse error... */
+ exc = mono_get_exception_file_not_found (assRef->name);
+ mono_raise_exception (exc);
+ }
+
+ ass = mono_assembly_load (&aname, NULL, &status);
+ free_assembly_name (&aname);
+
+ if (!ass && (refass = try_assembly_resolve (domain, assRef->name)) == NULL){
+ /* FIXME: it doesn't make much sense since we really don't have a filename ... */
+ MonoException *exc = mono_get_exception_file_not_found (assRef->name);
+ mono_raise_exception (exc);
+ }
+
+ if (refass != NULL)
+ return refass;
+
+ return mono_assembly_get_object (domain, ass);
+}
+
+void
+ves_icall_System_AppDomain_Unload (MonoAppDomain *ad)
+{
+ MONO_ARCH_SAVE_REGS;
- if ((domain == mono_root_domain))
- mono_root_domain = NULL;
+ mono_domain_unload (ad->data, FALSE);
}
gint32
MonoDomain *cdom = mono_domain_get ();
MonoAssembly *assembly;
MonoImage *image;
- MonoCLIImageInfo *iinfo;
MonoMethod *method;
MonoObject *margs;
char *filename;
gint32 res;
+ MONO_ARCH_SAVE_REGS;
+
mono_domain_set (ad->data);
filename = mono_string_to_utf8 (file);
- assembly = mono_assembly_open (filename, NULL, NULL);
+ assembly = mono_assembly_open (filename, NULL);
g_free (filename);
if (!assembly) {
}
image = assembly->image;
- iinfo = image->image_info;
- method = mono_get_method (image, iinfo->cli_cli_header.ch_entry_point, NULL);
+
+ method = mono_get_method (image, mono_image_get_entry_point (image), NULL);
if (!method)
g_error ("No entry point method found in %s", image->name);
margs = mono_domain_transfer_object (cdom, ad->data, (MonoObject *)args);
- res = mono_runtime_exec_main (method, (MonoArray *)margs);
+ if (!margs)
+ margs = (MonoObject *) mono_array_new (ad->data, mono_defaults.string_class, 0);
+ res = mono_runtime_exec_main (method, (MonoArray *)margs, NULL);
mono_domain_set (cdom);
return res;
}
+
projects / mono.git / blobdiff