Call into PerfMap logic exclusively in preemptive mode

src/coreclr/System.Private.CoreLib/src/System/Delegate.CoreCLR.cs

@@ -494,27 +494,82 @@ internal static Delegate CreateDelegateForDynamicMethod(Type type, object? targe
             Justification = "The parameter 'methodType' is passed by ref to QCallTypeHandle")]
         private bool BindToMethodName(object? target, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.AllMethods)] RuntimeType methodType, string method, DelegateBindingFlags flags)
         {
-            Delegate d = this;
-            return BindToMethodName(ObjectHandleOnStack.Create(ref d), ObjectHandleOnStack.Create(ref target),
-                new QCallTypeHandle(ref methodType), method, flags);
+            bool ret;
+            BindToMethodDetails bindToMethodDetails;
+
+            unsafe
+            {
+                ret = BindToMethodName(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null,
+                new QCallTypeHandle(ref methodType), method, flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails);
+            }
+
+            if (ret)
+            {
+                // Apply the results of the QCall to the delegate instance.
+                _methodPtr = bindToMethodDetails.methodPtr;
+                _methodPtrAux = bindToMethodDetails.methodPtrAux;
+                _extraData = bindToMethodDetails.extraData;
+                if (bindToMethodDetails.loaderAllocatorGCHandle.IsAllocated)
+                {
+                    _helperObject = bindToMethodDetails.loaderAllocatorGCHandle.Target;
+                    GC.KeepAlive(methodType);
+                }
+
+                if (bindToMethodDetails.selfReferentialTarget != 0)
+                    _target = this;
+                else
+                    _target = target;
+            }
+            return ret;
+        }
+
+        private struct BindToMethodDetails
+        {
+            public int selfReferentialTarget; // Whether the delegate's target object is the same as the first argument of the method to bind to. Only meaningful for open instance delegates.
+            public IntPtr methodPtr;
+            public IntPtr methodPtrAux;
+            public IntPtr extraData;
+            public GCHandle loaderAllocatorGCHandle; // The loader allocator needed if the delegate needs to keep it alive
         }
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodName", StringMarshalling = StringMarshalling.Utf8)]
         [return: MarshalAs(UnmanagedType.Bool)]
-        private static partial bool BindToMethodName(ObjectHandleOnStack d, ObjectHandleOnStack target, QCallTypeHandle methodType, string method, DelegateBindingFlags flags);
+        private static partial bool BindToMethodName(MethodTable* pDelegateMT, MethodTable *pTargetMT, QCallTypeHandle methodType, string method, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails);
 
         private bool BindToMethodInfo(object? target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags)
         {
-            Delegate d = this;
-            bool ret = BindToMethodInfo(ObjectHandleOnStack.Create(ref d), ObjectHandleOnStack.Create(ref target),
-                method.Value, new QCallTypeHandle(ref methodType), flags);
-            GC.KeepAlive(method);
+            bool ret;
+            BindToMethodDetails bindToMethodDetails;
+
+            unsafe
+            {
+                ret = BindToMethodInfo(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null,
+                    IRuntimeMethodInfo.GetValue(method), new QCallTypeHandle(ref methodType), flags, ObjectHandleOnStack.Create(ref target), out bindToMethodDetails);
+            }
+
+            if (ret)
+            {
+                // Apply the results of the QCall to the delegate instance.
+                _methodPtr = bindToMethodDetails.methodPtr;
+                _methodPtrAux = bindToMethodDetails.methodPtrAux;
+                _extraData = bindToMethodDetails.extraData;
+                if (bindToMethodDetails.loaderAllocatorGCHandle.IsAllocated)
+                {
+                    _helperObject = bindToMethodDetails.loaderAllocatorGCHandle.Target;
+                    GC.KeepAlive(method);
+                }
+
+                if (bindToMethodDetails.selfReferentialTarget != 0)
+                    _target = this;
+                else
+                    _target = target;
+            }
             return ret;
         }
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_BindToMethodInfo")]
         [return: MarshalAs(UnmanagedType.Bool)]
