Add public MethodInvoker and ConstructorInvoker classes

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {

src/coreclr/System.Private.CoreLib/System.Private.CoreLib.csproj

@@ -185,6 +185,7 @@
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\AssemblyExtensions.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\Metadata\MetadataUpdater.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBase.CoreCLR.cs" />
+ <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodBaseInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\MethodInvoker.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\ModifiedType.CoreCLR.cs" />
  <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />

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

@@ -1,18 +1,21 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
-
 namespace System.Reflection
 {
-internal partial class ConstructorInvoker
+public partial class ConstructorInvoker
  {
- public InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
+
+ internal unsafe ConstructorInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke;
+ }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe object? InterpretedInvoke(object? obj, IntPtr* args)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+ return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
  }
 }

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

@@ -24,7 +24,7 @@ public sealed partial class DynamicMethod : MethodInfo
  private Module _module;
  internal bool _skipVisibility;
  internal RuntimeType? _typeOwner;
- private MethodInvoker? _invoker;
+ private MethodBaseInvoker? _invoker;
  private Signature? _signature;
  private string _name;
  private MethodAttributes _attributes;
@@ -85,12 +85,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
  return new RuntimeMethodHandle(_methodHandle!);
  }
 
- private MethodInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- return _invoker ??= new MethodInvoker(this, Signature);
+ return _invoker ??= new MethodBaseInvoker(this, Signature);
  }
  }
 
@@ -134,136 +134,28 @@ Signature LazyCreateSignature()
  throw new TargetParameterCountException(SR.Arg_ParmCnt);
 
  object? retValue;
-
- unsafe
+ switch (argCount)
  {
- if (argCount == 0)
- {
- retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
- }
- else if (argCount > MaxStackAllocArgCount)
- {
- Debug.Assert(parameters != null);
- retValue = InvokeWithManyArguments(this, argCount, obj, invokeAttr, binder, parameters, culture);
- }
- else
- {
- Debug.Assert(parameters != null);
- StackAllocedArguments argStorage = default;
- Span<object?> copyOfParameters = argStorage._args.AsSpan(argCount);
- Span<ParameterCopyBackAction> shouldCopyBackParameters = argStorage._copyBacks.AsSpan(argCount);
-
- StackAllocatedByRefs byrefStorage = default;
-#pragma warning disable CS8500
- IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
-#pragma warning restore CS8500
-
- CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
- }
+ case 0:
+ retValue = Invoker.InvokeWithNoArgs(obj, invokeAttr);
+ break;
+ case 1:
+ retValue = Invoker.InvokeWithOneArg(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ case 2:
+ case 3:
+ case 4:
+ retValue = Invoker.InvokeWithFewArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
+ default:
+ retValue = Invoker.InvokeWithManyArgs(obj, invokeAttr, binder, parameters!, culture);
+ break;
  }
 
  GC.KeepAlive(this);
  return retValue;
  }
 
