Add IL Emit support for MethodInfo.Invoke() and friends

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

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <EnableDefaultItems>false</EnableDefaultItems>
@@ -155,12 +155,12 @@
     <Compile Include="$(BclSourcesRoot)\System\Reflection\AssemblyName.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Associates.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\ConstructorInfo.CoreCLR.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Reflection\ConstructorInvoker.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\AssemblyBuilder.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\ConstructorBuilder.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\CustomAttributeBuilder.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicILGenerator.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicMethod.cs" />
-    <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\DynamicMethodInvoker.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\EnumBuilder.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\EventBuilder.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\Emit\FieldBuilder.cs" />
@@ -187,6 +187,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\MethodInvoker.CoreCLR.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\RtFieldInfo.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\RuntimeAssembly.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Reflection\RuntimeConstructorInfo.CoreCLR.cs" />

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

@@ -0,0 +1,18 @@
+// 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 InvocationFlags _invocationFlags;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+        {
+            return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _method.Signature, isConstructor: obj is null)!;
+        }
+    }
+}

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

@@ -23,7 +23,7 @@ public sealed class DynamicMethod : MethodInfo
         private RuntimeModule m_module = null!;
         internal bool m_skipVisibility;
         internal RuntimeType? m_typeOwner; // can be null
-        private DynamicMethodInvoker? _invoker;
+        private MethodInvoker? _invoker;
         private Signature? _signature;
 
         // We want the creator of the DynamicMethod to control who has access to the
@@ -434,13 +434,12 @@ internal RuntimeMethodHandle GetMethodDescriptor()
 
         public override bool IsSecurityTransparent => false;
 
-        private DynamicMethodInvoker Invoker
+        private MethodInvoker Invoker
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                _invoker ??= new DynamicMethodInvoker(this);
-
+                _invoker ??= new MethodInvoker(this, Signature);
                 return _invoker;
             }
         }
@@ -490,7 +489,7 @@ Signature LazyCreateSignature()
             {
                 if (argCount == 0)
                 {
-                    retValue = Invoker.InvokeUnsafe(obj, args: default, invokeAttr);
+                    retValue = Invoker.InlinedInvoke(obj, args: default, invokeAttr);
                 }
                 else if (argCount > MaxStackAllocArgCount)
                 {
@@ -501,8 +500,8 @@ Signature LazyCreateSignature()
                 {
                     Debug.Assert(parameters != null);
                     StackAllocedArguments argStorage = default;
-                    Span<object?> copyOfParameters = new Span<object?>(ref argStorage._arg0, argCount);
-                    Span<bool> shouldCopyBackParameters = new Span<bool>(ref argStorage._copyBack0, argCount);
+                    Span<object?> copyOfParameters = new(ref argStorage._arg0, argCount);
+                    Span<ParameterCopyBackAction> shouldCopyBackParameters = new(ref argStorage._copyBack0, argCount);
 
                     StackAllocatedByRefs byrefStorage = default;
                     IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
@@ -517,14 +516,25 @@ Signature LazyCreateSignature()
                         culture,
                         invokeAttr);
 
-                    retValue = Invoker.InvokeUnsafe(obj, pByRefStorage, 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++)
                     {
-                        if (shouldCopyBackParameters[i])
+                        ParameterCopyBackAction action = shouldCopyBackParameters[i];
+                        if (action != ParameterCopyBackAction.None)
                         {
-                            parameters[i] = copyOfParameters[i];
+                            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]);
+                            }
                         }
                     }
                 }
@@ -546,15 +556,15 @@ Signature LazyCreateSignature()
             CultureInfo? culture)
         {
             object[] objHolder = new object[argCount];
-            Span<object?> copyOfParameters = new Span<object?>(objHolder, 0, 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];
             Buffer.ZeroMemory((byte*)pByRefStorage, (uint)(argCount * sizeof(IntPtr)));
 
-            bool* boolHolder = stackalloc bool[argCount];
-            Span<bool> shouldCopyBackParameters = new Span<bool>(boolHolder, argCount);
+            ParameterCopyBackAction* copyBackActions = stackalloc ParameterCopyBackAction[argCount];
+            Span<ParameterCopyBackAction> shouldCopyBackParameters = new(copyBackActions, argCount);
 
             GCFrameRegistration reg = new(pByRefStorage, (uint)argCount, areByRefs: true);
 
@@ -572,7 +582,7 @@ Signature LazyCreateSignature()
                     culture,
                     invokeAttr);
 
-                retValue = mi.Invoker.InvokeUnsafe(obj, pByRefStorage, invokeAttr);
+                retValue = mi.Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
             }
             finally
             {
@@ -582,36 +592,26 @@ Signature LazyCreateSignature()
             // Copy modified values out. This should be done only with ByRef or Type.Missing parameters.
             for (int i = 0; i < argCount; i++)
             {
-                if (shouldCopyBackParameters[i])
+                ParameterCopyBackAction action = shouldCopyBackParameters[i];
+                if (action != ParameterCopyBackAction.None)
                 {
-                    parameters[i] = copyOfParameters[i];
+                    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;
         }
 
-        [DebuggerHidden]
-        [DebuggerStepThrough]
-        internal unsafe object? InvokeNonEmitUnsafe(object? obj, IntPtr* arguments, BindingFlags invokeAttr)
-        {
-            if ((invokeAttr & BindingFlags.DoNotWrapExceptions) == 0)
-            {
-                try
-                {
-                    return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, Signature, isConstructor: false);
-                }
-                catch (Exception e)
-                {
-                    throw new TargetInvocationException(e);
-                }
-            }
-            else
-            {
-                return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, Signature, isConstructor: false);
-            }
-        }
-
         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
         {
             return m_dynMethod.GetCustomAttributes(attributeType, inherit);

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

@@ -0,0 +1,33 @@
+// 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 MethodInvoker
+    {
+        private readonly Signature _signature;
+        internal InvocationFlags _invocationFlags;
+
+        public MethodInvoker(MethodBase method, Signature signature)
+        {
+            _method = method;
+            _signature = signature;
+
+#if USE_NATIVE_INVOKE
+            // Always use the native invoke; useful for testing.
+            _strategyDetermined = true;
+#elif USE_EMIT_INVOKE
+            // Always use emit invoke (if IsDynamicCodeCompiled == true); useful for testing.
+            _invoked = true;
+#endif
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private unsafe object? InterpretedInvoke(object? obj, IntPtr* arguments)
+        {
+            return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, _signature, isConstructor: false);
+        }
+    }
+}

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