-        private static partial bool BindToMethodInfo(ObjectHandleOnStack d, ObjectHandleOnStack target, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags);
+        private static partial bool BindToMethodInfo(MethodTable* pDelegateMT, MethodTable *pTargetMT, RuntimeMethodHandleInternal method, QCallTypeHandle methodType, DelegateBindingFlags flags, ObjectHandleOnStack targetParameter, out BindToMethodDetails bindToMethodDetails);
 
         private static Delegate InternalAlloc(RuntimeType type)
         {
@@ -562,12 +617,31 @@ private void DelegateConstruct(object target, IntPtr method)
                 throw new ArgumentNullException(nameof(method));
             }
 
-            Delegate _this = this;
-            Construct(ObjectHandleOnStack.Create(ref _this), ObjectHandleOnStack.Create(ref target), method);
+            BindToMethodDetails bindToMethodDetails;
+
+            unsafe
+            {
+                Construct(RuntimeHelpers.GetMethodTable(this), (target != null) ? RuntimeHelpers.GetMethodTable(target) : null,
+                    method, out bindToMethodDetails);
+            }
+
+            // Apply the results of the QCall to the delegate instance.
+            _methodPtr = bindToMethodDetails.methodPtr;
+            _methodPtrAux = bindToMethodDetails.methodPtrAux;
+            _extraData = bindToMethodDetails.extraData;
+            if (bindToMethodDetails.loaderAllocatorGCHandle.IsAllocated)
+            {
+                _helperObject = bindToMethodDetails.loaderAllocatorGCHandle.Target;
+            }
+
+            if (bindToMethodDetails.selfReferentialTarget != 0)
+                _target = this;
+            else
+                _target = target;
         }
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_Construct")]
-        private static partial void Construct(ObjectHandleOnStack _this, ObjectHandleOnStack target, IntPtr method);
+        private static partial void Construct(MethodTable* pDelegateMT, MethodTable* pTargetMT, IntPtr method, out BindToMethodDetails bindToMethodDetails);
 
         [MethodImpl(MethodImplOptions.InternalCall)]
         private static extern unsafe void* GetMulticastInvoke(MethodTable* pMT);
@@ -805,11 +879,16 @@ private static Wrapper[] DeleteFromInvocationList(ReadOnlySpan<Wrapper> invocati
 
         internal static IntPtr AdjustTarget(object target, IntPtr methodPtr)
         {
-            return AdjustTarget(ObjectHandleOnStack.Create(ref target), methodPtr);
+            unsafe
+            {
+                IntPtr result = AdjustTarget(RuntimeHelpers.GetMethodTable(target), methodPtr);
+                GC.KeepAlive(target);
+                return result;
+            }
         }
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Delegate_AdjustTarget")]
-        private static partial IntPtr AdjustTarget(ObjectHandleOnStack target, IntPtr methodPtr);
+        private static partial IntPtr AdjustTarget(MethodTable* targetMT, IntPtr methodPtr);
 
         internal void InitializeVirtualCallStub(IntPtr methodPtr)
         {

src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicILGenerator.cs

@@ -652,7 +652,7 @@ internal DynamicResolver(DynamicILInfo dynamicILInfo)
 
             // We can never ever have two active destroy scouts for the same method. We need to initialize the scout
             // outside the try/reregister block to avoid possibility of reregistration for finalization with active scout.
-            scout.m_methodHandle = method._methodHandle.Value;
+            scout.m_methodHandle = IRuntimeMethodInfo.GetValue(method._methodHandle);
         }
 
         private sealed class DestroyScout
@@ -1028,7 +1028,7 @@ public int GetTokenFor(RuntimeMethodHandle method)
             IRuntimeMethodInfo methodReal = method.GetMethodInfo();
             if (methodReal != null)
             {
-                RuntimeMethodHandleInternal rmhi = methodReal.Value;
+                RuntimeMethodHandleInternal rmhi = IRuntimeMethodInfo.GetValue(methodReal);
                 if (!RuntimeMethodHandle.IsDynamicMethod(rmhi))
                 {
                     RuntimeType type = RuntimeMethodHandle.GetDeclaringType(rmhi);

src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/DynamicMethod.CoreCLR.cs

@@ -51,7 +51,7 @@ public sealed override Delegate CreateDelegate(Type delegateType, object? target
                 // Compile the method since accessibility checks are done as part of compilation
                 GetMethodDescriptor();
                 IRuntimeMethodInfo? methodHandle = _methodHandle;
-                CompileMethod(methodHandle != null ? methodHandle.Value : RuntimeMethodHandleInternal.EmptyHandle);
+                CompileMethod(methodHandle != null ? IRuntimeMethodInfo.GetValue(methodHandle) : RuntimeMethodHandleInternal.EmptyHandle);
                 GC.KeepAlive(methodHandle);
             }
 

src/coreclr/System.Private.CoreLib/src/System/Reflection/Emit/RuntimeModuleBuilder.cs

@@ -129,7 +129,7 @@ private int GetMemberRefOfMethodInfo(int tr, RuntimeMethodInfo method)
             Debug.Assert(method != null);
 
             RuntimeModuleBuilder thisModule = this;
-            int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, ((IRuntimeMethodInfo)method).Value);
+            int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method));
             GC.KeepAlive(method);
             return result;
         }
