Enable non-blittable struct returns on UnmanagedCallersOnly

src/coreclr/ToolBox/superpmi/superpmi-shared/lwmlist.h

@@ -132,7 +132,6 @@ LWM(GetTypeForPrimitiveValueClass, DWORDLONG, DWORD)
 LWM(GetTypeForPrimitiveNumericClass, DWORDLONG, DWORD)
 LWM(GetUnboxedEntry, DWORDLONG, DLD);
 LWM(GetUnBoxHelper, DWORDLONG, DWORD)
-LWM(GetUnmanagedCallConv, DWORDLONG, DWORD)
 LWM(GetVarArgsHandle, GetVarArgsHandleValue, DLDL)
 LWM(GetVars, DWORDLONG, Agnostic_GetVars)
 DENSELWM(HandleException, DWORD)
@@ -149,12 +148,13 @@ LWM(IsValidToken, DLD, DWORD)
 LWM(IsValueClass, DWORDLONG, DWORD)
 LWM(MergeClasses, DLDL, DWORDLONG)
 LWM(IsMoreSpecificType, DLDL, DWORD)
-LWM(PInvokeMarshalingRequired, PInvokeMarshalingRequiredValue, DWORD)
+LWM(PInvokeMarshalingRequired, MethodOrSigInfoValue, DWORD)
 LWM(ResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, ResolveTokenValue)
 LWM(ResolveVirtualMethod, Agnostic_ResolveVirtualMethodKey, Agnostic_ResolveVirtualMethodResult)
 LWM(TryResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, TryResolveTokenValue)
 LWM(SatisfiesClassConstraints, DWORDLONG, DWORD)
 LWM(SatisfiesMethodConstraints, DLDL, DWORD)
+LWM(GetUnmanagedCallConv, MethodOrSigInfoValue, DD)
 
 
 #undef LWM

src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.cpp

@@ -1624,35 +1624,6 @@ bool MethodContext::repIsIntrinsicType(CORINFO_CLASS_HANDLE cls)
     return result;
 }
 
