[mono] Implement public hot reload API

Also add ApplyUpdateSdb that takes byte[] arguments for use with
mono/debugger-libs as its awkward to call a ROS<byte> method from the debugger.

Contributes to dotnet#45689

Author: lambdageek

src/mono/System.Private.CoreLib/src/ILLink/ILLink.Descriptors.xml

@@ -548,11 +548,6 @@
 			<method signature="System.Void .ctor(System.Object)" />
 		</type>
 
-		<!-- Used by metadata update -->
-		<type fullname="System.Runtime.CompilerServices.RuntimeFeature">
-			<method name="LoadMetadataUpdate" />
-		</type>
-
 		<!-- domain.c: mono_defaults.marshal_class -->
 		<type fullname="System.Runtime.InteropServices.Marshal" preserve="fields" >
 			<!-- marshal.c (mono_marshal_get_struct_to_ptr) -->
@@ -637,5 +632,11 @@
 			<!-- marshal-ilgen.c:emit_invoke_call -->
 			<method signature="System.Void .ctor()" />
 		</type>
+
+    <!-- Used by metadata update -->
+		<type fullname="System.Reflection.Metadata.AssemblyExtensions">
+			<method name="ApplyUpdateSdb" />
+		</type>
+
 	</assembly>
 </linker>

src/mono/System.Private.CoreLib/src/System/Reflection/Metadata/AssemblyExtensions.cs

@@ -1,13 +1,69 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Runtime.CompilerServices;
+
 namespace System.Reflection.Metadata
 {
     public static class AssemblyExtensions
     {
         [CLSCompliant(false)]
         public static unsafe bool TryGetRawMetadata(this Assembly assembly, out byte* blob, out int length) => throw new NotImplementedException();
 
-        public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta) => throw new NotImplementedException();
+        /// <summary>
+        /// Updates the specified assembly using the provided metadata, IL and PDB deltas.
+        /// </summary>
+        /// <remarks>
+        /// Currently executing methods will continue to use the existing IL. New executions of modified methods will
+        /// use the new IL. Different runtimes may have different limitations on what kinds of changes are supported,
+        /// and runtimes make no guarantees as to the state of the assembly and process if the delta includes
+        /// unsupported changes.
+        /// </remarks>
+        /// <param name="assembly">The assembly to update.</param>
+        /// <param name="metadataDelta">The metadata changes to be applied.</param>
+        /// <param name="ilDelta">The IL changes to be applied.</param>
+        /// <param name="pdbDelta">The PDB changes to be applied.</param>
+        /// <exception cref="ArgumentNullException">The assembly argument is null.</exception>
+        /// <exception cref="NotSupportedException">The update could not be applied.</exception>
+        public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta = default)
+        {
+#if !FEATURE_METADATA_UPDATE
+            throw new NotSupportedException ("Method body replacement not supported in this runtime");
+#else
+            if (assembly == null)
+            {
+                throw new ArgumentNullException(nameof(assembly));
+            }
+
+            RuntimeAssembly? runtimeAssembly = assembly as RuntimeAssembly;
+            if (runtimeAssembly == null)
+            {
+                throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
+            }
+
+            unsafe
+            {
+                IntPtr monoAssembly = runtimeAssembly.GetUnderlyingNativeHandle ();
+                fixed (byte* metadataDeltaPtr = metadataDelta, ilDeltaPtr = ilDelta, pdbDeltaPtr = pdbDelta)
+                {
+                    ApplyUpdate_internal(monoAssembly, metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length);
+                }
+            }
+#endif
+        }
+
+        internal static void ApplyUpdateSdb(Assembly assembly, byte[] metadataDelta, byte[] ilDelta, byte[]? pdbDelta = null)
+        {
+            ReadOnlySpan<byte> md = metadataDelta;
+            ReadOnlySpan<byte> il = ilDelta;
+            ReadOnlySpan<byte> dpdb = pdbDelta == null ? default : pdbDelta;
+            ApplyUpdate (assembly, md, il, dpdb);
+        }
+
+#if FEATURE_METADATA_UPDATE
+        [MethodImpl (MethodImplOptions.InternalCall)]
+        private static unsafe extern void ApplyUpdate_internal (IntPtr base_assm, byte* dmeta_bytes, int dmeta_length, byte *dil_bytes, int dil_length, byte *dpdb_bytes, int dpdb_length);
+#endif
+
     }
 }

src/mono/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeFeature.Mono.cs

