checkpoint generic wrapper methods

Author: lambdageek

src/mono/mono/metadata/marshal.c

@@ -5226,31 +5226,80 @@ mono_marshal_get_unsafe_accessor_wrapper (MonoMethod *accessor_method, MonoUnsaf
 	MonoMethod *res;
 	GHashTable *cache;
 	MonoGenericContext *ctx = NULL;
+	MonoGenericContainer *container = NULL;
 	MonoMethod *orig_method = NULL;
 	WrapperInfo *info;
+	gboolean is_generic = FALSE;
 
 	if (member_name == NULL && kind != MONO_UNSAFE_ACCESSOR_CTOR)
 		member_name = accessor_method->name;
 
+	if (accessor_method->is_generic) {
+		/* got a generic method definition. need to make a generic method definition wrapper */
+		g_assert (!accessor_method->is_inflated);
+		printf ("accessor method is generic: %s\n", mono_method_full_name (accessor_method, TRUE));
+		is_generic = TRUE;
+	}
+
+	/* FIXME: Support generic methods too */
+	if (accessor_method->is_inflated && !mono_method_get_context (accessor_method)->method_inst) {
+		orig_method = accessor_method;
+		ctx = &((MonoMethodInflated*)accessor_method)->context;
+		accessor_method = ((MonoMethodInflated*)accessor_method)->declaring;
+		container = mono_method_get_generic_container (accessor_method);
+		if (!container)
+			container = mono_class_try_get_generic_container (accessor_method->klass); //FIXME is this a case of a try?
+		g_assert (container);
+	} else if (accessor_method->is_inflated && mono_method_get_context(accessor_method)->method_inst) {
+		// FIXME: ak: do we need a different case? it should work, right?
+		// N.B. both method_inst and type_inst might be set
+		orig_method = accessor_method;
+		ctx = &((MonoMethodInflated*)accessor_method)->context;
+		accessor_method = ((MonoMethodInflated*)accessor_method)->declaring;
+		container = mono_method_get_generic_container (accessor_method);
+		if (!container)
+			container = mono_class_try_get_generic_container (accessor_method->klass); //FIXME is this a case of a try?
+		g_assert (container);
+	}
+
 	/*
 	 * Check cache
 	 */
 	if (ctx) {
-		cache = NULL;
-		g_assert_not_reached ();
+		/* FIXME get the right cache */
+		cache = NULL; /* get_cache (&((MonoMethodInflated*)orig_method)->owner->wrapper_caches.synchronized_cache , mono_aligned_addr_hash, NULL); */
+		/* res = check_generic_wrapper_cache (cache, orig_method, orig_method, method);*/
+		res = NULL;
+		if (res)
+			return res;
 	} else {
 		cache = get_cache (&mono_method_get_wrapper_cache (accessor_method)->unsafe_accessor_cache, mono_aligned_addr_hash, NULL);
 		if ((res = mono_marshal_find_in_cache (cache, accessor_method)))
 			return res;
 	}
 
-	sig = mono_metadata_signature_dup_full (get_method_image (accessor_method), mono_method_signature_internal (accessor_method));
-	sig->pinvoke = 0;
 
 	mb = mono_mb_new (accessor_method->klass, accessor_method->name, MONO_WRAPPER_OTHER);
+	if (is_generic) {
+		mb->method->is_generic = is_generic;
+		container = mono_class_try_get_generic_container (accessor_method->klass);
+		container = mono_metadata_load_generic_params (m_class_get_image (accessor_method->klass), accessor_method->token, container, /*owner:*/mb->method);
+		mono_method_set_generic_container (mb->method, container);
+
+		MonoGenericContext ctx = {0,};
+		ctx.method_inst = container->context.method_inst;
+
+		ERROR_DECL (error);
+		sig = mono_inflate_generic_signature (mono_method_signature_internal (accessor_method), &ctx, error);
+		mono_error_assert_ok (error); // FIXME
+	} else {
+		sig = mono_metadata_signature_dup_full (get_method_image (accessor_method), mono_method_signature_internal (accessor_method));
+	}
+	sig->pinvoke = 0;
 
 	get_marshal_cb ()->mb_skip_visibility (mb);
 
+	// TODO: pass container, too
 	get_marshal_cb ()->emit_unsafe_accessor_wrapper (mb, accessor_method, sig, ctx, kind, member_name);
 
 	info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_UNSAFE_ACCESSOR);

