Support generic arguments for calli in CoreCLR

src/coreclr/vm/ceeload.cpp

@@ -4696,7 +4696,7 @@ PTR_VOID ReflectionModule::GetRvaField(RVA field) // virtual
 //==========================================================================
 // Enregisters a VASig.
 //==========================================================================
-VASigCookie *Module::GetVASigCookie(Signature vaSignature)
+VASigCookie *Module::GetVASigCookie(Signature vaSignature, const SigTypeContext* typeContext)
 {
  CONTRACT(VASigCookie*)
  {
@@ -4734,13 +4734,7 @@ VASigCookie *Module::GetVASigCookie(Signature vaSignature)
 
  // Compute the size of args first, outside of the lock.
 
- // @TODO GENERICS: We may be calling a varargs method from a
- // generic type/method. Using an empty context will make such a
- // case cause an unexpected exception. To make this work,
- // we need to create a specialized signature for every instantiation
- SigTypeContext typeContext;
-
- MetaSig metasig(vaSignature, this, &typeContext);
+ MetaSig metasig(vaSignature, this, typeContext);
  ArgIterator argit(&metasig);
 
  // Upper estimate of the vararg size
@@ -4778,6 +4772,10 @@ VASigCookie *Module::GetVASigCookie(Signature vaSignature)
  pCookie->pNDirectILStub = NULL;
  pCookie->sizeOfArgs = sizeOfArgs;
  pCookie->signature = vaSignature;
+ pCookie->classInst = typeContext->m_classInst.GetRawArgs();
+ pCookie->classInstCount = typeContext->m_classInst.GetNumArgs();
+ pCookie->methInst = typeContext->m_methodInst.GetRawArgs();
+ pCookie->methInstCount = typeContext->m_methodInst.GetNumArgs();
 
  // Finally, now that it's safe for asynchronous readers to see it,
  // update the count.

src/coreclr/vm/ceeload.h

@@ -339,6 +339,10 @@ struct VASigCookie
  Volatile<PCODE> pNDirectILStub; // will be use if target is NDirect (tag == 0)
  PTR_Module pModule;
  Signature signature;
+ TypeHandle* classInst;
+ DWORD classInstCount;
+ TypeHandle* methInst;
+ DWORD methInstCount;
 };
 
 //
@@ -1361,7 +1365,7 @@ class Module : public ModuleBase
  void NotifyEtwLoadFinished(HRESULT hr);
 
  // Enregisters a VASig.
- VASigCookie *GetVASigCookie(Signature vaSignature);
+ VASigCookie *GetVASigCookie(Signature vaSignature, const SigTypeContext* typeContext);
 
 public:
 #ifndef DACCESS_COMPILE

src/coreclr/vm/dllimport.cpp

@@ -4186,6 +4186,7 @@ namespace
  pHashParams,
  pParams->m_dwStubFlags,
  pParams->m_pModule,
+ pParams->m_pTypeContext,
  pParams->m_sig.GetRawSig(),
  pParams->m_sig.GetRawSigLen(),
  pamTracker,
@@ -5034,6 +5035,12 @@ namespace
  }
  else
  {
+ // For generic calli, we only support blittable types
+ if (!pSigDesc->m_typeContext.IsEmpty() && SF_IsCALLIStub(dwStubFlags) && NDirect::MarshalingRequired(pStubMD))
+ {
+ COMPlusThrow(kMarshalDirectiveException, IDS_EE_NDIRECT_UNSUPPORTED_SIG);
+ }
+
  CreateNDirectStubWorker(pss,
  pSigDesc,
  nlType,
@@ -6059,6 +6066,7 @@ PCODE GetILStubForCalli(VASigCookie *pVASigCookie, MethodDesc *pMD)
  }
 
  StubSigDesc sigDesc(pMD, signature, pVASigCookie->pModule);
+ sigDesc.InitTypeContext(pVASigCookie->classInst, pVASigCookie->classInstCount, pVASigCookie->methInst, pVASigCookie->methInstCount);
 
  MethodDesc* pStubMD = NDirect::CreateCLRToNativeILStub(&sigDesc,
  nlType,

src/coreclr/vm/dllimport.h

@@ -56,6 +56,15 @@ struct StubSigDesc
  }
  }
 #endif // _DEBUG
+
+#ifndef DACCESS_COMPILE
+ void InitTypeContext(TypeHandle* classInst, DWORD classInstCount, TypeHandle* methInst, DWORD methInstCount)
+ {
+ LIMITED_METHOD_CONTRACT;
+
+ m_typeContext = SigTypeContext(Instantiation(classInst, classInstCount), Instantiation(methInst, methInstCount));
+ }
+#endif
 };
 
 //=======================================================================

src/coreclr/vm/ilstubcache.cpp

