[mono] More domain cleanups. (#48291)

* Remove the MonoClassRuntimeInfo structure, store the runtime vtable directly in MonoClass.

* Remove the 'domain' argument from mono_class_vtable_checked ().

* Remove the 'domain' argument from the object allocation functions.

* Remove the 'domain' argument from the m_.._alloc methods.

* Revert accidental changes.

* Remove more unused 'domain' parameters.

* Remove more remoting code.

* Remove shared code support.

* Remove the 'domain' argument from the IMT builder functions.

* Remove the 'domain' argument from the m_method_ functions.

* Remove more domain usage from the JIT backends.

* Remove the MONO_ARCH_HAVE_PATCH_CODE_NEW ifdef, all architectures support it now.

* Remove 'domain' argument from mini_jit_info_table_find ().

* Remove 'domain' argument from mono_arch_unwind_frame ().

* Remove unused/unfinished AOT cache code.

* Remove the 'domain' argument from mono_resolve_patch_target ().

* Remove domains from the stack walk/exception handling code.

* Remove domains from mono-debug.c.

The memory in mono-debug.c is now owned by a MonoMemoryManager instead of by a domain.

* Remove unused mono-mlist.{h,c}.

* Fix the coverage profiler build.

* Fix the build.

Author: vargaz

src/mono/mono/metadata/appdomain.c

@@ -201,11 +201,11 @@ create_domain_objects (MonoDomain *domain)
 	 * Initialize String.Empty. This enables the removal of
 	 * the static cctor of the String class.
 	 */
-	string_vt = mono_class_vtable_checked (domain, mono_defaults.string_class, error);
+	string_vt = mono_class_vtable_checked (mono_defaults.string_class, error);
 	mono_error_assert_ok (error);
 	string_empty_fld = mono_class_get_field_from_name_full (mono_defaults.string_class, "Empty", NULL);
 	g_assert (string_empty_fld);
-	MonoStringHandle empty_str = mono_string_new_handle (domain, "", error);
+	MonoStringHandle empty_str = mono_string_new_handle ("", error);
 	mono_error_assert_ok (error);
 	empty_str = mono_string_intern_checked (empty_str, error);
 	mono_error_assert_ok (error);
@@ -215,7 +215,7 @@ create_domain_objects (MonoDomain *domain)
 	/*
 	 * Create an instance early since we can't do it when there is no memory.
 	 */
-	arg = mono_string_new_handle (domain, "Out of memory", error);
+	arg = mono_string_new_handle ("Out of memory", error);
 	mono_error_assert_ok (error);
 	domain->out_of_memory_ex = MONO_HANDLE_RAW (mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "OutOfMemoryException", arg, NULL_HANDLE_STRING, error));
 	mono_error_assert_ok (error);
@@ -224,17 +224,17 @@ create_domain_objects (MonoDomain *domain)
 	 * These two are needed because the signal handlers might be executing on
 	 * an alternate stack, and Boehm GC can't handle that.
 	 */
-	arg = mono_string_new_handle (domain, "A null value was found where an object instance was required", error);
+	arg = mono_string_new_handle ("A null value was found where an object instance was required", error);
 	mono_error_assert_ok (error);
 	domain->null_reference_ex = MONO_HANDLE_RAW (mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "NullReferenceException", arg, NULL_HANDLE_STRING, error));
 	mono_error_assert_ok (error);
-	arg = mono_string_new_handle (domain, "The requested operation caused a stack overflow.", error);
+	arg = mono_string_new_handle ("The requested operation caused a stack overflow.", error);
 	mono_error_assert_ok (error);
 	domain->stack_overflow_ex = MONO_HANDLE_RAW (mono_exception_from_name_two_strings_checked (mono_defaults.corlib, "System", "StackOverflowException", arg, NULL_HANDLE_STRING, error));
 	mono_error_assert_ok (error);
 
 	/*The ephemeron tombstone i*/
-	domain->ephemeron_tombstone = MONO_HANDLE_RAW (mono_object_new_handle (domain, mono_defaults.object_class, error));
+	domain->ephemeron_tombstone = MONO_HANDLE_RAW (mono_object_new_handle (mono_defaults.object_class, error));
 	mono_error_assert_ok (error);
 
 	if (domain != old_domain)
