Convert more COM interop MethodDescCallSite to UCO

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

@@ -1492,6 +1492,156 @@ internal static void SetPendingExceptionObject(Exception? exception)
         [SupportedOSPlatform("windows")]
         internal static object GetIEnumeratorToEnumVariantMarshaler() => EnumeratorToEnumVariantMarshaler.GetInstance(string.Empty);
 
+        private const int DispatchExPropertyCanRead = 1;
+        private const int DispatchExPropertyCanWrite = 2;
+
+        [SupportedOSPlatform("windows")]
+        [UnmanagedCallersOnly]
+        private static unsafe void GetDispatchExPropertyFlags(PropertyInfo* pMemberInfo, int* pResult, Exception* pException)
+        {
+            try
+            {
+                int result = 0;
+                PropertyInfo property = *pMemberInfo;
+                if (property.CanRead)
+                {
+                    result |= DispatchExPropertyCanRead;
+                }
+
+                if (property.CanWrite)
+                {
+                    result |= DispatchExPropertyCanWrite;
+                }
+
+                *pResult = result;
+            }
+            catch (Exception ex)
+            {
+                *pException = ex;
+            }
+        }
+
+        [SupportedOSPlatform("windows")]
+        [UnmanagedCallersOnly]
+        private static unsafe void CallICustomQueryInterface(ICustomQueryInterface* pObject, Guid* pIid, IntPtr* ppObject, int* pResult, Exception* pException)
+        {
+            try
+            {
+                *pResult = (int)pObject->GetInterface(ref *pIid, out *ppObject);
+            }
+            catch (Exception ex)
+            {
+                *pException = ex;
+            }
+        }
+
+        private static unsafe ulong InvokeArgSlotMethodWithOneArg(object target, RuntimeMethodHandle methodHandle, nint methodEntryPoint, object? arg0)
+        {
+            IRuntimeMethodInfo methodInfo = methodHandle.GetMethodInfo();
+            Signature signature = new(methodInfo, RuntimeMethodHandle.GetDeclaringType(methodInfo));
+            RuntimeType returnType = signature.ReturnType;
+            Debug.Assert(methodEntryPoint != 0);
+
+            if (returnType == typeof(void))
+            {
+                ((delegate*<object, object?, void>)methodEntryPoint)(target, arg0);
+                return 0;
+            }
+
+            if (returnType == typeof(bool))
+            {
+                return ((delegate*<object, object?, bool>)methodEntryPoint)(target, arg0) ? 1UL : 0UL;
+            }
+
+            if (returnType == typeof(int))
+            {
+                return unchecked((ulong)((delegate*<object, object?, int>)methodEntryPoint)(target, arg0));
+            }
+
+            if (returnType == typeof(uint))
+            {
+                return ((delegate*<object, object?, uint>)methodEntryPoint)(target, arg0);
+            }
+
+            if (returnType == typeof(long))
+            {
+                return unchecked((ulong)((delegate*<object, object?, long>)methodEntryPoint)(target, arg0));
+            }
+
+            if (returnType == typeof(ulong))
+            {
+                return ((delegate*<object, object?, ulong>)methodEntryPoint)(target, arg0);
+            }
+
+            if (returnType == typeof(IntPtr))
+            {
+                return (ulong)(nuint)((delegate*<object, object?, nint>)methodEntryPoint)(target, arg0);
+            }
+
+            if (returnType == typeof(UIntPtr))
+            {
+                return (ulong)((delegate*<object, object?, nuint>)methodEntryPoint)(target, arg0);
+            }
+
+            throw new NotSupportedException();
+        }
+
+        [SupportedOSPlatform("windows")]
+        [UnmanagedCallersOnly]
+        private static unsafe void InvokeConnectionPointProviderMethod(
+            object* pProvider,
+            IntPtr pProviderMethodPtr,
+            object* pDelegate,
+            IntPtr pDelegateCtorMethodPtr,
+            object* pSubscriber,
+            IntPtr pEventMethodCodePtr,
+            bool useUIntPtrCtor,
+            Exception* pException)
+        {
+            try
+            {
+                nint delegateCtorMethodEntryPoint = (nint)pDelegateCtorMethodPtr;
+                Debug.Assert(delegateCtorMethodEntryPoint != 0);
+
+                // Construct the delegate before invoking the provider method.
+                if (useUIntPtrCtor)
+                {
+                    ((delegate*<object, object?, nuint, void>)delegateCtorMethodEntryPoint)(*pDelegate, *pSubscriber, (nuint)pEventMethodCodePtr);
+                }
+                else
+                {
+                    ((delegate*<object, object?, nint, void>)delegateCtorMethodEntryPoint)(*pDelegate, *pSubscriber, (nint)pEventMethodCodePtr);
+                }
+
+                nint providerMethodEntryPoint = (nint)pProviderMethodPtr;
+                Debug.Assert(providerMethodEntryPoint != 0);
+                ((delegate*<object, object?, void>)providerMethodEntryPoint)(*pProvider, *pDelegate);
+            }
+            catch (Exception ex)
+            {
+                *pException = ex;
+            }
+        }
+
+        [SupportedOSPlatform("windows")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2062:Value passed to parameter cannot be statically determined", Justification = "The runtime passes a RuntimeType describing the COM event provider. The dynamic constructor access requirements are enforced by runtime callsite semantics.")]
+        [UnmanagedCallersOnly]
+        // pResult is an unmanaged ARG_SLOT* (see vm/callhelpers.h). ARG_SLOT is always 8 bytes,
+        // so we use ulong purely as a fixed-width bit container, not for numeric semantics.
+        private static unsafe void InvokeClrToComEventProviderMethod(__ComObject* pComObject, RuntimeType* pProviderType, IntPtr pMethodDesc, IntPtr pMethodEntryPoint, Delegate* pEventHandler, ulong* pResult, Exception* pException)
+        {
+            try
+            {
+                object eventProvider = pComObject->GetEventProvider(*pProviderType);
+                RuntimeMethodHandle methodHandle = RuntimeMethodHandle.FromIntPtr(pMethodDesc);
+                *pResult = InvokeArgSlotMethodWithOneArg(eventProvider, methodHandle, (nint)pMethodEntryPoint, *pEventHandler);
+            }
+            catch (Exception ex)
+            {
+                *pException = ex;
+            }
+        }
+
         [SupportedOSPlatform("windows")]
         [UnmanagedCallersOnly]
         private static unsafe void GetIEnumeratorToEnumVariantMarshaler(object* pResult, Exception* pException)

src/coreclr/vm/class.h

@@ -1468,16 +1468,6 @@ class EEClass // DO NOT CREATE A NEW EEClass USING NEW!
         GetOptionalFields()->m_pCoClassForIntf = th;
     }
 
