New function pointer APIs

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

@@ -244,6 +244,18 @@ public override void EmitCalli(OpCode opcode, CallingConvention unmanagedCallCon
             PutInteger4(token);
         }
 
+        /// <inheritdoc/>
+        public override void EmitCalli(Type functionPointerType)
+        {
+            ArgumentNullException.ThrowIfNull(functionPointerType);
+
+            if (!functionPointerType.IsFunctionPointer)
+                throw new ArgumentException(SR.Argument_MustBeFunctionPointer, nameof(functionPointerType));
+
+            SignatureHelper sig = SignatureHelper.GetMethodSigHelper(m_scope, functionPointerType);
+            Emit(OpCodes.Calli, sig);
+        }
+
         public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[]? optionalParameterTypes)
         {
             ArgumentNullException.ThrowIfNull(methodInfo);

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

@@ -105,6 +105,51 @@ internal static SignatureHelper GetMethodSigHelper(Module? mod, CallingConventio
             return new SignatureHelper(mod, intCall, returnType, null, null);
         }
 
+        internal static SignatureHelper GetMethodSigHelper(DynamicScope scope, Type functionPointerType)
+        {
+            Debug.Assert(functionPointerType.IsFunctionPointer);
+
+            Type retType = functionPointerType.GetFunctionPointerReturnType();
+            Type[] retTypeModReqs = retType.GetRequiredCustomModifiers();
+            Type[] retTypeModOpts = retType.GetOptionalCustomModifiers();
+            Type[] paramTypes = functionPointerType.GetFunctionPointerParameterTypes();
+            Type[][] paramModReqs = new Type[paramTypes.Length][];
+            Type[][] paramModOpts = new Type[paramTypes.Length][];
+
+            retType = retType.UnderlyingSystemType;
+
+            for (int i = 0; i < paramTypes.Length; i++)
+            {
+                paramModReqs[i] = paramTypes[i].GetRequiredCustomModifiers();
+                paramModOpts[i] = paramTypes[i].GetOptionalCustomModifiers();
+                paramTypes[i] = paramTypes[i].UnderlyingSystemType;
+            }
+
+            MdSigCallingConvention callConv = MdSigCallingConvention.Default;
+
+            if (functionPointerType.IsUnmanagedFunctionPointer)
+            {
+                callConv = MdSigCallingConvention.Unmanaged;
+
+                if (functionPointerType.GetFunctionPointerCallingConventions() is { Length: 1 } conventions)
+                {
+                    callConv = conventions[0].FullName switch
+                    {
+                        "System.Runtime.CompilerServices.CallConvCdecl" => MdSigCallingConvention.C,
+                        "System.Runtime.CompilerServices.CallConvStdcall" => MdSigCallingConvention.StdCall,
+                        "System.Runtime.CompilerServices.CallConvThiscall" => MdSigCallingConvention.ThisCall,
+                        "System.Runtime.CompilerServices.CallConvFastcall" => MdSigCallingConvention.FastCall,
+                        _ => MdSigCallingConvention.Unmanaged
+                    };
+                }
+            }
+
+            SignatureHelper sig = new(null, callConv);
+            sig.AddDynamicArgument(scope, retType, retTypeModReqs, retTypeModOpts, false);
+            sig.AddArguments(scope, paramTypes, paramModReqs, paramModOpts);
+            return sig;
+        }
+
         public static SignatureHelper GetLocalVarSigHelper()
         {
             return GetLocalVarSigHelper(null);
@@ -320,8 +365,8 @@ private void AddOneArgTypeHelper(Type clsArgument, Type[]? requiredCustomModifie
             AddOneArgTypeHelper(clsArgument);
         }
 
-        private void AddOneArgTypeHelper(Type clsArgument) { AddOneArgTypeHelperWorker(clsArgument, false); }
-        private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst)
+        private void AddOneArgTypeHelper(Type clsArgument, DynamicScope? scope = null) { AddOneArgTypeHelperWorker(clsArgument, false, scope); }
+        private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst, DynamicScope? scope)
         {
             if (clsArgument.IsGenericParameter)
             {
@@ -336,7 +381,7 @@ private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst
             {
                 AddElementType(CorElementType.ELEMENT_TYPE_GENERICINST);
 
-                AddOneArgTypeHelperWorker(clsArgument.GetGenericTypeDefinition(), true);
+                AddOneArgTypeHelperWorker(clsArgument.GetGenericTypeDefinition(), true, scope);
 
                 Type[] args = clsArgument.GetGenericArguments();
 
@@ -424,6 +469,25 @@ private void AddOneArgTypeHelperWorker(Type clsArgument, bool lastWasGenericInst
                         AddData(0);
                 }
             }
+            else if (clsArgument.IsFunctionPointer)
+            {
+                if (scope == null)
+                    throw new NotSupportedException(SR.NotSupported_FunctionPointerSignature);
+
+                AddData((int)CorElementType.ELEMENT_TYPE_FNPTR);
+                SignatureHelper sig = GetMethodSigHelper(scope, clsArgument);
+                byte[] bytes = sig.GetSignature();
+
+                if (m_currSig + bytes.Length > m_signature.Length)
+                {
+                    m_signature = ExpandArray(m_signature, m_signature.Length + bytes.Length);
+                }
+
+                for (int i = 0; i < bytes.Length; i++)
+                {
+                    m_signature[m_currSig++] = bytes[i];
+                }
+            }
             else
             {
                 CorElementType type = CorElementType.ELEMENT_TYPE_MAX;
@@ -729,9 +793,10 @@ internal byte[] InternalGetSignatureArray()
             return temp;
         }
 
-        internal void AddDynamicArgument(DynamicScope dynamicScope, Type clsArgument, Type[]? requiredCustomModifiers, Type[]? optionalCustomModifiers)
+        internal void AddDynamicArgument(DynamicScope dynamicScope, Type clsArgument, Type[]? requiredCustomModifiers, Type[]? optionalCustomModifiers, bool incrementArgCount = true)
         {
-            IncrementArgCounts();
+            if (incrementArgCount)
+                IncrementArgCounts();
 
             Debug.Assert(clsArgument != null);
 
@@ -744,12 +809,6 @@ internal void AddDynamicArgument(DynamicScope dynamicScope, Type clsArgument, Ty
                     if (t is not RuntimeType rtType)
                         throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(optionalCustomModifiers));
 
-                    if (t.HasElementType)
-                        throw new ArgumentException(SR.Argument_ArraysInvalid, nameof(optionalCustomModifiers));
-
-                    if (t.ContainsGenericParameters)
-                        throw new ArgumentException(SR.Argument_GenericsInvalid, nameof(optionalCustomModifiers));
-
                     AddElementType(CorElementType.ELEMENT_TYPE_CMOD_OPT);
 
                     int token = dynamicScope.GetTokenFor(rtType.TypeHandle);
@@ -767,12 +826,6 @@ internal void AddDynamicArgument(DynamicScope dynamicScope, Type clsArgument, Ty
                     if (t is not RuntimeType rtType)
                         throw new ArgumentException(SR.Argument_MustBeRuntimeType, nameof(requiredCustomModifiers));
 
-                    if (t.HasElementType)
-                        throw new ArgumentException(SR.Argument_ArraysInvalid, nameof(requiredCustomModifiers));
-
-                    if (t.ContainsGenericParameters)
-                        throw new ArgumentException(SR.Argument_GenericsInvalid, nameof(requiredCustomModifiers));
-
                     AddElementType(CorElementType.ELEMENT_TYPE_CMOD_REQD);
 
                     int token = dynamicScope.GetTokenFor(rtType.TypeHandle);
@@ -781,7 +834,18 @@ internal void AddDynamicArgument(DynamicScope dynamicScope, Type clsArgument, Ty
                 }
             }
 
-            AddOneArgTypeHelper(clsArgument);
+            AddOneArgTypeHelper(clsArgument, dynamicScope);
+        }
+
+        internal void AddArguments(DynamicScope dynamicScope, Type[]? arguments, Type[][]? requiredCustomModifiers, Type[][]? optionalCustomModifiers)
+        {
+            if (arguments is null)
+                return;
+
+            for (int i = 0; i < arguments.Length; i++)
+            {
+                AddDynamicArgument(dynamicScope, arguments[i], requiredCustomModifiers?[i], optionalCustomModifiers?[i]);
+            }
         }
 
         #endregion

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

@@ -813,6 +813,29 @@ internal RuntimeType MakeByRef()
             return type!;
         }
 
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakeFunctionPointer")]
+        private static partial void MakeFunctionPointer(nint* retAndParamTypes, int numArgs, [MarshalAs(UnmanagedType.Bool)] bool isUnmanaged, ObjectHandleOnStack type);
+
+        internal RuntimeType MakeFunctionPointer(Type[] parameterTypes, bool isUnmanaged)
+        {
+            int count = 1 + parameterTypes.Length;
+            nint[] retAndParamTypeHandles = new nint[count];
+
+            retAndParamTypeHandles[0] = GetNativeHandle().Value;
+            for (int i = 0; i < parameterTypes.Length; i++)
+                retAndParamTypeHandles[i + 1] = parameterTypes[i].TypeHandle.Value;
+
+            RuntimeType? type = null;
+            fixed (nint* pRetAndParamTypeHandles = retAndParamTypeHandles)
+            {
+                MakeFunctionPointer(pRetAndParamTypeHandles, parameterTypes.Length, isUnmanaged, ObjectHandleOnStack.Create(ref type));
+            }
+
+            GC.KeepAlive(m_type);
+            GC.KeepAlive(parameterTypes);
+            return type!;
+        }
+
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_MakePointer")]
         private static partial void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type);
 

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

@@ -3729,6 +3729,24 @@ public override Type MakeArrayType(int rank)
             return new RuntimeTypeHandle(this).MakeArray(rank);
         }
 
+        public override Type MakeFunctionPointerType(Type[]? parameterTypes, bool isUnmanaged = false)
+        {
+            parameterTypes = (parameterTypes != null) ? (Type[])parameterTypes.Clone() : [];
+            for (int i = 0; i < parameterTypes.Length; i++)
+            {
+                Type paramType = parameterTypes[i];
+                ArgumentNullException.ThrowIfNull(paramType, nameof(parameterTypes));
+
+                if (paramType is not RuntimeType)
+                    return Type.MakeFunctionPointerSignatureType(this, parameterTypes, isUnmanaged);
+
+                if (paramType == typeof(void) || paramType.IsGenericTypeDefinition)
+                    throw new ArgumentException(string.Format(SR.FunctionPointer_ParameterInvalid, paramType.ToString()), nameof(parameterTypes));
+            }
+
+            return new RuntimeTypeHandle(this).MakeFunctionPointer(parameterTypes, isUnmanaged);
+        }
+
         public override StructLayoutAttribute? StructLayoutAttribute => PseudoCustomAttribute.GetStructLayoutCustomAttribute(this);
 
         #endregion

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/General/TypeUnifier.cs