@@ -17,24 +17,5 @@ public static bool IsDynamicCodeCompiled
             [Intrinsic]  // the JIT/AOT compiler will change this flag to false for FullAOT scenarios, otherwise true
             get => IsDynamicCodeCompiled;
         }
-
-#if !FEATURE_METADATA_UPDATE
-        internal static void LoadMetadataUpdate (Assembly assm, byte[] dmeta_data, byte[] dil_data) {
-            throw new NotSupportedException ("Method body replacement not supported in this runtime");
-        }
-#else
-        [MethodImplAttribute (MethodImplOptions.InternalCall)]
-        private static unsafe extern void LoadMetadataUpdate_internal (IntPtr base_assm, byte* dmeta_bytes, int dmeta_length, byte *dil_bytes, int dil_length);
-
-        internal static void LoadMetadataUpdate (Assembly assm, byte[] dmeta_data, byte[] dil_data) {
-            unsafe {
-                fixed (byte* dmeta_bytes = dmeta_data)
-                fixed (byte* dil_bytes = dil_data) {
-                    IntPtr mono_assembly = ((RuntimeAssembly)assm).GetUnderlyingNativeHandle ();
-                    LoadMetadataUpdate_internal (mono_assembly, dmeta_bytes, dmeta_data.Length, dil_bytes, dil_data.Length);
-                }
-            }
-        }
-#endif
     }
 }

src/mono/mono/metadata/icall-decl.h

@@ -239,7 +239,7 @@ ICALL_EXPORT void ves_icall_System_Runtime_Intrinsics_X86_X86Base___cpuidex (int
 #endif
 
 #ifdef ENABLE_METADATA_UPDATE
-ICALL_EXPORT void ves_icall_Mono_Runtime_LoadMetadataUpdate (MonoAssembly *assm, gconstpointer dmeta_bytes, int32_t dmeta_len, gconstpointer dil_bytes, int32_t dil_len);
+ICALL_EXPORT void ves_icall_AssemblyExtensions_ApplyUpdate (MonoAssembly *assm, gconstpointer dmeta_bytes, int32_t dmeta_len, gconstpointer dil_bytes, int32_t dil_len, gconstpointer dpdb_bytes, int32_t dpdb_len);
 #endif
 
 #endif // __MONO_METADATA_ICALL_DECL_H__

src/mono/mono/metadata/icall-def-netcore.h

@@ -239,6 +239,11 @@ HANDLES(FILEDI_1, "get_marshal_info", ves_icall_System_Reflection_FieldInfo_get_
 
 HANDLES(FILEDI_2, "internal_from_handle_type", ves_icall_System_Reflection_FieldInfo_internal_from_handle_type, MonoReflectionField, 2, (MonoClassField_ref, MonoType_ref))
 
+#ifdef ENABLE_METADATA_UPDATE
+ICALL_TYPE(ASSMEXT, "System.Reflection.Metadata.AssemblyExtensions", ASSMEXT_1)
+NOHANDLES(ICALL(ASSMEXT_1, "ApplyUpdate_internal", ves_icall_AssemblyExtensions_ApplyUpdate))
+#endif
+
 ICALL_TYPE(MBASE, "System.Reflection.MethodBase", MBASE_1)
 HANDLES(MBASE_1, "GetCurrentMethod", ves_icall_GetCurrentMethod, MonoReflectionMethod, 0, ())
 
@@ -324,11 +329,6 @@ HANDLES_REUSE_WRAPPER(MPROP_3, "get_metadata_token", ves_icall_reflection_get_to
 HANDLES(MPROP_4, "get_property_info", ves_icall_RuntimePropertyInfo_get_property_info, void, 3, (MonoReflectionProperty, MonoPropertyInfo_ref, PInfo))
 HANDLES(MPROP_5, "internal_from_handle_type", ves_icall_System_Reflection_RuntimePropertyInfo_internal_from_handle_type, MonoReflectionProperty, 2, (MonoProperty_ptr, MonoType_ptr))
 
-#ifdef ENABLE_METADATA_UPDATE
-ICALL_TYPE(RUNF, "System.Runtime.CompilerServices.RuntimeFeature", RUNF_1)
-NOHANDLES(ICALL(RUNF_1, "LoadMetadataUpdate_internal", ves_icall_Mono_Runtime_LoadMetadataUpdate))
-#endif
-
 ICALL_TYPE(RUNH, "System.Runtime.CompilerServices.RuntimeHelpers", RUNH_1)
 HANDLES(RUNH_1, "GetObjectValue", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue, MonoObject, 1, (MonoObject))
 HANDLES(RUNH_2, "GetUninitializedObjectInternal", ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetUninitializedObjectInternal, MonoObject, 1, (MonoType_ptr))

src/mono/mono/metadata/icall.c

@@ -5855,15 +5855,17 @@ ves_icall_Mono_Runtime_DumpStateTotal (guint64 *portable_hash, guint64 *unportab
 
 #ifdef ENABLE_METADATA_UPDATE
 void
-ves_icall_Mono_Runtime_LoadMetadataUpdate (MonoAssembly *assm,
+ves_icall_AssemblyExtensions_ApplyUpdate (MonoAssembly *assm,
 					   gconstpointer dmeta_bytes, int32_t dmeta_len,
-					   gconstpointer dil_bytes, int32_t dil_len)
+                                           gconstpointer dil_bytes, int32_t dil_len,
+                                           gconstpointer dpdb_bytes, int32_t dpdb_len)
 {
 	ERROR_DECL (error);
 	g_assert (assm);
 	g_assert (dmeta_len >= 0);
 	MonoImage *image_base = assm->image;
 	g_assert (image_base);
+	// TODO: use dpdb_bytes
 
 	MonoDomain *domain = mono_domain_get ();
 	mono_image_load_enc_delta (domain, image_base, dmeta_bytes, dmeta_len, dil_bytes, dil_len, error);

src/mono/sample/mbr/DeltaHelper/DeltaHelper.cs

@@ -6,26 +6,23 @@
 
 namespace MonoDelta {
 	public class DeltaHelper {
-		const string name = "System.Runtime.CompilerServices.RuntimeFeature";
-
 		private static MethodBase _updateMethod;
 
 		private static MethodBase UpdateMethod => _updateMethod ?? InitUpdateMethod();
 
 		private static MethodBase InitUpdateMethod ()
 		{
-			var monoType = Type.GetType (name, throwOnError: true);
-			if (monoType == null)
-				throw new Exception ($"Couldn't get the type {name}");
-			_updateMethod = monoType.GetMethod ("LoadMetadataUpdate", BindingFlags.NonPublic | BindingFlags.Static);
-			if (_updateMethod == null)
-				throw new Exception ($"Couldn't get LoadMetadataUpdate from {name}");
-			return _updateMethod;
-		}
+            var monoType = typeof(System.Reflection.Metadata.AssemblyExtensions);
+            const string methodName = "ApplyUpdateSdb";
+            _updateMethod = monoType.GetMethod (methodName, BindingFlags.NonPublic | BindingFlags.Static);
+            if (_updateMethod == null)
+                throw new Exception ($"Couldn't get {methodName} from {monoType.FullName}");
+            return _updateMethod;
+        }
 
-		private static void LoadMetadataUpdate (Assembly assm, byte[] dmeta_data, byte[] dil_data)
+		private static void LoadMetadataUpdate (Assembly assm, byte[] dmeta_data, byte[] dil_data, byte[] dpdb_data)
 		{
-			UpdateMethod.Invoke (null, new object [] { assm, dmeta_data, dil_data});
+			UpdateMethod.Invoke (null, new object [] { assm, dmeta_data, dil_data, dpdb_data});
 		}
 
 		DeltaHelper () { }
@@ -49,7 +46,8 @@ public static void InjectUpdate (string assemblyName, string dmeta_base64, strin
 				throw new ArgumentException ("assemblyName");
 			var dmeta_data = Convert.FromBase64String (dmeta_base64);
 			var dil_data = Convert.FromBase64String (dil_base64);
-			LoadMetadataUpdate (assm, dmeta_data, dil_data);
+            byte[] dpdb_data = null;
+			LoadMetadataUpdate (assm, dmeta_data, dil_data, dpdb_data);
 		}
 
 		private Dictionary<Assembly, int> assembly_count = new Dictionary<Assembly, int> ();
@@ -72,8 +70,9 @@ public void Update (Assembly assm) {
 			string dil_name = $"{basename}.{count}.dil";
 			byte[] dmeta_data = System.IO.File.ReadAllBytes (dmeta_name);
 			byte[] dil_data = System.IO.File.ReadAllBytes (dil_name);
+            byte[] dpdb_data = null; // TODO also use the dpdb data
 
-			LoadMetadataUpdate (assm, dmeta_data, dil_data);
+			LoadMetadataUpdate (assm, dmeta_data, dil_data, dpdb_data);
 		}
 	}
 }