@@ -236,7 +236,7 @@ public override void SetValue(object? obj, object? value, BindingFlags invokeAtt
 
             CheckConsistency(obj);
 
-            bool _ref = false;
+            ParameterCopyBackAction _ref = default;
             RuntimeType fieldType = (RuntimeType)FieldType;
             if (value is null)
             {

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

@@ -95,27 +95,6 @@ Signature LazyCreateSignature()
 
         internal BindingFlags BindingFlags => m_bindingFlags;
 
-
-        [DebuggerStepThrough]
-        [DebuggerHidden]
-        internal unsafe object InvokeNonEmitUnsafe(object? obj, IntPtr* args, Span<object?> argsForTemporaryMonoSupport, BindingFlags invokeAttr)
-        {
-            if ((invokeAttr & BindingFlags.DoNotWrapExceptions) == 0)
-            {
-                try
-                {
-                    return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, Signature, isConstructor: obj is null)!;
-                }
-                catch (Exception ex)
-                {
-                    throw new TargetInvocationException(ex);
-                }
-            }
-            else
-            {
-                return RuntimeMethodHandle.InvokeMethod(obj, (void**)args, Signature, isConstructor: obj is null)!;
-            }
-        }
         #endregion
 
         #region Object Overrides

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

@@ -48,7 +48,7 @@ private MethodInvoker Invoker
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             get
             {
-                m_invoker ??= new MethodInvoker(this);
+                m_invoker ??= new MethodInvoker(this, Signature);
                 return m_invoker;
             }
         }
@@ -351,7 +351,7 @@ public override MethodImplAttributes GetMethodImplementationFlags()
                 StackAllocedArguments argStorage = default;
                 Span<object?> copyOfParameters = new(ref argStorage._arg0, 1);
                 ReadOnlySpan<object?> parameters = new(in parameter);
-                Span<bool> shouldCopyBackParameters = new(ref argStorage._copyBack0, 1);
+                Span<ParameterCopyBackAction> shouldCopyBackParameters = new(ref argStorage._copyBack0, 1);
 
                 StackAllocatedByRefs byrefStorage = default;
                 IntPtr* pByRefStorage = (IntPtr*)&byrefStorage;
@@ -366,33 +366,16 @@ public override MethodImplAttributes GetMethodImplementationFlags()
                     culture,
                     invokeAttr);
 
-                retValue = Invoker.InvokeUnsafe(obj, pByRefStorage, copyOfParameters, invokeAttr);
+#if MONO // Temporary until Mono is updated.
+                retValue = Invoker.InlinedInvoke(obj, copyOfParameters, invokeAttr);
+#else
+                retValue = Invoker.InlinedInvoke(obj, pByRefStorage, invokeAttr);
+#endif
             }
 
             return retValue;
         }
 
-        [DebuggerHidden]
-        [DebuggerStepThrough]
-        internal unsafe object? InvokeNonEmitUnsafe(object? obj, IntPtr* arguments, Span<object?> argsForTemporaryMonoSupport, BindingFlags invokeAttr)
-        {
-            if ((invokeAttr & BindingFlags.DoNotWrapExceptions) == 0)
-            {
-                try
-                {
-                    return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, Signature, isConstructor: false);
-                }
-                catch (Exception e)
-                {
-                    throw new TargetInvocationException(e);
-                }
-            }
-            else
-            {
-                return RuntimeMethodHandle.InvokeMethod(obj, (void**)arguments, Signature, isConstructor: false);
-            }
-        }
-
         #endregion
 
         #region MethodInfo Overrides

src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs

@@ -138,6 +138,19 @@ internal static bool IsByRef(RuntimeType type)
             return corElemType == CorElementType.ELEMENT_TYPE_BYREF;
         }
 
+        internal static bool TryGetByRefElementType(RuntimeType type, [NotNullWhen(true)] out RuntimeType? elementType)
+        {
+            CorElementType corElemType = GetCorElementType(type);
+            if (corElemType == CorElementType.ELEMENT_TYPE_BYREF)
+            {
+                elementType = GetElementType(type);
+                return true;
+            }
+
+            elementType = null;
+            return false;
+        }
+
         internal static bool IsPointer(RuntimeType type)
         {
             CorElementType corElemType = GetCorElementType(type);
@@ -981,6 +994,12 @@ internal static MdUtf8String GetUtf8Name(RuntimeMethodHandleInternal method)
         [MethodImpl(MethodImplOptions.InternalCall)]
         internal static extern object? InvokeMethod(object? target, void** arguments, Signature sig, bool isConstructor);
 
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern object? ReboxFromNullable(object? src);
+
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern object ReboxToNullable(object? src, RuntimeType destNullableType);
+
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetMethodInstantiation")]
         private static partial void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray);