Add hot reload apply changes API: AssemblyExtensions.ApplyUpdate

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

@@ -40,5 +40,46 @@ 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 void ApplyUpdate(QCallAssembly assembly, byte* metadataDelta, int metadataDeltaLength, byte* ilDelta, int ilDeltaLength, byte* pdbDelta, int pdbDeltaLength);
+
+        /// <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)
+        {
+            if (assembly == null)
+            {
+                throw new ArgumentNullException(nameof(assembly));
+            }
+
+            RuntimeAssembly? runtimeAssembly = assembly as RuntimeAssembly;
+            if (runtimeAssembly == null)
+            {
+                throw new ArgumentException(SR.Argument_MustBeRuntimeAssembly);
+            }
+
+            unsafe
+            {
+                RuntimeAssembly rtAsm = runtimeAssembly;
+                fixed (byte* metadataDeltaPtr = metadataDelta, ilDeltaPtr = ilDelta, pdbDeltaPtr = pdbDelta)
+                {
+                    ApplyUpdate(new QCallAssembly(ref rtAsm), metadataDeltaPtr, metadataDelta.Length, ilDeltaPtr, ilDelta.Length, pdbDeltaPtr, pdbDelta.Length);
+                }
+            }
+        }
     }
 }

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,48 @@ void QCALLTYPE AssemblyNative::TraceSatelliteSubdirectoryPathProbed(LPCWSTR file
 
     END_QCALL;
 }
+
+// static
+void QCALLTYPE AssemblyNative::ApplyUpdate(
+    QCall::AssemblyHandle assembly,
+    UINT8* metadataDelta,
+    INT32 metadataDeltaLength,
+    UINT8* ilDelta,
+    INT32 ilDeltaLength,
+    UINT8* pdbDelta,
+    INT32 pdbDeltaLength)
+{
+    QCALL_CONTRACT;
+
+    BEGIN_QCALL;
+
+    _ASSERTE(assembly != nullptr);
+    _ASSERTE(metadataDelta != nullptr);
+    _ASSERTE(metadataDeltaLength > 0);
+    _ASSERTE(ilDelta != nullptr);
+    _ASSERTE(ilDeltaLength > 0);
+
+#ifdef EnC_SUPPORTED
+    GCX_COOP();
+    {
+        if (CORDebuggerAttached())
+        {
+            COMPlusThrow(kNotSupportedException);
+        }
+        Module* pModule = assembly->GetDomainAssembly()->GetModule();
+        if (!pModule->IsEditAndContinueEnabled())
+        {
+            COMPlusThrow(kInvalidOperationException, W("InvalidOperation_AssemblyNotEditable"));
+        }
+        HRESULT hr = ((EditAndContinueModule*)pModule)->ApplyEditAndContinue(metadataDeltaLength, metadataDelta, ilDeltaLength, ilDelta);
+        if (FAILED(hr))
+        {
+            COMPlusThrow(kInvalidOperationException, W("InvalidOperation_EditFailed"));
+        }
+    }
+#else
+    COMPlusThrow(kNotImplementedException);
+#endif
+
+    END_QCALL;
+}

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 void QCALLTYPE ApplyUpdate(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("ApplyUpdate", AssemblyNative::ApplyUpdate)
 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;
     }
 
@@ -391,12 +397,15 @@ HRESULT EditAndContinueModule::AddMethod(mdMethodDef token)
         return hr;
     }
 
-    // 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))
+    // Tell the debugger about the new method so it gets the version number properly
+    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.Private.CoreLib/src/Resources/Strings.resx

@@ -3673,4 +3673,10 @@
   <data name="ResourceManager_ReflectionNotAllowed" xml:space="preserve">
     <value>Use of ResourceManager for custom types is disabled. Set the MSBuild Property CustomResourceTypesSupport to true in order to enable it.</value>
   </data>
+  <data name="InvalidOperation_AssemblyNotEditable" xml:space="preserve">
+    <value>The assembly can not be edited or changed.</value>
+  </data>
+  <data name="InvalidOperation_EditFailed" xml:space="preserve">
+    <value>The assembly update failed.</value>
+  </data>
 </root>