- // Slower path that does a heap alloc for copyOfParameters and registers byrefs to those objects.
- // This is a separate method to support better performance for the faster paths.
- private static unsafe object? InvokeWithManyArguments(
- DynamicMethod mi,
- int argCount,
- object? obj,
- BindingFlags invokeAttr,
- Binder? binder,
- object?[] parameters,
- CultureInfo? culture)
- {
- object[] objHolder = new object[argCount];
- Span<object?> copyOfParameters = new(objHolder, 0, argCount);
-
- // We don't check a max stack size since we are invoking a method which
- // naturally requires a stack size that is dependent on the arg count\size.
- IntPtr* pByRefStorage = stackalloc IntPtr[argCount];
- NativeMemory.Clear(pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
-
- ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
- Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
-
- GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
-
- object? retValue;
- try
- {
- RegisterForGCReporting(&reg);
- mi.CheckArguments(
- copyOfParameters,
- pByRefStorage,
- shouldCopyBackParameters,
- parameters,
- mi.Signature.Arguments,
- binder,
- culture,
- invokeAttr);
-
- retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
- }
- finally
- {
- UnregisterForGCReporting(&reg);
- }
-
- // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
- for (int i = 0; i < argCount; i++)
- {
- ParameterCopyBackAction action = shouldCopyBackParameters[i];
- if (action != ParameterCopyBackAction.None)
- {
- if (action == ParameterCopyBackAction.Copy)
- {
- parameters[i] = copyOfParameters[i];
- }
- else
- {
- Debug.Assert(action == ParameterCopyBackAction.CopyNullable);
- Debug.Assert(copyOfParameters[i] != null);
- Debug.Assert(((RuntimeType)copyOfParameters[i]!.GetType()).IsNullableOfT);
- parameters[i] = RuntimeMethodHandle.ReboxFromNullable(copyOfParameters[i]);
- }
- }
- }
-
- return retValue;
- }
-
  public DynamicILInfo GetDynamicILInfo()
  {
  if (_dynamicILInfo == null)

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

@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Reflection.Emit;
+
+namespace System.Reflection
+{
+ internal partial class MethodBaseInvoker
+ {
+ private readonly Signature? _signature;
+
+ internal unsafe MethodBaseInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ internal unsafe MethodBaseInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
+ {
+ _signature = constructor.Signature;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ }
+
+ internal unsafe MethodBaseInvoker(DynamicMethod method, Signature signature) : this(method, signature.Arguments)
+ {
+ _signature = signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ }
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor : false);
+ }
+}

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

@@ -1,36 +1,39 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Runtime.CompilerServices;
+using System.Reflection.Emit;
 
 namespace System.Reflection
 {
-internal partial class MethodInvoker
+public partial class MethodInvoker
  {
- private readonly Signature _signature;
- internal InvocationFlags _invocationFlags;
+ private readonly Signature? _signature;
 
-public MethodInvoker(MethodBase method, Signature signature)
+private unsafe MethodInvoker(RuntimeMethodInfo method) : this(method, method.Signature.Arguments)
  {
- _method = method;
- _signature = signature;
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ _invocationFlags = method.ComputeAndUpdateInvocationFlags();
+ }
 
- if (LocalAppContextSwitches.ForceInterpretedInvoke && !LocalAppContextSwitches.ForceEmitInvoke)
- {
- // Always use the native invoke; useful for testing.
- _strategyDetermined = true;
- }
- else if (LocalAppContextSwitches.ForceEmitInvoke && !LocalAppContextSwitches.ForceInterpretedInvoke)
- {
- // Always use emit invoke (if IsDynamicCodeSupported == true); useful for testing.
- _invoked = true;
- }
+ private unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+ {
+ _signature = method.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Method;
+ // No _invocationFlags for DynamicMethod.
  }
 
- [MethodImpl(MethodImplOptions.AggressiveInlining)]
- private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+ private unsafe MethodInvoker(RuntimeConstructorInfo constructor) : this(constructor, constructor.Signature.Arguments)
  {
- return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+ _signature = constructor.Signature;
+ _invokeFunc_RefArgs = InterpretedInvoke_Constructor;
+ _invocationFlags = constructor.ComputeAndUpdateInvocationFlags();
  }
+
+ private unsafe object? InterpretedInvoke_Method(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: false);
+
+ private unsafe object? InterpretedInvoke_Constructor(object? obj, IntPtr* args) =>
+ RuntimeMethodHandle.InvokeMethod(obj, (void**)args, _signature!, isConstructor: obj is null);
  }
 }

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

@@ -194,18 +194,17 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
  CheckConsistency(obj);
 
- ParameterCopyBackAction _ref = default;
  RuntimeType fieldType = (RuntimeType)FieldType;
  if (value is null)
  {
  if (RuntimeTypeHandle.IsValueType(fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
  }
  else if (!ReferenceEquals(value.GetType(), fieldType))
  {
- fieldType.CheckValue(ref value, copyBack: ref _ref, binder, culture, invokeAttr);
+ fieldType.CheckValue(ref value, binder, culture, invokeAttr);
  }
 
  bool domainInitialized = false;

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

@@ -4,7 +4,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
 using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 using System.Text;
@@ -29,28 +28,25 @@ internal sealed partial class RuntimeConstructorInfo : ConstructorInfo, IRuntime
  private readonly MethodAttributes m_methodAttributes;
  private readonly BindingFlags m_bindingFlags;
  private Signature? m_signature;
- private ConstructorInvoker? m_invoker;
+ private MethodBaseInvoker? m_invoker;
 
  internal InvocationFlags InvocationFlags
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
  InvocationFlags flags = Invoker._invocationFlags;
- if ((flags & InvocationFlags.Initialized) == 0)
- {
- flags = ComputeAndUpdateInvocationFlags(this, ref Invoker._invocationFlags);
- }
+ Debug.Assert((flags & InvocationFlags.Initialized) == InvocationFlags.Initialized);
  return flags;
  }
  }
 
- private ConstructorInvoker Invoker
+ private MethodBaseInvoker Invoker
  {
  [MethodImpl(MethodImplOptions.AggressiveInlining)]
  get
  {
- m_invoker ??= new ConstructorInvoker(this);
+ m_invoker ??= new MethodBaseInvoker(this);
  return m_invoker;
  }
  }

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

@@ -1259,7 +1259,7 @@ private static void AddCustomAttributes(
  continue;
  }
 
- setMethod.InvokeOneParameter(attribute, BindingFlags.Default, null, value, null);
+ setMethod.InvokePropertySetter(attribute, BindingFlags.Default, null, value, null);
  }
  else
  {