src/mono/mono/metadata/method-builder-ilgen.c

@@ -214,6 +214,18 @@ create_method_ilgen (MonoMethodBuilder *mb, MonoMethodSignature *signature, int
 		mono_image_unlock (image);
 	}
 
+	if (mb->method->is_generic) {
+		method->is_generic = TRUE;
+		MonoGenericContainer *container = mono_method_get_generic_container (mb->method);
+		mono_method_set_generic_container (method, container);
+		g_assert (!container->is_anonymous);
+		g_assert (container->is_method);
+		g_assert (container->owner.method == mb->method);
+		// HACK: reassign container owner from the method builder placeholder to the
+		// final created method
+		container->owner.method = method;
+	}
+
 	return method;
 }
 

src/mono/mono/mini/aot-compiler.c

@@ -3874,6 +3874,15 @@ encode_method_ref (MonoAotCompile *acfg, MonoMethod *method, guint8 *buf, guint8
 					encode_value (len, p, &p);
 					encode_string (info->d.unsafe_accessor.member_name, p, &p);
 				}
+				if (method->is_inflated) {
+					encode_value(1, p, &p);
+					MonoMethodInflated *inflated = (MonoMethodInflated*)method;
+					MonoGenericContext *ctx = &inflated->context;
+					encode_generic_context (acfg, ctx, p, &p);
+				} else {
+					encode_value(0, p, &p);
+				}
+
 			}
 			else if (info->subtype == WRAPPER_SUBTYPE_INTERP_IN)
 				encode_signature (acfg, info->d.interp_in.sig, p, &p);
@@ -4829,6 +4838,18 @@ mono_aot_can_enter_interp (MonoMethod *method)
 	return FALSE;
 }
 
+static MonoMethod*
+instantiate_wrapper_like_decl (MonoMethod *extern_method_inst, MonoUnsafeAccessorKind accessor_kind, const char *member_name, MonoError *error)
+{
+	g_assert (extern_method_inst->is_inflated);
+	MonoMethodInflated *infl = (MonoMethodInflated*)extern_method_inst;
+	MonoMethod *extern_decl = infl->declaring;
+	MonoMethod *generic_wrapper = mono_marshal_get_unsafe_accessor_wrapper (extern_decl, accessor_kind, member_name);
+	MonoGenericContext *ctx = &infl->context;
+	MonoMethod *inflated_wrapper = mono_class_inflate_generic_method_checked (generic_wrapper, ctx, error);
+	return inflated_wrapper;
+}
+
 /**
  * Replaces some extern \c method by a wrapper.
  *
@@ -4848,6 +4869,8 @@ replace_generated_method (MonoAotCompile *acfg, MonoMethod *method, MonoError *e
 	{
 		char * method_name = mono_method_get_full_name (method);
 		g_print ("ADDING no header %s generic instances\n", method_name);
+		if (strstr (method_name, "!!0") != NULL)
+			g_print("anon\n");
 		g_free (method_name);
 	}
 
@@ -4857,15 +4880,20 @@ replace_generated_method (MonoAotCompile *acfg, MonoMethod *method, MonoError *e
 	char *member_name = NULL;
 	int accessor_kind = -1;
 	if (mono_method_get_unsafe_accessor_attr_data (method, &accessor_kind, &member_name, error)) {
-		// FIXME: if `method` was inflated, get the uninflated wrapper and then re-inflate
-		// it.
-		MonoMethod *wrapper = mono_marshal_get_unsafe_accessor_wrapper (method, (MonoUnsafeAccessorKind)accessor_kind, member_name);
-		{
-			char * method_name = mono_method_get_full_name (wrapper);
-			g_print ("REPLACED by %s in generic instances\n", method_name);
-			g_free (method_name);
+		MonoMethod *wrapper = NULL;
+		if (method->is_inflated) {
+			wrapper = instantiate_wrapper_like_decl (method, (MonoUnsafeAccessorKind)accessor_kind, member_name, error);
+		} else {
+			wrapper = mono_marshal_get_unsafe_accessor_wrapper (method, (MonoUnsafeAccessorKind)accessor_kind, member_name);
+		}
+		if (is_ok (error)) {
+			{
+				char * method_name = mono_method_get_full_name (wrapper);
+				g_print ("REPLACED by %s in generic instances\n", method_name);
+				g_free (method_name);
+			}
+			return wrapper;
 		}
-		return wrapper;
 	}
 
 	if (!is_ok (error)) {
@@ -7925,6 +7953,12 @@ emit_exception_debug_info (MonoAotCompile *acfg, MonoCompile *cfg, gboolean stor
 		 */
 		buf2 = (guint8 *)g_malloc (4096);
 		p2 = buf2;
