*
* Copyright 2001-2003 Ximian, Inc (http://www.ximian.com)
* Copyright 2004-2009 Novell, Inc (http://www.novell.com)
+ * Copyright 2011 Xamarin, Inc (http://www.xamarin.com)
*
* This file is used by the interpreter and the JIT engine to locate
* assemblies. Used to load AssemblyRef and later to resolve various
#include <mono/metadata/marshal.h>
#include <mono/metadata/lock-tracer.h>
#include <mono/metadata/verify-internals.h>
-#include <mono/utils/mono-logger.h>
+#include <mono/utils/mono-logger-internal.h>
#include <mono/utils/mono-dl.h>
#include <mono/utils/mono-membar.h>
#include <mono/utils/mono-counters.h>
+#include <mono/utils/mono-error-internals.h>
+#include <mono/utils/mono-tls.h>
MonoDefaults mono_defaults;
* domain lock.
*/
static CRITICAL_SECTION loader_mutex;
+static gboolean loader_lock_inited;
/* Statistics */
static guint32 inflated_signatures_size;
static guint32 memberref_sig_cache_size;
+static guint32 methods_size;
+static guint32 signatures_size;
/*
* This TLS variable contains the last type load error encountered by the loader.
*/
-guint32 loader_error_thread_id;
+MonoNativeTlsKey loader_error_thread_id;
/*
* This TLS variable holds how many times the current thread has acquired the loader
* lock.
*/
-guint32 loader_lock_nest_id;
+MonoNativeTlsKey loader_lock_nest_id;
+
+static void dllmap_cleanup (void);
void
mono_loader_init ()
if (!inited) {
InitializeCriticalSection (&loader_mutex);
+ loader_lock_inited = TRUE;
- loader_error_thread_id = TlsAlloc ();
- loader_lock_nest_id = TlsAlloc ();
+ mono_native_tls_alloc (&loader_error_thread_id, NULL);
+ mono_native_tls_alloc (&loader_lock_nest_id, NULL);
mono_counters_register ("Inflated signatures size",
MONO_COUNTER_GENERICS | MONO_COUNTER_INT, &inflated_signatures_size);
mono_counters_register ("Memberref signature cache size",
MONO_COUNTER_METADATA | MONO_COUNTER_INT, &memberref_sig_cache_size);
+ mono_counters_register ("MonoMethod size",
+ MONO_COUNTER_METADATA | MONO_COUNTER_INT, &methods_size);
+ mono_counters_register ("MonoMethodSignature size",
+ MONO_COUNTER_METADATA | MONO_COUNTER_INT, &signatures_size);
inited = TRUE;
}
void
mono_loader_cleanup (void)
{
- TlsFree (loader_error_thread_id);
- TlsFree (loader_lock_nest_id);
+ dllmap_cleanup ();
+
+ mono_native_tls_free (loader_error_thread_id);
+ mono_native_tls_free (loader_lock_nest_id);
- /*DeleteCriticalSection (&loader_mutex);*/
+ DeleteCriticalSection (&loader_mutex);
+ loader_lock_inited = FALSE;
}
/*
static void
set_loader_error (MonoLoaderError *error)
{
- TlsSetValue (loader_error_thread_id, error);
+ mono_loader_clear_error ();
+ mono_native_tls_set_value (loader_error_thread_id, error);
}
/**
* assert.
*/
if (ref_only)
- g_warning ("Cannot resolve dependency to assembly '%s' because it has not been preloaded. When using the ReflectionOnly APIs, dependent assemblies must be pre-loaded or loaded on demand through the ReflectionOnlyAssemblyResolve event.", assembly_name);
+ mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_ASSEMBLY, "Cannot resolve dependency to assembly '%s' because it has not been preloaded. When using the ReflectionOnly APIs, dependent assemblies must be pre-loaded or loaded on demand through the ReflectionOnlyAssemblyResolve event.", assembly_name);
else
- g_warning ("Could not load file or assembly '%s' or one of its dependencies.", assembly_name);
+ mono_trace (G_LOG_LEVEL_WARNING, MONO_TRACE_ASSEMBLY, "Could not load file or assembly '%s' or one of its dependencies.", assembly_name);
set_loader_error (error);
}
* can't deal with load errors, and this message is more helpful than an
* assert.
*/
- g_warning ("The class %s could not be loaded, used in %s", class_name, assembly_name);
+ mono_trace_warning (MONO_TRACE_TYPE, "The class %s could not be loaded, used in %s", class_name, assembly_name);
set_loader_error (error);
}
MonoLoaderError*
mono_loader_get_last_error (void)
{
- return (MonoLoaderError*)TlsGetValue (loader_error_thread_id);
+ return (MonoLoaderError*)mono_native_tls_get_value (loader_error_thread_id);
}
/**
void
mono_loader_clear_error (void)
{
- MonoLoaderError *ex = (MonoLoaderError*)TlsGetValue (loader_error_thread_id);
+ MonoLoaderError *ex = (MonoLoaderError*)mono_native_tls_get_value (loader_error_thread_id);
if (ex) {
g_free (ex->class_name);
g_free (ex->assembly_name);
g_free (ex->msg);
g_free (ex);
-
- TlsSetValue (loader_error_thread_id, NULL);
+
+ mono_native_tls_set_value (loader_error_thread_id, NULL);
}
}
}
case MONO_EXCEPTION_MISSING_FIELD: {
- char *cnspace = g_strdup ((error->klass && *error->klass->name_space) ? error->klass->name_space : "");
- char *cname = g_strdup (error->klass ? error->klass->name : "");
+ char *class_name;
char *cmembername = g_strdup (error->member_name);
- char *class_name;
+ if (error->klass)
+ class_name = mono_type_get_full_name (error->klass);
+ else
+ class_name = g_strdup ("");
mono_loader_clear_error ();
- class_name = g_strdup_printf ("%s%s%s", cnspace, cnspace ? "." : "", cname);
ex = mono_get_exception_missing_field (class_name, cmembername);
g_free (class_name);
- g_free (cname);
g_free (cmembername);
- g_free (cnspace);
break;
}
fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
- if (!mono_verifier_verify_memberref_signature (image, cols [MONO_MEMBERREF_SIGNATURE], NULL)) {
+ if (!mono_verifier_verify_memberref_field_signature (image, cols [MONO_MEMBERREF_SIGNATURE], NULL)) {
mono_loader_set_error_bad_image (g_strdup_printf ("Bad field signature class token 0x%08x field name %s token 0x%08x on image %s", class, fname, token, image->name));
return NULL;
}
return result;
}
- mono_loader_lock ();
+ mono_image_lock (image);
if ((field = g_hash_table_lookup (image->field_cache, GUINT_TO_POINTER (token)))) {
*retklass = field->parent;
- mono_loader_unlock ();
+ mono_image_unlock (image);
return field;
}
- mono_loader_unlock ();
+ mono_image_unlock (image);
if (mono_metadata_token_table (token) == MONO_TABLE_MEMBERREF)
field = field_from_memberref (image, token, retklass, context);
field = mono_class_get_field (k, token);
}
- mono_loader_lock ();
+ mono_image_lock (image);
if (field && field->parent && !field->parent->generic_class && !field->parent->generic_container)
g_hash_table_insert (image->field_cache, GUINT_TO_POINTER (token), field);
- mono_loader_unlock ();
+ mono_image_unlock (image);
return field;
}
continue;
method = mono_get_method (klass->image, MONO_TOKEN_METHOD_DEF | (klass->method.first + i + 1), klass);
- other_sig = mono_method_signature (method);
- if (method && other_sig && (sig->call_convention != MONO_CALL_VARARG) && mono_metadata_signature_equal (sig, other_sig))
- return method;
+ if (method) {
+ other_sig = mono_method_signature (method);
+ if (other_sig && (sig->call_convention != MONO_CALL_VARARG) && mono_metadata_signature_equal (sig, other_sig))
+ return method;
+ }
}
}
mono_class_setup_methods (klass);
+ /*
+ We can't fail lookup of methods otherwise the runtime will fail with MissingMethodException instead of TypeLoadException.
+ See mono/tests/generic-type-load-exception.2.il
+ FIXME we should better report this error to the caller
+ */
+ if (!klass->methods)
+ return NULL;
for (i = 0; i < klass->method.count; ++i) {
MonoMethod *m = klass->methods [i];
MonoMethodSignature *msig;
+ /* We must cope with failing to load some of the types. */
+ if (!m)
+ continue;
+
if (!((fqname && !strcmp (m->name, fqname)) ||
(qname && !strcmp (m->name, qname)) ||
(name && !strcmp (m->name, name))))
if (name [0] == '.' && (!strcmp (name, ".ctor") || !strcmp (name, ".cctor")))
break;
- g_assert (from_class->interface_offsets_count == in_class->interface_offsets_count);
+ /*
+ * This happens when we fail to lazily load the interfaces of one of the types.
+ * On such case we can't just bail out since user code depends on us trying harder.
+ */
+ if (from_class->interface_offsets_count != in_class->interface_offsets_count) {
+ in_class = in_class->parent;
+ from_class = from_class->parent;
+ continue;
+ }
+
for (i = 0; i < in_class->interface_offsets_count; i++) {
MonoClass *in_ic = in_class->interfaces_packed [i];
MonoClass *from_ic = from_class->interfaces_packed [i];
}
static MonoMethodSignature*
-inflate_generic_signature (MonoImage *image, MonoMethodSignature *sig, MonoGenericContext *context)
+inflate_generic_signature_checked (MonoImage *image, MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error)
{
MonoMethodSignature *res;
gboolean is_open;
int i;
+ mono_error_init (error);
if (!context)
return sig;
res = g_malloc0 (MONO_SIZEOF_METHOD_SIGNATURE + ((gint32)sig->param_count) * sizeof (MonoType*));
res->param_count = sig->param_count;
res->sentinelpos = -1;
- res->ret = mono_class_inflate_generic_type (sig->ret, context);
+ res->ret = mono_class_inflate_generic_type_checked (sig->ret, context, error);
+ if (!mono_error_ok (error))
+ goto fail;
is_open = mono_class_is_open_constructed_type (res->ret);
for (i = 0; i < sig->param_count; ++i) {
- res->params [i] = mono_class_inflate_generic_type (sig->params [i], context);
+ res->params [i] = mono_class_inflate_generic_type_checked (sig->params [i], context, error);
+ if (!mono_error_ok (error))
+ goto fail;
+
if (!is_open)
is_open = mono_class_is_open_constructed_type (res->params [i]);
}
res->has_type_parameters = is_open;
res->is_inflated = 1;
return res;
+
+fail:
+ if (res->ret)
+ mono_metadata_free_type (res->ret);
+ for (i = 0; i < sig->param_count; ++i) {
+ if (res->params [i])
+ mono_metadata_free_type (res->params [i]);
+ }
+ g_free (res);
+ return NULL;
+}
+
+/*
+ * mono_inflate_generic_signature:
+ *
+ * Inflate SIG with CONTEXT, and return a canonical copy. On error, set ERROR, and return NULL.
+ */
+MonoMethodSignature*
+mono_inflate_generic_signature (MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error)
+{
+ MonoMethodSignature *res, *cached;
+
+ res = inflate_generic_signature_checked (NULL, sig, context, error);
+ if (!mono_error_ok (error))
+ return NULL;
+ cached = mono_metadata_get_inflated_signature (res, context);
+ if (cached != res)
+ mono_metadata_free_inflated_signature (res);
+ return cached;
}
static MonoMethodHeader*
return mono_method_signature (method);
if (table == MONO_TABLE_METHODSPEC) {
- g_assert (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) &&
- mono_method_signature (method));
- g_assert (method->is_inflated);
+ /* the verifier (do_invoke_method) will turn the NULL into a verifier error */
+ if ((method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) || !method->is_inflated)
+ return NULL;
return mono_method_signature (method);
}
if (method->klass->generic_class)
return mono_method_signature (method);
- if (image->dynamic)
- /* FIXME: This might be incorrect for vararg methods */
- return mono_method_signature (method);
+#ifndef DISABLE_REFLECTION_EMIT
+ if (image->dynamic) {
+ sig = mono_reflection_lookup_signature (image, method, token);
+ } else {
+#endif
+ mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
+ sig_idx = cols [MONO_MEMBERREF_SIGNATURE];
- mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
- sig_idx = cols [MONO_MEMBERREF_SIGNATURE];
+ sig = find_cached_memberref_sig (image, sig_idx);
+ if (!sig) {
+ if (!mono_verifier_verify_memberref_method_signature (image, sig_idx, NULL)) {
+ guint32 class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
+ const char *fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
- sig = find_cached_memberref_sig (image, sig_idx);
- if (!sig) {
- if (!mono_verifier_verify_memberref_signature (image, sig_idx, NULL)) {
+ mono_loader_set_error_bad_image (g_strdup_printf ("Bad method signature class token 0x%08x field name %s token 0x%08x on image %s", class, fname, token, image->name));
+ return NULL;
+ }
+
+ ptr = mono_metadata_blob_heap (image, sig_idx);
+ mono_metadata_decode_blob_size (ptr, &ptr);
+ sig = mono_metadata_parse_method_signature (image, 0, ptr, NULL);
+ if (!sig)
+ return NULL;
+ sig = cache_memberref_sig (image, sig_idx, sig);
+ }
+ /* FIXME: we probably should verify signature compat in the dynamic case too*/
+ if (!mono_verifier_is_sig_compatible (image, method, sig)) {
guint32 class = cols [MONO_MEMBERREF_CLASS] & MONO_MEMBERREF_PARENT_MASK;
const char *fname = mono_metadata_string_heap (image, cols [MONO_MEMBERREF_NAME]);
- mono_loader_set_error_bad_image (g_strdup_printf ("Bad method signature class token 0x%08x field name %s token 0x%08x on image %s", class, fname, token, image->name));
+ mono_loader_set_error_bad_image (g_strdup_printf ("Incompatible method signature class token 0x%08x field name %s token 0x%08x on image %s", class, fname, token, image->name));
return NULL;
}
-
- ptr = mono_metadata_blob_heap (image, sig_idx);
- mono_metadata_decode_blob_size (ptr, &ptr);
- sig = mono_metadata_parse_method_signature (image, 0, ptr, NULL);
- if (!sig)
- return NULL;
- sig = cache_memberref_sig (image, sig_idx, sig);
+#ifndef DISABLE_REFLECTION_EMIT
}
+#endif
+
if (context) {
+ MonoError error;
MonoMethodSignature *cached;
/* This signature is not owned by a MonoMethod, so need to cache */
- sig = inflate_generic_signature (image, sig, context);
+ sig = inflate_generic_signature_checked (image, sig, context, &error);
+ if (!mono_error_ok (&error)) {/*XXX bubble up this and kill one use of loader errors */
+ mono_loader_set_error_bad_image (g_strdup_printf ("Could not inflate signature %s", mono_error_get_message (&error)));
+ mono_error_cleanup (&error);
+ return NULL;
+ }
+
cached = mono_metadata_get_inflated_signature (sig, context);
if (cached != sig)
mono_metadata_free_inflated_signature (sig);
int i;
mono_class_setup_methods (klass);
-
+ g_assert (!klass->exception_type); /*FIXME this should not fail, right?*/
for (i = 0; i < klass->method.count; ++i) {
MonoMethod *method = klass->methods [i];
if (strcmp (method->name, name) == 0 && sig->param_count == method->signature->param_count)
sig_idx = cols [MONO_MEMBERREF_SIGNATURE];
- if (!mono_verifier_verify_memberref_signature (image, sig_idx, NULL)) {
+ if (!mono_verifier_verify_memberref_method_signature (image, sig_idx, NULL)) {
mono_loader_set_error_method_load (klass->name, mname);
return NULL;
}
g_assert (param_count);
inst = mono_metadata_parse_generic_inst (image, NULL, param_count, ptr, &ptr);
+ if (!inst)
+ return NULL;
+
if (context && inst->is_open) {
inst = mono_metadata_inflate_generic_inst (inst, context, &error);
if (!mono_error_ok (&error)) {
return mono_dllmap_lookup_list (global_dll_map, dll, func, rdll, rfunc);
}
-/*
+/**
* mono_dllmap_insert:
+ * @assembly: if NULL, this is a global mapping, otherwise the remapping of the dynamic library will only apply to the specified assembly
+ * @dll: The name of the external library, as it would be found in the DllImport declaration. If prefixed with 'i:' the matching of the library name is done without case sensitivity
+ * @func: if not null, the mapping will only applied to the named function (the value of EntryPoint)
+ * @tdll: The name of the library to map the specified @dll if it matches.
+ * @tfunc: if func is not NULL, the name of the function that replaces the invocation
*
* LOCKING: Acquires the loader lock.
*
+ * This function is used to programatically add DllImport remapping in either
+ * a specific assembly, or as a global remapping. This is done by remapping
+ * references in a DllImport attribute from the @dll library name into the @tdll
+ * name. If the @dll name contains the prefix "i:", the comparison of the
+ * library name is done without case sensitivity.
+ *
+ * If you pass @func, this is the name of the EntryPoint in a DllImport if specified
+ * or the name of the function as determined by DllImport. If you pass @func, you
+ * must also pass @tfunc which is the name of the target function to invoke on a match.
+ *
+ * Example:
+ * mono_dllmap_insert (NULL, "i:libdemo.dll", NULL, relocated_demo_path, NULL);
+ *
+ * The above will remap DllImport statments for "libdemo.dll" and "LIBDEMO.DLL" to
+ * the contents of relocated_demo_path for all assemblies in the Mono process.
+ *
* NOTE: This can be called before the runtime is initialized, for example from
* mono_config_parse ().
*/
mono_loader_unlock ();
}
+static void
+free_dllmap (MonoDllMap *map)
+{
+ while (map) {
+ MonoDllMap *next = map->next;
+
+ g_free (map->dll);
+ g_free (map->target);
+ g_free (map->func);
+ g_free (map->target_func);
+ g_free (map);
+ map = next;
+ }
+}
+
+static void
+dllmap_cleanup (void)
+{
+ free_dllmap (global_dll_map);
+ global_dll_map = NULL;
+}
+
static GHashTable *global_module_map;
static MonoDl*
cached_module_load (const char *name, int flags, char **err)
{
MonoDl *res;
+
+ if (err)
+ *err = NULL;
mono_loader_lock ();
if (!global_module_map)
global_module_map = g_hash_table_new (g_str_hash, g_str_equal);
res = g_hash_table_lookup (global_module_map, name);
if (res) {
- *err = NULL;
mono_loader_unlock ();
return res;
}
return res;
}
+static MonoDl *internal_module;
+
+static gboolean
+is_absolute_path (const char *path)
+{
+#ifdef PLATFORM_MACOSX
+ if (!strncmp (path, "@executable_path/", 17) || !strncmp (path, "@loader_path/", 13) ||
+ !strncmp (path, "@rpath/", 7))
+ return TRUE;
+#endif
+ return g_path_is_absolute (path);
+}
+
gpointer
mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char **exc_arg)
{
const char *orig_scope;
const char *new_scope;
char *error_msg;
- char *full_name, *file_name;
+ char *full_name, *file_name, *found_name = NULL;
int i;
MonoDl *module = NULL;
+ gboolean cached = FALSE;
g_assert (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL);
+ if (exc_class) {
+ *exc_class = NULL;
+ *exc_arg = NULL;
+ }
+
if (piinfo->addr)
return piinfo->addr;
orig_scope = method_aux->dll;
}
else {
- if (!piinfo->implmap_idx)
+ if (!piinfo->implmap_idx || piinfo->implmap_idx > im->rows)
return NULL;
mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE);
+ if (!im_cols [MONO_IMPLMAP_SCOPE] || im_cols [MONO_IMPLMAP_SCOPE] > mr->rows)
+ return NULL;
+
piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS];
import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]);
scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME);
mono_dllmap_lookup (image, orig_scope, import, &new_scope, &import);
- mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport attempting to load: '%s'.", new_scope);
-
- if (exc_class) {
- *exc_class = NULL;
- *exc_arg = NULL;
+ if (!module) {
+ mono_loader_lock ();
+ if (!image->pinvoke_scopes) {
+ image->pinvoke_scopes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+ image->pinvoke_scope_filenames = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+ }
+ module = g_hash_table_lookup (image->pinvoke_scopes, new_scope);
+ found_name = g_hash_table_lookup (image->pinvoke_scope_filenames, new_scope);
+ mono_loader_unlock ();
+ if (module)
+ cached = TRUE;
+ if (found_name)
+ found_name = g_strdup (found_name);
}
- /* we allow a special name to dlopen from the running process namespace */
- if (strcmp (new_scope, "__Internal") == 0)
- module = mono_dl_open (NULL, MONO_DL_LAZY, &error_msg);
+ if (!module) {
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
+ "DllImport attempting to load: '%s'.", new_scope);
+
+ /* we allow a special name to dlopen from the running process namespace */
+ if (strcmp (new_scope, "__Internal") == 0){
+ if (internal_module == NULL)
+ internal_module = mono_dl_open (NULL, MONO_DL_LAZY, &error_msg);
+ module = internal_module;
+ }
+ }
/*
* Try loading the module using a variety of names
*/
for (i = 0; i < 4; ++i) {
+ char *base_name = NULL, *dir_name = NULL;
+ gboolean is_absolute = is_absolute_path (new_scope);
+
switch (i) {
case 0:
/* Try the original name */
continue;
break;
case 2:
- if (strstr (new_scope, "lib") != new_scope) {
+ if (is_absolute) {
+ dir_name = g_path_get_dirname (new_scope);
+ base_name = g_path_get_basename (new_scope);
+ if (strstr (base_name, "lib") != base_name) {
+ char *tmp = g_strdup_printf ("lib%s", base_name);
+ g_free (base_name);
+ base_name = tmp;
+ file_name = g_strdup_printf ("%s%s%s", dir_name, G_DIR_SEPARATOR_S, base_name);
+ break;
+ }
+ } else if (strstr (new_scope, "lib") != new_scope) {
file_name = g_strdup_printf ("lib%s", new_scope);
+ break;
}
- else
- continue;
- break;
+ continue;
default:
#ifndef TARGET_WIN32
if (!g_ascii_strcasecmp ("user32.dll", new_scope) ||
break;
#endif
}
+
+ if (is_absolute) {
+ if (!dir_name)
+ dir_name = g_path_get_dirname (file_name);
+ if (!base_name)
+ base_name = g_path_get_basename (file_name);
+ }
+
+ if (!module && is_absolute) {
+ module = cached_module_load (file_name, MONO_DL_LAZY, &error_msg);
+ if (!module) {
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
+ "DllImport error loading library '%s': '%s'.",
+ file_name, error_msg);
+ g_free (error_msg);
+ } else {
+ found_name = g_strdup (file_name);
+ }
+ }
- if (!module) {
+ if (!module && !is_absolute) {
void *iter = NULL;
- while ((full_name = mono_dl_build_path (NULL, file_name, &iter))) {
- mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport loading location: '%s'.", full_name);
+ char *mdirname = g_path_get_dirname (image->name);
+ while ((full_name = mono_dl_build_path (mdirname, file_name, &iter))) {
module = cached_module_load (full_name, MONO_DL_LAZY, &error_msg);
if (!module) {
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport error loading library: '%s'.",
- error_msg);
+ "DllImport error loading library '%s': '%s'.",
+ full_name, error_msg);
g_free (error_msg);
+ } else {
+ found_name = g_strdup (full_name);
}
g_free (full_name);
if (module)
break;
}
+ g_free (mdirname);
}
if (!module) {
void *iter = NULL;
- while ((full_name = mono_dl_build_path (".", file_name, &iter))) {
- mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport loading library: '%s'.", full_name);
+ char *file_or_base = is_absolute ? base_name : file_name;
+ while ((full_name = mono_dl_build_path (dir_name, file_or_base, &iter))) {
module = cached_module_load (full_name, MONO_DL_LAZY, &error_msg);
if (!module) {
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport error loading library '%s'.",
- error_msg);
+ "DllImport error loading library '%s': '%s'.",
+ full_name, error_msg);
g_free (error_msg);
+ } else {
+ found_name = g_strdup (full_name);
}
g_free (full_name);
if (module)
}
if (!module) {
- mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport loading: '%s'.", file_name);
module = cached_module_load (file_name, MONO_DL_LAZY, &error_msg);
if (!module) {
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
- "DllImport error loading library '%s'.",
- error_msg);
+ "DllImport error loading library '%s': '%s'.",
+ file_name, error_msg);
+ } else {
+ found_name = g_strdup (file_name);
}
}
g_free (file_name);
+ if (is_absolute) {
+ g_free (base_name);
+ g_free (dir_name);
+ }
if (module)
break;
return NULL;
}
+ if (!cached) {
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
+ "DllImport loaded library '%s'.", found_name);
+ mono_loader_lock ();
+ if (!g_hash_table_lookup (image->pinvoke_scopes, new_scope)) {
+ g_hash_table_insert (image->pinvoke_scopes, g_strdup (new_scope), module);
+ g_hash_table_insert (image->pinvoke_scope_filenames, g_strdup (new_scope), g_strdup (found_name));
+ }
+ mono_loader_unlock ();
+ }
+
+ mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
+ "DllImport searching in: '%s' ('%s').", new_scope, found_name);
+ g_free (found_name);
+
+#ifdef TARGET_WIN32
+ if (import && import [0] == '#' && isdigit (import [1])) {
+ char *end;
+ long id;
+
+ id = strtol (import + 1, &end, 10);
+ if (id > 0 && *end == '\0')
+ import++;
+ }
+#endif
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
"Searching for '%s'.", import);
"Probing '%s'.", mangled_name2);
error_msg = mono_dl_symbol (module, mangled_name2, &piinfo->addr);
+ g_free (error_msg);
+ error_msg = NULL;
if (piinfo->addr)
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
mono_metadata_decode_row (&image->tables [MONO_TABLE_METHOD], idx - 1, cols, 6);
if ((cols [2] & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
- (cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL))
+ (cols [1] & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)) {
result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodPInvoke));
- else
- result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodNormal));
+ } else {
+ result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethod));
+ methods_size += sizeof (MonoMethod);
+ }
mono_stats.method_count ++;
mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass,
MonoGenericContext *context)
{
- MonoMethod *result;
+ MonoMethod *result = NULL;
gboolean used_context = FALSE;
/* We do everything inside the lock to prevent creation races */
if (!image->method_cache)
image->method_cache = g_hash_table_new (NULL, NULL);
result = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
- } else {
+ } else if (!image->dynamic) {
if (!image->methodref_cache)
image->methodref_cache = g_hash_table_new (NULL, NULL);
result = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
if (result)
return result;
+
result = mono_get_method_from_token (image, token, klass, context, &used_context);
if (!result)
return NULL;
mono_image_lock (image);
if (!used_context && !result->is_inflated) {
- MonoMethod *result2;
+ MonoMethod *result2 = NULL;
+
if (mono_metadata_token_table (token) == MONO_TABLE_METHOD)
result2 = g_hash_table_lookup (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)));
- else
+ else if (!image->dynamic)
result2 = g_hash_table_lookup (image->methodref_cache, GINT_TO_POINTER (token));
if (result2) {
if (mono_metadata_token_table (token) == MONO_TABLE_METHOD)
g_hash_table_insert (image->method_cache, GINT_TO_POINTER (mono_metadata_token_index (token)), result);
- else
+ else if (!image->dynamic)
g_hash_table_insert (image->methodref_cache, GINT_TO_POINTER (token), result);
}
return result;
}
-/**
- * mono_get_method_constrained:
- *
- * This is used when JITing the `constrained.' opcode.
- *
- * This returns two values: the contrained method, which has been inflated
- * as the function return value; And the original CIL-stream method as
- * declared in cil_method. The later is used for verification.
- */
-MonoMethod *
-mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constrained_class,
- MonoGenericContext *context, MonoMethod **cil_method)
+static MonoMethod *
+get_method_constrained (MonoImage *image, MonoMethod *method, MonoClass *constrained_class, MonoGenericContext *context)
{
- MonoMethod *method, *result;
+ MonoMethod *result;
MonoClass *ic = NULL;
MonoGenericContext *method_context = NULL;
MonoMethodSignature *sig, *original_sig;
- mono_loader_lock ();
-
- *cil_method = mono_get_method_from_token (image, token, NULL, context, NULL);
- if (!*cil_method) {
- mono_loader_unlock ();
- return NULL;
- }
-
mono_class_init (constrained_class);
- method = *cil_method;
original_sig = sig = mono_method_signature (method);
- if (sig == NULL)
+ if (sig == NULL) {
return NULL;
+ }
if (method->is_inflated && sig->generic_param_count) {
MonoMethodInflated *imethod = (MonoMethodInflated *) method;
* any type argument which a concrete type. See #325283.
*/
if (method_context->class_inst) {
+ MonoError error;
MonoGenericContext ctx;
ctx.method_inst = NULL;
ctx.class_inst = method_context->class_inst;
-
- sig = inflate_generic_signature (method->klass->image, sig, &ctx);
- if (sig == NULL)
+ /*Fixme, property propagate this error*/
+ sig = inflate_generic_signature_checked (method->klass->image, sig, &ctx, &error);
+ if (!mono_error_ok (&error)) {
+ mono_error_cleanup (&error);
return NULL;
+ }
}
}
mono_metadata_free_inflated_signature (sig);
if (!result) {
- g_warning ("Missing method %s.%s.%s in assembly %s token %x", method->klass->name_space,
- method->klass->name, method->name, image->name, token);
- mono_loader_unlock ();
+ char *m = mono_method_full_name (method, 1);
+ g_warning ("Missing method %s.%s.%s in assembly %s method %s", method->klass->name_space,
+ method->klass->name, method->name, image->name, m);
+ g_free (m);
return NULL;
}
if (method_context)
result = mono_class_inflate_generic_method (result, method_context);
+ return result;
+}
+
+MonoMethod *
+mono_get_method_constrained_with_method (MonoImage *image, MonoMethod *method, MonoClass *constrained_class,
+ MonoGenericContext *context)
+{
+ MonoMethod *result;
+
+ g_assert (method);
+
+ mono_loader_lock ();
+
+ result = get_method_constrained (image, method, constrained_class, context);
+
+ mono_loader_unlock ();
+ return result;
+}
+/**
+ * mono_get_method_constrained:
+ *
+ * This is used when JITing the `constrained.' opcode.
+ *
+ * This returns two values: the contrained method, which has been inflated
+ * as the function return value; And the original CIL-stream method as
+ * declared in cil_method. The later is used for verification.
+ */
+MonoMethod *
+mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constrained_class,
+ MonoGenericContext *context, MonoMethod **cil_method)
+{
+ MonoMethod *result;
+
+ mono_loader_lock ();
+
+ *cil_method = mono_get_method_from_token (image, token, NULL, context, NULL);
+ if (!*cil_method) {
+ mono_loader_unlock ();
+ return NULL;
+ }
+
+ result = get_method_constrained (image, *cil_method, constrained_class, context);
+
mono_loader_unlock ();
return result;
}
mono_image_property_remove (method->klass->image, method);
g_free ((char*)method->name);
- if (mw->method.header) {
- g_free ((char*)mw->method.header->code);
- for (i = 0; i < mw->method.header->num_locals; ++i)
- g_free (mw->method.header->locals [i]);
- g_free (mw->method.header->clauses);
- g_free (mw->method.header);
+ if (mw->header) {
+ g_free ((char*)mw->header->code);
+ for (i = 0; i < mw->header->num_locals; ++i)
+ g_free (mw->header->locals [i]);
+ g_free (mw->header->clauses);
+ g_free (mw->header);
}
g_free (mw->method_data);
g_free (method->signature);
return;
}
+ if (method->wrapper_type) {
+ char **pnames = NULL;
+
+ mono_image_lock (klass->image);
+ if (klass->image->wrapper_param_names)
+ pnames = g_hash_table_lookup (klass->image->wrapper_param_names, method);
+ mono_image_unlock (klass->image);
+
+ if (pnames) {
+ for (i = 0; i < signature->param_count; ++i)
+ names [i] = pnames [i];
+ }
+ return;
+ }
+
methodt = &klass->image->tables [MONO_TABLE_METHOD];
paramt = &klass->image->tables [MONO_TABLE_PARAM];
idx = mono_method_get_index (method);
if (dyn_specs [i]) {
mspecs [i] = g_new0 (MonoMarshalSpec, 1);
memcpy (mspecs [i], dyn_specs [i], sizeof (MonoMarshalSpec));
+ mspecs [i]->data.custom_data.custom_name = g_strdup (dyn_specs [i]->data.custom_data.custom_name);
+ mspecs [i]->data.custom_data.cookie = g_strdup (dyn_specs [i]->data.custom_data.cookie);
}
}
return;
return data [id];
}
-static void
-default_stack_walk (MonoStackWalk func, gboolean do_il_offset, gpointer user_data) {
- g_error ("stack walk not installed");
-}
-
-static MonoStackWalkImpl stack_walk = default_stack_walk;
+typedef struct {
+ MonoStackWalk func;
+ gpointer user_data;
+} StackWalkUserData;
-void
-mono_stack_walk (MonoStackWalk func, gpointer user_data)
+static gboolean
+stack_walk_adapter (MonoStackFrameInfo *frame, MonoContext *ctx, gpointer data)
{
- stack_walk (func, TRUE, user_data);
+ StackWalkUserData *d = data;
+
+ switch (frame->type) {
+ case FRAME_TYPE_DEBUGGER_INVOKE:
+ case FRAME_TYPE_MANAGED_TO_NATIVE:
+ return FALSE;
+ case FRAME_TYPE_MANAGED:
+ g_assert (frame->ji);
+ return d->func (mono_jit_info_get_method (frame->ji), frame->native_offset, frame->il_offset, frame->managed, d->user_data);
+ break;
+ default:
+ g_assert_not_reached ();
+ return FALSE;
+ }
}
void
-mono_stack_walk_no_il (MonoStackWalk func, gpointer user_data)
+mono_stack_walk (MonoStackWalk func, gpointer user_data)
{
- stack_walk (func, FALSE, user_data);
+ StackWalkUserData ud = { func, user_data };
+ mono_get_eh_callbacks ()->mono_walk_stack_with_ctx (stack_walk_adapter, NULL, MONO_UNWIND_LOOKUP_ALL, &ud);
}
void
-mono_install_stack_walk (MonoStackWalkImpl func)
+mono_stack_walk_no_il (MonoStackWalk func, gpointer user_data)
{
- stack_walk = func;
+ StackWalkUserData ud = { func, user_data };
+ mono_get_eh_callbacks ()->mono_walk_stack_with_ctx (stack_walk_adapter, NULL, MONO_UNWIND_DEFAULT, &ud);
}
static gboolean
mono_method_get_last_managed (void)
{
MonoMethod *m = NULL;
- stack_walk (last_managed, FALSE, &m);
+ mono_stack_walk_no_il (last_managed, &m);
return m;
}
{
mono_locks_acquire (&loader_mutex, LoaderLock);
if (G_UNLIKELY (loader_lock_track_ownership)) {
- TlsSetValue (loader_lock_nest_id, GUINT_TO_POINTER (GPOINTER_TO_UINT (TlsGetValue (loader_lock_nest_id)) + 1));
+ mono_native_tls_set_value (loader_lock_nest_id, GUINT_TO_POINTER (GPOINTER_TO_UINT (mono_native_tls_get_value (loader_lock_nest_id)) + 1));
}
}
{
mono_locks_release (&loader_mutex, LoaderLock);
if (G_UNLIKELY (loader_lock_track_ownership)) {
- TlsSetValue (loader_lock_nest_id, GUINT_TO_POINTER (GPOINTER_TO_UINT (TlsGetValue (loader_lock_nest_id)) - 1));
+ mono_native_tls_set_value (loader_lock_nest_id, GUINT_TO_POINTER (GPOINTER_TO_UINT (mono_native_tls_get_value (loader_lock_nest_id)) - 1));
}
}
{
g_assert (loader_lock_track_ownership);
- return GPOINTER_TO_UINT (TlsGetValue (loader_lock_nest_id)) > 0;
+ return GPOINTER_TO_UINT (mono_native_tls_get_value (loader_lock_nest_id)) > 0;
+}
+
+/*
+ * mono_loader_lock_if_inited:
+ *
+ * Acquire the loader lock if it has been initialized, no-op otherwise. This can
+ * be used in runtime initialization code which can be executed before mono_loader_init ().
+ */
+void
+mono_loader_lock_if_inited (void)
+{
+ if (loader_lock_inited)
+ mono_loader_lock ();
+}
+
+void
+mono_loader_unlock_if_inited (void)
+{
+ if (loader_lock_inited)
+ mono_loader_unlock ();
}
/**
* mono_method_signature:
*
- * Return the signature of the method M. On failure, returns NULL.
+ * Return the signature of the method M. On failure, returns NULL, and ERR is set.
*/
MonoMethodSignature*
-mono_method_signature (MonoMethod *m)
+mono_method_signature_checked (MonoMethod *m, MonoError *error)
{
int idx;
int size;
/* We need memory barriers below because of the double-checked locking pattern */
+ mono_error_init (error);
+
if (m->signature)
return m->signature;
MonoMethodInflated *imethod = (MonoMethodInflated *) m;
/* the lock is recursive */
signature = mono_method_signature (imethod->declaring);
- signature = inflate_generic_signature (imethod->declaring->klass->image, signature, mono_method_get_context (m));
+ signature = inflate_generic_signature_checked (imethod->declaring->klass->image, signature, mono_method_get_context (m), error);
+ if (!mono_error_ok (error)) {
+ mono_loader_unlock ();
+ return NULL;
+ }
inflated_signatures_size += mono_metadata_signature_size (signature);
if (!signature) {
const char *sig_body;
/*TODO we should cache the failure result somewhere*/
- if (!mono_verifier_verify_method_signature (img, sig_offset, NULL)) {
+ if (!mono_verifier_verify_method_signature (img, sig_offset, error)) {
mono_loader_unlock ();
return NULL;
}
signature = mono_metadata_parse_method_signature_full (img, container, idx, sig_body, NULL);
if (!signature) {
+ mono_error_set_from_loader_error (error);
mono_loader_unlock ();
return NULL;
}
if (can_cache_signature)
g_hash_table_insert (img->method_signatures, (gpointer)sig, signature);
+
+ signatures_size += mono_metadata_signature_size (signature);
}
/* Verify metadata consistency */
if (signature->generic_param_count) {
if (!container || !container->is_method) {
- g_warning ("Signature claims method has generic parameters, but generic_params table says it doesn't for method 0x%08x from image %s", idx, img->name);
mono_loader_unlock ();
+ mono_error_set_method_load (error, m->klass, m->name, "Signature claims method has generic parameters, but generic_params table says it doesn't for method 0x%08x from image %s", idx, img->name);
return NULL;
}
if (container->type_argc != signature->generic_param_count) {
- g_warning ("Inconsistent generic parameter count. Signature says %d, generic_params table says %d for method 0x%08x from image %s",
- signature->generic_param_count, container->type_argc, idx, img->name);
mono_loader_unlock ();
+ mono_error_set_method_load (error, m->klass, m->name, "Inconsistent generic parameter count. Signature says %d, generic_params table says %d for method 0x%08x from image %s", signature->generic_param_count, container->type_argc, idx, img->name);
return NULL;
}
} else if (container && container->is_method && container->type_argc) {
- g_warning ("generic_params table claims method has generic parameters, but signature says it doesn't for method 0x%08x from image %s", idx, img->name);
mono_loader_unlock ();
+ mono_error_set_method_load (error, m->klass, m->name, "generic_params table claims method has generic parameters, but signature says it doesn't for method 0x%08x from image %s", idx, img->name);
return NULL;
}
if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)
case PINVOKE_ATTRIBUTE_CALL_CONV_GENERIC:
case PINVOKE_ATTRIBUTE_CALL_CONV_GENERICINST:
default:
- g_warning ("unsupported calling convention : 0x%04x for method 0x%08x from image %s", piinfo->piflags, idx, img->name);
mono_loader_unlock ();
+ mono_error_set_method_load (error, m->klass, m->name, "unsupported calling convention : 0x%04x for method 0x%08x from image %s", piinfo->piflags, idx, img->name);
return NULL;
}
signature->call_convention = conv;
return m->signature;
}
+/**
+ * mono_method_signature:
+ *
+ * Return the signature of the method M. On failure, returns NULL.
+ */
+MonoMethodSignature*
+mono_method_signature (MonoMethod *m)
+{
+ MonoError error;
+ MonoMethodSignature *sig;
+
+ sig = mono_method_signature_checked (m, &error);
+ if (!sig) {
+ char *type_name = mono_type_get_full_name (m->klass);
+ g_warning ("Could not load signature of %s:%s due to: %s", type_name, m->name, mono_error_get_message (&error));
+ g_free (type_name);
+ mono_error_cleanup (&error);
+ }
+
+ return sig;
+}
+
const char*
mono_method_get_name (MonoMethod *method)
{
guint32 rva;
MonoImage* img;
gpointer loc;
- MonoMethodNormal* mn = (MonoMethodNormal*) method;
MonoMethodHeader *header;
if ((method->flags & METHOD_ATTRIBUTE_ABSTRACT) || (method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) || (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) || (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL))
return NULL;
-#ifdef G_LIKELY
- if (G_LIKELY (mn->header))
-#else
- if (mn->header)
-#endif
- return mn->header;
-
if (method->is_inflated) {
MonoMethodInflated *imethod = (MonoMethodInflated *) method;
MonoMethodHeader *header;
- header = mono_method_get_header (imethod->declaring);
-
mono_loader_lock ();
- if (mn->header) {
+ if (imethod->header) {
mono_loader_unlock ();
- return mn->header;
+ return imethod->header;
}
- mn->header = inflate_generic_header (header, mono_method_get_context (method));
+ header = mono_method_get_header (imethod->declaring);
+ if (!header) {
+ mono_loader_unlock ();
+ return NULL;
+ }
+
+ imethod->header = inflate_generic_header (header, mono_method_get_context (method));
mono_loader_unlock ();
- return mn->header;
+ mono_metadata_free_mh (header);
+ return imethod->header;
+ }
+
+ if (method->wrapper_type != MONO_WRAPPER_NONE || method->sre_method) {
+ MonoMethodWrapper *mw = (MonoMethodWrapper *)method;
+ g_assert (mw->header);
+ return mw->header;
}
/*
- * Do most of the work outside the loader lock, to avoid assembly loader hook
- * deadlocks.
+ * We don't need locks here: the new header is allocated from malloc memory
+ * and is not stored anywhere in the runtime, the user needs to free it.
*/
g_assert (mono_metadata_token_table (method->token) == MONO_TABLE_METHOD);
idx = mono_metadata_token_index (method->token);
img = method->klass->image;
rva = mono_metadata_decode_row_col (&img->tables [MONO_TABLE_METHOD], idx - 1, MONO_METHOD_RVA);
- loc = mono_image_rva_map (img, rva);
-
- g_assert (loc);
if (!mono_verifier_verify_method_header (img, rva, NULL))
return NULL;
- header = mono_metadata_parse_mh_full (img, mono_method_get_generic_container (method), loc);
-
- mono_loader_lock ();
-
- if (mn->header) {
- /* header is allocated from the image mempool, no need to free it */
- mono_loader_unlock ();
- return mn->header;
- }
-
- mono_memory_barrier ();
+ loc = mono_image_rva_map (img, rva);
+ if (!loc)
+ return NULL;
- mn->header = header;
+ header = mono_metadata_parse_mh_full (img, mono_method_get_generic_container (method), loc);
- mono_loader_unlock ();
- return mn->header;
+ return header;
}
guint32
MonoClass *klass = method->klass;
int i;
+ if (klass->rank)
+ /* constructed array methods are not in the MethodDef table */
+ return 0;
+
if (method->token)
return mono_metadata_token_index (method->token);
mono_class_setup_methods (klass);
+ if (klass->exception_type)
+ return 0;
for (i = 0; i < klass->method.count; ++i) {
if (method == klass->methods [i]) {
if (klass->image->uncompressed_metadata)
projects / mono.git / blobdiff