Fix calling convention gap in ILGenerator.EmitCalli (#27429)

* Expose EmitCalli overload

* Add EmitCalli overload test

* Improve TestEmitCalliStdCall test method

* Add EmitCalliStdCall test for dynamic ilgenerator

* Add EmitCalliCdecl tests

* Convert EmitCalli tests from theory to fact

* Improve EmitCalli tests

* Fix test name

Author: petarpetrovt

src/System.Reflection.Emit.ILGeneration/ref/System.Reflection.Emit.ILGeneration.cs

@@ -48,6 +48,7 @@ public virtual void Emit(System.Reflection.Emit.OpCode opcode, string str) { }
         public virtual void Emit(System.Reflection.Emit.OpCode opcode, System.Type cls) { }
         public virtual void EmitCall(System.Reflection.Emit.OpCode opcode, System.Reflection.MethodInfo methodInfo, System.Type[] optionalParameterTypes) { }
         public virtual void EmitCalli(System.Reflection.Emit.OpCode opcode, System.Reflection.CallingConventions callingConvention, System.Type returnType, System.Type[] parameterTypes, System.Type[] optionalParameterTypes) { }
+        public virtual void EmitCalli(System.Reflection.Emit.OpCode opcode, System.Runtime.InteropServices.CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes) { }
         public virtual void EmitWriteLine(System.Reflection.Emit.LocalBuilder localBuilder) { }
         public virtual void EmitWriteLine(System.Reflection.FieldInfo fld) { }
         public virtual void EmitWriteLine(string value) { }

src/System.Reflection.Emit.ILGeneration/ref/System.Reflection.Emit.ILGeneration.csproj

@@ -13,6 +13,7 @@
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\System.Runtime\ref\System.Runtime.csproj" />
+    <ProjectReference Include="..\..\System.Runtime.InteropServices\ref\System.Runtime.InteropServices.csproj" />
     <ProjectReference Include="..\..\System.Reflection\ref\System.Reflection.csproj" />
     <ProjectReference Include="..\..\System.Reflection.Primitives\ref\System.Reflection.Primitives.csproj" />
   </ItemGroup>

src/System.Reflection.Emit.ILGeneration/tests/ILGenerator/Emit4Tests.cs

@@ -0,0 +1,133 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using System.Runtime.InteropServices;
+using Xunit;
+
+namespace System.Reflection.Emit.Tests
+{
+    public class ILGeneratorEmit4
+    {
+        [Fact]
+        public void TestEmitCalliBlittable()
+        {
+            int a = 1, b = 1, result = 2;
+
+            ModuleBuilder moduleBuilder = Helpers.DynamicModule();
+            TypeBuilder typeBuilder = moduleBuilder.DefineType("T", TypeAttributes.Public);
+            Type returnType = typeof(int);
+
+            MethodBuilder methodBuilder = typeBuilder.DefineMethod("F",
+                MethodAttributes.Public | MethodAttributes.Static, returnType, new Type[] { typeof(IntPtr), typeof(int), typeof(int) });
+            methodBuilder.SetImplementationFlags(MethodImplAttributes.NoInlining);
+
+            ILGenerator il = methodBuilder.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_1);
+            il.Emit(OpCodes.Ldarg_2);
+            il.Emit(OpCodes.Ldarg_0);
+            il.EmitCalli(OpCodes.Calli, CallingConvention.StdCall, returnType, new Type[] { typeof(int), typeof(int) });
+            il.Emit(OpCodes.Ret);
+
+            Type dynamicType = typeBuilder.CreateType();
+            IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(new Int32SumStdCall(Int32Sum));
+
+            object resultValue = dynamicType
+                .GetMethod("F", BindingFlags.Public | BindingFlags.Static)
+                .Invoke(null, new object[] { funcPtr, a, b });
+
+            Assert.IsType(returnType, resultValue);
+            Assert.Equal(result, resultValue);
+        }
+
+        [Fact]
+        public void TestDynamicMethodEmitCalliBlittable()
+        {
+            int a = 1, b = 1, result = 2;
+
+            Type returnType = typeof(int);
+
+            var dynamicMethod = new DynamicMethod("F", returnType, new Type[] { typeof(IntPtr), typeof(int), typeof(int) });
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_1);
+            il.Emit(OpCodes.Ldarg_2);
+            il.Emit(OpCodes.Ldarg_0);
+            il.EmitCalli(OpCodes.Calli, CallingConvention.StdCall, returnType, new Type[] { typeof(int), typeof(int) });
+            il.Emit(OpCodes.Ret);
+
+            IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(new Int32SumStdCall(Int32Sum));
+
+            object resultValue = dynamicMethod
+                .Invoke(null, new object[] { funcPtr, a, b });
+
+            Assert.IsType(returnType, resultValue);
+            Assert.Equal(result, resultValue);
+        }
+
+        [Fact]
+        public void TestEmitCalliNonBlittable()
+        {
+            string input = "Test string!", result = "!gnirts tseT";
+
+            ModuleBuilder moduleBuilder = Helpers.DynamicModule();
+            TypeBuilder typeBuilder = moduleBuilder.DefineType("T", TypeAttributes.Public);
+            Type returnType = typeof(string);
+
+            MethodBuilder methodBuilder = typeBuilder.DefineMethod("F",
+                MethodAttributes.Public | MethodAttributes.Static, returnType, new Type[] { typeof(IntPtr), typeof(string) });
+            methodBuilder.SetImplementationFlags(MethodImplAttributes.NoInlining);
+
+            ILGenerator il = methodBuilder.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_1);
+            il.Emit(OpCodes.Ldarg_0);
+            il.EmitCalli(OpCodes.Calli, CallingConvention.Cdecl, returnType, new Type[] { typeof(string) });
+            il.Emit(OpCodes.Ret);
+
+            Type dynamicType = typeBuilder.CreateType();
+            IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(new StringReverseCdecl(StringReverse));
+
+            object resultValue = dynamicType
+                .GetMethod("F", BindingFlags.Public | BindingFlags.Static)
+                .Invoke(null, new object[] { funcPtr, input });
+
+            Assert.IsType(returnType, resultValue);
+            Assert.Equal(result, resultValue);
+        }
+
+        [Fact]
+        public void TestDynamicMethodEmitCalliNonBlittable()
+        {
+            string input = "Test string!", result = "!gnirts tseT";
+
+            Type returnType = typeof(string);
+
+            var dynamicMethod = new DynamicMethod("F", returnType, new Type[] { typeof(IntPtr), typeof(string) });
+
+            ILGenerator il = dynamicMethod.GetILGenerator();
+            il.Emit(OpCodes.Ldarg_1);
+            il.Emit(OpCodes.Ldarg_0);
+            il.EmitCalli(OpCodes.Calli, CallingConvention.Cdecl, returnType, new Type[] { typeof(string) });
+            il.Emit(OpCodes.Ret);
+
+            IntPtr funcPtr = Marshal.GetFunctionPointerForDelegate(new StringReverseCdecl(StringReverse));
+
+            object resultValue = dynamicMethod
+                .Invoke(null, new object[] { funcPtr, input });
+
+            Assert.IsType(returnType, resultValue);
+            Assert.Equal(result, resultValue);
+        }
+
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        private delegate int Int32SumStdCall(int a, int b);
+
+        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
+        private delegate string StringReverseCdecl(string a);
+
+        private static int Int32Sum(int a, int b) => a + b;
+
+        private static string StringReverse(string a) => string.Join("", a.Reverse());
+    }
+}

src/System.Reflection.Emit.ILGeneration/tests/System.Reflection.Emit.ILGeneration.Tests.csproj

@@ -12,6 +12,7 @@
     <Compile Include="ILGenerator\Emit1Tests.cs" />
     <Compile Include="ILGenerator\Emit2Tests.cs" />
     <Compile Include="ILGenerator\Emit3Tests.cs" />
+    <Compile Include="ILGenerator\Emit4Tests.cs" />
     <Compile Include="ILGenerator\EmitWriteLineTests.cs" />
     <Compile Include="ILGenerator\ExceptionEmitTests.cs" />
     <Compile Include="ILGenerator\ILOffsetTests.cs" />