@@ -297,7 +297,7 @@ mono_runtime_init_checked (MonoDomain *domain, MonoThreadStartCB start_cb, MonoT
 
 		klass = mono_class_get_appdomain_class ();
 
-		ad = MONO_HANDLE_CAST (MonoAppDomain, mono_object_new_pinned_handle (domain, klass, error));
+		ad = MONO_HANDLE_CAST (MonoAppDomain, mono_object_new_pinned_handle (klass, error));
 		goto_if_nok (error, exit);
 
 		domain->domain = MONO_HANDLE_RAW (ad);
@@ -449,7 +449,7 @@ mono_context_init_checked (MonoDomain *domain, MonoError *error)
 		goto exit;
 
 	klass = mono_class_load_from_name (mono_defaults.corlib, "System.Runtime.Remoting.Contexts", "Context");
-	context = MONO_HANDLE_CAST (MonoAppContext, mono_object_new_pinned_handle (domain, klass, error));
+	context = MONO_HANDLE_CAST (MonoAppContext, mono_object_new_pinned_handle (klass, error));
 	goto_if_nok (error, exit);
 
 	MONO_HANDLE_SETVAL (context, domain_id, gint32, domain->domain_id);
@@ -582,7 +582,7 @@ mono_domain_try_type_resolve (MonoDomain *domain, char *name, MonoObject *typebu
 
 	// This will not work correctly on netcore
 	if (name) {
-		MonoStringHandle name_handle = mono_string_new_handle (mono_domain_get (), name, error);
+		MonoStringHandle name_handle = mono_string_new_handle (name, error);
 		goto_if_nok (error, exit);
 		ret = mono_domain_try_type_resolve_name (domain, NULL, name_handle, error);
 	} else {
@@ -691,7 +691,7 @@ get_assembly_array_from_domain (MonoDomain *domain, MonoError *error)
 
 	assemblies = mono_domain_get_assemblies (domain);
 
-	MonoArrayHandle res = mono_array_new_handle (domain, mono_class_get_assembly_class (), assemblies->len, error);
+	MonoArrayHandle res = mono_array_new_handle (mono_class_get_assembly_class (), assemblies->len, error);
 	goto_if_nok (error, leave);
 	for (i = 0; i < assemblies->len; ++i) {
 		if (!add_assembly_to_array (domain, res, i, (MonoAssembly *)g_ptr_array_index (assemblies, i), error))
@@ -716,7 +716,7 @@ mono_try_assembly_resolve (MonoAssemblyLoadContext *alc, const char *fname_raw,
 	HANDLE_FUNCTION_ENTER ();
 	error_init (error);
 	MonoAssembly *result = NULL;
-	MonoStringHandle fname = mono_string_new_handle (mono_alc_domain (alc), fname_raw, error);
+	MonoStringHandle fname = mono_string_new_handle (fname_raw, error);
 	goto_if_nok (error, leave);
 	result = mono_try_assembly_resolve_handle (alc, fname, requesting, error);
 leave:

src/mono/mono/metadata/assembly-load-context.c

@@ -285,7 +285,7 @@ invoke_resolve_method (MonoMethod *resolve_method, MonoAssemblyLoadContext *alc,
 
 	aname_str = mono_stringify_assembly_name (aname);
 
-	MonoStringHandle aname_obj = mono_string_new_handle (mono_alc_domain (alc), aname_str, error);
+	MonoStringHandle aname_obj = mono_string_new_handle (aname_str, error);
 	goto_if_nok (error, leave);
 
 	MonoReflectionAssemblyHandle assm;

src/mono/mono/metadata/class-getters.h

@@ -69,7 +69,7 @@ MONO_CLASS_GETTER(m_class_get_methods, MonoMethod **, ,  MonoClass, methods)
 MONO_CLASS_GETTER(m_class_get_this_arg, MonoType*, &, MonoClass, this_arg)
 MONO_CLASS_GETTER(m_class_get_byval_arg, MonoType*, &, MonoClass, _byval_arg)
 MONO_CLASS_GETTER(m_class_get_gc_descr, MonoGCDescriptor, , MonoClass, gc_descr)
-MONO_CLASS_GETTER(m_class_get_runtime_info, MonoClassRuntimeInfo *, , MonoClass, runtime_info)
+MONO_CLASS_GETTER(m_class_get_runtime_vtable, MonoVTable*, , MonoClass, runtime_vtable)
 MONO_CLASS_GETTER(m_class_get_vtable, MonoMethod **, , MonoClass, vtable)
 MONO_CLASS_GETTER(m_class_get_infrequent_data, MonoPropertyBag*, &, MonoClass, infrequent_data)
 

src/mono/mono/metadata/class-init.c

@@ -3958,52 +3958,6 @@ mono_class_setup_nested_types (MonoClass *klass)
 	mono_loader_unlock ();
 }
 
-/**
- * mono_class_setup_runtime_info:
- * \param klass the class to setup
- * \param domain the domain of the \p vtable
- * \param vtable
- *
- * Store \p vtable in \c klass->runtime_info.
- *
- * Sets the following field in MonoClass:
- *   -   runtime_info
- *
- * LOCKING: domain lock and loaderlock must be held.
- */
-void
-mono_class_setup_runtime_info (MonoClass *klass, MonoDomain *domain, MonoVTable *vtable)
-{
-	MonoClassRuntimeInfo *old_info = m_class_get_runtime_info (klass);
-	if (old_info && old_info->max_domain >= domain->domain_id) {
-		/* someone already created a large enough runtime info */
-		old_info->domain_vtables [domain->domain_id] = vtable;
-	} else {
-		int new_size = domain->domain_id;
-		if (old_info)
-			new_size = MAX (new_size, old_info->max_domain);
-		new_size++;
-		/* make the new size a power of two */
-		int i = 2;
-		while (new_size > i)
-			i <<= 1;
-		new_size = i;
-		/* this is a bounded memory retention issue: may want to 
-		 * handle it differently when we'll have a rcu-like system.
-		 */
-		MonoClassRuntimeInfo *runtime_info = (MonoClassRuntimeInfo *)mono_image_alloc0 (m_class_get_image (klass), MONO_SIZEOF_CLASS_RUNTIME_INFO + new_size * sizeof (gpointer));
-		runtime_info->max_domain = new_size - 1;
-		/* copy the stuff from the older info */
-		if (old_info) {
-			memcpy (runtime_info->domain_vtables, old_info->domain_vtables, (old_info->max_domain + 1) * sizeof (gpointer));
-		}
-		runtime_info->domain_vtables [domain->domain_id] = vtable;
-		/* keep this last*/
-		mono_memory_barrier ();
-		klass->runtime_info = runtime_info;
-	}
-}
-
 /**
  * mono_class_create_array_fill_type:
  *
@@ -4025,6 +3979,12 @@ mono_class_create_array_fill_type (void)
 	return &aklass.klass;
 }
 
+void
+mono_class_set_runtime_vtable (MonoClass *klass, MonoVTable *vtable)
+{
+	klass->runtime_vtable = vtable;
+}
+
 /**
  * mono_classes_init:
  *

src/mono/mono/metadata/class-init.h

@@ -82,10 +82,10 @@ mono_class_setup_has_finalizer (MonoClass *klass);
 void
 mono_class_setup_nested_types (MonoClass *klass);
 
-void
-mono_class_setup_runtime_info (MonoClass *klass, MonoDomain *domain, MonoVTable *vtable);
-
 MonoClass *
 mono_class_create_array_fill_type (void);
 
+void
+mono_class_set_runtime_vtable (MonoClass *klass, MonoVTable *vtable);
+
 #endif

src/mono/mono/metadata/class-internals.h

@@ -223,17 +223,6 @@ typedef enum {
 	/* add other exception type */
 } MonoExceptionType;
 
-/* This struct collects the info needed for the runtime use of a class,
- * like the vtables for a domain, the GC descriptor, etc.
- */
-typedef struct {
-	guint16 max_domain;
-	/* domain_vtables is indexed by the domain id and the size is max_domain + 1 */
-	MonoVTable *domain_vtables [MONO_ZERO_LEN_ARRAY];
-} MonoClassRuntimeInfo;
-
-#define MONO_SIZEOF_CLASS_RUNTIME_INFO (sizeof (MonoClassRuntimeInfo) - MONO_ZERO_LEN_ARRAY * SIZEOF_VOID_P)
-
 typedef struct {
 	MonoPropertyBagItem head;
 
@@ -1237,7 +1226,7 @@ MonoClassField*
 mono_class_get_field_from_name_full (MonoClass *klass, const char *name, MonoType *type);
 
 MonoVTable*
-mono_class_vtable_checked (MonoDomain *domain, MonoClass *klass, MonoError *error);
+mono_class_vtable_checked (MonoClass *klass, MonoError *error);
 
 void
 mono_class_is_assignable_from_checked (MonoClass *klass, MonoClass *oklass, gboolean *result, MonoError *error);
@@ -1544,48 +1533,71 @@ m_field_get_offset (MonoClassField *field)
 }
 
 /*
- * Memory allocation for classes/methods
+ * Memory allocation for images/classes/methods
  *
  *   These should be used to allocate memory whose lifetime is equal to
- * the lifetime of the domain+class/method pair.
+ * the lifetime of the image/class/method.
  */
 
 static inline MonoMemoryManager*
-m_class_get_mem_manager (MonoDomain *domain, MonoClass *klass)
+m_image_get_mem_manager (MonoImage *image)
 {
-	// FIXME:
-	return mono_domain_memory_manager (domain);
+	return (MonoMemoryManager*)mono_image_get_alc (image)->memory_manager;
+}
+
+static inline void *
+m_image_alloc (MonoImage *image, guint size)
+{
+	return mono_mem_manager_alloc (m_image_get_mem_manager (image), size);
+}
+
+static inline void *
+m_image_alloc0 (MonoImage *image, guint size)
+{
+	return mono_mem_manager_alloc0 (m_image_get_mem_manager (image), size);
+}
+
+static inline MonoMemoryManager*
+m_class_get_mem_manager (MonoClass *klass)
+{
+	// FIXME: Generics
+	MonoAssemblyLoadContext *alc = mono_image_get_alc (m_class_get_image (klass));
+	if (alc)
+		return (MonoMemoryManager*)alc->memory_manager;
+	else
+		/* Dynamic assemblies */
+		return mono_domain_ambient_memory_manager (mono_get_root_domain ());
 }
 
 static inline void *
-m_class_alloc (MonoDomain *domain, MonoClass *klass, guint size)
+m_class_alloc (MonoClass *klass, guint size)
 {
-	return mono_mem_manager_alloc (m_class_get_mem_manager (domain, klass), size);
+	return mono_mem_manager_alloc (m_class_get_mem_manager (klass), size);
 }
 
 static inline void *
-m_class_alloc0 (MonoDomain *domain, MonoClass *klass, guint size)
+m_class_alloc0 (MonoClass *klass, guint size)
 {
-	return mono_mem_manager_alloc0 (m_class_get_mem_manager (domain, klass), size);
+	return mono_mem_manager_alloc0 (m_class_get_mem_manager (klass), size);
 }
 
 static inline MonoMemoryManager*
-m_method_get_mem_manager (MonoDomain *domain, MonoMethod *method)
+m_method_get_mem_manager (MonoMethod *method)
 {
 	// FIXME:
-	return mono_domain_memory_manager (domain);
+	return mono_domain_memory_manager (mono_get_root_domain ());
 }
 
 static inline void *
-m_method_alloc (MonoDomain *domain, MonoMethod *method, guint size)
+m_method_alloc (MonoMethod *method, guint size)
 {
-	return mono_mem_manager_alloc (m_method_get_mem_manager (domain, method), size);
+	return mono_mem_manager_alloc (m_method_get_mem_manager (method), size);
 }
 
 static inline void *
-m_method_alloc0 (MonoDomain *domain, MonoMethod *method, guint size)
+m_method_alloc0 (MonoMethod *method, guint size)
 {
-	return mono_mem_manager_alloc0 (m_method_get_mem_manager (domain, method), size);
+	return mono_mem_manager_alloc0 (m_method_get_mem_manager (method), size);
 }
 
 // Enum and static storage for JIT icalls.

src/mono/mono/metadata/class-private-definition.h

@@ -117,7 +117,7 @@ struct _MonoClass {
 
 	MonoGCDescriptor gc_descr;
 
-	MonoClassRuntimeInfo *runtime_info;
+	MonoVTable *runtime_vtable;
 
 	/* Generic vtable. Initialized by a call to mono_class_setup_vtable () */
 	MonoMethod **vtable;

src/mono/mono/metadata/class.c

@@ -1606,27 +1606,18 @@ mono_error_set_for_class_failure (MonoError *oerror, const MonoClass *klass)
 /*
  * mono_class_alloc:
  *
- *   Allocate memory for some data belonging to CLASS, either from its image's mempool,
- * or from the heap.
+ *   Allocate memory for data belonging to CLASS.
  */
 gpointer
 mono_class_alloc (MonoClass *klass, int size)
 {
-	MonoGenericClass *gklass = mono_class_try_get_generic_class (klass);
-	if (gklass)
-		return mono_image_set_alloc (gklass->owner, size);
-	else
-		return mono_image_alloc (m_class_get_image (klass), size);
+	return m_class_alloc (klass, size);
 }
 
 gpointer
 (mono_class_alloc0) (MonoClass *klass, int size)
 {
-	gpointer res;
-
-	res = mono_class_alloc (klass, size);
-	memset (res, 0, size);
-	return res;
+	return m_class_alloc0 (klass, size);
 }
 
 #define mono_class_new0(klass,struct_type, n_structs)		\

src/mono/mono/metadata/cominterop.c

@@ -1795,7 +1795,7 @@ ves_icall_System_ComObject_CreateRCW (MonoReflectionTypeHandle ref_type, MonoErr
 	 * is called by the corresponding real proxy to create the real RCW.
 	 * Constructor does not need to be called. Will be called later.
 	 */
-	MonoVTable *vtable = mono_class_vtable_checked (domain, klass, error);
+	MonoVTable *vtable = mono_class_vtable_checked (klass, error);
 	return_val_if_nok (error, NULL_HANDLE);
 	return mono_object_new_alloc_by_vtable (vtable, error);
 }
@@ -3218,21 +3218,21 @@ mono_string_from_bstr_checked (mono_bstr_const bstr, MonoError *error)
 		return NULL_HANDLE_STRING;
 #ifdef HOST_WIN32
 #if HAVE_API_SUPPORT_WIN32_BSTR
-	return mono_string_new_utf16_handle (mono_domain_get (), bstr, SysStringLen ((BSTR)bstr), error);
+	return mono_string_new_utf16_handle (bstr, SysStringLen ((BSTR)bstr), error);
 #else
-	return mono_string_new_utf16_handle (mono_domain_get (), bstr, *((guint32 *)bstr - 1) / sizeof (gunichar2), error);
+	return mono_string_new_utf16_handle (bstr, *((guint32 *)bstr - 1) / sizeof (gunichar2), error);
 #endif /* HAVE_API_SUPPORT_WIN32_BSTR */
 #else
 #ifndef DISABLE_COM
 	if (com_provider == MONO_COM_DEFAULT)
 #endif
-		return mono_string_new_utf16_handle (mono_domain_get (), bstr, *((guint32 *)bstr - 1) / sizeof (gunichar2), error);
+		return mono_string_new_utf16_handle (bstr, *((guint32 *)bstr - 1) / sizeof (gunichar2), error);
 #ifndef DISABLE_COM
 	else if (com_provider == MONO_COM_MS && init_com_provider_ms ()) {
 		glong written = 0;
 		// FIXME mono_string_new_utf32_handle to combine g_ucs4_to_utf16 and mono_string_new_utf16_handle.
 		gunichar2* utf16 = g_ucs4_to_utf16 ((const gunichar *)bstr, sys_string_len_ms (bstr), NULL, &written, NULL);
-		MonoStringHandle res = mono_string_new_utf16_handle (mono_domain_get (), utf16, written, error);
+		MonoStringHandle res = mono_string_new_utf16_handle (utf16, written, error);
 		g_free (utf16);
 		return res;
 	} else {