[coop] Transition various public APIs into an external/internal form to avoid unneces...

Relevant issue: mono/mono#14376

There are potentially more functions this can apply to, but this covers the ones listed in the issue and an extra one I found in the process.

Functions were either broken off into an external-only and internal version, or such a pair already existed and the internal version was moved from the source file to a separate `-internals` header, similarly to in mono/mono@3c74df566776f468366d96dd164dd1a6b3d780cc.

This gets slightly complicated with `mono_domain_set` and `mono_domain_set_internal`, both of which are currently public (thanks to mono/mono@4beada28924879ede55f3bf8b3f5b798d0f4637e) and have different signatures. Additionally, the latter does not actually include the gc-unsafe transition despite being public.
I've opted to introduce `mono_domain_set_fast` as the 'internal' version of `mono_domain_set`, to add the proper gc-unsafe transition to `mono_domain_set_internal`, and then to migrate internal usage to `mono_domain_set_internal_with_options`. As part of that I've marked `mono_domain_set_internal` as external only, which is unfortunate naming-wise but I believe the best option here without introducing API breakage.

Commit migrated from https://github.com/mono/mono/commit/96b1fd837d6caf1be1b657c0726af3b8caae7060

diff --git a/src/mono/mono/metadata/appdomain.c b/src/mono/mono/metadata/appdomain.c
index 032f26a..195c4ca 100644 (file)
--- a/src/mono/mono/metadata/appdomain.c
+++ b/src/mono/mono/metadata/appdomain.c
@@ -47,6 +47,7 @@
 #include <mono/metadata/threadpool.h>
 #include <mono/metadata/tabledefs.h>
 #include <mono/metadata/mono-gc.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include <mono/metadata/marshal.h>
 #include <mono/metadata/marshal-internals.h>
 #include <mono/metadata/monitor.h>
