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);
  }
 

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);
  }
 

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);
  }
 

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);
  }
 

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);
  }
 

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);
  }
 

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);
  }
 

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);
  }