-void MethodContext::recGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CorInfoUnmanagedCallConv result)
-{
-    if (GetUnmanagedCallConv == nullptr)
-        GetUnmanagedCallConv = new LightWeightMap<DWORDLONG, DWORD>();
-
-    GetUnmanagedCallConv->Add((DWORDLONG)method, result);
-    DEBUG_REC(dmpGetUnmanagedCallConv((DWORDLONG)method, (DWORD)result));
-}
-void MethodContext::dmpGetUnmanagedCallConv(DWORDLONG key, DWORD result)
-{
-    printf("GetUnmanagedCallConv key ftn-%016llX, value res-%u", key, result);
-}
-CorInfoUnmanagedCallConv MethodContext::repGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method)
-{
-    if ((GetUnmanagedCallConv == nullptr) || (GetUnmanagedCallConv->GetIndex((DWORDLONG)method) == -1))
-    {
-#ifdef sparseMC
-        LogDebug("Sparse - repGetUnmanagedCallConv returning CORINFO_UNMANAGED_CALLCONV_STDCALL");
-        return CORINFO_UNMANAGED_CALLCONV_STDCALL;
-#else
-        LogException(EXCEPTIONCODE_MC, "Found a null GetUnmanagedCallConv.  Probably missing a fatTrigger for %016llX.",
-                     (DWORDLONG)method);
-#endif
-    }
-    CorInfoUnmanagedCallConv result = (CorInfoUnmanagedCallConv)GetUnmanagedCallConv->Get((DWORDLONG)method);
-    DEBUG_REP(dmpGetUnmanagedCallConv((DWORDLONG)method, (DWORD)result));
-    return result;
-}
-
 void MethodContext::recAsCorInfoType(CORINFO_CLASS_HANDLE cls, CorInfoType result)
 {
     if (AsCorInfoType == nullptr)
@@ -3086,7 +3057,7 @@ void MethodContext::recResolveVirtualMethod(CORINFO_DEVIRTUALIZATION_INFO * info
     key.context        = (DWORDLONG)info->context;
     Agnostic_ResolveVirtualMethodResult result;
     result.returnValue = returnValue;
-    result.devirtualizedMethod = (DWORDLONG)info->devirtualizedMethod;    
+    result.devirtualizedMethod = (DWORDLONG)info->devirtualizedMethod;
     result.requiresInstMethodTableArg = info->requiresInstMethodTableArg;
     result.exactContext = (DWORDLONG)info->exactContext;
     ResolveVirtualMethod->Add(key, result);
@@ -3771,10 +3742,10 @@ void MethodContext::recPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method,
                                                  bool                  result)
 {
     if (PInvokeMarshalingRequired == nullptr)
-        PInvokeMarshalingRequired = new LightWeightMap<PInvokeMarshalingRequiredValue, DWORD>();
+        PInvokeMarshalingRequired = new LightWeightMap<MethodOrSigInfoValue, DWORD>();
 
-    PInvokeMarshalingRequiredValue key;
-    ZeroMemory(&key, sizeof(PInvokeMarshalingRequiredValue)); // We use the input structs as a key and use memcmp to
+    MethodOrSigInfoValue key;
+    ZeroMemory(&key, sizeof(MethodOrSigInfoValue)); // We use the input structs as a key and use memcmp to
                                                               // compare.. so we need to zero out padding too
 
     key.method     = (DWORDLONG)method;
@@ -3785,7 +3756,7 @@ void MethodContext::recPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method,
     PInvokeMarshalingRequired->Add(key, (DWORD)result);
     DEBUG_REC(dmpPInvokeMarshalingRequired(key, (DWORD)result));
 }
-void MethodContext::dmpPInvokeMarshalingRequired(const PInvokeMarshalingRequiredValue& key, DWORD value)
+void MethodContext::dmpPInvokeMarshalingRequired(const MethodOrSigInfoValue& key, DWORD value)
 {
     printf("PInvokeMarshalingRequired key mth-%016llX scp-%016llX sig-%u, value res-%u", key.method, key.scope,
            key.pSig_Index, value);
@@ -3796,9 +3767,9 @@ bool MethodContext::repPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, C
     if (PInvokeMarshalingRequired == nullptr) // so when we replay checked on free, we throw from lwm
         return TRUE;                          // TODO-Cleanup: hackish...
 
-    PInvokeMarshalingRequiredValue key;
-    ZeroMemory(&key, sizeof(PInvokeMarshalingRequiredValue)); // We use the input structs as a key and use memcmp to
-                                                              // compare.. so we need to zero out padding too
+    MethodOrSigInfoValue key;
+    ZeroMemory(&key, sizeof(MethodOrSigInfoValue)); // We use the input structs as a key and use memcmp to
+                                                      // compare.. so we need to zero out padding too
 
     key.method     = (DWORDLONG)method;
     key.pSig_Index = (DWORD)PInvokeMarshalingRequired->Contains((unsigned char*)callSiteSig->pSig, callSiteSig->cbSig);
@@ -3810,6 +3781,60 @@ bool MethodContext::repPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, C
     return value;
 }
 
+void MethodContext::recGetUnmanagedCallConv(CORINFO_METHOD_HANDLE    method,
+                                             CORINFO_SIG_INFO*        callSiteSig,
+                                             CorInfoCallConvExtension result,
+                                             bool suppressGCTransitionResult)
+{
+    if (GetUnmanagedCallConv == nullptr)
+        GetUnmanagedCallConv = new LightWeightMap<MethodOrSigInfoValue, DD>();
+
+    MethodOrSigInfoValue key;
+    ZeroMemory(&key, sizeof(MethodOrSigInfoValue)); // We use the input structs as a key and use memcmp to
+                                                              // compare.. so we need to zero out padding too
+
+    key.method     = (DWORDLONG)method;
+    key.pSig_Index = (DWORD)PInvokeMarshalingRequired->AddBuffer((unsigned char*)callSiteSig->pSig, callSiteSig->cbSig);
+    key.cbSig      = (DWORD)callSiteSig->cbSig;
+    key.scope      = (DWORDLONG)callSiteSig->scope;
+
+    GetUnmanagedCallConv->Add(key, { (DWORD)result, (DWORD)suppressGCTransitionResult });
+    DEBUG_REC(dmpGetUnmanagedCallConv(key, { (DWORD)result, (DWORD)suppressGCTransitionResult }));
+}
+void MethodContext::dmpGetUnmanagedCallConv(const MethodOrSigInfoValue& key, DD value)
+{
+    printf("GetUnmanagedCallConv key mth-%016llX scp-%016llX sig-%u, value res-%u,%u", key.method, key.scope,
+           key.pSig_Index, value.A, value.B);
+}
+// Note the jit interface implementation seems to only care about scope and pSig from callSiteSig
+CorInfoCallConvExtension MethodContext::repGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, bool* pSuppressGCTransition)
+{
+    if (GetUnmanagedCallConv == nullptr)
+    {
+#ifdef sparseMC
+        LogDebug("Sparse - repGetUnmanagedCallConv returning CorInfoCallConvExtension::Managed");
+        return CorInfoCallConvExtension::Managed;
+#else
+        LogException(EXCEPTIONCODE_MC, "Found a null GetUnmGetUnmanagedCallConvanagedCallConv.  Probably missing a fatTrigger for %016llX.",
+                     (DWORDLONG)method);
+#endif
+    }
+
+    MethodOrSigInfoValue key;
+    ZeroMemory(&key, sizeof(MethodOrSigInfoValue)); // We use the input structs as a key and use memcmp to
+                                                      // compare.. so we need to zero out padding too
+
+    key.method     = (DWORDLONG)method;
+    key.pSig_Index = (DWORD)GetUnmanagedCallConv->Contains((unsigned char*)callSiteSig->pSig, callSiteSig->cbSig);
+    key.cbSig      = (DWORD)callSiteSig->cbSig;
+    key.scope      = (DWORDLONG)callSiteSig->scope;
+
+    DD value = GetUnmanagedCallConv->Get(key);
+    DEBUG_REP(dmpGetUnmanagedCallConv(key, value));
+    *pSuppressGCTransition = value.B != 0;
+    return (CorInfoCallConvExtension)value.A;
+}
+
 void MethodContext::recFindSig(CORINFO_MODULE_HANDLE  module,
                                unsigned               sigTOK,
                                CORINFO_CONTEXT_HANDLE context,
@@ -5290,7 +5315,7 @@ void MethodContext::recGetLikelyClass(CORINFO_METHOD_HANDLE ftnHnd, CORINFO_CLAS
 }
 void MethodContext::dmpGetLikelyClass(const Agnostic_GetLikelyClass& key, const Agnostic_GetLikelyClassResult& value)
 {
-    printf("GetLikelyClass key ftn-%016llX base-%016llX il-%u, class-%016llX likelihood-%u numberOfClasses-%u", 
+    printf("GetLikelyClass key ftn-%016llX base-%016llX il-%u, class-%016llX likelihood-%u numberOfClasses-%u",
         key.ftnHnd, key.baseHnd, key.ilOffset, value.classHnd, value.likelihood, value.numberOfClasses);
 }
 CORINFO_CLASS_HANDLE MethodContext::repGetLikelyClass(CORINFO_METHOD_HANDLE ftnHnd, CORINFO_CLASS_HANDLE baseHnd, UINT32 ilOffset, UINT32* pLikelihood, UINT32* pNumberOfClasses)

src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.h

@@ -318,7 +318,7 @@ class MethodContext
         DWORD     sigTOK;
         DWORDLONG context;
     };
-    struct PInvokeMarshalingRequiredValue
+    struct MethodOrSigInfoValue
     {
         DWORDLONG method;
         DWORD     pSig_Index;
@@ -730,10 +730,6 @@ class MethodContext
     void dmpGetIntrinsicID(DWORDLONG key, DD value);
     CorInfoIntrinsics repGetIntrinsicID(CORINFO_METHOD_HANDLE method, bool* pMustExpand);
 
-    void recGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CorInfoUnmanagedCallConv result);
-    void dmpGetUnmanagedCallConv(DWORDLONG key, DWORD result);
-    CorInfoUnmanagedCallConv repGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method);
-
     void recAsCorInfoType(CORINFO_CLASS_HANDLE cls, CorInfoType result);
     void dmpAsCorInfoType(DWORDLONG key, DWORD value);
     CorInfoType repAsCorInfoType(CORINFO_CLASS_HANDLE cls);
