common_sources = \
$(platform_sources) \
+ appdomain-icalls.h \
assembly.c \
assembly-internals.h \
attach.h \
--- /dev/null
+/*
+ * Appdomain-related icalls.
+ * Copyright 2016 Microsoft
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
+ */
+
+#ifndef __MONO_METADATA_APPDOMAIN_ICALLS_H__
+#define __MONO_METADATA_APPDOMAIN_ICALLS_H__
+
+#include <mono/metadata/appdomain.h>
+#include <mono/metadata/handle.h>
+#include <mono/metadata/object-internals.h>
+
+MonoAppDomain *
+ves_icall_System_AppDomain_getCurDomain (void);
+
+MonoAppDomain *
+ves_icall_System_AppDomain_getRootDomain (void);
+
+MonoAppDomain *
+ves_icall_System_AppDomain_createDomain (MonoString *friendly_name,
+ MonoAppDomainSetup *setup);
+
+MonoObject *
+ves_icall_System_AppDomain_GetData (MonoAppDomain *ad,
+ MonoString *name);
+
+MonoReflectionAssemblyHandle
+ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomainHandle ad,
+ MonoArrayHandle raw_assembly,
+ MonoArrayHandle raw_symbol_store,
+ MonoObjectHandle evidence,
+ MonoBoolean refonly,
+ MonoError *error);
+
+void
+ves_icall_System_AppDomain_SetData (MonoAppDomain *ad,
+ MonoString *name,
+ MonoObject *data);
+
+MonoAppDomainSetup *
+ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad);
+
+MonoString *
+ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad);
+
+MonoArrayHandle
+ves_icall_System_AppDomain_GetAssemblies (MonoAppDomainHandle ad,
+ MonoBoolean refonly,
+ MonoError *error);
+
+MonoReflectionAssemblyHandle
+ves_icall_System_Reflection_Assembly_LoadFrom (MonoStringHandle fname,
+ MonoBoolean refonly,
+ MonoError *error);
+
+MonoReflectionAssemblyHandle
+ves_icall_System_AppDomain_LoadAssembly (MonoAppDomainHandle ad,
+ MonoStringHandle assRef,
+ MonoObjectHandle evidence,
+ MonoBoolean refonly,
+ MonoError *error);
+
+gboolean
+ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id);
+
+void
+ves_icall_System_AppDomain_InternalUnload (gint32 domain_id);
+
+void
+ves_icall_System_AppDomain_DoUnhandledException (MonoException *exc);
+
+gint32
+ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad,
+ MonoReflectionAssembly *refass,
+ MonoArray *args);
+
+MonoAppDomain *
+ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad);
+
+MonoAppDomain *
+ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid);
+
+void
+ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad);
+
+void
+ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id);
+
+void
+ves_icall_System_AppDomain_InternalPopDomainRef (void);
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalGetContext (void);
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalGetDefaultContext (void);
+
+MonoAppContext *
+ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc);
+
+gint32
+ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad);
+
+MonoString *
+ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid);
+
+MonoBoolean
+ves_icall_System_CLRConfig_CheckThrowUnobservedTaskExceptions (void);
+
+
+#endif /*__MONO_METADATA_APPDOMAIN_ICALLS_H__*/
#include <mono/metadata/gc-internals.h>
#include <mono/metadata/object.h>
+#include <mono/metadata/appdomain-icalls.h>
#include <mono/metadata/domain-internals.h>
#include "mono/metadata/metadata-internals.h"
#include <mono/metadata/assembly.h>
static MonoLoadFunc load_function = NULL;
/* Lazy class loading functions */
-static GENERATE_GET_CLASS_WITH_CACHE (assembly, System.Reflection, Assembly)
+static GENERATE_GET_CLASS_WITH_CACHE (assembly, System.Reflection, Assembly);
+
+static GENERATE_GET_CLASS_WITH_CACHE (appdomain, System, AppDomain);
void
mono_install_runtime_load (MonoLoadFunc func)
mono_error_init (error);
- adclass = mono_class_load_from_name (mono_defaults.corlib, "System", "AppDomain");
+ adclass = mono_class_get_appdomain_class ();
/* FIXME: pin all those objects */
data = mono_domain_create();
{
static MonoMethod *method = NULL;
MonoReflectionAssembly *ret;
- MonoClass *klass;
void *params [1];
mono_error_init (error);
g_assert (domain != NULL && ((name != NULL) || (tb != NULL)));
if (method == NULL) {
- klass = domain->domain->mbr.obj.vtable->klass;
- g_assert (klass);
-
- method = mono_class_get_method_from_name (klass, "DoTypeResolve", -1);
+ method = mono_class_get_method_from_name (mono_class_get_appdomain_class (), "DoTypeResolve", -1);
if (method == NULL) {
g_warning ("Method AppDomain.DoTypeResolve not found.\n");
return NULL;
return ad;
}
-MonoArray *
-ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad, MonoBoolean refonly)
+static gboolean
+add_assembly_to_array (MonoDomain *domain, MonoArrayHandle dest, int dest_idx, MonoAssembly* assm, MonoError *error)
{
- MonoError error;
- MonoDomain *domain = ad->data;
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoReflectionAssemblyHandle assm_obj = mono_assembly_get_object_handle (domain, assm, error);
+ if (!is_ok (error))
+ goto leave;
+ MONO_HANDLE_ARRAY_SETREF (dest, dest_idx, assm_obj);
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (is_ok (error));
+}
+
+MonoArrayHandle
+ves_icall_System_AppDomain_GetAssemblies (MonoAppDomainHandle ad, MonoBoolean refonly, MonoError *error)
+{
+ mono_error_init (error);
+ MonoDomain *domain = MONO_HANDLE_GETVAL (ad, data);
MonoAssembly* ass;
- MonoArray *res;
GSList *tmp;
int i;
GPtrArray *assemblies;
- mono_error_init (&error);
-
/*
* Make a copy of the list of assemblies because we can't hold the assemblies
* lock while creating objects etc.
}
mono_domain_assemblies_unlock (domain);
- res = mono_array_new_checked (domain, mono_class_get_assembly_class (), assemblies->len, &error);
- if (!is_ok (&error))
+ MonoArrayHandle res = mono_array_new_handle (domain, mono_class_get_assembly_class (), assemblies->len, error);
+ if (!is_ok (error))
goto leave;
for (i = 0; i < assemblies->len; ++i) {
- ass = (MonoAssembly *)g_ptr_array_index (assemblies, i);
- MonoReflectionAssembly *ass_obj = mono_assembly_get_object_checked (domain, ass, &error);
- if (!mono_error_ok (&error))
+ if (!add_assembly_to_array (domain, res, i, (MonoAssembly *)g_ptr_array_index (assemblies, i), error))
goto leave;
- mono_array_setref (res, i, ass_obj);
}
leave:
g_ptr_array_free (assemblies, TRUE);
- if (!mono_error_ok (&error))
- mono_error_set_pending_exception (&error);
return res;
}
-MonoReflectionAssembly *
-mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly, MonoError *error)
+MonoAssembly*
+mono_try_assembly_resolve (MonoDomain *domain, const char *fname_raw, MonoAssembly *requesting, gboolean refonly, MonoError *error)
{
- MonoReflectionAssembly *ret;
- MonoClass *klass;
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoAssembly *result = NULL;
+ MonoStringHandle fname = mono_string_new_handle (domain, fname_raw, error);
+ if (!is_ok (error))
+ goto leave;
+ result = mono_try_assembly_resolve_handle (domain, fname, requesting, refonly, error);
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (result);
+}
+
+MonoAssembly*
+mono_try_assembly_resolve_handle (MonoDomain *domain, MonoStringHandle fname, MonoAssembly *requesting, gboolean refonly, MonoError *error)
+{
+ MonoAssembly *ret = NULL;
MonoMethod *method;
MonoBoolean isrefonly;
gpointer params [3];
mono_error_init (error);
if (mono_runtime_get_no_exec ())
- return NULL;
+ return ret;
- g_assert (domain != NULL && fname != NULL);
+ g_assert (domain != NULL && !MONO_HANDLE_IS_NULL (fname));
- klass = domain->domain->mbr.obj.vtable->klass;
- g_assert (klass);
-
- method = mono_class_get_method_from_name (klass, "DoAssemblyResolve", -1);
- if (method == NULL) {
- g_warning ("Method AppDomain.DoAssemblyResolve not found.\n");
- return NULL;
- }
+ method = mono_class_get_method_from_name (mono_class_get_appdomain_class (), "DoAssemblyResolve", -1);
+ g_assert (method != NULL);
isrefonly = refonly ? 1 : 0;
- params [0] = fname;
+ MonoReflectionAssemblyHandle requesting_handle;
if (requesting) {
- params[1] = mono_assembly_get_object_checked (domain, requesting, error);
- return_val_if_nok (error, NULL);
- } else
- params [1] = NULL;
+ requesting_handle = mono_assembly_get_object_handle (domain, requesting, error);
+ return_val_if_nok (error, ret);
+ }
+ params [0] = MONO_HANDLE_RAW (fname);
+ params[1] = requesting ? MONO_HANDLE_RAW (requesting_handle) : NULL;
params [2] = &isrefonly;
-
- ret = (MonoReflectionAssembly *) mono_runtime_invoke_checked (method, domain->domain, params, error);
- return_val_if_nok (error, NULL);
-
+ MonoReflectionAssemblyHandle result = MONO_HANDLE_NEW (MonoReflectionAssembly, mono_runtime_invoke_checked (method, domain->domain, params, error));
+ ret = !MONO_HANDLE_IS_NULL (result) ? MONO_HANDLE_GETVAL (result, assembly) : NULL;
return ret;
}
gboolean refonly)
{
MonoError error;
- MonoReflectionAssembly *assembly;
+ MonoAssembly *assembly;
MonoDomain *domain = mono_domain_get ();
char *aname_str;
- MonoString *str;
aname_str = mono_stringify_assembly_name (aname);
/* FIXME: We invoke managed code here, so there is a potential for deadlocks */
- str = mono_string_new (domain, aname_str);
- g_free (aname_str);
- if (!str) {
- return NULL;
- }
- assembly = mono_try_assembly_resolve (domain, str, requesting, refonly, &error);
+ assembly = mono_try_assembly_resolve (domain, aname_str, requesting, refonly, &error);
+ g_free (aname_str);
mono_error_cleanup (&error);
- if (assembly)
- return assembly->assembly;
- else
- return NULL;
+ return assembly;
}
/*
static MonoMethod *assembly_load_method;
MonoError error;
MonoDomain *domain = mono_domain_get ();
- MonoReflectionAssembly *ref_assembly;
MonoClass *klass;
gpointer load_value;
void *params [1];
return;
}
- ref_assembly = mono_assembly_get_object_checked (domain, assembly, &error);
+ MonoReflectionAssemblyHandle ref_assembly = mono_assembly_get_object_handle (domain, assembly, &error);
mono_error_assert_ok (&error);
if (assembly_load_method == NULL) {
g_assert (assembly_load_method);
}
- *params = ref_assembly;
+ *params = MONO_HANDLE_RAW(ref_assembly);
mono_runtime_invoke_checked (assembly_load_method, domain->domain, params, &error);
mono_error_cleanup (&error);
return NULL;
}
-MonoReflectionAssembly *
-ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname, MonoBoolean refOnly)
+MonoReflectionAssemblyHandle
+ves_icall_System_Reflection_Assembly_LoadFrom (MonoStringHandle fname, MonoBoolean refOnly, MonoError *error)
{
- MonoError error;
- MonoReflectionAssembly *result;
+ mono_error_init (error);
MonoDomain *domain = mono_domain_get ();
char *name, *filename;
MonoImageOpenStatus status = MONO_IMAGE_OK;
- MonoAssembly *ass = NULL;
+ MonoReflectionAssemblyHandle result = MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
name = NULL;
result = NULL;
- mono_error_init (&error);
-
if (fname == NULL) {
- mono_error_set_argument_null (&error, "assemblyFile", "");
+ mono_error_set_argument_null (error, "assemblyFile", "");
goto leave;
}
- name = filename = mono_string_to_utf8_checked (fname, &error);
- if (!is_ok (&error))
+ name = filename = mono_string_handle_to_utf8 (fname, error);
+ if (!is_ok (error))
goto leave;
- ass = mono_assembly_open_full (filename, &status, refOnly);
+ MonoAssembly *ass = mono_assembly_open_full (filename, &status, refOnly);
if (!ass) {
if (status == MONO_IMAGE_IMAGE_INVALID)
- mono_error_set_bad_image_name (&error, g_strdup (name), "");
+ mono_error_set_bad_image_name (error, g_strdup (name), "");
else
- mono_error_set_assembly_load (&error, g_strdup (name), "%s", "");
+ mono_error_set_assembly_load (error, g_strdup (name), "%s", "");
goto leave;
}
- result = mono_assembly_get_object_checked (domain, ass, &error);
+ result = mono_assembly_get_object_handle (domain, ass, error);
leave:
- mono_error_set_pending_exception (&error);
g_free (name);
return result;
}
-MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
- MonoArray *raw_assembly,
- MonoArray *raw_symbol_store, MonoObject *evidence,
- MonoBoolean refonly)
+MonoReflectionAssemblyHandle
+ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomainHandle ad,
+ MonoArrayHandle raw_assembly,
+ MonoArrayHandle raw_symbol_store, MonoObjectHandle evidence,
+ MonoBoolean refonly,
+ MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoAssembly *ass;
- MonoReflectionAssembly *refass = NULL;
- MonoDomain *domain = ad->data;
+ MonoReflectionAssemblyHandle refass = MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
+ MonoDomain *domain = MONO_HANDLE_GETVAL(ad, data);
MonoImageOpenStatus status;
- guint32 raw_assembly_len = mono_array_length (raw_assembly);
- MonoImage *image = mono_image_open_from_data_full (mono_array_addr (raw_assembly, gchar, 0), raw_assembly_len, TRUE, NULL, refonly);
+ guint32 raw_assembly_len = mono_array_handle_length (raw_assembly);
+
+ /* Copy the data ourselves to unpin the raw assembly byte array as soon as possible */
+ char *assembly_data = (char*) g_try_malloc (raw_assembly_len);
+ if (!assembly_data) {
+ mono_error_set_out_of_memory (error, "Could not allocate %ud bytes to copy raw assembly data", raw_assembly_len);
+ return refass;
+ }
+ uint32_t gchandle;
+ mono_byte *raw_data = (mono_byte*) MONO_ARRAY_HANDLE_PIN (raw_assembly, gchar, 0, &gchandle);
+ memcpy (assembly_data, raw_data, raw_assembly_len);
+ mono_gchandle_free (gchandle); /* unpin */
+ MONO_HANDLE_ASSIGN (raw_assembly, NULL_HANDLE); /* don't reference the data anymore */
+
+ MonoImage *image = mono_image_open_from_data_full (assembly_data, raw_assembly_len, FALSE, NULL, refonly);
if (!image) {
- mono_set_pending_exception (mono_get_exception_bad_image_format (""));
- return NULL;
+ mono_error_set_bad_image_name (error, g_strdup (""), "%s", "");
+ return refass;
}
- if (raw_symbol_store != NULL)
- mono_debug_open_image_from_memory (image, mono_array_addr (raw_symbol_store, guint8, 0), mono_array_length (raw_symbol_store));
+ if (!MONO_HANDLE_IS_NULL(raw_symbol_store)) {
+ guint32 symbol_len = mono_array_handle_length (raw_symbol_store);
+ uint32_t symbol_gchandle;
+ mono_byte *raw_symbol_data = (mono_byte*) MONO_ARRAY_HANDLE_PIN (raw_symbol_store, mono_byte, 0, &symbol_gchandle);
+ mono_debug_open_image_from_memory (image, raw_symbol_data, symbol_len);
+ mono_gchandle_free (symbol_gchandle);
+ }
ass = mono_assembly_load_from_full (image, "", &status, refonly);
if (!ass) {
mono_image_close (image);
- mono_set_pending_exception (mono_get_exception_bad_image_format (""));
- return NULL;
+ mono_error_set_bad_image_name (error, g_strdup (""), "%s", "");
+ return refass;
}
- refass = mono_assembly_get_object_checked (domain, ass, &error);
- if (!refass)
- mono_error_set_pending_exception (&error);
- else
- MONO_OBJECT_SETREF (refass, evidence, evidence);
+ refass = mono_assembly_get_object_handle (domain, ass, error);
+ if (!MONO_HANDLE_IS_NULL(refass))
+ MONO_HANDLE_SET (refass, evidence, evidence);
return refass;
}
-MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad, MonoString *assRef, MonoObject *evidence, MonoBoolean refOnly)
+MonoReflectionAssemblyHandle
+ves_icall_System_AppDomain_LoadAssembly (MonoAppDomainHandle ad, MonoStringHandle assRef, MonoObjectHandle evidence, MonoBoolean refOnly, MonoError *error)
{
- MonoError error;
- MonoDomain *domain = ad->data;
+ mono_error_init (error);
+ MonoDomain *domain = MONO_HANDLE_GETVAL (ad, data);
MonoImageOpenStatus status = MONO_IMAGE_OK;
MonoAssembly *ass;
MonoAssemblyName aname;
- MonoReflectionAssembly *refass = NULL;
gchar *name = NULL;
gboolean parsed;
g_assert (assRef);
- name = mono_string_to_utf8_checked (assRef, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
+ name = mono_string_handle_to_utf8 (assRef, error);
+ if (!is_ok (error))
+ goto fail;
parsed = mono_assembly_name_parse (name, &aname);
+ g_free (name);
if (!parsed) {
+ MonoReflectionAssemblyHandle refass = MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
/* This is a parse error... */
if (!refOnly) {
- refass = mono_try_assembly_resolve (domain, assRef, NULL, refOnly, &error);
- if (!is_ok (&error))
- goto leave;
+ MonoAssembly *assm = mono_try_assembly_resolve_handle (domain, assRef, NULL, refOnly, error);
+ if (!is_ok (error))
+ goto fail;
+ if (assm) {
+ refass = mono_assembly_get_object_handle (domain, assm, error);
+ if (!is_ok (error))
+ goto fail;
+ }
}
return refass;
}
if (!ass) {
/* MS.NET doesn't seem to call the assembly resolve handler for refonly assemblies */
if (!refOnly) {
- refass = mono_try_assembly_resolve (domain, assRef, NULL, refOnly, &error);
- if (!is_ok (&error))
- goto leave;
+ ass = mono_try_assembly_resolve_handle (domain, assRef, NULL, refOnly, error);
+ if (!is_ok (error))
+ goto fail;
}
- else
- refass = NULL;
- if (!refass)
- goto leave;
- ass = refass->assembly;
+ if (!ass)
+ goto fail;
}
g_assert (ass);
- if (refass == NULL) {
- refass = mono_assembly_get_object_checked (domain, ass, &error);
- if (!is_ok (&error))
- goto leave;
- }
+ MonoReflectionAssemblyHandle refass = mono_assembly_get_object_handle (domain, ass, error);
+ if (!is_ok (error))
+ goto fail;
- MONO_OBJECT_SETREF (refass, evidence, evidence);
+ MONO_HANDLE_SET (refass, evidence, evidence);
-leave:
- g_free (name);
- mono_error_set_pending_exception (&error);
return refass;
+fail:
+ return MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
}
void
res = probe_for_partial_name (gacpath, fullname, aname, status);
g_free (gacpath);
+ g_free (fullname);
+ mono_assembly_name_free (aname);
+
if (res)
res->in_gac = TRUE;
else {
MonoDomain *domain = mono_domain_get ();
- MonoReflectionAssembly *refasm;
- refasm = mono_try_assembly_resolve (domain, mono_string_new (domain, name), NULL, FALSE, &error);
+ res = mono_try_assembly_resolve (domain, name, NULL, FALSE, &error);
if (!is_ok (&error)) {
- g_free (fullname);
- mono_assembly_name_free (aname);
mono_error_cleanup (&error);
if (*status == MONO_IMAGE_OK)
*status = MONO_IMAGE_IMAGE_INVALID;
}
-
- if (refasm)
- res = refasm->assembly;
}
-
- g_free (fullname);
- mono_assembly_name_free (aname);
return res;
}
mono_error_set_pending_exception (&error);
}
-static MonoObject*
-create_custom_attr_data (MonoImage *image, MonoCustomAttrEntry *cattr, MonoError *error)
+static MonoObjectHandle
+create_custom_attr_data_handle (MonoImage *image, MonoCustomAttrEntry *cattr, MonoError *error)
{
static MonoMethod *ctor;
MonoDomain *domain;
- MonoObject *attr;
void *params [4];
mono_error_init (error);
ctor = mono_class_get_method_from_name (mono_defaults.customattribute_data_class, ".ctor", 4);
domain = mono_domain_get ();
- attr = mono_object_new_checked (domain, mono_defaults.customattribute_data_class, error);
- return_val_if_nok (error, NULL);
- params [0] = mono_method_get_object_checked (domain, cattr->ctor, NULL, error);
- return_val_if_nok (error, NULL);
- params [1] = mono_assembly_get_object_checked (domain, image->assembly, error);
- return_val_if_nok (error, NULL);
+
+ MonoObjectHandle attr = MONO_HANDLE_NEW (MonoObject, mono_object_new_checked (domain, mono_defaults.customattribute_data_class, error));
+ if (!is_ok (error))
+ goto fail;
+
+ MonoReflectionMethod *ctor_obj = mono_method_get_object_checked (domain, cattr->ctor, NULL, error);
+ if (!is_ok (error))
+ goto fail;
+ MonoReflectionAssemblyHandle assm = mono_assembly_get_object_handle (domain, image->assembly, error);
+ if (!is_ok (error))
+ goto fail;
+ params [0] = ctor_obj;
+ params [1] = MONO_HANDLE_RAW (assm);
params [2] = (gpointer)&cattr->data;
params [3] = &cattr->data_size;
- mono_runtime_invoke_checked (ctor, attr, params, error);
- return_val_if_nok (error, NULL);
+ mono_runtime_invoke_checked (ctor, MONO_HANDLE_RAW (attr), params, error);
return attr;
+fail:
+ return MONO_HANDLE_NEW (MonoObject, NULL);
+}
+
+static MonoObject *
+create_custom_attr_data (MonoImage *image, MonoCustomAttrEntry *cattr, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ MonoObjectHandle obj = create_custom_attr_data_handle (image, cattr, error);
+ HANDLE_FUNCTION_RETURN_OBJ (obj);
}
static MonoArray*
void
mono_jit_code_hash_init (MonoInternalHashTable *jit_code_hash);
-MonoAppDomain *
-ves_icall_System_AppDomain_getCurDomain (void);
-
-MonoAppDomain *
-ves_icall_System_AppDomain_getRootDomain (void);
-
-MonoAppDomain *
-ves_icall_System_AppDomain_createDomain (MonoString *friendly_name,
- MonoAppDomainSetup *setup);
-
-MonoObject *
-ves_icall_System_AppDomain_GetData (MonoAppDomain *ad,
- MonoString *name);
-
-MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssemblyRaw (MonoAppDomain *ad,
- MonoArray *raw_assembly,
- MonoArray *raw_symbol_store,
- MonoObject *evidence,
- MonoBoolean refonly);
-
-void
-ves_icall_System_AppDomain_SetData (MonoAppDomain *ad,
- MonoString *name,
- MonoObject *data);
-
-MonoAppDomainSetup *
-ves_icall_System_AppDomain_getSetup (MonoAppDomain *ad);
-
-MonoString *
-ves_icall_System_AppDomain_getFriendlyName (MonoAppDomain *ad);
-
-MonoArray *
-ves_icall_System_AppDomain_GetAssemblies (MonoAppDomain *ad,
- MonoBoolean refonly);
-
-MonoReflectionAssembly *
-ves_icall_System_Reflection_Assembly_LoadFrom (MonoString *fname,
- MonoBoolean refonly);
-
-MonoReflectionAssembly *
-ves_icall_System_AppDomain_LoadAssembly (MonoAppDomain *ad,
- MonoString *assRef,
- MonoObject *evidence,
- MonoBoolean refonly);
-
-gboolean
-ves_icall_System_AppDomain_InternalIsFinalizingForUnload (gint32 domain_id);
-
-void
-ves_icall_System_AppDomain_InternalUnload (gint32 domain_id);
-
-void
-ves_icall_System_AppDomain_DoUnhandledException (MonoException *exc);
-
-gint32
-ves_icall_System_AppDomain_ExecuteAssembly (MonoAppDomain *ad,
- MonoReflectionAssembly *refass,
- MonoArray *args);
-
-MonoAppDomain *
-ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomain *ad);
-
-MonoAppDomain *
-ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid);
-
-void
-ves_icall_System_AppDomain_InternalPushDomainRef (MonoAppDomain *ad);
-
-void
-ves_icall_System_AppDomain_InternalPushDomainRefByID (gint32 domain_id);
-
-void
-ves_icall_System_AppDomain_InternalPopDomainRef (void);
-
-MonoAppContext *
-ves_icall_System_AppDomain_InternalGetContext (void);
-
-MonoAppContext *
-ves_icall_System_AppDomain_InternalGetDefaultContext (void);
-
-MonoAppContext *
-ves_icall_System_AppDomain_InternalSetContext (MonoAppContext *mc);
-
-gint32
-ves_icall_System_AppDomain_GetIDFromDomain (MonoAppDomain * ad);
-
-MonoString *
-ves_icall_System_AppDomain_InternalGetProcessGuid (MonoString* newguid);
-
-MonoBoolean
-ves_icall_System_CLRConfig_CheckThrowUnobservedTaskExceptions (void);
-
MonoAssembly *
mono_assembly_load_corlib (const MonoRuntimeInfo *runtime, MonoImageOpenStatus *status);
MONO_API void
mono_domain_add_class_static_data (MonoDomain *domain, MonoClass *klass, gpointer data, guint32 *bitmap);
-MonoReflectionAssembly *
-mono_try_assembly_resolve (MonoDomain *domain, MonoString *fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);
+MonoAssembly *
+mono_try_assembly_resolve (MonoDomain *domain, const char *fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);
MonoAssembly *
mono_domain_assembly_postload_search (MonoAssemblyName *aname, MonoAssembly *requesting, gboolean refonly);
MonoRawHandle
mono_stack_mark_pop_value (MonoThreadInfo *info, HandleStackMark *stackmark, MonoRawHandle value)
{
- g_error ("impl me");
+ MonoObject *obj = value ? *((MonoObject**)value) : NULL;
+ mono_stack_mark_pop (info, stackmark);
+ return mono_handle_new (obj);
}
/* Temporary place for some of the handle enabled wrapper functions*/
mono_stack_mark_record_size (__info, &__mark, __FUNCTION__); \
mono_stack_mark_pop (__info, &__mark);
+#define CLEAR_ICALL_FRAME_VALUE(RESULT, HANDLE) \
+ mono_stack_mark_record_size (__info, &__mark, __FUNCTION__); \
+ (RESULT) = mono_stack_mark_pop_value (__info, &__mark, (HANDLE));
+
+
#define HANDLE_FUNCTION_ENTER() do { \
MonoThreadInfo *__info = mono_thread_info_current (); \
SETUP_ICALL_FRAME \
return __result; \
} while (0); } while (0);
+#define HANDLE_FUNCTION_RETURN_REF(TYPE, HANDLE) \
+ do { \
+ MonoRawHandle __result; \
+ CLEAR_ICALL_FRAME_VALUE (__result, ((MonoRawHandle) (HANDLE))); \
+ return MONO_HANDLE_CAST (TYPE, __result); \
+ } while (0); } while (0);
+
#ifdef MONO_NEEDS_STACK_WATERMARK
static void
static inline void
mono_handle_assign (MonoObjectHandleOut dest, MonoObjectHandle src)
{
- mono_gc_wbarrier_generic_store (&dest->__obj, MONO_HANDLE_RAW(src));
+ mono_gc_wbarrier_generic_store (&dest->__obj, src ? MONO_HANDLE_RAW(src) : NULL);
}
//FIXME this should go somewhere else
ICALL_TYPE(APPDOM, "System.AppDomain", APPDOM_23)
ICALL(APPDOM_23, "DoUnhandledException", ves_icall_System_AppDomain_DoUnhandledException)
ICALL(APPDOM_1, "ExecuteAssembly", ves_icall_System_AppDomain_ExecuteAssembly)
-ICALL(APPDOM_2, "GetAssemblies", ves_icall_System_AppDomain_GetAssemblies)
+HANDLES(ICALL(APPDOM_2, "GetAssemblies", ves_icall_System_AppDomain_GetAssemblies))
ICALL(APPDOM_3, "GetData", ves_icall_System_AppDomain_GetData)
ICALL(APPDOM_4, "InternalGetContext", ves_icall_System_AppDomain_InternalGetContext)
ICALL(APPDOM_5, "InternalGetDefaultContext", ves_icall_System_AppDomain_InternalGetDefaultContext)
ICALL(APPDOM_12, "InternalSetDomain", ves_icall_System_AppDomain_InternalSetDomain)
ICALL(APPDOM_13, "InternalSetDomainByID", ves_icall_System_AppDomain_InternalSetDomainByID)
ICALL(APPDOM_14, "InternalUnload", ves_icall_System_AppDomain_InternalUnload)
-ICALL(APPDOM_15, "LoadAssembly", ves_icall_System_AppDomain_LoadAssembly)
-ICALL(APPDOM_16, "LoadAssemblyRaw", ves_icall_System_AppDomain_LoadAssemblyRaw)
+HANDLES(ICALL(APPDOM_15, "LoadAssembly", ves_icall_System_AppDomain_LoadAssembly))
+HANDLES(ICALL(APPDOM_16, "LoadAssemblyRaw", ves_icall_System_AppDomain_LoadAssemblyRaw))
ICALL(APPDOM_17, "SetData", ves_icall_System_AppDomain_SetData)
ICALL(APPDOM_18, "createDomain", ves_icall_System_AppDomain_createDomain)
ICALL(APPDOM_19, "getCurDomain", ves_icall_System_AppDomain_getCurDomain)
ICALL_TYPE(ASSEM, "System.Reflection.Assembly", ASSEM_1a)
HANDLES(ICALL(ASSEM_1a, "GetAotId", ves_icall_System_Reflection_Assembly_GetAotId))
-ICALL(ASSEM_2, "GetCallingAssembly", ves_icall_System_Reflection_Assembly_GetCallingAssembly)
-ICALL(ASSEM_3, "GetEntryAssembly", ves_icall_System_Reflection_Assembly_GetEntryAssembly)
-ICALL(ASSEM_4, "GetExecutingAssembly", ves_icall_System_Reflection_Assembly_GetExecutingAssembly)
+HANDLES(ICALL(ASSEM_2, "GetCallingAssembly", ves_icall_System_Reflection_Assembly_GetCallingAssembly))
+HANDLES(ICALL(ASSEM_3, "GetEntryAssembly", ves_icall_System_Reflection_Assembly_GetEntryAssembly))
+HANDLES(ICALL(ASSEM_4, "GetExecutingAssembly", ves_icall_System_Reflection_Assembly_GetExecutingAssembly))
ICALL(ASSEM_5, "GetFilesInternal", ves_icall_System_Reflection_Assembly_GetFilesInternal)
HANDLES(ICALL(ASSEM_6, "GetManifestModuleInternal", ves_icall_System_Reflection_Assembly_GetManifestModuleInternal))
HANDLES(ICALL(ASSEM_7, "GetManifestResourceInfoInternal", ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal))
HANDLES(ICALL(ASSEM_12, "InternalGetReferencedAssemblies", ves_icall_System_Reflection_Assembly_InternalGetReferencedAssemblies))
ICALL(ASSEM_15, "InternalGetType", ves_icall_System_Reflection_Assembly_InternalGetType)
HANDLES(ICALL(ASSEM_16, "InternalImageRuntimeVersion", ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion))
-ICALL(ASSEM_17, "LoadFrom", ves_icall_System_Reflection_Assembly_LoadFrom)
+HANDLES(ICALL(ASSEM_17, "LoadFrom", ves_icall_System_Reflection_Assembly_LoadFrom))
ICALL(ASSEM_18, "LoadPermissions", ves_icall_System_Reflection_Assembly_LoadPermissions)
/* normal icalls again */
ICALL(ASSEM_23, "get_fullname", ves_icall_System_Reflection_Assembly_get_fullName)
ICALL(ASSEM_24, "get_global_assembly_cache", ves_icall_System_Reflection_Assembly_get_global_assembly_cache)
HANDLES(ICALL(ASSEM_25, "get_location", ves_icall_System_Reflection_Assembly_get_location))
-ICALL(ASSEM_26, "load_with_partial_name", ves_icall_System_Reflection_Assembly_load_with_partial_name)
+HANDLES(ICALL(ASSEM_26, "load_with_partial_name", ves_icall_System_Reflection_Assembly_load_with_partial_name))
ICALL_TYPE(ASSEMN, "System.Reflection.AssemblyName", ASSEMN_0)
ICALL(ASSEMN_0, "GetNativeName", ves_icall_System_Reflection_AssemblyName_GetNativeName)
ICALL_TYPE(RTH, "System.RuntimeTypeHandle", RTH_1)
ICALL(RTH_1, "GetArrayRank", ves_icall_RuntimeTypeHandle_GetArrayRank)
-ICALL(RTH_2, "GetAssembly", ves_icall_RuntimeTypeHandle_GetAssembly)
+HANDLES(ICALL(RTH_2, "GetAssembly", ves_icall_RuntimeTypeHandle_GetAssembly))
ICALL(RTH_3, "GetAttributes", ves_icall_RuntimeTypeHandle_GetAttributes)
ICALL(RTH_4, "GetBaseType", ves_icall_RuntimeTypeHandle_GetBaseType)
ICALL(RTH_5, "GetElementType", ves_icall_RuntimeTypeHandle_GetElementType)
#include <mono/metadata/socket-io.h>
#include <mono/metadata/mono-endian.h>
#include <mono/metadata/tokentype.h>
-#include <mono/metadata/domain-internals.h>
#include <mono/metadata/metadata-internals.h>
#include <mono/metadata/class-internals.h>
#include <mono/metadata/reflection-internals.h>
#include <mono/metadata/mono-gc.h>
#include <mono/metadata/rand.h>
#include <mono/metadata/sysmath.h>
+#include <mono/metadata/appdomain-icalls.h>
#include <mono/metadata/string-icalls.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/w32process.h>
extern MonoString* ves_icall_System_Environment_GetOSVersionString (void);
-ICALL_EXPORT MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void);
+ICALL_EXPORT MonoReflectionAssemblyHandle ves_icall_System_Reflection_Assembly_GetCallingAssembly (MonoError *error);
/* Lazy class loading functions */
static GENERATE_GET_CLASS_WITH_CACHE (system_version, System, Version)
return mono_module_get_object_handle (domain, klass->image, error);
}
-ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionType *type)
+ICALL_EXPORT MonoReflectionAssemblyHandle
+ves_icall_RuntimeTypeHandle_GetAssembly (MonoReflectionTypeHandle type, MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoDomain *domain = mono_domain_get ();
- MonoClass *klass = mono_class_from_mono_type (type->type);
- MonoReflectionAssembly *result = mono_assembly_get_object_checked (domain, klass->image->assembly, &error);
- mono_error_set_pending_exception (&error);
- return result;
+ MonoType *t = MONO_HANDLE_GETVAL (type, type);
+ MonoClass *klass = mono_class_from_mono_type (t);
+ return mono_assembly_get_object_handle (domain, klass->image->assembly, error);
}
ICALL_EXPORT MonoReflectionType*
return mass->in_gac;
}
-ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString *mname, MonoObject *evidence)
+ICALL_EXPORT MonoReflectionAssemblyHandle
+ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoStringHandle mname, MonoObjectHandle evidence, MonoError *error)
{
- MonoError error;
gchar *name;
- MonoAssembly *res;
MonoImageOpenStatus status;
- MonoReflectionAssembly* result = NULL;
+ MonoReflectionAssemblyHandle result = MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
- name = mono_string_to_utf8_checked (mname, &error);
- if (mono_error_set_pending_exception (&error))
- return NULL;
- res = mono_assembly_load_with_partial_name (name, &status);
+ name = mono_string_handle_to_utf8 (mname, error);
+ if (!is_ok (error))
+ goto leave;
+ MonoAssembly *res = mono_assembly_load_with_partial_name (name, &status);
g_free (name);
if (res == NULL)
- return NULL;
- result = mono_assembly_get_object_checked (mono_domain_get (), res, &error);
- if (!result)
- mono_error_set_pending_exception (&error);
+ goto leave;
+ result = mono_assembly_get_object_handle (mono_domain_get (), res, error);
+leave:
return result;
}
return result;
}
-ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void)
+ICALL_EXPORT MonoReflectionAssemblyHandle
+ves_icall_System_Reflection_Assembly_GetExecutingAssembly (MonoError *error)
{
- MonoError error;
- MonoReflectionAssembly *result;
- MonoMethod *dest = NULL;
+ mono_error_init (error);
+ MonoMethod *dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
g_assert (dest);
- result = mono_assembly_get_object_checked (mono_domain_get (), dest->klass->image->assembly, &error);
- if (!result)
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_assembly_get_object_handle (mono_domain_get (), dest->klass->image->assembly, error);
}
-ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_System_Reflection_Assembly_GetEntryAssembly (void)
+ICALL_EXPORT MonoReflectionAssemblyHandle
+ves_icall_System_Reflection_Assembly_GetEntryAssembly (MonoError *error)
{
- MonoError error;
- MonoReflectionAssembly *result;
+ mono_error_init (error);
+
MonoDomain* domain = mono_domain_get ();
if (!domain->entry_assembly)
- return NULL;
+ return MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
- result = mono_assembly_get_object_checked (domain, domain->entry_assembly, &error);
- if (!result)
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_assembly_get_object_handle (domain, domain->entry_assembly, error);
}
-ICALL_EXPORT MonoReflectionAssembly*
-ves_icall_System_Reflection_Assembly_GetCallingAssembly (void)
+ICALL_EXPORT MonoReflectionAssemblyHandle
+ves_icall_System_Reflection_Assembly_GetCallingAssembly (MonoError *error)
{
- MonoError error;
+ mono_error_init (error);
MonoMethod *m;
MonoMethod *dest;
- MonoReflectionAssembly *result;
dest = NULL;
mono_stack_walk_no_il (get_executing, &dest);
if (!dest)
dest = m;
if (!m) {
- mono_set_pending_exception (mono_get_exception_not_supported ("Stack walks are not supported on this platform."));
- return NULL;
+ mono_error_set_not_supported (error, "Stack walks are not supported on this platform.");
+ return MONO_HANDLE_CAST (MonoReflectionAssembly, NULL_HANDLE);
}
- result = mono_assembly_get_object_checked (mono_domain_get (), dest->klass->image->assembly, &error);
- if (!result)
- mono_error_set_pending_exception (&error);
- return result;
+ return mono_assembly_get_object_handle (mono_domain_get (), dest->klass->image->assembly, error);
}
ICALL_EXPORT MonoStringHandle
MonoDomain *data;
};
+/* Safely access System.AppDomain from native code */
+TYPED_HANDLE_DECL (MonoAppDomain);
+
typedef struct _MonoStringBuilder MonoStringBuilder;
struct _MonoStringBuilder {
MonoArray *pktoken; /* as hexadecimal byte[] */
} MonoReflectionAssemblyBuilder;
+/* Safely access System.Reflection.Emit.AssemblyBuilder from native code */
+TYPED_HANDLE_DECL (MonoReflectionAssemblyBuilder);
+
typedef struct {
MonoObject object;
guint32 attrs;
MonoArray *resources;
} MonoReflectionModuleBuilder;
+/* Safely acess System.Reflection.Emit.ModuleBuidler from native code */
+TYPED_HANDLE_DECL (MonoReflectionModuleBuilder);
+
typedef struct {
MonoReflectionType type;
MonoString *name;
void
ves_icall_ModuleBuilder_set_wrappers_type (MonoReflectionModuleBuilder *moduleb, MonoReflectionType *type);
+MonoAssembly*
+mono_try_assembly_resolve_handle (MonoDomain *domain, MonoStringHandle fname, MonoAssembly *requesting, gboolean refonly, MonoError *error);
+
#endif /* __MONO_OBJECT_INTERNALS_H__ */
MonoImage *
mono_find_dynamic_image_owner (void *ptr);
-MonoReflectionAssembly*
-mono_assembly_get_object_checked (MonoDomain *domain, MonoAssembly *assembly, MonoError *error);
-
MonoReflectionAssemblyHandle
mono_assembly_get_object_handle (MonoDomain *domain, MonoAssembly *assembly, MonoError *error);
return CHECK_OR_CONSTRUCT_HANDLE (MonoReflectionAssemblyHandle, assembly, NULL, assembly_object_construct, NULL);
}
-/*
- * mono_assembly_get_object_handle:
- * @domain: an app domain
- * @assembly: an assembly
- *
- * Return an System.Reflection.Assembly object representing the MonoAssembly @assembly.
- */
-MonoReflectionAssembly*
-mono_assembly_get_object_checked (MonoDomain *domain, MonoAssembly *assembly, MonoError *error)
-{
- HANDLE_FUNCTION_ENTER ();
- mono_error_init (error);
- MonoReflectionAssemblyHandle result = mono_assembly_get_object_handle (domain, assembly, error);
- HANDLE_FUNCTION_RETURN_OBJ (result);
-}
-
-
-
MonoReflectionModule*
mono_module_get_object (MonoDomain *domain, MonoImage *image)
{
}
+static MonoType*
+module_builder_array_get_type (MonoArrayHandle module_builders, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoType *type = NULL;
+ MonoReflectionModuleBuilderHandle mb = MONO_HANDLE_NEW (MonoReflectionModuleBuilder, NULL);
+ MONO_HANDLE_ARRAY_GETREF (mb, module_builders, i);
+ MonoDynamicImage *dynamic_image = MONO_HANDLE_GETVAL (mb, dynamic_image);
+ type = mono_reflection_get_type_internal (rootimage, &dynamic_image->image, info, ignorecase, error);
+ HANDLE_FUNCTION_RETURN_VAL (type);
+}
+
+static MonoType*
+module_array_get_type (MonoArrayHandle modules, int i, MonoImage *rootimage, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER ();
+ mono_error_init (error);
+ MonoType *type = NULL;
+ MonoReflectionModuleHandle mod = MONO_HANDLE_NEW (MonoReflectionModule, NULL);
+ MONO_HANDLE_ARRAY_GETREF (mod, modules, i);
+ MonoImage *image = MONO_HANDLE_GETVAL (mod, image);
+ type = mono_reflection_get_type_internal (rootimage, image, info, ignorecase, error);
+ HANDLE_FUNCTION_RETURN_VAL (type);
+}
+
static MonoType*
mono_reflection_get_type_internal_dynamic (MonoImage *rootimage, MonoAssembly *assembly, MonoTypeNameParse *info, gboolean ignorecase, MonoError *error)
{
- MonoReflectionAssemblyBuilder *abuilder;
- MonoType *type;
+ HANDLE_FUNCTION_ENTER ();
+ MonoType *type = NULL;
int i;
mono_error_init (error);
g_assert (assembly_is_dynamic (assembly));
- abuilder = (MonoReflectionAssemblyBuilder*)mono_assembly_get_object_checked (((MonoDynamicAssembly*)assembly)->domain, assembly, error);
- if (!abuilder)
- return NULL;
+ MonoReflectionAssemblyBuilderHandle abuilder = MONO_HANDLE_CAST (MonoReflectionAssemblyBuilder, mono_assembly_get_object_handle (((MonoDynamicAssembly*)assembly)->domain, assembly, error));
+ if (!is_ok (error))
+ goto leave;
/* Enumerate all modules */
- type = NULL;
- if (abuilder->modules) {
- for (i = 0; i < mono_array_length (abuilder->modules); ++i) {
- MonoReflectionModuleBuilder *mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder*, i);
- type = mono_reflection_get_type_internal (rootimage, &mb->dynamic_image->image, info, ignorecase, error);
+ MonoArrayHandle modules = MONO_HANDLE_NEW (MonoArray, NULL);
+ MONO_HANDLE_GET (modules, abuilder, modules);
+ if (!MONO_HANDLE_IS_NULL (modules)) {
+ int n = mono_array_handle_length (modules);
+ for (i = 0; i < n; ++i) {
+ type = module_builder_array_get_type (modules, i, rootimage, info, ignorecase, error);
if (type)
break;
- if (!mono_error_ok (error))
- return NULL;
+ if (!is_ok (error))
+ goto leave;
}
}
- if (!type && abuilder->loaded_modules) {
- for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) {
- MonoReflectionModule *mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule*, i);
- type = mono_reflection_get_type_internal (rootimage, mod->image, info, ignorecase, error);
+ MonoArrayHandle loaded_modules = MONO_HANDLE_NEW (MonoArray, NULL);
+ MONO_HANDLE_GET (loaded_modules, abuilder, loaded_modules);
+ if (!type && !MONO_HANDLE_IS_NULL(loaded_modules)) {
+ int n = mono_array_handle_length (loaded_modules);
+ for (i = 0; i < n; ++i) {
+ type = module_array_get_type (loaded_modules, i, rootimage, info, ignorecase, error);
if (type)
break;
- if (!mono_error_ok (error))
- return NULL;
+ if (!is_ok (error))
+ goto leave;
}
}
- return type;
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (type);
}
MonoType*
return ERR_NONE;
}
+static ErrorCode
+get_assembly_object_command (MonoDomain *domain, MonoAssembly *ass, Buffer *buf, MonoError *error)
+{
+ HANDLE_FUNCTION_ENTER();
+ ErrorCode err = ERR_NONE;
+ mono_error_init (error);
+ MonoReflectionAssemblyHandle o = mono_assembly_get_object_handle (domain, ass, error);
+ if (MONO_HANDLE_IS_NULL (o)) {
+ err = ERR_INVALID_OBJECT;
+ goto leave;
+ }
+ buffer_add_objid (buf, MONO_HANDLE_RAW (MONO_HANDLE_CAST (MonoObject, o)));
+leave:
+ HANDLE_FUNCTION_RETURN_VAL (err);
+}
+
+
static ErrorCode
assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
{
}
case CMD_ASSEMBLY_GET_OBJECT: {
MonoError error;
- MonoObject *o = (MonoObject*)mono_assembly_get_object_checked (domain, ass, &error);
- if (!o) {
- mono_error_cleanup (&error); /* FIXME don't swallow the error */
- return ERR_INVALID_OBJECT;
- }
- buffer_add_objid (buf, o);
- break;
+ err = get_assembly_object_command (domain, ass, buf, &error);
+ mono_error_cleanup (&error);
+ return err;
}
case CMD_ASSEMBLY_GET_TYPE: {
MonoError error;
MonoObject*
mono_get_assembly_object (MonoImage *image)
{
- MonoError error;
- MonoObject *result;
- result = (MonoObject*)mono_assembly_get_object_checked (mono_domain_get (), image->assembly, &error);
- if (!result)
- mono_error_set_pending_exception (&error);
- return result;
+ ICALL_ENTRY();
+ MonoObjectHandle result = MONO_HANDLE_CAST (MonoObject, mono_assembly_get_object_handle (mono_domain_get (), image->assembly, &error));
+ ICALL_RETURN_OBJ (result);
}
MonoObject*
</ItemGroup>\r
<ItemGroup>\r
<ClInclude Include="..\mono\metadata\appdomain.h" />\r
+ <ClInclude Include="..\mono\metadata\appdomain-icalls.h" />\r
<ClInclude Include="..\mono\metadata\assembly.h" />\r
<ClInclude Include="..\mono\metadata\attach.h" />\r
<ClInclude Include="..\mono\metadata\cil-coff.h" />\r
projects / mono.git / commitdiff