@@ -57,6 +57,11 @@ public static RuntimeTypeInfo GetPointerType(this RuntimeTypeInfo targetType)
             return RuntimePointerTypeInfo.GetPointerTypeInfo(targetType);
         }
 
+        public static RuntimeTypeInfo GetFunctionPointerType(this RuntimeTypeInfo returnType, RuntimeTypeInfo[] parameterTypes, bool isUnmanaged)
+        {
+            return RuntimeFunctionPointerTypeInfo.GetFunctionPointerTypeInfo(returnType, parameterTypes, isUnmanaged);
+        }
+
         public static RuntimeTypeInfo GetConstructedGenericTypeNoConstraintCheck(this RuntimeTypeInfo genericTypeDefinition, RuntimeTypeInfo[] genericTypeArguments)
         {
             return RuntimeConstructedGenericTypeInfo.GetRuntimeConstructedGenericTypeInfoNoConstraintCheck(genericTypeDefinition, genericTypeArguments);

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/TypeInfos/RuntimeTypeInfo.cs

@@ -414,6 +414,28 @@ public Type MakeArrayType(int rank)
             return this.GetMultiDimArrayType(rank).ToType();
         }
 
+        public Type MakeFunctionPointerType(Type[]? parameterTypes, bool isUnmanaged = false)
+        {
+            parameterTypes ??= [];
+            RuntimeTypeInfo[] runtimeParameterTypes = new RuntimeTypeInfo[parameterTypes.Length];
+
+            for (int i = 0; i < parameterTypes.Length; i++)
+            {
+                Type paramType = parameterTypes[i];
+                ArgumentNullException.ThrowIfNull(paramType, nameof(parameterTypes));
+
+                if (paramType is not RuntimeType rtType)
+                    return Type.MakeFunctionPointerSignatureType(this.ToType(), parameterTypes, isUnmanaged);
+
+                if (rtType == typeof(void) || rtType.IsGenericTypeDefinition)
+                    throw new ArgumentException(string.Format(SR.FunctionPointer_ParameterInvalid, rtType.ToString()), nameof(parameterTypes));
+
+                runtimeParameterTypes[i] = rtType.GetRuntimeTypeInfo();
+            }
+
+            return this.GetFunctionPointerType(runtimeParameterTypes, isUnmanaged).ToType();
+        }
+
         public Type MakePointerType()
         {
             return this.GetPointerType().ToType();

src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeType.NativeAot.cs

@@ -856,6 +856,9 @@ public override Type MakeArrayType()
         public override Type MakeArrayType(int rank)
             => GetRuntimeTypeInfo().MakeArrayType(rank);
 
+        public override Type MakeFunctionPointerType(Type[]? parameterTypes, bool isUnmanaged = false)
+            => GetRuntimeTypeInfo().MakeFunctionPointerType(parameterTypes, isUnmanaged);
+
         [RequiresDynamicCode("The native code for this instantiation might not be available at runtime.")]
         [RequiresUnreferencedCode("If some of the generic arguments are annotated (either with DynamicallyAccessedMembersAttribute, or generic constraints), trimming can't validate that the requirements of those annotations are met.")]
         public override Type MakeGenericType(params Type[] instantiation)

src/coreclr/vm/qcallentrypoints.cpp

@@ -132,6 +132,7 @@ static const Entry s_QCall[] =
     DllImportEntry(RuntimeTypeHandle_MakeByRef)
     DllImportEntry(RuntimeTypeHandle_MakeSZArray)
     DllImportEntry(RuntimeTypeHandle_MakeArray)
+    DllImportEntry(RuntimeTypeHandle_MakeFunctionPointer)
     DllImportEntry(RuntimeTypeHandle_GetConstraints)
     DllImportEntry(RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer)
     DllImportEntry(RuntimeTypeHandle_GetAssemblySlow)

src/coreclr/vm/runtimehandles.cpp

@@ -1091,6 +1091,22 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan
     return;
 }
 
+extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType)
+{
+    QCALL_CONTRACT;
+
+    TypeHandle fnPtrHandle;
+
+    BEGIN_QCALL;
+    BYTE callConv = (BYTE)(isUnmanaged ? IMAGE_CEE_CS_CALLCONV_UNMANAGED : IMAGE_CEE_CS_CALLCONV_DEFAULT);
+    fnPtrHandle = ClassLoader::LoadFnptrTypeThrowing(callConv, numArgs, pRetAndArgTypes);
+    GCX_COOP();
+    retType.Set(fnPtrHandle.GetManagedClassObject());
+    END_QCALL;
+
+    return;
+}
+
 extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType)
 {
     QCALL_CONTRACT;

src/coreclr/vm/runtimehandles.h

@@ -160,6 +160,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan
 extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType);
+extern "C" void QCALLTYPE RuntimeTypeHandle_MakeFunctionPointer(TypeHandle* pRetAndArgTypes, INT32 numArgs, BOOL isUnmanaged, QCall::ObjectHandleOnStack retType);
 extern "C" void QCALLTYPE RuntimeTypeHandle_PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache);
 extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString);
 extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result);

src/libraries/System.Private.CoreLib/src/Resources/Strings.resx

@@ -4441,4 +4441,16 @@
   <data name="IO_SharedMemory_DirectoryOwnerPermissionsIncorrect" xml:space="preserve">
     <value>The directory '{0}' does not have the expected owner permissions: {1}.</value>
   </data>
+  <data name="Argument_MustBeFunctionPointer" xml:space="preserve">
+    <value>Argument must represent a function pointer type.</value>
+  </data>
+  <data name="ManagedFunctionPointer_CallingConventionsNotAllowed">
+    <value>Unmanaged calling conventions cannot be specified for managed function pointers.</value>
+  </data>
+  <data name="FunctionPointer_ParameterInvalid">
+    <value>'{0}' cannot be used as a parameter type for a function pointer.</value>
+  </data>
+  <data name="NotSupported_FunctionPointerSignature">
+    <value>Function pointer signature can only be encoded by dynamic ILGenerator.</value>
+  </data>
 </root>

src/libraries/System.Private.CoreLib/src/System.Private.CoreLib.Shared.projitems

@@ -778,9 +778,11 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureByRefType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureCallingConvention.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureConstructedGenericType.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureFunctionPointerType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureGenericMethodParameterType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureGenericParameterType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureHasElementType.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureModifiedType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignaturePointerType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureType.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Reflection\SignatureTypeExtensions.cs" />
@@ -2938,4 +2940,4 @@
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Wasi\WasiPollWorld.wit.imports.wasi.io.v0_2_0.IPoll.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)System\Threading\Wasi\WasiPollWorld.wit.imports.wasi.io.v0_2_0.PollInterop.cs" />
   </ItemGroup>
-</Project>
+</Project>

src/libraries/System.Private.CoreLib/src/System/Reflection/Emit/ILGenerator.cs

@@ -44,6 +44,16 @@ public abstract void EmitCalli(OpCode opcode, CallingConventions callingConventi
 
         public abstract void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type? returnType, Type[]? parameterTypes);
 
+        /// <summary>
+        /// Puts a <see cref="OpCodes.Calli"/> instruction onto the Microsoft intermediate language (MSIL) stream,
+        /// specifying the type of the function pointer to indirectly call.
+        /// </summary>
+        /// <param name="functionPointerType">
+        /// The type of the function pointer to indirectly call.
+        /// The specified type must represent a function pointer type.
+        /// </param>
+        public virtual void EmitCalli(Type functionPointerType) => throw new NotSupportedException(SR.NotSupported_SubclassOverride);
+
         public abstract void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[]? optionalParameterTypes);
 
         public abstract void Emit(OpCode opcode, SignatureHelper signature);