@@ -1003,9 +999,13 @@ class MethodContext
     CORINFO_CLASS_HANDLE repEmbedClassHandle(CORINFO_CLASS_HANDLE handle, void** ppIndirection);
 
     void recPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, bool result);
-    void dmpPInvokeMarshalingRequired(const PInvokeMarshalingRequiredValue& key, DWORD value);
+    void dmpPInvokeMarshalingRequired(const MethodOrSigInfoValue& key, DWORD value);
     bool repPInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig);
 
+    void recGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, CorInfoCallConvExtension result, bool suppressGCTransitionResult);
+    void dmpGetUnmanagedCallConv(const MethodOrSigInfoValue& key, DD value);
+    CorInfoCallConvExtension repGetUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, bool* pSuppressGCTransition);
+
     void recFindSig(CORINFO_MODULE_HANDLE  module,
                     unsigned               sigTOK,
                     CORINFO_CONTEXT_HANDLE context,

src/coreclr/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp

@@ -289,12 +289,15 @@ bool interceptor_ICJI::isIntrinsicType(CORINFO_CLASS_HANDLE classHnd)
     return temp;
 }
 
-// return the unmanaged calling convention for a PInvoke
-CorInfoUnmanagedCallConv interceptor_ICJI::getUnmanagedCallConv(CORINFO_METHOD_HANDLE method)
+// return the entry point calling convention for any of the following
+// - a P/Invoke
+// - a method marked with UnmanagedCallersOnly
+// - a function pointer with the CORINFO_CALLCONV_UNMANAGED calling convention.
+CorInfoCallConvExtension interceptor_ICJI::getUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, bool* pSuppressGCTransition)
 {
     mc->cr->AddCall("getUnmanagedCallConv");
-    CorInfoUnmanagedCallConv temp = original_ICorJitInfo->getUnmanagedCallConv(method);
-    mc->recGetUnmanagedCallConv(method, temp);
+    CorInfoCallConvExtension temp = original_ICorJitInfo->getUnmanagedCallConv(method, callSiteSig, pSuppressGCTransition);
+    mc->recGetUnmanagedCallConv(method, callSiteSig, temp, *pSuppressGCTransition);
     return temp;
 }
 
