Add hot reload apply changes API: AssemblyExtensions.ApplyUpdate

Issue: dotnet#45689

Currently Windows only.

Fail hot reload API if debugging.

Author: Mike McLaughlin

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

@@ -40,5 +40,54 @@ public static unsafe bool TryGetRawMetadata(this Assembly assembly, out byte* bl
 
             return InternalTryGetRawMetadata(new QCallAssembly(ref rtAsm), ref blob, ref length);
         }
+
+        [DllImport(RuntimeHelpers.QCall)]
+        private static extern unsafe int ApplyHotReloadUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength);
+
+        /// <summary>
+        /// Hot reload update API
+        /// Applies an update to the given assembly using the metadata, IL and PDB deltas. Currently executing
+        /// methods will continue to use the existing IL. New executions of modified methods will use the new
+        /// IL. The supported changes are runtime specific - different .NET runtimes may have different
+        /// limitations. The runtime makes no guarantees if the delta includes unsupported changes.
+        /// </summary>
+        /// <param name="assembly">The assembly to update</param>
+        /// <param name="metadataDelta">The metadata changes</param>
+        /// <param name="ilDelta">The IL changes</param>
+        /// <param name="pdbDelta">The PDB changes. Current not supported on .NET Core</param>
+        /// <exception cref="ArgumentNullException">if assembly parameter is null</exception>
+        /// <exception cref="NotSupportedException">update failed</exception>
+        public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta = default)
+        {
+            if (assembly == null)
+            {
+                throw new ArgumentNullException(nameof(assembly));
+            }
+
+            RuntimeAssembly? runtimeAssembly = assembly as RuntimeAssembly;
+            if (runtimeAssembly == null)
+            {
+                throw new ArgumentException("Not a RuntimeAssembly", nameof(assembly));
+            }
+
+            unsafe
+            {
+                RuntimeAssembly rtAsm = runtimeAssembly;
+                fixed (byte* metadataDeltaPtr = metadataDelta, ilDeltaPtr = ilDelta, pdbDeltaPtr = pdbDelta)
+                {
+                    if (ApplyHotReloadUpdate(
+                        new QCallAssembly(ref rtAsm),
+                        metadataDeltaPtr,
+                        metadataDelta.Length,
+                        ilDeltaPtr,
+                        ilDelta.Length,
+                        pdbDeltaPtr,
+                        pdbDelta.Length) != 0)
+                    {
+                        throw new NotSupportedException();
+                    }
+                }
+            }
+        }
     }
 }

src/coreclr/vm/assemblynative.cpp

@@ -25,6 +25,8 @@
 #include "interoputil.h"
 #include "frames.h"
 #include "typeparse.h"
+#include "encee.h"
+#include "threadsuspend.h"
 
 #include "appdomainnative.hpp"
 #include "../binder/inc/bindertracing.h"
@@ -1407,3 +1409,57 @@ void QCALLTYPE AssemblyNative::TraceSatelliteSubdirectoryPathProbed(LPCWSTR file
 
     END_QCALL;
 }
+
+// static
+INT32 QCALLTYPE AssemblyNative::ApplyHotReloadUpdate(
+    QCall::AssemblyHandle assembly,
+    UINT8* metadataDelta,
+    INT32 metadataDeltaLength,
+    UINT8* ilDelta,
+    INT32 ilDeltaLength,
+    UINT8* pdbDelta,
+    INT32 pdbDeltaLength)
+{
+    QCALL_CONTRACT;
+
+    INT32 result = E_NOTIMPL;
+
+    BEGIN_QCALL;
+
+    _ASSERTE(assembly != nullptr);
+    _ASSERTE(metadataDelta != nullptr);
+    _ASSERTE(metadataDeltaLength > 0);
+    _ASSERTE(ilDelta != nullptr);
+    _ASSERTE(ilDeltaLength > 0);
+
+#ifdef EnC_SUPPORTED
+    GCX_COOP();
+    {
+        if (!CORDebuggerAttached())
+        {
+            // Suspend the runtime.
+            ThreadSuspend::SuspendEE(ThreadSuspend::SUSPEND_OTHER);
+
+            Module* pModule = assembly->GetDomainAssembly()->GetModule();
+            if (pModule->IsEditAndContinueEnabled())
+            {
+                result = ((EditAndContinueModule*)pModule)->ApplyEditAndContinue(metadataDeltaLength, metadataDelta, ilDeltaLength, ilDelta);
+            }
+            else
+            {
+                result = E_INVALIDARG;
+            }
+
+            ThreadSuspend::RestartEE(FALSE, TRUE);
+        }
+        else
+        {
+            result = E_ACCESSDENIED;
+        }
+    }
+#endif
+
+    END_QCALL;
+
+    return result;
+}