-    OBJECTHANDLE GetOHDelegate()
-    {
-        LIMITED_METHOD_CONTRACT;
-        return m_ohDelegate;
-    }
-    void SetOHDelegate (OBJECTHANDLE _ohDelegate)
-    {
-        LIMITED_METHOD_CONTRACT;
-        m_ohDelegate = _ohDelegate;
-    }
     // Set the COM interface type.
     CorIfaceAttr GetComInterfaceType()
     {
@@ -1688,16 +1678,8 @@ class EEClass // DO NOT CREATE A NEW EEClass USING NEW!
     PTR_MethodDescChunk m_pChunks;
 
 #ifdef FEATURE_COMINTEROP
-    union
-    {
-        // For CLR wrapper objects that extend an unmanaged class, this field
-        // may contain a delegate to be called to allocate the aggregated
-        // unmanaged class (instead of using CoCreateInstance).
-        OBJECTHANDLE    m_ohDelegate;
-
-        // For interfaces this contains the COM interface type.
-        CorIfaceAttr    m_ComInterfaceType;
-    };
+    // For interfaces this contains the COM interface type.
+    CorIfaceAttr    m_ComInterfaceType;
 
     ComCallWrapperTemplate *m_pccwTemplate;   // points to interop data structures used when this type is exposed to COM
 #endif // FEATURE_COMINTEROP

src/coreclr/vm/clrtocomcall.cpp

@@ -297,11 +297,9 @@ UINT32 CLRToCOMEventCallWorker(CLRToCOMMethodFrame* pFrame, CLRToCOMCallMethodDe
 
     struct {
         OBJECTREF EventProviderTypeObj;
-        OBJECTREF EventProviderObj;
         OBJECTREF ThisObj;
     } gc;
     gc.EventProviderTypeObj = NULL;
-    gc.EventProviderObj = NULL;
     gc.ThisObj = NULL;
 
     LOG((LF_STUBS, LL_INFO1000, "Calling CLRToCOMEventCallWorker %s::%s \n", pMD->m_pszDebugClassName, pMD->m_pszDebugMethodName));
@@ -316,32 +314,28 @@ UINT32 CLRToCOMEventCallWorker(CLRToCOMMethodFrame* pFrame, CLRToCOMCallMethodDe
         gc.EventProviderTypeObj = pEvProvMT->GetManagedClassObject();
         gc.ThisObj = pFrame->GetThis();
 
-        UnmanagedCallersOnlyCaller getEventProvider(METHOD__COM_OBJECT__GET_EVENT_PROVIDER);
-
-        // Retrieve the event provider for the event interface type.
-        getEventProvider.InvokeThrowing(&gc.ThisObj, &gc.EventProviderTypeObj, &gc.EventProviderObj);
-
         // Set up an arg iterator to retrieve the arguments from the frame.
         MetaSig mSig(pMD);
         ArgIterator ArgItr(&mSig);
 
-        // Make the call on the event provider method desc.
-        MethodDescCallSite eventProvider(pEvProvMD, &gc.EventProviderObj);
-
         // Retrieve the event handler passed in.
         OBJECTREF EventHandlerObj = ObjectToOBJECTREF(*(Object**)(pFrame->GetTransitionBlock() + ArgItr.GetNextOffset()));
 
-        ARG_SLOT EventMethArgs[] =
-        {
-            ObjToArgSlot(gc.EventProviderObj),
-            ObjToArgSlot(EventHandlerObj)
-        };
+        ARG_SLOT eventProviderResult = 0;
+        UnmanagedCallersOnlyCaller invokeClrToComEventProviderMethod(METHOD__STUBHELPERS__INVOKE_CLR_TO_COM_EVENT_PROVIDER_METHOD);
+        invokeClrToComEventProviderMethod.InvokeThrowing(
+            &gc.ThisObj,
+            &gc.EventProviderTypeObj,
+            (INT_PTR)pEvProvMD,
+            (INT_PTR)pEvProvMD->GetMultiCallableAddrOfCode(),
+            &EventHandlerObj,
+            &eventProviderResult);
 
         //
         // If this can ever return something bigger than an INT64 byval
         // then this code is broken.  Currently, however, it cannot.
         //
-        *(ARG_SLOT *)(pFrame->GetReturnValuePtr()) = eventProvider.Call_RetArgSlot(EventMethArgs);
+        *(ARG_SLOT *)(pFrame->GetReturnValuePtr()) = eventProviderResult;
 
         // The COM event call worker does not support value returned in
         // floating point registers.

src/coreclr/vm/comcallablewrapper.cpp

@@ -2340,22 +2340,13 @@ VOID __stdcall InvokeICustomQueryInterfaceGetInterface_CallBack(LPVOID ptr)
 
         GCPROTECT_BEGIN(pObj);
 
-        // 1. Get MD
-        MethodDesc *pMD = pArgs->pWrap->GetSimpleWrapper()->GetComCallWrapperTemplate()->GetICustomQueryInterfaceGetInterfaceMD();
+        INT_PTR queriedInterface = reinterpret_cast<INT_PTR>(*pArgs->ppUnk);
+        INT32 result = static_cast<INT32>(CustomQueryInterfaceResult::NotHandled);
+        UnmanagedCallersOnlyCaller callICustomQueryInterface(METHOD__STUBHELPERS__CALL_ICUSTOM_QUERY_INTERFACE);
+        callICustomQueryInterface.InvokeThrowing(&pObj, pArgs->pGuid, &queriedInterface, &result);
 
-        // 2. Get Object Handle
-        OBJECTHANDLE hndCustomQueryInterface = pArgs->pWrap->GetObjectHandle();
-
-        // 3 construct the MethodDescCallSite
-        MethodDescCallSite GetInterface(pMD, hndCustomQueryInterface);
-
-        ARG_SLOT Args[] = {
-            ObjToArgSlot(pObj),
-            PtrToArgSlot(pArgs->pGuid),
-            PtrToArgSlot(pArgs->ppUnk),
-            };
-
-        *(pArgs->pRetVal) = (CustomQueryInterfaceResult)GetInterface.Call_RetArgSlot(Args);
+        *pArgs->ppUnk = reinterpret_cast<IUnknown*>(queriedInterface);
+        *(pArgs->pRetVal) = (CustomQueryInterfaceResult)result;
         GCPROTECT_END();
     }
 }
@@ -4674,7 +4665,6 @@ ComCallWrapperTemplate* ComCallWrapperTemplate::CreateTemplate(TypeHandle thClas
         pTemplate->m_pClassComMT = NULL;        // Defer setting this up.
         pTemplate->m_pBasicComMT = NULL;
         pTemplate->m_pDefaultItf = NULL;
-        pTemplate->m_pICustomQueryInterfaceGetInterfaceMD = NULL;
         pTemplate->m_flags = 0;
 
         // Determine the COM visibility of classes in our hierarchy.
@@ -4794,7 +4784,6 @@ ComCallWrapperTemplate *ComCallWrapperTemplate::CreateTemplateForInterface(Metho
     pTemplate->m_pClassComMT = NULL;
     pTemplate->m_pBasicComMT = NULL;
     pTemplate->m_pDefaultItf = pItfMT;
-    pTemplate->m_pICustomQueryInterfaceGetInterfaceMD = NULL;
     pTemplate->m_flags = enum_RepresentsVariantInterface;
 
     // Initialize the one ComMethodTable
@@ -4928,24 +4917,6 @@ ComMethodTable *ComCallWrapperTemplate::SetupComMethodTableForClass(MethodTable
 }
 
 
-MethodDesc * ComCallWrapperTemplate::GetICustomQueryInterfaceGetInterfaceMD()
-{
-    CONTRACT (MethodDesc*)
-    {
-        THROWS;
-        GC_TRIGGERS;
-        MODE_ANY;
-        PRECONDITION(m_flags & enum_ImplementsICustomQueryInterface);
-    }
-    CONTRACT_END;
-
-    if (m_pICustomQueryInterfaceGetInterfaceMD == NULL)
-        m_pICustomQueryInterfaceGetInterfaceMD = m_thClass.GetMethodTable()->GetMethodDescForInterfaceMethod(
-           CoreLibBinder::GetMethod(METHOD__ICUSTOM_QUERYINTERFACE__GET_INTERFACE),
-           TRUE /* throwOnConflict */);
-    RETURN m_pICustomQueryInterfaceGetInterfaceMD;
-}
-
 //--------------------------------------------------------------------------
 //  Module* ComCallMethodDesc::GetModule()
 //  Get Module

src/coreclr/vm/comcallablewrapper.h

@@ -235,8 +235,6 @@ class ComCallWrapperTemplate
     // Sets up the class method table for the IClassX and also lays it out.
     static ComMethodTable *SetupComMethodTableForClass(MethodTable *pMT, BOOL bLayOutComMT);
 
-    MethodDesc * GetICustomQueryInterfaceGetInterfaceMD();
-
     BOOL HasInvisibleParent()
     {
         LIMITED_METHOD_CONTRACT;
@@ -328,7 +326,6 @@ class ComCallWrapperTemplate
         enum_IsSafeTypeForMarshalling         = 0x2000, // The class can be safely marshalled out of process via DCOM
     };
     DWORD                                   m_flags;
-    MethodDesc*                             m_pICustomQueryInterfaceGetInterfaceMD;
     ULONG                                   m_cbInterfaces;
     SLOT*                                   m_rgpIPtr[1];
 };