@@ -139,7 +139,7 @@ private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method)
             Debug.Assert(method != null);
 
             RuntimeModuleBuilder thisModule = this;
-            int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, ((IRuntimeMethodInfo)method).Value);
+            int result = GetMemberRefOfMethodInfo(new QCallModule(ref thisModule), tr, IRuntimeMethodInfo.GetValue(method));
             GC.KeepAlive(method);
             return result;
         }

src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeConstructorInfo.CoreCLR.cs

@@ -66,8 +66,6 @@ internal RuntimeConstructorInfo(
         #endregion
 
         #region NonPublic Methods
-        RuntimeMethodHandleInternal IRuntimeMethodInfo.Value => new RuntimeMethodHandleInternal(m_handle);
-
         internal override bool CacheEquals(object? o) =>
             o is RuntimeConstructorInfo m && m.m_handle == m_handle &&
             ReferenceEquals(m_declaringType, m.m_declaringType);

src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeCustomAttributeData.cs

@@ -1701,7 +1701,7 @@ private static bool FilterCustomAttributeRecord(
             RuntimeTypeHandle attributeTypeHandle = attributeType.TypeHandle;
 
             bool result = RuntimeMethodHandle.IsCAVisibleFromDecoratedType(new QCallTypeHandle(ref attributeTypeHandle),
-                                                                    ctorWithParameters is not null ? ctorWithParameters.Value : RuntimeMethodHandleInternal.EmptyHandle,
+                                                                    ctorWithParameters is not null ? IRuntimeMethodInfo.GetValue(ctorWithParameters) : RuntimeMethodHandleInternal.EmptyHandle,
                                                                     new QCallTypeHandle(ref parentTypeHandle),
                                                                     new QCallModule(ref decoratedModule)) != Interop.BOOL.FALSE;
 

src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs

@@ -69,8 +69,6 @@ internal RuntimeMethodInfo(
         #endregion
 
         #region Private Methods
-        RuntimeMethodHandleInternal IRuntimeMethodInfo.Value => new RuntimeMethodHandleInternal(m_handle);
-
         private RuntimeType ReflectedTypeInternal => m_reflectedTypeCache.GetRuntimeType();
 
         private ParameterInfo[] FetchNonReturnParameters() =>

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs

@@ -213,7 +213,7 @@ public static unsafe void PrepareMethod(RuntimeMethodHandle method, RuntimeTypeH
             ReadOnlySpan<IntPtr> instantiationHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(instantiation, stackScratch: stackalloc IntPtr[8]);
             fixed (IntPtr* pInstantiation = instantiationHandles)
             {
-                PrepareMethod(methodInfo.Value, pInstantiation, instantiationHandles.Length);
+                PrepareMethod(IRuntimeMethodInfo.GetValue(methodInfo), pInstantiation, instantiationHandles.Length);
                 GC.KeepAlive(instantiation);
                 GC.KeepAlive(methodInfo);
             }

src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/Marshal.CoreCLR.cs

@@ -217,7 +217,7 @@ private static void PrelinkCore(MethodInfo m)
                 throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(m));
             }
 
-            InternalPrelink(((IRuntimeMethodInfo)rmi).Value);
+            InternalPrelink(IRuntimeMethodInfo.GetValue(rmi));
             GC.KeepAlive(rmi);
         }