src/coreclr/vm/assemblynative.hpp

@@ -127,6 +127,8 @@ class AssemblyNative
     static void QCALLTYPE TraceAssemblyResolveHandlerInvoked(LPCWSTR assemblyName, LPCWSTR handlerName, LPCWSTR resultAssemblyName, LPCWSTR resultAssemblyPath);
     static void QCALLTYPE TraceAssemblyLoadFromResolveHandlerInvoked(LPCWSTR assemblyName, bool isTrackedAssembly, LPCWSTR requestingAssemblyPath, LPCWSTR requestedAssemblyPath);
     static void QCALLTYPE TraceSatelliteSubdirectoryPathProbed(LPCWSTR filePath, HRESULT hr);
+
+    static INT32 QCALLTYPE ApplyHotReloadUpdate(QCall::AssemblyHandle assembly, UINT8* metadataDelta, INT32 metadataDeltaLength, UINT8* ilDelta, INT32 ilDeltaLength, UINT8* pdbDelta, INT32 pdbDeltaLength);
 };
 
 #endif

src/coreclr/vm/ecalllist.h

@@ -440,6 +440,7 @@ FCFuncEnd()
 
 FCFuncStart(gAssemblyExtensionsFuncs)
     QCFuncElement("InternalTryGetRawMetadata", AssemblyNative::InternalTryGetRawMetadata)
+    QCFuncElement("ApplyHotReloadUpdate", AssemblyNative::ApplyHotReloadUpdate)
 FCFuncEnd()
 
 FCFuncStart(gAssemblyLoadContextFuncs)

src/coreclr/vm/encee.cpp

@@ -173,9 +173,9 @@ HRESULT EditAndContinueModule::ApplyEditAndContinue(
     // Ensure the metadata is RW.
     EX_TRY
     {
-        // ConvertMetadataToRWForEnC should only ever be called on EnC capable files.
+        // ConvertMDInternalToReadWrite should only ever be called on EnC capable files.
         _ASSERTE(IsEditAndContinueCapable()); // this also checks that the file is EnC capable
-        GetFile()->ConvertMetadataToRWForEnC();
+        GetFile()->ConvertMDInternalToReadWrite();
     }
     EX_CATCH_HRESULT(hr);
 
@@ -310,10 +310,13 @@ HRESULT EditAndContinueModule::UpdateMethod(MethodDesc *pMethod)
     CONTRACTL_END;
 
     // Notify the debugger of the update
-    HRESULT hr = g_pDebugInterface->UpdateFunction(pMethod, m_applyChangesCount);
-    if (FAILED(hr))
+    if (CORDebuggerAttached())
     {
-        return hr;
+        HRESULT hr = g_pDebugInterface->UpdateFunction(pMethod, m_applyChangesCount);
+        if (FAILED(hr))
+        {
+            return hr;
+        }
     }
 
     // Notify the JIT that we've got new IL for this method
@@ -375,7 +378,10 @@ HRESULT EditAndContinueModule::AddMethod(mdMethodDef token)
         // Class isn't loaded yet, don't have to modify any existing EE data structures beyond the metadata.
         // Just notify debugger and return.
         LOG((LF_ENC, LL_INFO100, "EnCModule::AM class %p not loaded, our work is done\n", parentTypeDef));
-        hr = g_pDebugInterface->UpdateNotYetLoadedFunction(token, this, m_applyChangesCount);
+        if (CORDebuggerAttached())
+        {
+            hr = g_pDebugInterface->UpdateNotYetLoadedFunction(token, this, m_applyChangesCount);
+        }
         return hr;
     }
 
