Add public Invoker 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" />
@@ -219,6 +220,7 @@
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeLibrary.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\Intrinsics\X86\X86Base.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\Loader\AssemblyLoadContext.CoreCLR.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\RuntimeImports.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\Versioning\CompatibilitySwitch.cs" />
     <Compile Include="$(BclSourcesRoot)\System\RuntimeArgumentHandle.cs" />
     <Compile Include="$(BclSourcesRoot)\System\RuntimeHandles.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
+        internal 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.Diagnostics;
+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)
+        internal 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;
-            }
+        internal unsafe MethodInvoker(DynamicMethod method) : this(method, method.Signature.Arguments)
+        {
+            _signature = method.Signature;
+            _invokeFunc_RefArgs = InterpretedInvoke_Method;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+        internal 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
+        internal 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
                         {