-/*
- * loader.c: Image Loader
+/**
+ * \file
+ * Image Loader
*
* Authors:
* Paolo Molaro (lupus@ximian.com)
#include <mono/metadata/class-internals.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/reflection.h>
-#include <mono/metadata/profiler.h>
#include <mono/metadata/profiler-private.h>
#include <mono/metadata/exception.h>
#include <mono/metadata/marshal.h>
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;
+static gint32 inflated_signatures_size;
+static gint32 memberref_sig_cache_size;
+static gint32 methods_size;
+static gint32 signatures_size;
/*
* This TLS variable holds how many times the current thread has acquired the loader
MonoNativeTlsKey loader_lock_nest_id;
static void dllmap_cleanup (void);
+static void cached_module_cleanup(void);
+/* Class lazy loading functions */
+GENERATE_GET_CLASS_WITH_CACHE (appdomain_unloaded_exception, "System", "AppDomainUnloadedException")
static void
global_loader_data_lock (void)
mono_loader_cleanup (void)
{
dllmap_cleanup ();
+ cached_module_cleanup ();
mono_native_tls_free (loader_lock_nest_id);
else {
g_hash_table_insert (image->memberref_signatures, GUINT_TO_POINTER (sig_idx), sig);
/* An approximation based on glib 2.18 */
- memberref_sig_cache_size += sizeof (gpointer) * 4;
+ InterlockedAdd (&memberref_sig_cache_size, sizeof (gpointer) * 4);
}
mono_image_unlock (image);
const char *ptr;
guint32 idx = mono_metadata_token_index (token);
- mono_error_init (error);
+ error_init (error);
mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, MONO_MEMBERREF_SIZE);
nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS;
return field;
}
-/*
+/**
* mono_field_from_token:
- * @deprecated use the _checked variant
+ * \deprecated use the \c _checked variant
* Notes: runtime code MUST not use this function
-*/
+ */
MonoClassField*
mono_field_from_token (MonoImage *image, guint32 token, MonoClass **retklass, MonoGenericContext *context)
{
guint32 type;
MonoClassField *field;
- mono_error_init (error);
+ error_init (error);
if (image_is_dynamic (image)) {
MonoClassField *result;
mono_class_init (k);
if (retklass)
*retklass = k;
- field = mono_class_get_field (k, token);
- if (!field) {
- mono_error_set_bad_image (error, image, "Could not resolve field token 0x%08x", token);
+ if (mono_class_has_failure (k)) {
+ MonoError causedby_error;
+ error_init (&causedby_error);
+ mono_error_set_for_class_failure (&causedby_error, k);
+ mono_error_set_bad_image (error, image, "Could not resolve field token 0x%08x, due to: %s", token, mono_error_get_message (&causedby_error));
+ mono_error_cleanup (&causedby_error);
+ } else {
+ field = mono_class_get_field (k, token);
+ if (!field) {
+ mono_error_set_bad_image (error, image, "Could not resolve field token 0x%08x", token);
+ }
}
}
int i;
/* Search directly in the metadata to avoid calling setup_methods () */
- mono_error_init (error);
+ error_init (error);
/* FIXME: !mono_class_is_ginst (from_class) condition causes test failures. */
if (klass->type_token && !image_is_dynamic (klass->image) && !klass->methods && !klass->rank && klass == from_class && !mono_class_is_ginst (from_class)) {
MonoMethod *result = NULL;
MonoClass *initial_class = in_class;
- mono_error_init (error);
+ error_init (error);
is_interface = MONO_CLASS_IS_INTERFACE (in_class);
if (ic) {
gboolean is_open;
int i;
- mono_error_init (error);
+ error_init (error);
if (!context)
return sig;
return NULL;
}
-/*
+/**
* mono_inflate_generic_signature:
*
- * Inflate SIG with CONTEXT, and return a canonical copy. On error, set ERROR, and return NULL.
+ * Inflate \p sig with \p context, and return a canonical copy. On error, set \p error, and return NULL.
*/
MonoMethodSignature*
mono_inflate_generic_signature (MonoMethodSignature *sig, MonoGenericContext *context, MonoError *error)
res->is_transient = TRUE;
- mono_error_init (error);
+ error_init (error);
for (int i = 0; i < header->num_locals; ++i) {
res->locals [i] = mono_class_inflate_generic_type_checked (header->locals [i], context, error);
return NULL;
}
-/*
- * token is the method_ref/def/spec token used in a call IL instruction.
- * @deprecated use the _checked variant
+/**
+ * mono_method_get_signature_full:
+ * \p token is the method ref/def/spec token used in a \c call IL instruction.
+ * \deprecated use the \c _checked variant
* Notes: runtime code MUST not use this function
*/
MonoMethodSignature*
MonoMethodSignature *sig;
const char *ptr;
- mono_error_init (error);
+ error_init (error);
/* !table is for wrappers: we should really assign their own token to them */
if (!table || table == MONO_TABLE_METHOD)
if (cached != sig)
mono_metadata_free_inflated_signature (sig);
else
- inflated_signatures_size += mono_metadata_signature_size (cached);
+ InterlockedAdd (&inflated_signatures_size, mono_metadata_signature_size (cached));
sig = cached;
}
return sig;
}
-/*
- * token is the method_ref/def/spec token used in a call IL instruction.
- * @deprecated use the _checked variant
+/**
+ * mono_method_get_signature:
+ * \p token is the method_ref/def/spec token used in a call IL instruction.
+ * \deprecated use the \c _checked variant
* Notes: runtime code MUST not use this function
*/
MonoMethodSignature*
MonoMethodSignature *sig;
const char *ptr;
- mono_error_init (error);
+ error_init (error);
mono_metadata_decode_row (&tables [MONO_TABLE_MEMBERREF], idx-1, cols, 3);
nindex = cols [MONO_MEMBERREF_CLASS] >> MONO_MEMBERREF_PARENT_BITS;
guint32 cols [MONO_METHODSPEC_SIZE];
guint32 token, nindex, param_count;
- mono_error_init (error);
+ error_init (error);
mono_metadata_decode_row (&tables [MONO_TABLE_METHODSPEC], idx - 1, cols, MONO_METHODSPEC_SIZE);
token = cols [MONO_METHODSPEC_METHOD];
/**
* 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: The name of the function that replaces the invocation. If NULL, it is replaced with a copy of @func.
+ * \param assembly if NULL, this is a global mapping, otherwise the remapping of the dynamic library will only apply to the specified assembly
+ * \param dll The name of the external library, as it would be found in the \c DllImport declaration. If prefixed with <code>i:</code> the matching of the library name is done without case sensitivity
+ * \param func if not null, the mapping will only applied to the named function (the value of <code>EntryPoint</code>)
+ * \param tdll The name of the library to map the specified \p dll if it matches.
+ * \param tfunc The name of the function that replaces the invocation. If NULL, it is replaced with a copy of \p func.
*
* LOCKING: Acquires the loader lock.
*
- * This function is used to programatically add DllImport remapping in either
+ * This function is used to programatically add \c 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
+ * references in a \c DllImport attribute from the \p dll library name into the \p tdll
+ * name. If the \p dll name contains the prefix <code>i:</code>, 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.
+ * If you pass \p func, this is the name of the \c EntryPoint in a \c DllImport if specified
+ * or the name of the function as determined by \c DllImport. If you pass \p func, you
+ * must also pass \p 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.
+ * <code>mono_dllmap_insert (NULL, "i:libdemo.dll", NULL, relocated_demo_path, NULL);</code>
+ *
+ * The above will remap \c DllImport statements for \c libdemo.dll and \c LIBDEMO.DLL to
+ * the contents of \c 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 ().
+ * \c mono_config_parse.
*/
void
mono_dllmap_insert (MonoImage *assembly, const char *dll, const char *func, const char *tdll, const char *tfunc)
g_hash_table_insert (global_module_map, g_strdup (name), module);
}
+static void
+remove_cached_module(gpointer key, gpointer value, gpointer user_data)
+{
+ mono_dl_close((MonoDl*)value);
+}
+
+static void
+cached_module_cleanup(void)
+{
+ if (global_module_map != NULL) {
+ g_hash_table_foreach(global_module_map, remove_cached_module, NULL);
+
+ g_hash_table_destroy(global_module_map);
+ global_module_map = NULL;
+ }
+}
+
static MonoDl *internal_module;
static gboolean
is_absolute_path (const char *path)
{
-#ifdef PLATFORM_MACOSX
+#ifdef HOST_DARWIN
if (!strncmp (path, "@executable_path/", 17) || !strncmp (path, "@loader_path/", 13) ||
!strncmp (path, "@rpath/", 7))
return TRUE;
return g_path_is_absolute (path);
}
+/**
+ * mono_lookup_pinvoke_call:
+ */
gpointer
mono_lookup_pinvoke_call (MonoMethod *method, const char **exc_class, const char **exc_arg)
{
int i,j;
MonoDl *module = NULL;
gboolean cached = FALSE;
+ gpointer addr = NULL;
g_assert (method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL);
"Searching for '%s'.", import);
if (piinfo->piflags & PINVOKE_ATTRIBUTE_NO_MANGLE) {
- error_msg = mono_dl_symbol (module, import, &piinfo->addr);
+ error_msg = mono_dl_symbol (module, import, &addr);
} else {
char *mangled_name = NULL, *mangled_name2 = NULL;
int mangle_charset;
#endif
for (mangle_param_count = 0; mangle_param_count <= (need_param_count ? 256 : 0); mangle_param_count += 4) {
- if (piinfo->addr)
+ if (addr)
continue;
mangled_name = (char*)import;
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
"Probing '%s'.", mangled_name2);
- error_msg = mono_dl_symbol (module, mangled_name2, &piinfo->addr);
+ error_msg = mono_dl_symbol (module, mangled_name2, &addr);
- if (piinfo->addr)
+ if (addr)
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_DLLIMPORT,
"Found as '%s'.", mangled_name2);
else
}
}
- if (!piinfo->addr) {
+ if (!addr) {
g_free (error_msg);
if (exc_class) {
*exc_class = "EntryPointNotFoundException";
}
return NULL;
}
- return piinfo->addr;
+ piinfo->addr = addr;
+ return addr;
}
/*
const char *sig = NULL;
guint32 cols [MONO_TYPEDEF_SIZE];
- mono_error_init (error);
+ error_init (error);
if (image_is_dynamic (image)) {
MonoClass *handle_class;
result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethodPInvoke));
} else {
result = (MonoMethod *)mono_image_alloc0 (image, sizeof (MonoMethod));
- methods_size += sizeof (MonoMethod);
+ InterlockedAdd (&methods_size, sizeof (MonoMethod));
}
- mono_stats.method_count ++;
+ InterlockedIncrement (&mono_stats.method_count);
result->slot = -1;
result->klass = klass;
return result;
}
+/**
+ * mono_get_method:
+ */
MonoMethod *
mono_get_method (MonoImage *image, guint32 token, MonoClass *klass)
{
return result;
}
+/**
+ * mono_get_method_full:
+ */
MonoMethod *
mono_get_method_full (MonoImage *image, guint32 token, MonoClass *klass,
MonoGenericContext *context)
/* We do everything inside the lock to prevent creation races */
- mono_error_init (error);
+ error_init (error);
mono_image_lock (image);
MonoGenericContext *method_context = NULL;
MonoMethodSignature *sig, *original_sig;
- mono_error_init (error);
+ error_init (error);
mono_class_init (constrained_class);
original_sig = sig = mono_method_signature_checked (method, error);
/**
* 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.
+ * This is used when JITing the <code>constrained.</code> opcode.
+ * \returns The contrained method, which has been inflated
+ * as the function return value; and the original CIL-stream method as
+ * declared in \p cil_method. The latter is used for verification.
*/
MonoMethod *
mono_get_method_constrained (MonoImage *image, guint32 token, MonoClass *constrained_class,
MonoMethod *
mono_get_method_constrained_checked (MonoImage *image, guint32 token, MonoClass *constrained_class, MonoGenericContext *context, MonoMethod **cil_method, MonoError *error)
{
- mono_error_init (error);
+ error_init (error);
- *cil_method = mono_get_method_from_token (image, token, NULL, context, NULL, error);
+ *cil_method = mono_get_method_checked (image, token, NULL, context, error);
if (!*cil_method)
return NULL;
return get_method_constrained (image, *cil_method, constrained_class, context, error);
}
+/**
+ * mono_free_method:
+ */
void
mono_free_method (MonoMethod *method)
{
- if (mono_profiler_get_events () & MONO_PROFILE_METHOD_EVENTS)
- mono_profiler_method_free (method);
+ MONO_PROFILER_RAISE (method_free, (method));
/* FIXME: This hack will go away when the profiler will support freeing methods */
- if (mono_profiler_get_events () != MONO_PROFILE_NONE)
+ if (G_UNLIKELY (mono_profiler_installed ()))
return;
if (method->signature) {
}
}
+/**
+ * mono_method_get_param_names:
+ */
void
mono_method_get_param_names (MonoMethod *method, const char **names)
{
}
}
+/**
+ * mono_method_get_param_token:
+ */
guint32
mono_method_get_param_token (MonoMethod *method, int index)
{
return 0;
}
+/**
+ * mono_method_get_marshal_info:
+ */
void
mono_method_get_marshal_info (MonoMethod *method, MonoMarshalSpec **mspecs)
{
}
}
+/**
+ * mono_method_has_marshal_info:
+ */
gboolean
mono_method_has_marshal_info (MonoMethod *method)
{
mono_get_eh_callbacks ()->mono_walk_stack_with_ctx (stack_walk_adapter, NULL, MONO_UNWIND_LOOKUP_ALL, &ud);
}
+/**
+ * mono_stack_walk_no_il:
+ */
void
mono_stack_walk_no_il (MonoStackWalk func, gpointer user_data)
{
}
-/*
+/**
* mono_stack_walk_async_safe:
- *
- * Async safe version callable from signal handlers.
+ * Async safe version callable from signal handlers.
*/
void
mono_stack_walk_async_safe (MonoStackWalkAsyncSafe func, void *initial_sig_context, void *user_data)
return managed;
}
+/**
+ * mono_method_get_last_managed:
+ */
MonoMethod*
mono_method_get_last_managed (void)
{
/**
* mono_loader_lock:
*
- * See docs/thread-safety.txt for the locking strategy.
+ * See \c docs/thread-safety.txt for the locking strategy.
*/
void
mono_loader_lock (void)
}
}
+/**
+ * mono_loader_unlock:
+ */
void
mono_loader_unlock (void)
{
}
/**
- * mono_method_signature:
+ * mono_method_signature_checked:
*
* Return the signature of the method M. On failure, returns NULL, and ERR is set.
*/
/* We need memory barriers below because of the double-checked locking pattern */
- mono_error_init (error);
+ error_init (error);
if (m->signature)
return m->signature;
if (!mono_error_ok (error))
return NULL;
- inflated_signatures_size += mono_metadata_signature_size (signature);
+ InterlockedAdd (&inflated_signatures_size, mono_metadata_signature_size (signature));
mono_image_lock (img);
mono_image_unlock (img);
}
- signatures_size += mono_metadata_signature_size (signature);
+ InterlockedAdd (&signatures_size, mono_metadata_signature_size (signature));
}
/* Verify metadata consistency */
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)
+ if (m->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) {
signature->pinvoke = 1;
- else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
+#ifdef TARGET_WIN32
+ /*
+ * On Windows the default pinvoke calling convention is STDCALL but
+ * we need CDECL since this is actually an icall.
+ */
+ signature->call_convention = MONO_CALL_C;
+#endif
+ } else if (m->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) {
MonoCallConvention conv = (MonoCallConvention)0;
MonoMethodPInvoke *piinfo = (MonoMethodPInvoke *)m;
signature->pinvoke = 1;
/**
* mono_method_signature:
- *
- * Return the signature of the method M. On failure, returns NULL.
+ * \returns the signature of the method \p m. On failure, returns NULL.
*/
MonoMethodSignature*
mono_method_signature (MonoMethod *m)
return sig;
}
+/**
+ * mono_method_get_name:
+ */
const char*
mono_method_get_name (MonoMethod *method)
{
return method->name;
}
+/**
+ * mono_method_get_class:
+ */
MonoClass*
mono_method_get_class (MonoMethod *method)
{
return method->klass;
}
+/**
+ * mono_method_get_token:
+ */
guint32
mono_method_get_token (MonoMethod *method)
{
gpointer loc;
MonoGenericContainer *container;
- mono_error_init (error);
+ error_init (error);
img = method->klass->image;
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 mono_metadata_parse_mh_full (img, container, (const char *)loc, error);
}
+/**
+ * mono_method_get_header:
+ */
MonoMethodHeader*
mono_method_get_header (MonoMethod *method)
{
}
+/**
+ * mono_method_get_flags:
+ */
guint32
mono_method_get_flags (MonoMethod *method, guint32 *iflags)
{
return method->flags;
}
-/*
- * Find the method index in the metadata methodDef table.
+/**
+ * mono_method_get_index:
+ * Find the method index in the metadata \c MethodDef table.
*/
guint32
mono_method_get_index (MonoMethod *method)
projects / mono.git / blobdiff