+		if (cfg->method->wrapper_type && cfg->method->is_generic) {
+			printf ("barf\n");
+		}
+		if (jinfo->d.method->wrapper_type && jinfo->d.method->is_generic) {
+			printf ("barf2\n");
+		}
 		encode_method_ref (acfg, jinfo->d.method, p2, &p2);
 		len = GPTRDIFF_TO_INT (p2 - buf2);
 		g_assert (len < 4096);

src/mono/mono/mini/aot-runtime.c

@@ -940,6 +940,14 @@ typedef struct {
 	gboolean no_aot_trampoline;
 } MethodRef;
 
+static MonoMethod*
+instantiate_wrapper_like_decl (MonoMethod *extern_decl, MonoGenericContext *ctx, MonoUnsafeAccessorKind accessor_kind, const char *member_name, MonoError *error)
+{
+	MonoMethod *generic_wrapper = mono_marshal_get_unsafe_accessor_wrapper (extern_decl, accessor_kind, member_name);
+	MonoMethod *inflated_wrapper = mono_class_inflate_generic_method_checked (generic_wrapper, ctx, error);
+	return inflated_wrapper;
+}
+
 /*
  * decode_method_ref_with_target:
  *
@@ -1079,7 +1087,17 @@ decode_method_ref_with_target (MonoAotModule *module, MethodRef *ref, MonoMethod
 				uint32_t name_len = decode_value (p, &p);
 				const char *member_name = (const char*)p;
 				p += name_len + 1;
-				ref->method = mono_marshal_get_unsafe_accessor_wrapper (m, kind, member_name);
+				uint8_t inflated = decode_value (p, &p);
+				if (inflated) {
+					MonoGenericContext ctx = {0,};
+					decode_generic_context (module, &ctx, p, &p, error);
+					mono_error_assert_ok (error);
+					ref->method = instantiate_wrapper_like_decl (m, &ctx, kind, member_name, error);
+					if (!is_ok (error))
+						return FALSE;
+				} else {
+					ref->method = mono_marshal_get_unsafe_accessor_wrapper (m, kind, member_name);
+				}
 			} else if (subtype == WRAPPER_SUBTYPE_GSHAREDVT_IN) {
 				ref->method = mono_marshal_get_gsharedvt_in_wrapper ();
 			} else if (subtype == WRAPPER_SUBTYPE_GSHAREDVT_OUT) {

src/mono/mono/mini/aot-runtime.h

@@ -11,7 +11,7 @@
 #include "mini.h"
 
 /* Version number of the AOT file format */
-#define MONO_AOT_FILE_VERSION 185
+#define MONO_AOT_FILE_VERSION 186
 
 #define MONO_AOT_TRAMP_PAGE_SIZE 16384
 

src/mono/sample/HelloWorld/Program.cs

@@ -16,7 +16,10 @@ public class Program
     public static void Main()
     {
         var box = new MyBox<string>("xyz");
-        RunIt<string>(box, "abc");
+        //Thinger<string>(box);
+        //RunIt<string>(box, "abc");
+        //Console.WriteLine (box.Value);
+        RunItAgain<string>(box, "hjk");
         Console.WriteLine (box.Value);
     }
 
@@ -27,6 +30,22 @@ public static void RunIt<H> (MyBox<H> dest, H input)
         boxWriter = input;
     }
 
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    public static void RunItAgain<S> (MyBox<S> dest, S input)
+    {
+        ref S boxWriter = ref AccessHelper<S>.AccessBox2(dest);
+        boxWriter = input;
+    }
+
     [UnsafeAccessor(UnsafeAccessorKind.Field, Name="_value")]
     private static extern ref W AccessBox<W>(MyBox<W> x);
+
+    [MethodImpl(MethodImplOptions.NoInlining)]
+    private static ref W Thinger<W>(MyBox<W> x) => throw new InvalidOperationException("oops");
+}
+
+public class AccessHelper<Q>
+{
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name="_value")]
+    public static extern ref Q AccessBox2(MyBox<Q> q);
 }