@@ -647,7 +648,7 @@ copy_app_domain_setup (MonoDomain *domain, MonoAppDomainSetupHandle setup, MonoE
        MonoAppDomainSetupHandle copy = MONO_HANDLE_CAST (MonoAppDomainSetup, mono_object_new_handle(domain, ads_class, error));
        goto_if_nok (error, leave);
 
-       mono_domain_set_internal (domain);
+       mono_domain_set_internal_with_options (domain, TRUE);
 
 #define XCOPY_FIELD(type, dst, field, src, error)                      \
        do {                                                            \
@@ -686,7 +687,7 @@ copy_app_domain_setup (MonoDomain *domain, MonoAppDomainSetupHandle setup, MonoE
 #undef XCOPY_FIELD
 #undef COPY_VAL
        
-       mono_domain_set_internal (caller_domain);
+       mono_domain_set_internal_with_options (caller_domain, TRUE);
 
        MONO_HANDLE_ASSIGN (result, copy);
 leave:
@@ -974,25 +975,14 @@ mono_domain_owns_vtable_slot (MonoDomain *domain, gpointer vtable_slot)
        return res;
 }
 
-/**
- * mono_domain_set:
- * \param domain domain
- * \param force force setting.
- *
- * Set the current appdomain to \p domain. If \p force is set, set it even
- * if it is being unloaded.
- *
- * \returns TRUE on success; FALSE if the domain is unloaded
- */
 gboolean
-mono_domain_set (MonoDomain *domain, gboolean force)
+mono_domain_set_fast (MonoDomain *domain, gboolean force)
 {
+       MONO_REQ_GC_UNSAFE_MODE;
        if (!force && domain->state == MONO_APPDOMAIN_UNLOADED)
                return FALSE;
 
-       MONO_ENTER_GC_UNSAFE;
-       mono_domain_set_internal (domain);
-       MONO_EXIT_GC_UNSAFE;
+       mono_domain_set_internal_with_options (domain, TRUE);
        return TRUE;
 }
 
@@ -1060,7 +1050,7 @@ ves_icall_System_AppDomain_SetData (MonoAppDomainHandle ad, MonoStringHandle nam
 
        mono_domain_lock (add);
 
-       mono_g_hash_table_insert (add->env, MONO_HANDLE_RAW (name), MONO_HANDLE_RAW (data));
+       mono_g_hash_table_insert_internal (add->env, MONO_HANDLE_RAW (name), MONO_HANDLE_RAW (data));
 
        mono_domain_unlock (add);
 }
@@ -2708,7 +2698,7 @@ ves_icall_System_AppDomain_InternalSetDomain (MonoAppDomainHandle ad, MonoError*
        error_init (error);
        MonoDomain *old_domain = mono_domain_get ();
 
-       if (!mono_domain_set (MONO_HANDLE_GETVAL (ad, data), FALSE)) {
+       if (!mono_domain_set_fast (MONO_HANDLE_GETVAL (ad, data), FALSE)) {
                mono_error_set_appdomain_unloaded (error);
                return MONO_HANDLE_CAST (MonoAppDomain, NULL_HANDLE);
        }
@@ -2722,7 +2712,7 @@ ves_icall_System_AppDomain_InternalSetDomainByID (gint32 domainid, MonoError *er
        MonoDomain *current_domain = mono_domain_get ();
        MonoDomain *domain = mono_domain_get_by_id (domainid);
 
-       if (!domain || !mono_domain_set (domain, FALSE)) {
+       if (!domain || !mono_domain_set_fast (domain, FALSE)) {
                mono_error_set_appdomain_unloaded (error);
                return MONO_HANDLE_CAST (MonoAppDomain, NULL_HANDLE);
        }
@@ -3081,7 +3071,7 @@ mono_domain_try_unload (MonoDomain *domain, MonoObject **exc)
                }
        }
 
-       mono_domain_set (domain, FALSE);
+       mono_domain_set_fast (domain, FALSE);
        /* Notify OnDomainUnload listeners */
        method = mono_class_get_method_from_name_checked (domain->domain->mbr.obj.vtable->klass, "DoDomainUnload", -1, 0, error);
        g_assert (method);
@@ -3098,10 +3088,10 @@ mono_domain_try_unload (MonoDomain *domain, MonoObject **exc)
        if (*exc) {
                /* Roll back the state change */
                domain->state = MONO_APPDOMAIN_CREATED;
-               mono_domain_set (caller_domain, FALSE);
+               mono_domain_set_fast (caller_domain, FALSE);
                goto exit;
        }
-       mono_domain_set (caller_domain, FALSE);
+       mono_domain_set_fast (caller_domain, FALSE);
 
        thread_data = g_new0 (unload_data, 1);
        thread_data->domain = domain;

diff --git a/src/mono/mono/metadata/appdomain.h b/src/mono/mono/metadata/appdomain.h
index 92c8d18..65848aa 100644 (file)
--- a/src/mono/mono/metadata/appdomain.h
+++ b/src/mono/mono/metadata/appdomain.h
@@ -82,10 +82,10 @@ mono_domain_get_id         (MonoDomain *domain);
 MONO_API const char *
 mono_domain_get_friendly_name (MonoDomain *domain);
 
-MONO_API mono_bool
+MONO_API MONO_RT_EXTERNAL_ONLY mono_bool
 mono_domain_set            (MonoDomain *domain, mono_bool force);
 
-MONO_API void
+MONO_API MONO_RT_EXTERNAL_ONLY void
 mono_domain_set_internal   (MonoDomain *domain);
 
 MONO_API MONO_RT_EXTERNAL_ONLY void

diff --git a/src/mono/mono/metadata/assembly.c b/src/mono/mono/metadata/assembly.c
index de8b108..f94bf49 100644 (file)
--- a/src/mono/mono/metadata/assembly.c
+++ b/src/mono/mono/metadata/assembly.c
@@ -33,6 +33,7 @@
 #include <mono/metadata/mono-debug.h>
 #include <mono/utils/mono-uri.h>
 #include <mono/metadata/mono-config.h>
+#include <mono/metadata/mono-config-internals.h>
 #include <mono/metadata/mono-config-dirs.h>
 #include <mono/utils/mono-digest.h>
 #include <mono/utils/mono-logger-internals.h>
@@ -2393,7 +2394,7 @@ mono_assembly_request_open (const char *filename, const MonoAssemblyOpenRequest
                        mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_ASSEMBLY,
                                "Assembly Loader loaded assembly from location: '%s'.", filename);
                if (!refonly)
-                       mono_config_for_assembly (ass->image);
+                       mono_config_for_assembly_internal (ass->image);
        }
 
        /* Clear the reference added by mono_image_open */

diff --git a/src/mono/mono/metadata/class-internals.h b/src/mono/mono/metadata/class-internals.h
index afc2f60..f5a3226 100644 (file)
--- a/src/mono/mono/metadata/class-internals.h
+++ b/src/mono/mono/metadata/class-internals.h
@@ -817,6 +817,9 @@ mono_class_has_special_static_fields (MonoClass *klass);
 const char*
 mono_class_get_field_default_value (MonoClassField *field, MonoTypeEnum *def_type);
 
+MonoProperty* 
+mono_class_get_property_from_name_internal (MonoClass *klass, const char *name);
+
 const char*
 mono_class_get_property_default_value (MonoProperty *property, MonoTypeEnum *def_type);
 
@@ -1221,6 +1224,9 @@ mono_class_has_variant_generic_params (MonoClass *klass);
 gboolean
 mono_class_is_variant_compatible (MonoClass *klass, MonoClass *oklass, gboolean check_for_reference_conv);
 
+gboolean 
+mono_class_is_subclass_of_internal (MonoClass *klass, MonoClass *klassc, gboolean check_interfaces);
+
 mono_bool
 mono_class_is_assignable_from_internal (MonoClass *klass, MonoClass *oklass);
 

diff --git a/src/mono/mono/metadata/class.c b/src/mono/mono/metadata/class.c
index 148f92f..8eae50b 100644 (file)
--- a/src/mono/mono/metadata/class.c
+++ b/src/mono/mono/metadata/class.c
@@ -65,10 +65,6 @@ static gboolean can_access_type (MonoClass *access_klass, MonoClass *member_klas
 static char* mono_assembly_name_from_token (MonoImage *image, guint32 type_token);
 static guint32 mono_field_resolve_flags (MonoClassField *field);
 
-static MonoProperty* mono_class_get_property_from_name_internal (MonoClass *klass, const char *name);
-
-static gboolean mono_class_is_subclass_of_internal (MonoClass *klass, MonoClass *klassc, gboolean check_interfaces);
-
 GENERATE_GET_CLASS_WITH_CACHE (valuetype, "System", "ValueType")
 GENERATE_TRY_GET_CLASS_WITH_CACHE (handleref, "System.Runtime.InteropServices", "HandleRef")
 
@@ -2497,25 +2493,6 @@ mono_class_get_event_token (MonoEvent *event)
        return 0;
 }
 
-/**
- * mono_class_get_property_from_name:
- * \param klass a class
- * \param name name of the property to lookup in the specified class
- *
- * Use this method to lookup a property in a class
- * \returns the \c MonoProperty with the given name, or NULL if the property
- * does not exist on the \p klass.
- */
-MonoProperty*
-mono_class_get_property_from_name (MonoClass *klass, const char *name)
-{
-       MonoProperty *result = NULL;
-       MONO_ENTER_GC_UNSAFE;
-       result = mono_class_get_property_from_name_internal (klass, name);
-       MONO_EXIT_GC_UNSAFE;
-       return result;
-}
-
 MonoProperty*
 mono_class_get_property_from_name_internal (MonoClass *klass, const char *name)
 {
@@ -3358,37 +3335,6 @@ mono_class_try_load_from_name (MonoImage *image, const char* name_space, const c
        return klass;
 }
 
-
-/**
- * mono_class_is_subclass_of:
- * \param klass class to probe if it is a subclass of another one
- * \param klassc the class we suspect is the base class
- * \param check_interfaces whether we should perform interface checks
- *
- * This method determines whether \p klass is a subclass of \p klassc.
- *
- * If the \p check_interfaces flag is set, then if \p klassc is an interface
- * this method return TRUE if the \p klass implements the interface or
- * if \p klass is an interface, if one of its base classes is \p klass.
- *
- * If \p check_interfaces is false, then if \p klass is not an interface,
- * it returns TRUE if the \p klass is a subclass of \p klassc.
- *
- * if \p klass is an interface and \p klassc is \c System.Object, then this function
- * returns TRUE.
- *
- */
-gboolean
-mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, 
-                          gboolean check_interfaces)
-{
-       gboolean result;
-       MONO_ENTER_GC_UNSAFE;
-       result = mono_class_is_subclass_of_internal (klass, klassc, check_interfaces);
-       MONO_EXIT_GC_UNSAFE;
-       return result;
-}
-
 static gboolean 
 mono_interface_implements_interface (MonoClass *interface_implementer, MonoClass *interface_implemented)
 {
@@ -3414,6 +3360,7 @@ gboolean
 mono_class_is_subclass_of_internal (MonoClass *klass, MonoClass *klassc,
                                    gboolean check_interfaces)
 {
+       MONO_REQ_GC_UNSAFE_MODE;
        /* FIXME test for interfaces with variant generic arguments */
        mono_class_init_internal (klass);
        mono_class_init_internal (klassc);

diff --git a/src/mono/mono/metadata/class.h b/src/mono/mono/metadata/class.h
index 356b5fe..9eac22e 100644 (file)
--- a/src/mono/mono/metadata/class.h
+++ b/src/mono/mono/metadata/class.h
@@ -92,7 +92,7 @@ mono_class_get_field_token (MonoClassField *field);
 MONO_API uint32_t
 mono_class_get_event_token (MonoEvent *event);
 
-MONO_API MonoProperty*
+MONO_API MONO_RT_EXTERNAL_ONLY MonoProperty *
 mono_class_get_property_from_name (MonoClass *klass, const char *name);
 
 MONO_API uint32_t
@@ -119,7 +119,7 @@ mono_class_min_align       (MonoClass *klass);
 MONO_API MONO_RT_EXTERNAL_ONLY MonoClass *
 mono_class_from_mono_type  (MonoType *type);
 
-MONO_API mono_bool
+MONO_API MONO_RT_EXTERNAL_ONLY mono_bool
 mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, 
                                                   mono_bool check_interfaces);
 

diff --git a/src/mono/mono/metadata/cominterop.c b/src/mono/mono/metadata/cominterop.c
index 79f7fd8..84131ee 100644 (file)
--- a/src/mono/mono/metadata/cominterop.c
+++ b/src/mono/mono/metadata/cominterop.c
@@ -25,6 +25,7 @@
 #include "metadata/appdomain.h"
 #include "metadata/reflection-internals.h"
 #include "mono/metadata/class-init.h"
+#include "mono/metadata/class-internals.h"
 #include "mono/metadata/debug-helpers.h"
 #include "mono/metadata/threads.h"
 #include "mono/metadata/monitor.h"
@@ -862,14 +863,14 @@ mono_cominterop_emit_object_to_ptr_conv (MonoMethodBuilder *mb, MonoType *type,
                        static MonoProperty* iunknown = NULL;
                        
                        if (!iunknown)
-                               iunknown = mono_class_get_property_from_name (mono_class_get_com_object_class (), "IUnknown");
+                               iunknown = mono_class_get_property_from_name_internal (mono_class_get_com_object_class (), "IUnknown");
                        mono_mb_emit_managed_call (mb, iunknown->get, NULL);
                }
                else if (conv == MONO_MARSHAL_CONV_OBJECT_IDISPATCH) {
                        static MonoProperty* idispatch = NULL;
                        
                        if (!idispatch)
-                               idispatch = mono_class_get_property_from_name (mono_class_get_com_object_class (), "IDispatch");
+                               idispatch = mono_class_get_property_from_name_internal (mono_class_get_com_object_class (), "IDispatch");
                        mono_mb_emit_managed_call (mb, idispatch->get, NULL);
                }
                else {

diff --git a/src/mono/mono/metadata/custom-attrs.c b/src/mono/mono/metadata/custom-attrs.c
index 0668317..61afd21 100644 (file)
--- a/src/mono/mono/metadata/custom-attrs.c
+++ b/src/mono/mono/metadata/custom-attrs.c
@@ -15,6 +15,7 @@
 #include <config.h>
 #include "mono/metadata/assembly.h"
 #include "mono/metadata/class-init.h"
+#include "mono/metadata/class-internals.h"
 #include "mono/metadata/gc-internals.h"
 #include "mono/metadata/mono-endian.h"
 #include "mono/metadata/object-internals.h"
@@ -956,7 +957,7 @@ create_custom_attr (MonoImage *image, MonoMethod *method, const guchar *data, gu
                        mono_field_set_value_internal (MONO_HANDLE_RAW (attr), field, val); // FIXMEcoop
                } else if (named_type == CATTR_TYPE_PROPERTY) {
                        MonoProperty *prop;
-                       prop = mono_class_get_property_from_name (mono_handle_class (attr), name);
+                       prop = mono_class_get_property_from_name_internal (mono_handle_class (attr), name);
                        if (!prop) {
                                mono_error_set_generic_error (error, "System.Reflection", "CustomAttributeFormatException", "Could not find a property with name %s", name);
                                goto fail;
@@ -1142,7 +1143,7 @@ mono_reflection_create_custom_attr_data_args (MonoImage *image, MonoMethod *meth
                        /* Named arg is a property */
                        MonoObject *obj;
                        MonoType *prop_type;
-                       MonoProperty *prop = mono_class_get_property_from_name (attrklass, name);
+                       MonoProperty *prop = mono_class_get_property_from_name_internal (attrklass, name);
 
                        if (!prop || !prop->set) {
                                g_free (name);
@@ -1292,7 +1293,7 @@ mono_reflection_create_custom_attr_data_args_noalloc (MonoImage *image, MonoMeth
                } else if (named_type == CATTR_TYPE_PROPERTY) {
                        /* Named arg is a property */
                        MonoType *prop_type;
-                       MonoProperty *prop = mono_class_get_property_from_name (attrklass, name);
+                       MonoProperty *prop = mono_class_get_property_from_name_internal (attrklass, name);
 
                        if (!prop || !prop->set) {
                                g_free (name);

diff --git a/src/mono/mono/metadata/domain-internals.h b/src/mono/mono/metadata/domain-internals.h
index 88a688c..00c9320 100644 (file)
--- a/src/mono/mono/metadata/domain-internals.h
+++ b/src/mono/mono/metadata/domain-internals.h
@@ -653,4 +653,7 @@ mono_runtime_register_appctx_properties (int nprops, const char **keys,  const c
 void
 mono_runtime_install_appctx_properties (void);
 
+gboolean 
+mono_domain_set_fast (MonoDomain *domain, gboolean force);
+
 #endif /* __MONO_METADATA_DOMAIN_INTERNALS_H__ */

diff --git a/src/mono/mono/metadata/domain.c b/src/mono/mono/metadata/domain.c
index 53cddaa..6ab116a 100644 (file)
--- a/src/mono/mono/metadata/domain.c
+++ b/src/mono/mono/metadata/domain.c
@@ -39,6 +39,7 @@
 #include <mono/metadata/metadata-internals.h>
 #include <mono/metadata/appdomain.h>
 #include <mono/metadata/mono-config.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include <mono/metadata/threads-types.h>
 #include <mono/metadata/runtime.h>
 #include <mono/metadata/w32mutex.h>
@@ -436,14 +437,14 @@ mono_domain_create (void)
        domain->mp = mono_mempool_new ();
        domain->code_mp = mono_code_manager_new ();
        domain->lock_free_mp = lock_free_mempool_new ();
-       domain->env = mono_g_hash_table_new_type ((GHashFunc)mono_string_hash_internal, (GCompareFunc)mono_string_equal_internal, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Environment Variable Table");
+       domain->env = mono_g_hash_table_new_type_internal ((GHashFunc)mono_string_hash_internal, (GCompareFunc)mono_string_equal_internal, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Environment Variable Table");
        domain->domain_assemblies = NULL;
        domain->assembly_bindings = NULL;
        domain->assembly_bindings_parsed = FALSE;
        domain->class_vtable_array = g_ptr_array_new ();
        domain->proxy_vtable_hash = g_hash_table_new ((GHashFunc)mono_ptrarray_hash, (GCompareFunc)mono_ptrarray_equal);
        mono_jit_code_hash_init (&domain->jit_code_hash);
-       domain->ldstr_table = mono_g_hash_table_new_type ((GHashFunc)mono_string_hash_internal, (GCompareFunc)mono_string_equal_internal, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain String Pool Table");
+       domain->ldstr_table = mono_g_hash_table_new_type_internal ((GHashFunc)mono_string_hash_internal, (GCompareFunc)mono_string_equal_internal, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain String Pool Table");
        domain->num_jit_info_table_duplicates = 0;
        domain->jit_info_table = mono_jit_info_table_new (domain);
        domain->jit_info_free_queue = NULL;
@@ -956,18 +957,6 @@ mono_domain_set_internal_with_options (MonoDomain *domain, gboolean migrate_exce
 }
 
 /**
- * mono_domain_set_internal:
- * \param domain the new domain
- *
- * Sets the current domain to \p domain.
- */
-void
-mono_domain_set_internal (MonoDomain *domain)
-{
-       mono_domain_set_internal_with_options (domain, TRUE);
-}
-
-/**
  * mono_domain_foreach:
  * \param func function to invoke with the domain data
  * \param user_data user-defined pointer that is passed to the supplied \p func fo reach domain
@@ -1044,9 +1033,9 @@ mono_domain_assembly_open_internal (MonoDomain *domain, const char *name)
        if (domain != mono_domain_get ()) {
                current = mono_domain_get ();
 
-               mono_domain_set (domain, FALSE);
+               mono_domain_set_fast (domain, FALSE);
                ass = mono_assembly_request_open (name, &req, NULL);
-               mono_domain_set (current, FALSE);
+               mono_domain_set_fast (current, FALSE);
        } else {
                ass = mono_assembly_request_open (name, &req, NULL);
        }

diff --git a/src/mono/mono/metadata/dynamic-image.c b/src/mono/mono/metadata/dynamic-image.c
index dfc682a..451ba99 100644 (file)
--- a/src/mono/mono/metadata/dynamic-image.c
+++ b/src/mono/mono/metadata/dynamic-image.c
@@ -21,6 +21,7 @@
 #include "mono/metadata/dynamic-stream-internals.h"
 #include "mono/metadata/gc-internals.h"
 #include "mono/metadata/metadata-internals.h"
+#include "mono/metadata/mono-hash-internals.h"
 #include "mono/metadata/profiler-private.h"
 #include "mono/metadata/reflection-internals.h"
 #include "mono/metadata/sre-internals.h"
@@ -167,7 +168,7 @@ mono_dynamic_image_register_token (MonoDynamicImage *assembly, guint32 token, Mo
                        g_assert_not_reached ();
                }
        }
-       mono_g_hash_table_insert (assembly->tokens, GUINT_TO_POINTER (token), MONO_HANDLE_RAW (obj));
+       mono_g_hash_table_insert_internal (assembly->tokens, GUINT_TO_POINTER (token), MONO_HANDLE_RAW (obj));
        dynamic_image_unlock (assembly);
 }
 #else
@@ -358,19 +359,19 @@ mono_dynamic_image_create (MonoDynamicAssembly *assembly, char *assembly_name, c
 
        mono_image_init (&image->image);
 
-       image->token_fixups = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash_internal, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Token Fixup Table");
+       image->token_fixups = mono_g_hash_table_new_type_internal ((GHashFunc)mono_object_hash_internal, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Token Fixup Table");
        image->method_to_table_idx = g_hash_table_new (NULL, NULL);
        image->field_to_table_idx = g_hash_table_new (NULL, NULL);
        image->method_aux_hash = g_hash_table_new (NULL, NULL);
        image->vararg_aux_hash = g_hash_table_new (NULL, NULL);
        image->handleref = g_hash_table_new (NULL, NULL);
-       image->tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Token Table");
-       image->generic_def_objects = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Generic Definition Table");
+       image->tokens = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Token Table");
+       image->generic_def_objects = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Generic Definition Table");
        image->typespec = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
        image->typeref = g_hash_table_new ((GHashFunc)mono_metadata_type_hash, (GCompareFunc)mono_metadata_type_equal);
        image->blob_cache = g_hash_table_new ((GHashFunc)mono_blob_entry_hash, (GCompareFunc)mono_blob_entry_equal);
        image->gen_params = g_ptr_array_new ();
-       image->remapped_tokens = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Remapped Token Table");
+       image->remapped_tokens = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_REFLECTION, NULL, "Reflection Dynamic Image Remapped Token Table");
 
        /*g_print ("string heap create for image %p (%s)\n", image, module_name);*/
        string_heap_init (&image->sheap);

diff --git a/src/mono/mono/metadata/exception.c b/src/mono/mono/metadata/exception.c
index e9fe031..2652bfa 100644 (file)
--- a/src/mono/mono/metadata/exception.c
+++ b/src/mono/mono/metadata/exception.c
@@ -21,6 +21,7 @@
 #include <mono/metadata/object-internals.h>
 #include <mono/metadata/metadata-internals.h>
 #include <mono/metadata/appdomain.h>
+#include <mono/metadata/domain-internals.h>
 #include <mono/metadata/mono-debug.h>
 #include <mono/utils/mono-error-internals.h>
 #include <mono/utils/mono-logger-internals.h>
@@ -102,14 +103,14 @@ mono_exception_new_by_name_domain (MonoDomain *domain, MonoImage *image,
        goto_if_nok (error, return_null);
 
        if (domain != caller_domain)
-               mono_domain_set_internal (domain);
+               mono_domain_set_internal_with_options (domain, TRUE);
 
        mono_runtime_object_init_handle (o, error);
        mono_error_assert_ok (error);
 
        // Restore domain in success and error path.
        if (domain != caller_domain)
-               mono_domain_set_internal (caller_domain);
+               mono_domain_set_internal_with_options (caller_domain, TRUE);
 
        goto_if_ok (error, exit);
 return_null:

diff --git a/src/mono/mono/metadata/external-only.c b/src/mono/mono/metadata/external-only.c
index 8961def..6b64c6b 100644 (file)
--- a/src/mono/mono/metadata/external-only.c
+++ b/src/mono/mono/metadata/external-only.c
@@ -12,6 +12,9 @@
 
 #include "config.h"
 #include "class-internals.h"
+#include "domain-internals.h"
+#include "mono-hash-internals.h"
+#include "mono-config-internals.h"
 #include "object-internals.h"
 #include "class-init.h"
 #include "marshal.h"
@@ -186,3 +189,93 @@ mono_class_init (MonoClass *klass)
 {
        MONO_EXTERNAL_ONLY_GC_UNSAFE (gboolean, mono_class_init_internal (klass));
 }
+
+/**
+ * mono_g_hash_table_new_type:
+ */
+MonoGHashTable*
+mono_g_hash_table_new_type (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg)
+{
+       MONO_EXTERNAL_ONLY_GC_UNSAFE (MonoGHashTable*, mono_g_hash_table_new_type_internal (hash_func, key_equal_func, type, source, key, msg));
+}
+
+/**
+ * mono_config_for_assembly:
+ */
+void 
+mono_config_for_assembly (MonoImage *assembly)
+{
+       MONO_EXTERNAL_ONLY_GC_UNSAFE_VOID (mono_config_for_assembly_internal (assembly));
+}
+
+/**
+ * mono_class_get_property_from_name:
+ * \param klass a class
+ * \param name name of the property to lookup in the specified class
+ *
+ * Use this method to lookup a property in a class
+ * \returns the \c MonoProperty with the given name, or NULL if the property
+ * does not exist on the \p klass.
+ */
+MonoProperty*
+mono_class_get_property_from_name (MonoClass *klass, const char *name)
+{
+       MONO_EXTERNAL_ONLY_GC_UNSAFE (MonoProperty*, mono_class_get_property_from_name_internal (klass, name));
+}
+
+/**
+ * mono_class_is_subclass_of:
+ * \param klass class to probe if it is a subclass of another one
+ * \param klassc the class we suspect is the base class
+ * \param check_interfaces whether we should perform interface checks
+ *
+ * This method determines whether \p klass is a subclass of \p klassc.
+ *
+ * If the \p check_interfaces flag is set, then if \p klassc is an interface
+ * this method return TRUE if the \p klass implements the interface or
+ * if \p klass is an interface, if one of its base classes is \p klass.
+ *
+ * If \p check_interfaces is false, then if \p klass is not an interface,
+ * it returns TRUE if the \p klass is a subclass of \p klassc.
+ *
+ * if \p klass is an interface and \p klassc is \c System.Object, then this function
+ * returns TRUE.
+ *
+ */
+gboolean
+mono_class_is_subclass_of (MonoClass *klass, MonoClass *klassc, gboolean check_interfaces)
+{
+       MONO_EXTERNAL_ONLY_GC_UNSAFE (gboolean, mono_class_is_subclass_of_internal (klass, klassc, check_interfaces));
+}
+
+/**
+ * mono_domain_set_internal:
+ * \param domain the new domain
+ *
+ * Sets the current domain to \p domain.
+ */
+void
+mono_domain_set_internal (MonoDomain *domain)
+{
+       MONO_EXTERNAL_ONLY_GC_UNSAFE_VOID (mono_domain_set_internal_with_options (domain, TRUE));
+}
+
+/**
+ * mono_domain_set:
+ * \param domain domain
+ * \param force force setting.
+ *
+ * Set the current appdomain to \p domain. If \p force is set, set it even
+ * if it is being unloaded.
+ *
+ * \returns TRUE on success; FALSE if the domain is unloaded
+ */
+gboolean
+mono_domain_set (MonoDomain *domain, gboolean force)
+{
+       if (!force && domain->state == MONO_APPDOMAIN_UNLOADED)
+               return FALSE;
+
+       MONO_EXTERNAL_ONLY_GC_UNSAFE_VOID (mono_domain_set_internal_with_options (domain, TRUE));
+       return TRUE;
+}

diff --git a/src/mono/mono/metadata/gc.c b/src/mono/mono/metadata/gc.c
index 21cf9be..362a7fa 100644 (file)
--- a/src/mono/mono/metadata/gc.c
+++ b/src/mono/mono/metadata/gc.c
@@ -257,7 +257,7 @@ mono_gc_run_finalize (void *obj, void *data)
        /* g_print ("Finalize run on %p %s.%s\n", o, mono_object_class (o)->name_space, mono_object_class (o)->name); */
 
        /* Use _internal here, since this thread can enter a doomed appdomain */
-       mono_domain_set_internal (mono_object_domain (o));
+       mono_domain_set_internal_with_options (mono_object_domain (o), TRUE);
 
        /* delegates that have a native function pointer allocated are
         * registered for finalization, but they don't have a Finalize
@@ -267,7 +267,7 @@ mono_gc_run_finalize (void *obj, void *data)
                MonoDelegate* del = (MonoDelegate*)o;
                if (del->delegate_trampoline)
                        mono_delegate_free_ftnptr ((MonoDelegate*)o);
-               mono_domain_set_internal (caller_domain);
+               mono_domain_set_internal_with_options (caller_domain, TRUE);
                return;
        }
 
@@ -280,7 +280,7 @@ mono_gc_run_finalize (void *obj, void *data)
         * of finalizer on object with CCW.
         */
        if (mono_marshal_free_ccw (o) && !finalizer) {
-               mono_domain_set_internal (caller_domain);
+               mono_domain_set_internal_with_options (caller_domain, TRUE);
                return;
        }
 
@@ -339,7 +339,7 @@ unhandled_error:
        if (exc)
                mono_thread_internal_unhandled_exception (exc);
 
-       mono_domain_set_internal (caller_domain);
+       mono_domain_set_internal_with_options (caller_domain, TRUE);
 }
 
 /*

diff --git a/src/mono/mono/metadata/icall.c b/src/mono/mono/metadata/icall.c
index dff3c09..db7c0ac 100644 (file)
--- a/src/mono/mono/metadata/icall.c
+++ b/src/mono/mono/metadata/icall.c
@@ -882,7 +882,7 @@ ves_icall_System_Array_FastCopy (MonoArrayHandle source, int source_idx, MonoArr
                        return FALSE;
 
                /* It's only safe to copy between arrays if we can ensure the source will always have a subtype of the destination. We bail otherwise. */
-               if (!mono_class_is_subclass_of (src_class, dest_class, FALSE))
+               if (!mono_class_is_subclass_of_internal (src_class, dest_class, FALSE))
                        return FALSE;
 
                if (m_class_is_native_pointer (src_class) || m_class_is_native_pointer (dest_class))
@@ -1957,13 +1957,13 @@ ves_icall_RuntimeTypeHandle_is_subclass_of (MonoType *childType, MonoType *baseT
                                break;
                        }
                        if (!is_generic_parameter (m_class_get_byval_arg (c))) {
-                               result = mono_class_is_subclass_of (c, baseClass, FALSE);
+                               result = mono_class_is_subclass_of_internal (c, baseClass, FALSE);
                                break;
                        } else
                                c = mono_generic_param_get_base_type (c);
                }
        } else {
-               result = mono_class_is_subclass_of (childClass, baseClass, FALSE);
+               result = mono_class_is_subclass_of_internal (childClass, baseClass, FALSE);
        }
 done:
        mono_error_set_pending_exception (error);
@@ -7636,7 +7636,7 @@ ves_icall_Remoting_RemotingServices_GetVirtualMethod (
                return ret;
 
        if ((method->flags & METHOD_ATTRIBUTE_FINAL) || !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) {
-               if (klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE))
+               if (klass == method->klass || mono_class_is_subclass_of_internal (klass, method->klass, FALSE))
                        ret = rmethod;
                return ret;
        }
@@ -7652,7 +7652,7 @@ ves_icall_Remoting_RemotingServices_GetVirtualMethod (
                if (offs >= 0)
                        res = vtable [offs + method->slot];
        } else {
-               if (!(klass == method->klass || mono_class_is_subclass_of (klass, method->klass, FALSE)))
+               if (!(klass == method->klass || mono_class_is_subclass_of_internal (klass, method->klass, FALSE)))
                        return ret;
 
                if (method->slot != -1)

diff --git a/src/mono/mono/metadata/marshal.c b/src/mono/mono/metadata/marshal.c
index 1df30ef..1d10921 100644 (file)
--- a/src/mono/mono/metadata/marshal.c
+++ b/src/mono/mono/metadata/marshal.c
@@ -3283,7 +3283,7 @@ mono_emit_marshal (EmitMarshalContext *m, int argnum, MonoType *t,
 #endif
 
                if (mono_class_try_get_safehandle_class () != NULL && t->data.klass &&
-                   mono_class_is_subclass_of (t->data.klass,  mono_class_try_get_safehandle_class (), FALSE))
+                   mono_class_is_subclass_of_internal (t->data.klass,  mono_class_try_get_safehandle_class (), FALSE))
                        return get_marshal_cb ()->emit_marshal_safehandle (m, argnum, t, spec, conv_arg, conv_arg_type, action);
                
                return get_marshal_cb ()->emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);

diff --git a/src/mono/mono/metadata/mono-config-internals.h b/src/mono/mono/metadata/mono-config-internals.h
new file mode 100644 (file)
index 0000000..ce26f5d
--- /dev/null
+++ b/src/mono/mono/metadata/mono-config-internals.h
@@ -0,0 +1,13 @@
+/**
+ * \file
+ */
+
+#ifndef __MONO_METADATA_CONFIG_INTERNALS_H__
+#define __MONO_METADATA_CONFIG_INTERNALS_H__
+
+#include "mono/metadata/mono-config.h"
+
+void 
+mono_config_for_assembly_internal (MonoImage *assembly);
+
+#endif /* __MONO_METADATA_CONFIG_INTERNALS_H__ */

diff --git a/src/mono/mono/metadata/mono-config.c b/src/mono/mono/metadata/mono-config.c
index 425479e..8c1c644 100644 (file)
--- a/src/mono/mono/metadata/mono-config.c
+++ b/src/mono/mono/metadata/mono-config.c
@@ -16,6 +16,7 @@
 #include "mono/metadata/assembly.h"
 #include "mono/metadata/loader.h"
 #include "mono/metadata/mono-config.h"
+#include "mono/metadata/mono-config-internals.h"
 #include "mono/metadata/metadata-internals.h"
 #include "mono/metadata/object-internals.h"
 #include "mono/utils/mono-logger-internals.h"
@@ -99,8 +100,6 @@
 #endif
 #endif
 
-static void mono_config_for_assembly_internal (MonoImage *assembly);
-
 /**
  * mono_config_get_os:
  *
@@ -608,17 +607,6 @@ mono_config_string_for_assembly_file (const char *filename)
        return NULL;
 }
 
-/**
- * mono_config_for_assembly:
- */
-void 
-mono_config_for_assembly (MonoImage *assembly)
-{
-       MONO_ENTER_GC_UNSAFE;
-       mono_config_for_assembly_internal (assembly);
-       MONO_EXIT_GC_UNSAFE;
-}
-
 void
 mono_config_for_assembly_internal (MonoImage *assembly)
 {

diff --git a/src/mono/mono/metadata/mono-config.h b/src/mono/mono/metadata/mono-config.h
index daebd02..91cdccd 100644 (file)
--- a/src/mono/mono/metadata/mono-config.h
+++ b/src/mono/mono/metadata/mono-config.h
@@ -24,7 +24,7 @@ MONO_API const char* mono_get_machine_config (void);
 
 MONO_API void mono_config_cleanup      (void);
 MONO_API void mono_config_parse        (const char *filename);
-MONO_API void mono_config_for_assembly (MonoImage *assembly);
+MONO_API MONO_RT_EXTERNAL_ONLY void mono_config_for_assembly (MonoImage *assembly);
 MONO_API void mono_config_parse_memory (const char *buffer);
 
 MONO_API const char* mono_config_string_for_assembly_file (const char *filename);

diff --git a/src/mono/mono/metadata/mono-hash-internals.h b/src/mono/mono/metadata/mono-hash-internals.h
new file mode 100644 (file)
index 0000000..1ba508b
--- /dev/null
+++ b/src/mono/mono/metadata/mono-hash-internals.h
@@ -0,0 +1,17 @@
+/**
+ * \file
+ */
+
+#ifndef __MONO_G_HASH_INTERNALS_H__
+#define __MONO_G_HASH_INTERNALS_H__
+
+#include "mono/metadata/mono-hash.h"
+#include "mono/metadata/mono-gc.h"
+
+MonoGHashTable *
+mono_g_hash_table_new_type_internal (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg);
+
+void 
+mono_g_hash_table_insert_internal (MonoGHashTable *h, gpointer k, gpointer v);
+
+#endif /* __MONO_G_HASH_INTERNALS_H__ */

diff --git a/src/mono/mono/metadata/mono-hash.c b/src/mono/mono/metadata/mono-hash.c
index 1fedfde..0323f01 100644 (file)
--- a/src/mono/mono/metadata/mono-hash.c
+++ b/src/mono/mono/metadata/mono-hash.c
@@ -30,8 +30,11 @@
 #include <stdio.h>
 #include <math.h>
 #include <glib.h>
+
 #include "mono-hash.h"
+#include "mono-hash-internals.h"
 #include "metadata/gc-internals.h"
+
 #include <mono/utils/checked-build.h>
 #include <mono/utils/mono-threads-coop.h>
 #include <mono/utils/unlocked.h>
@@ -53,9 +56,6 @@ struct _MonoGHashTable {
        const char *msg;
 };
 
-MonoGHashTable *
-mono_g_hash_table_new_type_internal (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg);
-
 #if UNUSED
 static gboolean
 test_prime (int x)
@@ -140,18 +140,6 @@ static inline int mono_g_hash_table_find_slot (MonoGHashTable *hash, const MonoO
        return i;
 }
 
-
-MonoGHashTable *
-mono_g_hash_table_new_type (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg)
-{
-       MonoGHashTable *result;
-       MONO_ENTER_GC_UNSAFE;
-       result = mono_g_hash_table_new_type_internal (hash_func, key_equal_func, type, source, key, msg);
-       MONO_EXIT_GC_UNSAFE;
-       return result;
-}
-
-
 MonoGHashTable *
 mono_g_hash_table_new_type_internal (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg)
 {
@@ -481,10 +469,17 @@ void
 mono_g_hash_table_insert (MonoGHashTable *h, gpointer k, gpointer v)
 {
        MONO_ENTER_GC_UNSAFE;
-       mono_g_hash_table_insert_replace (h, k, v, FALSE);
+       mono_g_hash_table_insert_internal (h, k, v);
        MONO_EXIT_GC_UNSAFE;
 }
 
+void
+mono_g_hash_table_insert_internal (MonoGHashTable *h, gpointer k, gpointer v)
+{
+       MONO_REQ_GC_UNSAFE_MODE;
+       mono_g_hash_table_insert_replace (h, k, v, FALSE);
+}
+
 /**
  * mono_g_hash_table_replace:
  */

diff --git a/src/mono/mono/metadata/mono-hash.h b/src/mono/mono/metadata/mono-hash.h
index a64e532..3082001 100644 (file)
--- a/src/mono/mono/metadata/mono-hash.h
+++ b/src/mono/mono/metadata/mono-hash.h
@@ -25,7 +25,8 @@ extern gint32 mono_g_hash_table_max_chain_length;
 
 typedef struct _MonoGHashTable MonoGHashTable;
 
-MONO_API MonoGHashTable *mono_g_hash_table_new_type (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg);
+MONO_API MONO_RT_EXTERNAL_ONLY MonoGHashTable *
+mono_g_hash_table_new_type (GHashFunc hash_func, GEqualFunc key_equal_func, MonoGHashGCType type, MonoGCRootSource source, void *key, const char *msg);
 MONO_API guint    mono_g_hash_table_size            (MonoGHashTable *hash);
 MONO_API gpointer mono_g_hash_table_lookup          (MonoGHashTable *hash, gconstpointer key);
 MONO_API gboolean mono_g_hash_table_lookup_extended (MonoGHashTable *hash, gconstpointer key, gpointer *orig_key, gpointer *value);
@@ -34,7 +35,7 @@ MONO_API gpointer mono_g_hash_table_find            (MonoGHashTable *hash, GHRFu
 MONO_API gboolean mono_g_hash_table_remove          (MonoGHashTable *hash, gconstpointer key);
 MONO_API guint    mono_g_hash_table_foreach_remove  (MonoGHashTable *hash, GHRFunc func, gpointer user_data);
 MONO_API void     mono_g_hash_table_destroy         (MonoGHashTable *hash);
-MONO_API void     mono_g_hash_table_insert          (MonoGHashTable *h, gpointer k, gpointer v);
+MONO_API MONO_RT_EXTERNAL_ONLY void mono_g_hash_table_insert (MonoGHashTable *h, gpointer k, gpointer v);
 MONO_API void     mono_g_hash_table_replace         (MonoGHashTable *h, gpointer k, gpointer v);
 MONO_API void     mono_g_hash_table_print_stats     (MonoGHashTable *table);
 

diff --git a/src/mono/mono/metadata/object.c b/src/mono/mono/metadata/object.c
index 4af7470..184854e 100644 (file)
--- a/src/mono/mono/metadata/object.c
+++ b/src/mono/mono/metadata/object.c
@@ -32,6 +32,7 @@
 #include "mono/metadata/class-init.h"
 #include <mono/metadata/assembly.h>
 #include <mono/metadata/marshal.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include "mono/metadata/debug-helpers.h"
 #include <mono/metadata/threads.h>
 #include <mono/metadata/threads-types.h>
@@ -487,7 +488,7 @@ mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error)
                if (mono_domain_get () != domain) {
                        /* Transfer into the target domain */
                        last_domain = mono_domain_get ();
-                       if (!mono_domain_set (domain, FALSE)) {
+                       if (!mono_domain_set_fast (domain, FALSE)) {
                                vtable->initialized = 1;
                                mono_type_initialization_unlock ();
                                mono_error_set_exception_instance (error, mono_get_exception_appdomain_unloaded ());
@@ -578,13 +579,13 @@ mono_runtime_class_init_full (MonoVTable *vtable, MonoError *error)
                         */
                        mono_domain_lock (domain);
                        if (!domain->type_init_exception_hash)
-                               domain->type_init_exception_hash = mono_g_hash_table_new_type (mono_aligned_addr_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Type Initialization Exception Table");
-                       mono_g_hash_table_insert (domain->type_init_exception_hash, klass, exc_to_throw);
+                               domain->type_init_exception_hash = mono_g_hash_table_new_type_internal (mono_aligned_addr_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Type Initialization Exception Table");
+                       mono_g_hash_table_insert_internal (domain->type_init_exception_hash, klass, exc_to_throw);
                        mono_domain_unlock (domain);
                }
 
                if (last_domain)
-                       mono_domain_set (last_domain, TRUE);
+                       mono_domain_set_fast (last_domain, TRUE);
 
                /* Signal to the other threads that we are done */
                mono_type_init_lock (lock);
@@ -7451,7 +7452,7 @@ mono_string_is_interned_lookup (MonoStringHandle str, gboolean insert, MonoError
        if (res)
                MONO_HANDLE_ASSIGN_RAW (s, res);
        else
-               mono_g_hash_table_insert (ldstr_table, MONO_HANDLE_RAW (s), MONO_HANDLE_RAW (s));
+               mono_g_hash_table_insert_internal (ldstr_table, MONO_HANDLE_RAW (s), MONO_HANDLE_RAW (s));
        ldstr_unlock ();
        return s;
 }
@@ -8099,7 +8100,7 @@ mono_wait_handle_new (MonoDomain *domain, HANDLE handle, MonoError *error)
 
        /* Even though this method is virtual, it's safe to invoke directly, since the object type matches.  */
        if (!handle_set)
-               handle_set = mono_class_get_property_from_name (mono_defaults.manualresetevent_class, "Handle")->set;
+               handle_set = mono_class_get_property_from_name_internal (mono_defaults.manualresetevent_class, "Handle")->set;
 
        params [0] = &handle;
 

diff --git a/src/mono/mono/metadata/reflection.c b/src/mono/mono/metadata/reflection.c
index 0c51604..f51462b 100644 (file)
--- a/src/mono/mono/metadata/reflection.c
+++ b/src/mono/mono/metadata/reflection.c
@@ -45,6 +45,7 @@
 #include <mono/metadata/debug-helpers.h>
 #include <mono/metadata/verify-internals.h>
 #include <mono/metadata/mono-ptr-array.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include <mono/utils/mono-string.h>
 #include <mono/utils/mono-error-internals.h>
 #include <mono/utils/checked-build.h>
@@ -500,7 +501,7 @@ mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *err
        mono_loader_lock (); /*FIXME mono_class_init_internal and mono_class_vtable acquire it*/
        mono_domain_lock (domain);
        if (!domain->type_hash)
-               domain->type_hash = mono_g_hash_table_new_type ((GHashFunc)mono_metadata_type_hash, 
+               domain->type_hash = mono_g_hash_table_new_type_internal ((GHashFunc)mono_metadata_type_hash, 
                                (GCompareFunc)mono_metadata_type_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DOMAIN, domain, "Domain Reflection Type Table");
        if ((res = (MonoReflectionType *)mono_g_hash_table_lookup (domain->type_hash, type))) {
                mono_domain_unlock (domain);
@@ -523,7 +524,7 @@ mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *err
                        mono_loader_unlock ();
                        return NULL;
                }
-               mono_g_hash_table_insert (domain->type_hash, type, res);
+               mono_g_hash_table_insert_internal (domain->type_hash, type, res);
                mono_domain_unlock (domain);
                mono_loader_unlock ();
                return res;
@@ -566,7 +567,7 @@ mono_type_get_object_checked (MonoDomain *domain, MonoType *type, MonoError *err
        }
 
        res->type = type;
-       mono_g_hash_table_insert (domain->type_hash, type, res);
+       mono_g_hash_table_insert_internal (domain->type_hash, type, res);
 
        if (type->type == MONO_TYPE_VOID)
                domain->typeof_void = (MonoObject*)res;
@@ -2648,7 +2649,7 @@ ves_icall_RuntimeMethodInfo_MakeGenericMethod_impl (MonoReflectionMethodHandle r
                 * to the reflection objects representing their generic definitions.
                 */
                mono_image_lock ((MonoImage*)image);
-               mono_g_hash_table_insert (image->generic_def_objects, imethod, MONO_HANDLE_RAW (rmethod));
+               mono_g_hash_table_insert_internal (image->generic_def_objects, imethod, MONO_HANDLE_RAW (rmethod));
                mono_image_unlock ((MonoImage*)image);
        }
 

diff --git a/src/mono/mono/metadata/remoting.c b/src/mono/mono/metadata/remoting.c
index 0935b0e..148d069 100644 (file)
--- a/src/mono/mono/metadata/remoting.c
+++ b/src/mono/mono/metadata/remoting.c
@@ -22,6 +22,7 @@
 #include "mono/metadata/tabledefs.h"
 #include "mono/metadata/exception.h"
 #include "mono/metadata/debug-helpers.h"
+#include "mono/metadata/domain-internals.h"
 #include "mono/metadata/reflection-internals.h"
 #include "mono/metadata/assembly.h"
 #include "icall-decl.h"
@@ -624,7 +625,7 @@ mono_marshal_set_domain_by_id (gint32 id, MonoBoolean push)
        MonoDomain *current_domain = mono_domain_get ();
        MonoDomain *domain = mono_domain_get_by_id (id);
 
-       if (!domain || !mono_domain_set (domain, FALSE)) {
+       if (!domain || !mono_domain_set_fast (domain, FALSE)) {
                mono_set_pending_exception (mono_get_exception_appdomain_unloaded ());
                return 0;
        }

diff --git a/src/mono/mono/metadata/sre-save.c b/src/mono/mono/metadata/sre-save.c
index a741da8..a4787ee 100644 (file)
--- a/src/mono/mono/metadata/sre-save.c
+++ b/src/mono/mono/metadata/sre-save.c
@@ -20,6 +20,7 @@
 #include "mono/metadata/dynamic-image-internals.h"
 #include "mono/metadata/dynamic-stream-internals.h"
 #include "mono/metadata/mono-ptr-array.h"
+#include "mono/metadata/mono-hash-internals.h"
 #include "mono/metadata/object-internals.h"
 #include "mono/metadata/sre-internals.h"
 #include "mono/metadata/security-manager.h"
@@ -240,7 +241,7 @@ mono_image_add_cattrs (MonoDynamicImage *assembly, guint32 idx, guint32 type, Mo
                         * fixup_cattrs () needs to fix this up. We can't use image->tokens, since it contains the old token for the
                         * method, not the one returned by mono_image_create_token ().
                         */
-                       mono_g_hash_table_insert (assembly->remapped_tokens, GUINT_TO_POINTER (token), cattr->ctor);
+                       mono_g_hash_table_insert_internal (assembly->remapped_tokens, GUINT_TO_POINTER (token), cattr->ctor);
                        break;
                case MONO_TABLE_MEMBERREF:
                        type |= MONO_CUSTOM_ATTR_TYPE_MEMBERREF;
@@ -388,7 +389,7 @@ method_encode_code (MonoDynamicImage *assembly, ReflectionMethodBuilder *mb, Mon
                idx = mono_image_add_stream_data (&assembly->code, &flags, 1);
                /* add to the fixup todo list */
                if (mb->ilgen && mb->ilgen->num_token_fixups)
-                       mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 1));
+                       mono_g_hash_table_insert_internal (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 1));
                mono_image_add_stream_data (&assembly->code, mono_array_addr_internal (code, char, 0), code_size);
                return assembly->text_rva + idx;
        } 
@@ -417,7 +418,7 @@ fat_header:
        idx = mono_image_add_stream_data (&assembly->code, fat_header, 12);
        /* add to the fixup todo list */
        if (mb->ilgen && mb->ilgen->num_token_fixups)
-               mono_g_hash_table_insert (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 12));
+               mono_g_hash_table_insert_internal (assembly->token_fixups, mb->ilgen, GUINT_TO_POINTER (idx + 12));
        
        mono_image_add_stream_data (&assembly->code, mono_array_addr_internal (code, char, 0), code_size);
        if (num_exception) {

diff --git a/src/mono/mono/metadata/threadpool-io.c b/src/mono/mono/metadata/threadpool-io.c
index 14cc5c3..7fb51b4 100644 (file)
--- a/src/mono/mono/metadata/threadpool-io.c
+++ b/src/mono/mono/metadata/threadpool-io.c
@@ -23,6 +23,7 @@
 #endif
 
 #include <mono/metadata/gc-internals.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include <mono/metadata/mono-mlist.h>
 #include <mono/metadata/threadpool.h>
 #include <mono/utils/atomic.h>
@@ -337,7 +338,7 @@ selector_thread (gpointer data)
                return 0;
        }
 
-       states = mono_g_hash_table_new_type (g_direct_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_THREAD_POOL, NULL, "Thread Pool I/O State Table");
+       states = mono_g_hash_table_new_type_internal (g_direct_hash, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_THREAD_POOL, NULL, "Thread Pool I/O State Table");
 
        while (!mono_runtime_is_shutting_down ()) {
                gint i, j;

diff --git a/src/mono/mono/metadata/threadpool.c b/src/mono/mono/metadata/threadpool.c
index f1ea753..d64d9fe 100644 (file)
--- a/src/mono/mono/metadata/threadpool.c
+++ b/src/mono/mono/metadata/threadpool.c
@@ -28,6 +28,7 @@
 #include <glib.h>
 
 #include <mono/metadata/class-internals.h>
+#include <mono/metadata/domain-internals.h>
 #include <mono/metadata/exception.h>
 #include <mono/metadata/gc-internals.h>
 #include <mono/metadata/object.h>
@@ -186,11 +187,11 @@ mono_threadpool_enqueue_work_item (MonoDomain *domain, MonoObject *work_item, Mo
                mono_runtime_invoke_checked (unsafe_queue_custom_work_item_method, NULL, args, error);
        } else {
                mono_thread_push_appdomain_ref (domain);
-               if (mono_domain_set (domain, FALSE)) {
+               if (mono_domain_set_fast (domain, FALSE)) {
                        mono_runtime_invoke_checked (unsafe_queue_custom_work_item_method, NULL, args, error);
-                       mono_domain_set (current_domain, TRUE);
+                       mono_domain_set_fast (current_domain, TRUE);
                } else {
-                       // mono_domain_set failing still leads to success.
+                       // mono_domain_set_fast failing still leads to success.
                }
                mono_thread_pop_appdomain_ref ();
        }
@@ -361,7 +362,7 @@ worker_callback (void)
                        ThreadState_Background);
 
                mono_thread_push_appdomain_ref (tpdomain->domain);
-               if (mono_domain_set (tpdomain->domain, FALSE)) {
+               if (mono_domain_set_fast (tpdomain->domain, FALSE)) {
                        MonoObject *exc = NULL, *res;
 
                        res = try_invoke_perform_wait_callback (&exc, error);
@@ -375,7 +376,7 @@ worker_callback (void)
                                retire = TRUE;
                        }
 
-                       mono_domain_set (mono_get_root_domain (), TRUE);
+                       mono_domain_set_fast (mono_get_root_domain (), TRUE);
                }
                mono_thread_pop_appdomain_ref ();
 

diff --git a/src/mono/mono/metadata/threads.c b/src/mono/mono/metadata/threads.c
index 5ab77cb..913f01e 100644 (file)
--- a/src/mono/mono/metadata/threads.c
+++ b/src/mono/mono/metadata/threads.c
@@ -26,6 +26,7 @@
 #include <mono/metadata/exception.h>
 #include <mono/metadata/environment.h>
 #include <mono/metadata/monitor.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include <mono/metadata/gc-internals.h>
 #include <mono/metadata/marshal.h>
 #include <mono/metadata/runtime.h>
@@ -875,7 +876,7 @@ mono_thread_attach_internal (MonoThread *thread, gboolean force_attach, gboolean
        domain = mono_object_domain (thread);
 
        mono_thread_push_appdomain_ref (domain);
-       if (!mono_domain_set (domain, force_domain)) {
+       if (!mono_domain_set_fast (domain, force_domain)) {
                mono_thread_pop_appdomain_ref ();
                goto fail;
        }
@@ -892,12 +893,12 @@ mono_thread_attach_internal (MonoThread *thread, gboolean force_attach, gboolean
                mono_g_hash_table_remove (threads_starting_up, thread);
 
        if (!threads) {
-               threads = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_THREADING, NULL, "Thread Table");
+               threads = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_THREADING, NULL, "Thread Table");
        }
 
        /* We don't need to duplicate thread->handle, because it is
         * only closed when the thread object is finalized by the GC. */
-       mono_g_hash_table_insert (threads, (gpointer)(gsize)(internal->tid), internal);
+       mono_g_hash_table_insert_internal (threads, (gpointer)(gsize)(internal->tid), internal);
 
        /* We have to do this here because mono_thread_start_cb
         * requires that root_domain_thread is set up. */
@@ -1341,9 +1342,9 @@ create_thread (MonoThread *thread, MonoInternalThread *internal, MonoObject *sta
                return FALSE;
        }
        if (threads_starting_up == NULL) {
-               threads_starting_up = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_THREADING, NULL, "Thread Starting Table");
+               threads_starting_up = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_KEY_VALUE_GC, MONO_ROOT_SOURCE_THREADING, NULL, "Thread Starting Table");
        }
-       mono_g_hash_table_insert (threads_starting_up, thread, thread);
+       mono_g_hash_table_insert_internal (threads_starting_up, thread, thread);
        mono_threads_unlock ();
 
        internal->threadpool_thread = flags & MONO_THREAD_CREATE_FLAGS_THREADPOOL;
@@ -1502,7 +1503,7 @@ mono_thread_attach (MonoDomain *domain)
 
        if (mono_thread_internal_current_is_attached ()) {
                if (domain != mono_domain_get ())
-                       mono_domain_set (domain, TRUE);
+                       mono_domain_set_fast (domain, TRUE);
                /* Already attached */
                return mono_thread_current ();
        }
@@ -6076,9 +6077,6 @@ mono_threads_attach_coop_internal (MonoDomain *domain, gpointer *cookie, MonoSta
                mono_thread_set_state (mono_thread_internal_current (), ThreadState_Background);
        }
 
-       if (orig != domain)
-               mono_domain_set (domain, TRUE);
-
        if (mono_threads_is_blocking_transition_enabled ()) {
                if (external) {
                        /* mono_thread_attach put the thread in RUNNING mode from STARTING, but we need to
@@ -6090,6 +6088,9 @@ mono_threads_attach_coop_internal (MonoDomain *domain, gpointer *cookie, MonoSta
                }
        }
 
+       if (orig != domain)
+               mono_domain_set_fast (domain, TRUE);
+
        return orig;
 }
 
@@ -6125,17 +6126,17 @@ mono_threads_detach_coop_internal (MonoDomain *orig, gpointer cookie, MonoStackD
        MonoDomain *domain = mono_domain_get ();
        g_assert (domain);
 
-       if (mono_threads_is_blocking_transition_enabled ()) {
-               /* it won't do anything if cookie is NULL
-                * thread state RUNNING -> (RUNNING|BLOCKING) */
-               mono_threads_exit_gc_unsafe_region_unbalanced_internal (cookie, stackdata);
-       }
-
        if (orig != domain) {
                if (!orig)
                        mono_domain_unset ();
                else
-                       mono_domain_set (orig, TRUE);
+                       mono_domain_set_fast (orig, TRUE);
+       }
+
+       if (mono_threads_is_blocking_transition_enabled ()) {
+               /* it won't do anything if cookie is NULL
+                * thread state RUNNING -> (RUNNING|BLOCKING) */
+               mono_threads_exit_gc_unsafe_region_unbalanced_internal (cookie, stackdata);
        }
 }
 

diff --git a/src/mono/mono/mini/debugger-agent.c b/src/mono/mono/mini/debugger-agent.c
index b1a4841..56f54b9 100644 (file)
--- a/src/mono/mono/mini/debugger-agent.c
+++ b/src/mono/mono/mini/debugger-agent.c
@@ -55,8 +55,10 @@
 
 #include <mono/metadata/mono-debug.h>
 #include <mono/metadata/debug-internals.h>
+#include <mono/metadata/domain-internals.h>
 #include <mono/metadata/gc-internals.h>
 #include <mono/metadata/environment.h>
+#include <mono/metadata/mono-hash-internals.h>
 #include <mono/metadata/threads-types.h>
 #include <mono/metadata/threadpool.h>
 #include <mono/metadata/assembly.h>
@@ -977,11 +979,11 @@ debugger_agent_init (void)
        /* Needed by the hash_table_new_type () call below */
        mono_gc_base_init ();
 
-       thread_to_tls = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash_internal, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger TLS Table");
+       thread_to_tls = mono_g_hash_table_new_type_internal ((GHashFunc)mono_object_hash_internal, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger TLS Table");
 
-       tid_to_thread = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger Thread Table");
+       tid_to_thread = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger Thread Table");
 
-       tid_to_thread_obj = mono_g_hash_table_new_type (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger Thread Object Table");
+       tid_to_thread_obj = mono_g_hash_table_new_type_internal (NULL, NULL, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger Thread Object Table");
 
        pending_assembly_loads = g_ptr_array_new ();
 
@@ -1920,7 +1922,7 @@ objrefs_init (void)
 {
        objrefs = g_hash_table_new_full (NULL, NULL, NULL, mono_debugger_free_objref);
        obj_to_objref = g_hash_table_new (NULL, NULL);
-       suspended_objs = mono_g_hash_table_new_type ((GHashFunc)mono_object_hash_internal, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger Suspended Object Table");
+       suspended_objs = mono_g_hash_table_new_type_internal ((GHashFunc)mono_object_hash_internal, NULL, MONO_HASH_KEY_GC, MONO_ROOT_SOURCE_DEBUGGER, NULL, "Debugger Suspended Object Table");
 }
 
 static void
@@ -1948,7 +1950,7 @@ get_objref (MonoObject *obj)
                 * Have to keep object refs created during suspensions alive for the duration of the suspension, so GCs during invokes don't collect them.
                 */
                dbg_lock ();
-               mono_g_hash_table_insert (suspended_objs, obj, NULL);
+               mono_g_hash_table_insert_internal (suspended_objs, obj, NULL);
                dbg_unlock ();
        }
 
@@ -3964,9 +3966,9 @@ thread_startup (MonoProfiler *prof, uintptr_t tid)
        DEBUG_PRINTF (1, "[%p] Thread started, obj=%p, tls=%p.\n", (gpointer)tid, thread, tls);
 
        mono_loader_lock ();
-       mono_g_hash_table_insert (thread_to_tls, thread, tls);
-       mono_g_hash_table_insert (tid_to_thread, (gpointer)tid, thread);
-       mono_g_hash_table_insert (tid_to_thread_obj, GUINT_TO_POINTER (tid), mono_thread_current ());
+       mono_g_hash_table_insert_internal (thread_to_tls, thread, tls);
+       mono_g_hash_table_insert_internal (tid_to_thread, (gpointer)tid, thread);
+       mono_g_hash_table_insert_internal (tid_to_thread_obj, GUINT_TO_POINTER (tid), mono_thread_current ());
        mono_loader_unlock ();
 
        process_profiler_event (EVENT_KIND_THREAD_START, thread);
@@ -4135,13 +4137,13 @@ send_types_for_domain (MonoDomain *domain, void *user_data)
 
        old_domain = mono_domain_get ();
 
-       mono_domain_set (domain, TRUE);
+       mono_domain_set_fast (domain, TRUE);
        
        mono_loader_lock ();
        g_hash_table_foreach (info->loaded_classes, emit_type_load, NULL);
        mono_loader_unlock ();
 
-       mono_domain_set (old_domain, TRUE);
+       mono_domain_set_fast (old_domain, TRUE);
 }
 
 static void
@@ -4152,7 +4154,7 @@ send_assemblies_for_domain (MonoDomain *domain, void *user_data)
 
        old_domain = mono_domain_get ();
 
-       mono_domain_set (domain, TRUE);
+       mono_domain_set_fast (domain, TRUE);
 
        mono_domain_assemblies_lock (domain);
        for (tmp = domain->domain_assemblies; tmp; tmp = tmp->next) {
@@ -4161,7 +4163,7 @@ send_assemblies_for_domain (MonoDomain *domain, void *user_data)
        }
        mono_domain_assemblies_unlock (domain);
 
-       mono_domain_set (old_domain, TRUE);
+       mono_domain_set_fast (old_domain, TRUE);
 }
 
 static void
@@ -7311,7 +7313,7 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
                MonoDomain *d = mono_domain_get ();
 
                /* This is needed to be able to find referenced assemblies */
-               res = mono_domain_set (domain, FALSE);
+               res = mono_domain_set_fast (domain, FALSE);
                g_assert (res);
 
                if (!mono_reflection_parse_type_checked (s, &info, error)) {
@@ -7332,7 +7334,7 @@ assembly_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
                mono_reflection_free_type_info (&info);
                g_free (s);
 
-               mono_domain_set (d, TRUE);
+               mono_domain_set_fast (d, TRUE);
 
                break;
        }
@@ -8093,11 +8095,11 @@ type_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 
        old_domain = mono_domain_get ();
 
-       mono_domain_set (domain, TRUE);
+       mono_domain_set_fast (domain, TRUE);
 
        err = type_commands_internal (command, klass, domain, p, end, buf);
 
-       mono_domain_set (old_domain, TRUE);
+       mono_domain_set_fast (old_domain, TRUE);
 
        return err;
 }
@@ -8546,11 +8548,11 @@ method_commands (int command, guint8 *p, guint8 *end, Buffer *buf)
 
        old_domain = mono_domain_get ();
 
-       mono_domain_set (domain, TRUE);
+       mono_domain_set_fast (domain, TRUE);
 
        err = method_commands_internal (command, method, domain, p, end, buf);
 
-       mono_domain_set (old_domain, TRUE);
+       mono_domain_set_fast (old_domain, TRUE);
 
        return err;
 }

diff --git a/src/mono/mono/mini/interp/transform.c b/src/mono/mono/mini/interp/transform.c
index 8c9f46d..193dfa2 100644 (file)
--- a/src/mono/mono/mini/interp/transform.c
+++ b/src/mono/mono/mini/interp/transform.c
@@ -10,6 +10,7 @@
 #include "config.h"
 #include <string.h>
 #include <mono/metadata/appdomain.h>
+#include <mono/metadata/class-internals.h>
 #include <mono/metadata/debug-helpers.h>
 #include <mono/metadata/exception.h>
 #include <mono/metadata/exception-internals.h>
@@ -1243,7 +1244,7 @@ interp_handle_intrinsics (TransformData *td, MonoMethod *target_method, MonoClas
                }
 
                g_error ("TODO: interp_transform_call %s:%s", m_class_get_name (target_method->klass), tm);
-       } else if (mono_class_is_subclass_of (target_method->klass, mono_defaults.array_class, FALSE)) {
+       } else if (mono_class_is_subclass_of_internal (target_method->klass, mono_defaults.array_class, FALSE)) {
                if (!strcmp (tm, "get_Rank")) {
                        *op = MINT_ARRAY_RANK;
                } else if (!strcmp (tm, "get_Length")) {

diff --git a/src/mono/mono/mini/method-to-ir.c b/src/mono/mono/mini/method-to-ir.c
index d83d8cd..9666dff 100644 (file)
--- a/src/mono/mono/mini/method-to-ir.c
+++ b/src/mono/mono/mini/method-to-ir.c
@@ -5496,7 +5496,7 @@ handle_ctor_call (MonoCompile *cfg, MonoMethod *cmethod, MonoMethodSignature *fs
                CHECK_CFG_EXCEPTION;
        } else if ((cfg->opt & MONO_OPT_INLINE) && cmethod && !context_used && !vtable_arg &&
                           mono_method_check_inlining (cfg, cmethod) &&
-                          !mono_class_is_subclass_of (cmethod->klass, mono_defaults.exception_class, FALSE)) {
+                          !mono_class_is_subclass_of_internal (cmethod->klass, mono_defaults.exception_class, FALSE)) {
                int costs;
 
                if ((costs = inline_method (cfg, cmethod, fsig, sp, ip, cfg->real_offset, FALSE))) {

diff --git a/src/mono/mono/mini/mini-runtime.c b/src/mono/mono/mini/mini-runtime.c
index 2790c63..2a88fcf 100644 (file)
--- a/src/mono/mono/mini/mini-runtime.c
+++ b/src/mono/mono/mini/mini-runtime.c
@@ -40,6 +40,7 @@
 #include <mono/metadata/threads.h>
 #include <mono/metadata/appdomain.h>
 #include <mono/metadata/debug-helpers.h>
+#include <mono/metadata/domain-internals.h>
 #include <mono/metadata/profiler-private.h>
 #include <mono/metadata/mono-config.h>
 #include <mono/metadata/environment.h>
@@ -857,7 +858,7 @@ mono_jit_thread_attach (MonoDomain *domain)
 
        orig = mono_domain_get ();
        if (orig != domain)
-               mono_domain_set (domain, TRUE);
+               mono_domain_set_fast (domain, TRUE);
 
        return orig != domain ? orig : NULL;
 }
@@ -873,7 +874,7 @@ mono_jit_set_domain (MonoDomain *domain)
        g_assert (!mono_threads_is_blocking_transition_enabled ());
 
        if (domain)
-               mono_domain_set (domain, TRUE);
+               mono_domain_set_fast (domain, TRUE);
 }
 
 /**