@@ -392,11 +398,14 @@ HRESULT EditAndContinueModule::AddMethod(mdMethodDef token)
     }
 
     // Tell the debugger about the new method so it get's the version number properly
-    hr = g_pDebugInterface->AddFunction(pMethod, m_applyChangesCount);
-    if (FAILED(hr))
+    if (CORDebuggerAttached())
     {
-        _ASSERTE(!"Failed to add function");
-        LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add method %p to debugger with hr 0x%x\n", token));
+        hr = g_pDebugInterface->AddFunction(pMethod, m_applyChangesCount);
+        if (FAILED(hr))
+        {
+            _ASSERTE(!"Failed to add function");
+            LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add method %p to debugger with hr 0x%x\n", token));
+        }
     }
 
     return hr;
@@ -463,10 +472,13 @@ HRESULT EditAndContinueModule::AddField(mdFieldDef token)
     }
 
     // Tell the debugger about the new field
-    hr = g_pDebugInterface->AddField(pField, m_applyChangesCount);
-    if (FAILED(hr))
+    if (CORDebuggerAttached())
     {
-        LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add field %p to debugger with hr 0x%x\n", token));
+        hr = g_pDebugInterface->AddField(pField, m_applyChangesCount);
+        if (FAILED(hr))
+        {
+            LOG((LF_ENC, LL_INFO100000, "**Error** EACM::AF: Failed to add field %p to debugger with hr 0x%x\n", token));
+        }
     }
 
 #ifdef _DEBUG

src/coreclr/vm/pefile.cpp

@@ -747,30 +747,6 @@ void PEFile::ConvertMDInternalToReadWrite()
     }
 }
 
-void PEFile::ConvertMetadataToRWForEnC()
-{
-    CONTRACTL
-    {
-        THROWS;
-        GC_NOTRIGGER;
-        MODE_ANY;
-    }
-    CONTRACTL_END;
-
-    // This should only ever be called on EnC capable files.
-    // One can check this using Module::IsEditAndContinueCapable().
-
-    // This should only be called if we're debugging, stopped, and on the helper thread.
-    _ASSERTE(CORDebuggerAttached());
-    _ASSERTE((g_pDebugInterface != NULL) && g_pDebugInterface->ThisIsHelperThread());
-    _ASSERTE((g_pDebugInterface != NULL) && g_pDebugInterface->IsStopped());
-
-    // Convert the metadata to RW for Edit and Continue, properly replacing the metadata import interface pointer and
-    // properly preserving the old importer. This will be called before the EnC system tries to apply a delta to the module's
-    // metadata. ConvertMDInternalToReadWrite() does that quite nicely for us.
-    ConvertMDInternalToReadWrite();
-}
-
 void PEFile::OpenMDImport_Unsafe()
 {
     CONTRACTL

src/coreclr/vm/pefile.h

@@ -427,7 +427,6 @@ class PEFile
     void OpenImporter();
     void OpenEmitter();
 
-    void ConvertMDInternalToReadWrite();
     void ReleaseMetadataInterfaces(BOOL bDestructor, BOOL bKeepNativeData=FALSE);
 
 
@@ -536,7 +535,7 @@ class PEFile
 
     static PEFile* Dummy();
     void MarkNativeImageInvalidIfOwned();
-    void ConvertMetadataToRWForEnC();
+    void ConvertMDInternalToReadWrite();
 
 protected:
     PTR_ICLRPrivAssembly m_pHostAssembly;

src/libraries/System.Runtime.Loader/ref/System.Runtime.Loader.cs

@@ -10,6 +10,7 @@ public static partial class AssemblyExtensions
     {
         [System.CLSCompliantAttribute(false)]
         public unsafe static bool TryGetRawMetadata(this System.Reflection.Assembly assembly, out byte* blob, out int length) { throw null; }
+        public static void ApplyUpdate(Assembly assembly, ReadOnlySpan<byte> metadataDelta, ReadOnlySpan<byte> ilDelta, ReadOnlySpan<byte> pdbDelta = default) { throw null; }
     }
 }
 namespace System.Runtime.Loader