@@ -500,6 +500,7 @@ MethodDesc* ILStubCache::GetStubMethodDesc(
  ILStubHashBlob* pHashBlob,
  DWORD dwStubFlags,
  Module* pSigModule,
+ SigTypeContext* pTypeContext,
  PCCOR_SIGNATURE pSig,
  DWORD cbSig,
  AllocMemTracker* pamTracker,
@@ -552,6 +553,10 @@ MethodDesc* ILStubCache::GetStubMethodDesc(
  {
  SigTypeContext::InitTypeContext(pTargetMD, &typeContext);
  }
+ else if (pTypeContext != NULL)
+ {
+ typeContext = *pTypeContext;
+ }
 
  pMD = ILStubCache::CreateNewMethodDesc(m_pAllocator->GetHighFrequencyHeap(), pStubMT, dwStubFlags, pSigModule, pSig, cbSig, &typeContext, pamTracker);
 

src/coreclr/vm/ilstubcache.h

@@ -53,6 +53,7 @@ class ILStubCache final
  ILStubHashBlob* pHashBlob,
  DWORD dwStubFlags, // bitmask of NDirectStubFlags
  Module* pSigModule,
+ SigTypeContext* pTypeContext,
  PCCOR_SIGNATURE pSig,
  DWORD cbSig,
  AllocMemTracker* pamTracker,

src/coreclr/vm/jitinterface.cpp

@@ -6306,7 +6306,11 @@ CORINFO_VARARGS_HANDLE CEEInfo::getVarArgsHandle(CORINFO_SIG_INFO *sig,
 
  Module* module = GetModule(sig->scope);
 
- result = CORINFO_VARARGS_HANDLE(module->GetVASigCookie(Signature(sig->pSig, sig->cbSig)));
+ Instantiation classInst = Instantiation((TypeHandle*) sig->sigInst.classInst, sig->sigInst.classInstCount);
+ Instantiation methodInst = Instantiation((TypeHandle*) sig->sigInst.methInst, sig->sigInst.methInstCount);
+ SigTypeContext typeContext = SigTypeContext(classInst, methodInst);
+
+ result = CORINFO_VARARGS_HANDLE(module->GetVASigCookie(Signature(sig->pSig, sig->cbSig), &typeContext));
 
  EE_TO_JIT_TRANSITION();
 
@@ -13425,7 +13429,8 @@ BOOL LoadDynamicInfoEntry(Module *currentModule,
  }
  {
  VarArgs:
- result = (size_t) CORINFO_VARARGS_HANDLE(currentModule->GetVASigCookie(Signature(pSig, cSig)));
+ SigTypeContext typeContext = SigTypeContext();
+ result = (size_t) CORINFO_VARARGS_HANDLE(currentModule->GetVASigCookie(Signature(pSig, cSig), &typeContext));
  }
  break;
 

src/tests/Interop/MarshalAPI/FunctionPointer/FunctionPointer.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Xunit;
 
@@ -111,4 +112,53 @@ public static void RunGetDelForOutIntTest()
  }
  Assert.Equal(expectedValue, outVar);
  }
+
+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvCdecl)])]
+ static int UnmanagedExportedFunction(float arg)
+ {
+ return Convert.ToInt32(arg);
+ }
+
+ class GenericCaller<T>
+ {
+ internal static unsafe T GenericCalli<U>(void* fnptr, U arg)
+ {
+ return ((delegate* unmanaged<U, T>)fnptr)(arg);
+ }
+ }
+
+ [Fact]
+ public static void RunGenericFunctionPointerTest()
+ {
+ Console.WriteLine($"Running {nameof(RunGenericFunctionPointerTest)}...");
+ int outVar = 0;
+ int expectedValue = 42;
+ unsafe
+ {
+ outVar = GenericCaller<int>.GenericCalli((delegate* unmanaged[Cdecl]<float, int>)&UnmanagedExportedFunction, 42.0f);
+ }
+ Assert.Equal(expectedValue, outVar);
+ }
+
+ [Fact]
+ public static void RunInvalidGenericFunctionPointerTest()
+ {
+ Console.WriteLine($"Running {nameof(RunInvalidGenericFunctionPointerTest)}...");
+ unsafe
+ {
+ nint lib = nint.Zero;
+ try
+ {
+ lib = NativeLibrary.Load(nameof(FunctionPointerNative));
+ Assert.Throws<MarshalDirectiveException>(() => GenericCaller<string>.GenericCalli((delegate* unmanaged[Cdecl]<string, string>)NativeLibrary.GetExport(lib, "ReturnParameter"), "test"));
+ }
+ finally
+ {
+ if (lib != nint.Zero)
+ {
+ NativeLibrary.Free(lib);
+ }
+ }
+ }
+ }
 }

src/tests/Interop/MarshalAPI/FunctionPointer/FunctionPointerNative.cpp

@@ -41,3 +41,8 @@ extern "C" DLL_EXPORT void FillOutIntParameter(intptr_t *p)
  *p = 50;
 }
 
+extern "C" DLL_EXPORT intptr_t* ReturnParameter(intptr_t *p)
+{
+ return p;
+}
+