@@ -2046,7 +2049,7 @@ HRESULT interceptor_ICJI::getMethodBlockCounts(CORINFO_METHOD_HANDLE ftnHnd,
 
 // Get the likely implementing class for a virtual call or interface call made by ftnHnd
 // at the indicated IL offset. baseHnd is the interface class or base class for the method
-// being called. 
+// being called.
 CORINFO_CLASS_HANDLE interceptor_ICJI::getLikelyClass(CORINFO_METHOD_HANDLE ftnHnd,
                                                       CORINFO_CLASS_HANDLE  baseHnd,
                                                       UINT32                ilOffset,

src/coreclr/ToolBox/superpmi/superpmi-shim-counter/icorjitinfo.cpp

@@ -162,11 +162,13 @@ bool interceptor_ICJI::isIntrinsicType(
     return original_ICorJitInfo->isIntrinsicType(classHnd);
 }
 
-CorInfoUnmanagedCallConv interceptor_ICJI::getUnmanagedCallConv(
-          CORINFO_METHOD_HANDLE method)
+CorInfoCallConvExtension interceptor_ICJI::getUnmanagedCallConv(
+          CORINFO_METHOD_HANDLE method,
+          CORINFO_SIG_INFO* callSiteSig,
+          bool* pSuppressGCTransition)
 {
     mcs->AddCall("getUnmanagedCallConv");
-    return original_ICorJitInfo->getUnmanagedCallConv(method);
+    return original_ICorJitInfo->getUnmanagedCallConv(method, callSiteSig, pSuppressGCTransition);
 }
 
 bool interceptor_ICJI::pInvokeMarshalingRequired(

src/coreclr/ToolBox/superpmi/superpmi-shim-simple/icorjitinfo.cpp

@@ -144,10 +144,12 @@ bool interceptor_ICJI::isIntrinsicType(
     return original_ICorJitInfo->isIntrinsicType(classHnd);
 }
 
-CorInfoUnmanagedCallConv interceptor_ICJI::getUnmanagedCallConv(
-          CORINFO_METHOD_HANDLE method)
+CorInfoCallConvExtension interceptor_ICJI::getUnmanagedCallConv(
+          CORINFO_METHOD_HANDLE method,
+          CORINFO_SIG_INFO* callSiteSig,
+          bool* pSuppressGCTransition)
 {
-    return original_ICorJitInfo->getUnmanagedCallConv(method);
+    return original_ICorJitInfo->getUnmanagedCallConv(method, callSiteSig, pSuppressGCTransition);
 }
 
 bool interceptor_ICJI::pInvokeMarshalingRequired(

src/coreclr/ToolBox/superpmi/superpmi/icorjitinfo.cpp

@@ -218,11 +218,14 @@ bool MyICJI::isIntrinsicType(CORINFO_CLASS_HANDLE classHnd)
     return jitInstance->mc->repIsIntrinsicType(classHnd) ? true : false;
 }
 
-// return the unmanaged calling convention for a PInvoke
-CorInfoUnmanagedCallConv MyICJI::getUnmanagedCallConv(CORINFO_METHOD_HANDLE method)
+// return the entry point calling convention for any of the following
+// - a P/Invoke
+// - a method marked with UnmanagedCallersOnly
+// - a function pointer with the CORINFO_CALLCONV_UNMANAGED calling convention.
+CorInfoCallConvExtension MyICJI::getUnmanagedCallConv(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig, bool* pSuppressGCTransition)
 {
     jitInstance->mc->cr->AddCall("getUnmanagedCallConv");
-    return jitInstance->mc->repGetUnmanagedCallConv(method);
+    return jitInstance->mc->repGetUnmanagedCallConv(method, callSiteSig, pSuppressGCTransition);
 }
 
 // return if any marshaling is required for PInvoke methods.  Note that
@@ -1803,7 +1806,7 @@ HRESULT MyICJI::getMethodBlockCounts(CORINFO_METHOD_HANDLE ftnHnd,
 
 // Get the likely implementing class for a virtual call or interface call made by ftnHnd
 // at the indicated IL offset. baseHnd is the interface class or base class for the method
-// being called. 
+// being called.
 CORINFO_CLASS_HANDLE MyICJI::getLikelyClass(CORINFO_METHOD_HANDLE ftnHnd,
                                             CORINFO_CLASS_HANDLE  baseHnd,
                                             UINT32                ilOffset,

src/coreclr/debug/daccess/nidump.cpp

@@ -7350,7 +7350,6 @@ static NativeImageDumper::EnumMnemonics g_NDirectFlags[] =
         NDF_ENTRY(kStdCall),
         NDF_ENTRY(kThisCall),
         NDF_ENTRY(kIsQCall),
-        NDF_ENTRY(kStdCallWithRetBuf),
 #undef NDF_ENTRY
 };
 NativeImageDumper::EnumMnemonics NativeImageDumper::s_IMDFlags[] =

src/coreclr/inc/corhdr.h

@@ -954,11 +954,21 @@ typedef enum CorSerializationType
 // Calling convention flags.
 //
 
+typedef enum CorUnmanagedCallingConvention
+{
+    IMAGE_CEE_UNMANAGED_CALLCONV_C         = 0x1,
+    IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL   = 0x2,
+    IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL  = 0x3,
+    IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL  = 0x4,
+} CorUnmanagedCallingConvention;
 
 typedef enum CorCallingConvention
 {
     IMAGE_CEE_CS_CALLCONV_DEFAULT       = 0x0,
-
+    IMAGE_CEE_CS_CALLCONV_C         = IMAGE_CEE_UNMANAGED_CALLCONV_C,
+    IMAGE_CEE_CS_CALLCONV_STDCALL   = IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL,
+    IMAGE_CEE_CS_CALLCONV_THISCALL  = IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL,
+    IMAGE_CEE_CS_CALLCONV_FASTCALL  = IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL,
     IMAGE_CEE_CS_CALLCONV_VARARG        = 0x5,
     IMAGE_CEE_CS_CALLCONV_FIELD         = 0x6,
     IMAGE_CEE_CS_CALLCONV_LOCAL_SIG     = 0x7,
@@ -979,20 +989,6 @@ typedef enum CorCallingConvention
 
 #define IMAGE_CEE_CS_CALLCONV_INSTANTIATION IMAGE_CEE_CS_CALLCONV_GENERICINST
 
-typedef enum CorUnmanagedCallingConvention
-{
-    IMAGE_CEE_UNMANAGED_CALLCONV_C         = 0x1,
-    IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL   = 0x2,
-    IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL  = 0x3,
-    IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL  = 0x4,
-
-    IMAGE_CEE_CS_CALLCONV_C         = IMAGE_CEE_UNMANAGED_CALLCONV_C,
-    IMAGE_CEE_CS_CALLCONV_STDCALL   = IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL,
-    IMAGE_CEE_CS_CALLCONV_THISCALL  = IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL,
-    IMAGE_CEE_CS_CALLCONV_FASTCALL  = IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL,
-
-} CorUnmanagedCallingConvention;
-
 
 typedef enum CorArgType
 {