}
/**
- * mono_images_rva_map:
+ * mono_image_rva_map:
* \param image a \c MonoImage
* \param addr relative virtual address (RVA)
*
for(hash_idx = 0; hash_idx < IMAGES_HASH_COUNT; hash_idx++)
loaded_images_hashes [hash_idx] = g_hash_table_new (g_str_hash, g_str_equal);
- debug_assembly_unload = g_getenv ("MONO_DEBUG_ASSEMBLY_UNLOAD") != NULL;
+ debug_assembly_unload = g_hasenv ("MONO_DEBUG_ASSEMBLY_UNLOAD");
install_pe_loader ();
* \param section section number that we will load/map into memory
*
* This routine makes sure that we have an in-memory copy of
- * an image section (.text, .rsrc, .data).
+ * an image section (<code>.text</code>, <code>.rsrc</code>, <code>.data</code>).
*
* \returns TRUE on success
*/
return image->modules [idx - 1];
}
+/**
+ * mono_image_load_module:
+ */
MonoImage*
mono_image_load_module (MonoImage *image, int idx)
{
return (gpointer*)&klass->next_class_cache;
}
+/**
+ * mono_image_init:
+ */
void
mono_image_init (MonoImage *image)
{
class_next_value);
image->field_cache = mono_conc_hashtable_new (NULL, NULL);
- image->typespec_cache = g_hash_table_new (NULL, NULL);
+ image->typespec_cache = mono_conc_hashtable_new (NULL, NULL);
image->memberref_signatures = g_hash_table_new (NULL, NULL);
image->helper_signatures = g_hash_table_new (g_str_hash, g_str_equal);
image->method_signatures = g_hash_table_new (NULL, NULL);
This is to be removed once a proper fix is shipped through nuget.
+Please keep this in sync with mcs/tools/xbuild/data/deniedAssembliesList.txt
+If any assemblies are added/removed, then this should be regenerated with:
+
+ $ mono tools/nuget-hash-extractor/nuget-hash-extractor.exe nugets guids_for_msbuild > mcs/tools/xbuild/data/deniedAssembliesList.txt
+
*/
typedef enum {
SYS_IO_COMPRESSION = 2, //System.IO.Compression
SYS_NET_HTTP = 3, //System.Net.Http
SYS_TEXT_ENC_CODEPAGES = 4, //System.Text.Encoding.CodePages
- SYS_REF_DISP_PROXY = 5, //System.Reflection.DispatchProxy
- SYS_VALUE_TUPLE = 6, //System.ValueTuple
+ SYS_THREADING_OVERLAPPED = 5, //System.Threading.Overlapped
} IgnoredAssemblyNames;
typedef struct {
"System.IO.Compression.dll",
"System.Net.Http.dll",
"System.Text.Encoding.CodePages.dll",
- "System.Reflection.DispatchProxy.dll",
- "System.ValueTuple.dll"
+ "System.Threading.Overlapped.dll"
};
#define IGNORED_ASSEMBLY(HASH, NAME, GUID, VER_STR) { .hash = HASH, .assembly_name = NAME, .guid = GUID }
IGNORED_ASSEMBLY (0x27726A90, SYS_NET_HTTP, "269B562C-CC15-4736-B1B1-68D4A43CAA98", "4.1.0 net46"),
IGNORED_ASSEMBLY (0x10CADA75, SYS_NET_HTTP, "EA2EC6DC-51DD-479C-BFC2-E713FB9E7E47", "4.1.1 net46"),
IGNORED_ASSEMBLY (0x8437178B, SYS_NET_HTTP, "C0E04D9C-70CF-48A6-A179-FBFD8CE69FD0", "4.3.0 net46"),
- IGNORED_ASSEMBLY (0x4A15555E, SYS_REF_DISP_PROXY, "E40AFEB4-CABE-4124-8412-B46AB79C92FD", "4.0.0 net46"),
- IGNORED_ASSEMBLY (0xD20D9783, SYS_REF_DISP_PROXY, "2A69F0AD-B86B-40F2-8E4C-5B671E47479F", "4.0.1 netstandard1.3"),
- IGNORED_ASSEMBLY (0xA33A7E68, SYS_REF_DISP_PROXY, "D4E8D2DB-BD65-4168-99EA-D2C1BDEBF9CC", "4.3.0 netstandard1.3"),
+ IGNORED_ASSEMBLY (0xFAFDA422, SYS_NET_HTTP, "817F01C3-4011-477D-890A-98232B85553D", "4.3.1 net46"),
+ IGNORED_ASSEMBLY (0x472FA630, SYS_NET_HTTP, "09D4A140-061C-4884-9B63-22067E841931", "4.3.2 net46"),
IGNORED_ASSEMBLY (0x46A4A1C5, SYS_RT_INTEROP_RUNTIME_INFO, "F13660F8-9D0D-419F-BA4E-315693DD26EA", "4.0.0 net45"),
IGNORED_ASSEMBLY (0xD07383BB, SYS_RT_INTEROP_RUNTIME_INFO, "DD91439F-3167-478E-BD2C-BF9C036A1395", "4.3.0 net45"),
IGNORED_ASSEMBLY (0x911D9EC3, SYS_TEXT_ENC_CODEPAGES, "C142254F-DEB5-46A7-AE43-6F10320D1D1F", "4.0.1 net46"),
IGNORED_ASSEMBLY (0xFA686A38, SYS_TEXT_ENC_CODEPAGES, "FD178CD4-EF4F-44D5-9C3F-812B1E25126B", "4.3.0 net46"),
- IGNORED_ASSEMBLY (0x75B4B041, SYS_VALUE_TUPLE, "F81A4140-A898-4E2B-B6E9-55CE78C273EC", "4.3.0 netstandard1.0"),
+ IGNORED_ASSEMBLY (0xF6D18A2E, SYS_TEXT_ENC_CODEPAGES, "F5CCCBEC-E1AD-4DBB-9B44-9B42C86B94B8", "4.4.0 net461"),
+ IGNORED_ASSEMBLY (0xAA21986B, SYS_THREADING_OVERLAPPED, "9F5D4F09-787A-458A-BA08-553AA71470F1", "4.0.0 net46"),
+ IGNORED_ASSEMBLY (0x7D927C2A, SYS_THREADING_OVERLAPPED, "FCBD003B-2BB4-4940-BAEF-63AF520C2336", "4.0.1 net46"),
+ IGNORED_ASSEMBLY (0x6FE03EE2, SYS_THREADING_OVERLAPPED, "87697E71-D192-4F0B-BAD4-02BBC7793005", "4.3.0 net46")
};
"System.IO.Compression",
"System.Net.Http",
"System.Text.Encoding.CodePages",
- "System.Reflection.DispatchProxy",
- "System.ValueTuple"
+ "System.Threading.Overlapped"
};
#define IGNORED_ASM_VER(NAME, MAJOR, MINOR, BUILD, REVISION) { .assembly_name = NAME, .major = MAJOR, .minor = MINOR, .build = BUILD, .revision = REVISION }
IGNORED_ASM_VER (SYS_NET_HTTP, 4, 1, 0, 0),
IGNORED_ASM_VER (SYS_NET_HTTP, 4, 1, 0, 1),
IGNORED_ASM_VER (SYS_NET_HTTP, 4, 1, 1, 0),
- IGNORED_ASM_VER (SYS_REF_DISP_PROXY, 4, 0, 0, 0),
- IGNORED_ASM_VER (SYS_REF_DISP_PROXY, 4, 0, 1, 0),
- IGNORED_ASM_VER (SYS_REF_DISP_PROXY, 4, 0, 2, 0),
+ IGNORED_ASM_VER (SYS_NET_HTTP, 4, 1, 1, 1),
IGNORED_ASM_VER (SYS_RT_INTEROP_RUNTIME_INFO, 4, 0, 0, 0),
IGNORED_ASM_VER (SYS_RT_INTEROP_RUNTIME_INFO, 4, 0, 1, 0),
IGNORED_ASM_VER (SYS_TEXT_ENC_CODEPAGES, 4, 0, 1, 0),
IGNORED_ASM_VER (SYS_TEXT_ENC_CODEPAGES, 4, 0, 2, 0),
- IGNORED_ASM_VER (SYS_VALUE_TUPLE, 4, 0, 1, 0),
+ IGNORED_ASM_VER (SYS_TEXT_ENC_CODEPAGES, 4, 1, 0, 0),
+ IGNORED_ASM_VER (SYS_THREADING_OVERLAPPED, 4, 0, 0, 0),
+ IGNORED_ASM_VER (SYS_THREADING_OVERLAPPED, 4, 0, 1, 0),
+ IGNORED_ASM_VER (SYS_THREADING_OVERLAPPED, 4, 0, 2, 0),
};
gboolean
GSList *errors = NULL;
GSList *l;
- mono_profiler_module_event (image, MONO_PROFILE_START_LOAD);
+ MONO_PROFILER_RAISE (image_loading, (image));
mono_image_init (image);
load_modules (image);
done:
- mono_profiler_module_loaded (image, MONO_PROFILE_OK);
+ MONO_PROFILER_RAISE (image_loaded, (image));
if (status)
*status = MONO_IMAGE_OK;
g_warning ("Could not load image %s due to %s", image->name, info->message);
mono_free_verify_list (errors);
}
- mono_profiler_module_loaded (image, MONO_PROFILE_FAILED);
+ MONO_PROFILER_RAISE (image_failed, (image));
mono_image_close (image);
return NULL;
}
* This routine verifies that the given image is loaded.
* It checks either reflection-only loads only, or normal loads only, as specified by parameter.
*
- * \returns the loaded MonoImage, or NULL on failure.
+ * \returns the loaded \c MonoImage, or NULL on failure.
*/
MonoImage *
mono_image_loaded_full (const char *name, gboolean refonly)
data->res = image;
}
+/**
+ * mono_image_loaded_by_guid_full:
+ */
MonoImage *
mono_image_loaded_by_guid_full (const char *guid, gboolean refonly)
{
return data.res;
}
+/**
+ * mono_image_loaded_by_guid:
+ */
MonoImage *
mono_image_loaded_by_guid (const char *guid)
{
return register_image (image);
}
+/**
+ * mono_image_open_from_data_with_name:
+ */
MonoImage *
mono_image_open_from_data_with_name (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly, const char *name)
{
return mono_image_open_from_data_internal (data, data_len, need_copy, status, refonly, FALSE, name);
}
+/**
+ * mono_image_open_from_data_full:
+ */
MonoImage *
mono_image_open_from_data_full (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status, gboolean refonly)
{
return mono_image_open_from_data_with_name (data, data_len, need_copy, status, refonly, NULL);
}
+/**
+ * mono_image_open_from_data:
+ */
MonoImage *
mono_image_open_from_data (char *data, guint32 data_len, gboolean need_copy, MonoImageOpenStatus *status)
{
}
#endif
+/**
+ * mono_image_open_full:
+ */
MonoImage *
mono_image_open_full (const char *fname, MonoImageOpenStatus *status, gboolean refonly)
{
}
#endif
- absfname = mono_path_canonicalize (fname);
+ absfname = mono_path_resolve_symlinks (fname);
/*
* The easiest solution would be to do all the loading inside the mutex,
* \param status An error condition is returned in this field
* \returns An open image of type \c MonoImage or NULL on error.
* The caller holds a temporary reference to the returned image which should be cleared
- * when no longer needed by calling mono_image_close().
+ * when no longer needed by calling \c mono_image_close.
* if NULL, then check the value of \p status for details on the error
*/
MonoImage *
* \param status An error condition is returned in this field
* \returns An open image of type \c MonoImage or NULL on error. if
* NULL, then check the value of \p status for details on the error.
- * This variant for mono_image_open DOES NOT SET UP CLI METADATA.
- * It's just a PE file loader, used for FileVersionInfo. It also does
+ * This variant for \c mono_image_open DOES NOT SET UP CLI METADATA.
+ * It's just a PE file loader, used for \c FileVersionInfo. It also does
* not use the image cache.
*/
MonoImage *
return do_mono_image_open (fname, status, TRUE, TRUE, FALSE, TRUE, FALSE);
}
+/**
+ * mono_image_fixup_vtable:
+ */
void
mono_image_fixup_vtable (MonoImage *image)
{
}
#endif
- mono_profiler_module_event (image, MONO_PROFILE_START_UNLOAD);
+ MONO_PROFILER_RAISE (image_unloading, (image));
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY, "Unloading image %s [%p].", image->name, image);
free_hash (image->pinvoke_scopes);
free_hash (image->pinvoke_scope_filenames);
free_hash (image->native_func_wrapper_cache);
- free_hash (image->typespec_cache);
+ mono_conc_hashtable_destroy (image->typespec_cache);
mono_wrapper_caches_free (&image->wrapper_caches);
mono_dynamic_image_free ((MonoDynamicImage*)image);
}
- mono_profiler_module_event (image, MONO_PROFILE_END_UNLOAD);
+ MONO_PROFILER_RAISE (image_unloaded, (image));
return TRUE;
}
mono_image_close_all (image->modules, image->module_count);
#ifndef DISABLE_PERFCOUNTERS
- mono_perfcounters->loader_bytes -= mono_mempool_get_allocated (image->mempool);
+ /* FIXME: use an explicit subtraction method as soon as it's available */
+ InterlockedAdd (&mono_perfcounters->loader_bytes, -1 * mono_mempool_get_allocated (image->mempool));
#endif
if (!image_is_dynamic (image)) {
/**
* mono_image_lookup_resource:
* \param image the image to look up the resource in
- * \param res_id A MONO_PE_RESOURCE_ID_ that represents the resource ID to lookup.
+ * \param res_id A \c MONO_PE_RESOURCE_ID_ that represents the resource ID to lookup.
* \param lang_id The language id.
* \param name the resource name to lookup.
* \returns NULL if not found, otherwise a pointer to the in-memory representation
- * of the given resource. The caller should free it using g_free() when no longer
+ * of the given resource. The caller should free it using \c g_free when no longer
* needed.
*/
gpointer
return res;
}
+/**
+ * mono_image_load_file_for_image:
+ */
MonoImage*
mono_image_load_file_for_image (MonoImage *image, int fileidx)
{
/**
* mono_image_get_strong_name:
* \param image a MonoImage
- * \param size a guint32 pointer, or NULL.
+ * \param size a \c guint32 pointer, or NULL.
*
* If the image has a strong name, and \p size is not NULL, the value
* pointed to by size will have the size of the strong name.
return image->name;
}
+/**
+ * mono_image_get_guid:
+ */
const char*
mono_image_get_guid (MonoImage *image)
{
return image->guid;
}
+/**
+ * mono_image_get_table_info:
+ */
const MonoTableInfo*
mono_image_get_table_info (MonoImage *image, int table_id)
{
return &image->tables [table_id];
}
+/**
+ * mono_image_get_table_rows:
+ */
int
mono_image_get_table_rows (MonoImage *image, int table_id)
{
return image->tables [table_id].rows;
}
+/**
+ * mono_table_info_get_rows:
+ */
int
mono_table_info_get_rows (const MonoTableInfo *table)
{
* \param image the \c MonoImage
*
* Determines if the given image was created dynamically through the
- * System.Reflection.Emit API
+ * \c System.Reflection.Emit API
* \returns TRUE if the image was created dynamically, FALSE if not.
*/
gboolean
gpointer res;
#ifndef DISABLE_PERFCOUNTERS
- mono_perfcounters->loader_bytes += size;
+ InterlockedAdd (&mono_perfcounters->loader_bytes, size);
#endif
mono_image_lock (image);
res = mono_mempool_alloc (image->mempool, size);
gpointer res;
#ifndef DISABLE_PERFCOUNTERS
- mono_perfcounters->loader_bytes += size;
+ InterlockedAdd (&mono_perfcounters->loader_bytes, size);
#endif
mono_image_lock (image);
res = mono_mempool_alloc0 (image->mempool, size);
char *res;
#ifndef DISABLE_PERFCOUNTERS
- mono_perfcounters->loader_bytes += strlen (s);
+ InterlockedAdd (&mono_perfcounters->loader_bytes, strlen (s));
#endif
mono_image_lock (image);
res = mono_mempool_strdup (image->mempool, s);
buf = mono_mempool_strdup_vprintf (image->mempool, format, args);
mono_image_unlock (image);
#ifndef DISABLE_PERFCOUNTERS
- mono_perfcounters->loader_bytes += strlen (buf);
+ InterlockedAdd (&mono_perfcounters->loader_bytes, strlen (buf));
#endif
return buf;
}
projects / mono.git / blobdiff