From 923907d9efdd0c1d9906cfc0bf9eb51bb99483d0 Mon Sep 17 00:00:00 2001 From: Adeel <3840695+am11@users.noreply.github.com> Date: Mon, 9 Mar 2026 13:25:07 +0200 Subject: [PATCH 1/2] Convert some COM interop to UCO --- .../Runtime/InteropServices/ComActivator.cs | 43 +++++++++++++++++++ .../src/System/RuntimeType.CoreCLR.cs | 41 ++++++++++++++++++ .../src/System/StubHelpers.cs | 14 ++++++ .../src/System/Variant.cs | 41 ++++++++++++++++++ .../src/System/__ComObject.cs | 16 +++++++ src/coreclr/vm/clrtocomcall.cpp | 41 ++++++++---------- src/coreclr/vm/corelib.h | 17 ++++---- src/coreclr/vm/custommarshalerinfo.cpp | 4 +- src/coreclr/vm/metasig.h | 7 +++ src/coreclr/vm/olevariant.cpp | 24 +++-------- src/coreclr/vm/runtimecallablewrapper.cpp | 26 +++++------ 11 files changed, 206 insertions(+), 68 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs index 5ac78f35cdcee0..6682edc1f43c48 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs @@ -768,6 +768,19 @@ public static object Create() return new LicenseInteropProxy(); } + [UnmanagedCallersOnly] + private static unsafe void CreateUco(object* pResult, Exception* pException) + { + try + { + *pResult = Create(); + } + catch (Exception ex) + { + *pException = ex; + } + } + // Determine if the type supports licensing public static bool HasLicense(Type type) { @@ -877,6 +890,23 @@ public void GetCurrentContextInfo(RuntimeTypeHandle rth, out bool isDesignTime, bstrKey = Marshal.StringToBSTR((string)key!); } + [UnmanagedCallersOnly] + private static unsafe void GetCurrentContextInfoUco(object* pProxy, object* pType, int* pIsDesignTime, IntPtr* pBstrKey, Exception* pException) + { + try + { + LicenseInteropProxy proxy = (LicenseInteropProxy)(*pProxy)!; + Type type = (Type)(*pType)!; + proxy.GetCurrentContextInfo(type.TypeHandle, out bool isDesignTime, out IntPtr bstrKey); + *pIsDesignTime = isDesignTime ? 1 : 0; + *pBstrKey = bstrKey; + } + catch (Exception ex) + { + *pException = ex; + } + } + // The CLR invokes this when instantiating a licensed COM // object inside a designtime license context. // It's purpose is to save away the license key that the CLR @@ -892,5 +922,18 @@ public void SaveKeyInCurrentContext(IntPtr bstrKey) SetSavedLicenseKey(_licContext!, _targetRcwType!, key); } + + [UnmanagedCallersOnly] + private static unsafe void SaveKeyInCurrentContextUco(object* pProxy, IntPtr bstrKey, Exception* pException) + { + try + { + ((LicenseInteropProxy)(*pProxy)!).SaveKeyInCurrentContext(bstrKey); + } + catch (Exception ex) + { + *pException = ex; + } + } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index 4ad338f0dc6a6d..71803b660c3140 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -4219,6 +4219,47 @@ private object InvokeDispMethod( return ret; } + [RequiresUnreferencedCode("The member might be removed")] + [UnmanagedCallersOnly] + private static unsafe void ForwardCallToInvokeMemberUco( + object* pRuntimeType, + object* pMemberName, + int flags, + object* pTarget, + object* pArgs, + object* pArgsIsByRef, + object* pArgsWrapperTypes, + object* pArgsTypes, + object* pRetType, + object* pResult, + Exception* pException) + { + try + { + RuntimeType runtimeType = (RuntimeType)(*pRuntimeType)!; + string memberName = (string)(*pMemberName)!; + object[] args = (object[])(*pArgs)!; + bool[] argsIsByRef = (bool[])(*pArgsIsByRef)!; + int[]? argsWrapperTypes = (int[]?)(*pArgsWrapperTypes); + Type[] argsTypes = (Type[])(*pArgsTypes)!; + Type retType = (Type)(*pRetType)!; + + *pResult = runtimeType.ForwardCallToInvokeMember( + memberName, + (BindingFlags)flags, + *pTarget, + args, + argsIsByRef, + argsWrapperTypes, + argsTypes, + retType); + } + catch (Exception ex) + { + *pException = ex; + } + } + private static void WrapArgsForInvokeCall(object[] aArgs, int[] aArgsWrapperTypes) { int cArgs = aArgs.Length; diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index b7b1601dfa5f1c..ca3f12cce9eed3 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -1491,6 +1491,20 @@ internal static void SetPendingExceptionObject(Exception? exception) #if FEATURE_COMINTEROP [SupportedOSPlatform("windows")] internal static object GetIEnumeratorToEnumVariantMarshaler() => EnumeratorToEnumVariantMarshaler.GetInstance(string.Empty); + + [SupportedOSPlatform("windows")] + [UnmanagedCallersOnly] + private static unsafe void GetIEnumeratorToEnumVariantMarshalerUco(object* pResult, Exception* pException) + { + try + { + *pResult = GetIEnumeratorToEnumVariantMarshaler(); + } + catch (Exception ex) + { + *pException = ex; + } + } #endif internal static object CreateCustomMarshaler(IntPtr pMD, int paramToken, IntPtr hndManagedType) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index 2296297be09108..a9fd89b9fefc39 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -192,6 +192,20 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria } } + [UnmanagedCallersOnly] + private static unsafe void MarshalHelperConvertObjectToVariantUco(object* pObject, ComVariant* pOle, Exception* pException) + { + try + { + MarshalHelperConvertObjectToVariant(*pObject, out ComVariant tmp); + *pOle = tmp; + } + catch (Exception ex) + { + *pException = ex; + } + } + // Helper code for marshaling VARIANTS to managed objects internal static unsafe object? MarshalHelperConvertVariantToObject(ref readonly ComVariant pOle) { @@ -320,6 +334,19 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria } } + [UnmanagedCallersOnly] + private static unsafe void MarshalHelperConvertVariantToObjectUco(ComVariant* pOle, object* pResult, Exception* pException) + { + try + { + *pResult = MarshalHelperConvertVariantToObject(in *pOle); + } + catch (Exception ex) + { + *pException = ex; + } + } + // Helper code: on the back propagation path where a VT_BYREF VARIANT* // is marshaled to a "ref Object", we use this helper to force the // updated object back to the original type. @@ -396,5 +423,19 @@ internal static void MarshalHelperCastVariant(object pValue, int vt, out ComVari }; } } + + [UnmanagedCallersOnly] + private static unsafe void MarshalHelperCastVariantUco(object* pValue, int vt, ComVariant* pOle, Exception* pException) + { + try + { + MarshalHelperCastVariant(*pValue!, vt, out ComVariant tmp); + *pOle = tmp; + } + catch (Exception ex) + { + *pException = ex; + } + } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs index a520097018d9f4..3bccbcdbdc0e89 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs @@ -126,6 +126,22 @@ internal object GetEventProvider( return CreateEventProvider(t); } + [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] + private static unsafe void GetEventProviderUco(object* pComObject, object* pProviderType, object* pResult, Exception* pException) + { + try + { + __ComObject comObject = (__ComObject)(*pComObject)!; + RuntimeType providerType = (RuntimeType)(*pProviderType)!; + *pResult = comObject.GetEventProvider(providerType); + } + catch (Exception ex) + { + *pException = ex; + } + } + private object CreateEventProvider( [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors)] RuntimeType t) { diff --git a/src/coreclr/vm/clrtocomcall.cpp b/src/coreclr/vm/clrtocomcall.cpp index 70cd6c13ff74ff..fdb1e1acdadeff 100644 --- a/src/coreclr/vm/clrtocomcall.cpp +++ b/src/coreclr/vm/clrtocomcall.cpp @@ -316,16 +316,10 @@ UINT32 CLRToCOMEventCallWorker(CLRToCOMMethodFrame* pFrame, CLRToCOMCallMethodDe gc.EventProviderTypeObj = pEvProvMT->GetManagedClassObject(); gc.ThisObj = pFrame->GetThis(); - MethodDescCallSite getEventProvider(METHOD__COM_OBJECT__GET_EVENT_PROVIDER, &gc.ThisObj); + UnmanagedCallersOnlyCaller getEventProvider(METHOD__COM_OBJECT__GET_EVENT_PROVIDER_UCO); // Retrieve the event provider for the event interface type. - ARG_SLOT GetEventProviderArgs[] = - { - ObjToArgSlot(gc.ThisObj), - ObjToArgSlot(gc.EventProviderTypeObj) - }; - - gc.EventProviderObj = getEventProvider.Call_RetOBJECTREF(GetEventProviderArgs); + getEventProvider.InvokeThrowing(&gc.ThisObj, &gc.EventProviderTypeObj, &gc.EventProviderObj); // Set up an arg iterator to retrieve the arguments from the frame. MetaSig mSig(pMD); @@ -601,6 +595,7 @@ UINT32 CLRToCOMLateBoundWorker( { OBJECTREF MemberName; OBJECTREF ItfTypeObj; + OBJECTREF ThisObj; PTRARRAYREF Args; BOOLARRAYREF ArgsIsByRef; PTRARRAYREF ArgsTypes; @@ -610,6 +605,7 @@ UINT32 CLRToCOMLateBoundWorker( } gc; gc.MemberName = NULL; gc.ItfTypeObj = NULL; + gc.ThisObj = NULL; gc.Args = NULL; gc.ArgsIsByRef = NULL; gc.ArgsTypes = NULL; @@ -648,6 +644,7 @@ UINT32 CLRToCOMLateBoundWorker( // Return type TypeHandle retValHandle = callsite.MetaSig.GetRetTypeHandleThrowing(); gc.RetValType = retValHandle.GetManagedClassObject(); + gc.ThisObj = pFrame->GetThis(); // the return value is written into the Frame's neginfo, so we don't // need to return it directly. We can just have the stub do that work. @@ -662,24 +659,20 @@ UINT32 CLRToCOMLateBoundWorker( } // Create a call site for the invoke - MethodDescCallSite forwardCallToInvoke(METHOD__CLASS__FORWARD_CALL_TO_INVOKE, &gc.ItfTypeObj); - - // Prepare the arguments that will be passed to the method. - ARG_SLOT invokeArgs[] = - { - ObjToArgSlot(gc.ItfTypeObj), - ObjToArgSlot(gc.MemberName), - (ARG_SLOT)binderFlags, - ObjToArgSlot(pFrame->GetThis()), - ObjToArgSlot(gc.Args), - ObjToArgSlot(gc.ArgsIsByRef), - ObjToArgSlot(gc.ArgsWrapperTypes), - ObjToArgSlot(gc.ArgsTypes), - ObjToArgSlot(gc.RetValType) - }; + UnmanagedCallersOnlyCaller forwardCallToInvoke(METHOD__CLASS__FORWARD_CALL_TO_INVOKE_UCO); // Invoke the method - gc.RetVal = forwardCallToInvoke.CallWithValueTypes_RetOBJECTREF(invokeArgs); + forwardCallToInvoke.InvokeThrowing( + &gc.ItfTypeObj, + reinterpret_cast(&gc.MemberName), + (INT32)binderFlags, + &gc.ThisObj, + reinterpret_cast(&gc.Args), + reinterpret_cast(&gc.ArgsIsByRef), + &gc.ArgsWrapperTypes, + reinterpret_cast(&gc.ArgsTypes), + &gc.RetValType, + &gc.RetVal); // Ensure all outs and return values are moved back to the current callsite CallsiteInspect::PropagateOutParametersBackToCallsite(gc.Args, gc.RetVal, callsite); diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 0199ff57ae6d07..984e5c97a666f2 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -160,6 +160,7 @@ DEFINE_METHOD(CLASS, CTOR, .ctor, #ifdef FEATURE_COMINTEROP DEFINE_METHOD(CLASS, FORWARD_CALL_TO_INVOKE, ForwardCallToInvokeMember, IM_Str_BindingFlags_Obj_ArrObj_ArrBool_ArrInt_ArrType_Type_RetObj) +DEFINE_METHOD(CLASS, FORWARD_CALL_TO_INVOKE_UCO, ForwardCallToInvokeMemberUco, SM_PtrObj_PtrObj_Int_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrException_RetVoid) #endif // FEATURE_COMINTEROP BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsSupported, true, true) @@ -179,15 +180,15 @@ DEFINE_CLASS_U(System, __ComObject, ComObject) DEFINE_FIELD_U(m_ObjectToDataMap, ComObject, m_ObjectToDataMap) DEFINE_CLASS(COM_OBJECT, System, __ComObject) DEFINE_METHOD(COM_OBJECT, RELEASE_ALL_DATA, ReleaseAllData, IM_RetVoid) -DEFINE_METHOD(COM_OBJECT, GET_EVENT_PROVIDER, GetEventProvider, IM_Class_RetObj) +DEFINE_METHOD(COM_OBJECT, GET_EVENT_PROVIDER_UCO, GetEventProviderUco, SM_PtrObj_PtrObj_PtrObj_PtrException_RetVoid) #ifdef FOR_ILLINK DEFINE_METHOD(COM_OBJECT, CTOR, .ctor, IM_RetVoid) #endif // FOR_ILLINK DEFINE_CLASS(LICENSE_INTEROP_PROXY, InternalInteropServices, LicenseInteropProxy) -DEFINE_METHOD(LICENSE_INTEROP_PROXY, CREATE, Create, SM_RetObj) -DEFINE_METHOD(LICENSE_INTEROP_PROXY, GETCURRENTCONTEXTINFO, GetCurrentContextInfo, IM_RuntimeTypeHandle_RefBool_RefIntPtr_RetVoid) -DEFINE_METHOD(LICENSE_INTEROP_PROXY, SAVEKEYINCURRENTCONTEXT, SaveKeyInCurrentContext, IM_IntPtr_RetVoid) +DEFINE_METHOD(LICENSE_INTEROP_PROXY, CREATE_UCO, CreateUco, SM_PtrObj_PtrException_RetVoid) +DEFINE_METHOD(LICENSE_INTEROP_PROXY, GETCURRENTCONTEXTINFO_UCO, GetCurrentContextInfoUco, SM_PtrObj_PtrObj_PtrInt_PtrIntPtr_PtrException_RetVoid) +DEFINE_METHOD(LICENSE_INTEROP_PROXY, SAVEKEYINCURRENTCONTEXT_UCO, SaveKeyInCurrentContextUco, SM_PtrObj_IntPtr_PtrException_RetVoid) #endif // FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -384,9 +385,9 @@ DEFINE_CLASS(GUID, System, Guid) BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsSupported, true, true) #ifdef FEATURE_COMINTEROP DEFINE_CLASS(VARIANT, System, Variant) -DEFINE_METHOD(VARIANT, CONVERT_OBJECT_TO_VARIANT,MarshalHelperConvertObjectToVariant,SM_Obj_RefComVariant_RetVoid) -DEFINE_METHOD(VARIANT, CAST_VARIANT, MarshalHelperCastVariant, SM_Obj_Int_RefComVariant_RetVoid) -DEFINE_METHOD(VARIANT, CONVERT_VARIANT_TO_OBJECT,MarshalHelperConvertVariantToObject,SM_RefComVariant_RetObject) +DEFINE_METHOD(VARIANT, CONVERT_OBJECT_TO_VARIANT_UCO, MarshalHelperConvertObjectToVariantUco, SM_PtrObj_PtrComVariant_PtrException_RetVoid) +DEFINE_METHOD(VARIANT, CAST_VARIANT_UCO, MarshalHelperCastVariantUco, SM_PtrObj_Int_PtrComVariant_PtrException_RetVoid) +DEFINE_METHOD(VARIANT, CONVERT_VARIANT_TO_OBJECT_UCO, MarshalHelperConvertVariantToObjectUco, SM_PtrComVariant_PtrObj_PtrException_RetVoid) #endif // FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -1045,7 +1046,7 @@ DEFINE_METHOD(STUBHELPERS, GET_HR_EXCEPTION_OBJECT, GetHRExceptionObjec DEFINE_METHOD(STUBHELPERS, GET_PENDING_EXCEPTION_OBJECT, GetPendingExceptionObject, SM_RetException) DEFINE_METHOD(STUBHELPERS, CREATE_CUSTOM_MARSHALER, CreateCustomMarshaler, SM_IntPtr_Int_IntPtr_RetObj) #ifdef FEATURE_COMINTEROP -DEFINE_METHOD(STUBHELPERS, GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER, GetIEnumeratorToEnumVariantMarshaler, SM_RetObj) +DEFINE_METHOD(STUBHELPERS, GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER_UCO, GetIEnumeratorToEnumVariantMarshalerUco, SM_PtrObj_PtrException_RetVoid) #endif // FEATURE_COMINTEROP DEFINE_METHOD(STUBHELPERS, CHECK_STRING_LENGTH, CheckStringLength, SM_Int_RetVoid) diff --git a/src/coreclr/vm/custommarshalerinfo.cpp b/src/coreclr/vm/custommarshalerinfo.cpp index 2638848324c723..bf3bee92a69a5a 100644 --- a/src/coreclr/vm/custommarshalerinfo.cpp +++ b/src/coreclr/vm/custommarshalerinfo.cpp @@ -120,8 +120,8 @@ CustomMarshalerInfo* CustomMarshalerInfo::CreateIEnumeratorMarshalerInfo(LoaderH GCX_COOP(); GCPROTECT_BEGIN(IEnumeratorMarshalerObj); - MethodDescCallSite getMarshaler(METHOD__STUBHELPERS__GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER); - IEnumeratorMarshalerObj = getMarshaler.Call_RetOBJECTREF(NULL); + UnmanagedCallersOnlyCaller getMarshaler(METHOD__STUBHELPERS__GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER_UCO); + getMarshaler.InvokeThrowing(&IEnumeratorMarshalerObj); pInfo = new (pHeap) CustomMarshalerInfo(pLoaderAllocator, pLoaderAllocator->AllocateHandle(IEnumeratorMarshalerObj)); diff --git a/src/coreclr/vm/metasig.h b/src/coreclr/vm/metasig.h index 504a481b0b2c92..319492f4bb7529 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -428,7 +428,14 @@ DEFINE_METASIG_T(SM(PtrResolver_Int_PtrIntPtr_PtrIntPtr_PtrIntPtr_PtrException_R DEFINE_METASIG_T(SM(PtrResolver_Int_Int_PtrArrByte_PtrException_RetVoid, P(C(RESOLVER)) i i P(a(b)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrResolver_Int_PtrStr_PtrException_RetVoid, P(C(RESOLVER)) i P(s) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrException_RetVoid, P(j) P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrObj_PtrException_RetVoid, P(j) P(j) P(j) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrStr_PtrException_RetVoid, P(j) P(s) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_PtrObj_Int_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrException_RetVoid, P(j) P(j) i P(j) P(j) P(j) P(j) P(j) P(j) P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrInt_PtrIntPtr_PtrException_RetVoid, P(j) P(j) P(i) P(I) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_IntPtr_PtrException_RetVoid, P(j) I P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_PtrComVariant_PtrException_RetVoid, P(j) P(g(COMVARIANT)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_Int_PtrComVariant_PtrException_RetVoid, P(j) i P(g(COMVARIANT)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrComVariant_PtrObj_PtrException_RetVoid, P(g(COMVARIANT)) P(j) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrException_PtrException_RetVoid, P(C(EXCEPTION)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrChar_PtrException_PtrObj_PtrException_RetVoid, P(u) P(C(EXCEPTION)) P(j) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrChar_PtrStr_PtrException_RetVoid, P(u) P(s) P(C(EXCEPTION)), v)) diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 4efc9c79c8bba6..bd410c2e831ce8 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -2158,7 +2158,7 @@ void OleVariant::MarshalOleRefVariantForObject(OBJECTREF *pObj, VARIANT *pOle) } else { - MethodDescCallSite castVariant(METHOD__VARIANT__CAST_VARIANT); + UnmanagedCallersOnlyCaller castVariant(METHOD__VARIANT__CAST_VARIANT_UCO); // MarshalOleRefVariantForObjectNoCast has checked that the variant is not an array // so we can use the marshal cast helper to coerce the object to the proper type. @@ -2166,11 +2166,7 @@ void OleVariant::MarshalOleRefVariantForObject(OBJECTREF *pObj, VARIANT *pOle) VariantInit(&vtmp); VARTYPE vt = V_VT(pOle) & ~VT_BYREF; - ARG_SLOT args[3]; - args[0] = ObjToArgSlot(*pObj); - args[1] = (ARG_SLOT)vt; - args[2] = PtrToArgSlot(&vtmp); - castVariant.Call(args); + castVariant.InvokeThrowing(pObj, (INT32)vt, &vtmp); // Managed implementation of CastVariant should either return correct type or throw. _ASSERTE(V_VT(&vtmp) == vt); @@ -2760,10 +2756,8 @@ void OleVariant::MarshalObjectForOleVariantUncommon(const VARIANT *pOle, OBJECTR } else { - MethodDescCallSite convertVariantToObject(METHOD__VARIANT__CONVERT_VARIANT_TO_OBJECT); - ARG_SLOT args[] = { PtrToArgSlot(pOle) }; - SetObjectReference( pObj, - convertVariantToObject.Call_RetOBJECTREF(args) ); + UnmanagedCallersOnlyCaller convertVariantToObject(METHOD__VARIANT__CONVERT_VARIANT_TO_OBJECT_UCO); + convertVariantToObject.InvokeThrowing(pOle, pObj); } } @@ -2802,14 +2796,8 @@ void OleVariant::MarshalOleVariantForObjectUncommon(OBJECTREF * const & pObj, VA } else { - MethodDescCallSite convertObjectToVariant(METHOD__VARIANT__CONVERT_OBJECT_TO_VARIANT); - - ARG_SLOT args[] = { - ObjToArgSlot(*pObj), - PtrToArgSlot(pOle), - }; - - convertObjectToVariant.Call(args); + UnmanagedCallersOnlyCaller convertObjectToVariant(METHOD__VARIANT__CONVERT_OBJECT_TO_VARIANT_UCO); + convertObjectToVariant.InvokeThrowing(pObj, pOle); } veh.SuppressRelease(); diff --git a/src/coreclr/vm/runtimecallablewrapper.cpp b/src/coreclr/vm/runtimecallablewrapper.cpp index db58879480b80a..8783200656b953 100644 --- a/src/coreclr/vm/runtimecallablewrapper.cpp +++ b/src/coreclr/vm/runtimecallablewrapper.cpp @@ -137,20 +137,16 @@ IUnknown *ComClassFactory::CreateInstanceFromClassFactory(IClassFactory *pClassF GCPROTECT_BEGIN(gc); // Create an instance of the object - MethodDescCallSite createObj(METHOD__LICENSE_INTEROP_PROXY__CREATE); - gc.pProxy = createObj.Call_RetOBJECTREF(NULL); + UnmanagedCallersOnlyCaller createObj(METHOD__LICENSE_INTEROP_PROXY__CREATE_UCO); + createObj.InvokeThrowing(&gc.pProxy); gc.pType = rth.GetManagedClassObject(); // Query the current licensing context - MethodDescCallSite getCurrentContextInfo(METHOD__LICENSE_INTEROP_PROXY__GETCURRENTCONTEXTINFO, &gc.pProxy); - CLR_BOOL fDesignTime = FALSE; - ARG_SLOT args[4]; - args[0] = ObjToArgSlot(gc.pProxy); - args[1] = ObjToArgSlot(gc.pType); - args[2] = (ARG_SLOT)&fDesignTime; - args[3] = (ARG_SLOT)(BSTR*)&bstrKey; - - getCurrentContextInfo.Call(args); + UnmanagedCallersOnlyCaller getCurrentContextInfo(METHOD__LICENSE_INTEROP_PROXY__GETCURRENTCONTEXTINFO_UCO); + INT32 fDesignTime = FALSE; + BSTR bstrKeyRaw = NULL; + getCurrentContextInfo.InvokeThrowing(&gc.pProxy, &gc.pType, &fDesignTime, reinterpret_cast(&bstrKeyRaw)); + bstrKey = bstrKeyRaw; if (fDesignTime) { @@ -181,11 +177,9 @@ IUnknown *ComClassFactory::CreateInstanceFromClassFactory(IClassFactory *pClassF // Store the requested license key if (SUCCEEDED(hr)) { - MethodDescCallSite saveKeyInCurrentContext(METHOD__LICENSE_INTEROP_PROXY__SAVEKEYINCURRENTCONTEXT, &gc.pProxy); - - args[0] = ObjToArgSlot(gc.pProxy); - args[1] = (ARG_SLOT)(BSTR)bstrKey; - saveKeyInCurrentContext.Call(args); + UnmanagedCallersOnlyCaller saveKeyInCurrentContext(METHOD__LICENSE_INTEROP_PROXY__SAVEKEYINCURRENTCONTEXT_UCO); + BSTR bstrKeyValue = (BSTR)bstrKey; + saveKeyInCurrentContext.InvokeThrowing(&gc.pProxy, reinterpret_cast(bstrKeyValue)); } } From 0b7f8d4f7717f5421eaa05df15926ed46503d6df Mon Sep 17 00:00:00 2001 From: Adeel <3840695+am11@users.noreply.github.com> Date: Mon, 9 Mar 2026 19:37:16 +0200 Subject: [PATCH 2/2] Address CR feedback --- .../Runtime/InteropServices/ComActivator.cs | 22 +++-------- .../src/System/RuntimeType.CoreCLR.cs | 38 ++++++++----------- .../src/System/StubHelpers.cs | 2 +- .../src/System/Variant.cs | 12 +++--- .../src/System/__ComObject.cs | 6 +-- src/coreclr/vm/clrtocomcall.cpp | 12 +++--- src/coreclr/vm/corelib.h | 19 +++++----- src/coreclr/vm/custommarshalerinfo.cpp | 2 +- src/coreclr/vm/metasig.h | 7 ++++ src/coreclr/vm/olevariant.cpp | 6 +-- src/coreclr/vm/runtimecallablewrapper.cpp | 14 +++---- 11 files changed, 62 insertions(+), 78 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs index 6682edc1f43c48..33b82d2fbb07e6 100644 --- a/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs +++ b/src/coreclr/System.Private.CoreLib/src/Internal/Runtime/InteropServices/ComActivator.cs @@ -762,18 +762,12 @@ private static extern bool Contains( [UnsafeAccessorType(LicInfoHelperLicenseContextTypeName)] object? licInfoHelperContext, string assemblyName); - // Helper function to create an object from the native side - public static object Create() - { - return new LicenseInteropProxy(); - } - [UnmanagedCallersOnly] - private static unsafe void CreateUco(object* pResult, Exception* pException) + private static unsafe void Create(object* pResult, Exception* pException) { try { - *pResult = Create(); + *pResult = new LicenseInteropProxy(); } catch (Exception ex) { @@ -891,15 +885,11 @@ public void GetCurrentContextInfo(RuntimeTypeHandle rth, out bool isDesignTime, } [UnmanagedCallersOnly] - private static unsafe void GetCurrentContextInfoUco(object* pProxy, object* pType, int* pIsDesignTime, IntPtr* pBstrKey, Exception* pException) + private static unsafe void GetCurrentContextInfo(LicenseInteropProxy* pProxy, Type* pType, bool* pIsDesignTime, IntPtr* pBstrKey, Exception* pException) { try { - LicenseInteropProxy proxy = (LicenseInteropProxy)(*pProxy)!; - Type type = (Type)(*pType)!; - proxy.GetCurrentContextInfo(type.TypeHandle, out bool isDesignTime, out IntPtr bstrKey); - *pIsDesignTime = isDesignTime ? 1 : 0; - *pBstrKey = bstrKey; + pProxy->GetCurrentContextInfo(pType->TypeHandle, out *pIsDesignTime, out *pBstrKey); } catch (Exception ex) { @@ -924,11 +914,11 @@ public void SaveKeyInCurrentContext(IntPtr bstrKey) } [UnmanagedCallersOnly] - private static unsafe void SaveKeyInCurrentContextUco(object* pProxy, IntPtr bstrKey, Exception* pException) + private static unsafe void SaveKeyInCurrentContext(LicenseInteropProxy* pProxy, IntPtr bstrKey, Exception* pException) { try { - ((LicenseInteropProxy)(*pProxy)!).SaveKeyInCurrentContext(bstrKey); + pProxy->SaveKeyInCurrentContext(bstrKey); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs index 71803b660c3140..3772691fc6a633 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs @@ -4221,38 +4221,30 @@ private object InvokeDispMethod( [RequiresUnreferencedCode("The member might be removed")] [UnmanagedCallersOnly] - private static unsafe void ForwardCallToInvokeMemberUco( - object* pRuntimeType, - object* pMemberName, + private static unsafe void ForwardCallToInvokeMember( + RuntimeType* pRuntimeType, + string* pMemberName, int flags, object* pTarget, - object* pArgs, - object* pArgsIsByRef, - object* pArgsWrapperTypes, - object* pArgsTypes, - object* pRetType, + object[]* pArgs, + bool[]* pArgsIsByRef, + int[]* pArgsWrapperTypes, + Type[]* pArgsTypes, + Type* pRetType, object* pResult, Exception* pException) { try { - RuntimeType runtimeType = (RuntimeType)(*pRuntimeType)!; - string memberName = (string)(*pMemberName)!; - object[] args = (object[])(*pArgs)!; - bool[] argsIsByRef = (bool[])(*pArgsIsByRef)!; - int[]? argsWrapperTypes = (int[]?)(*pArgsWrapperTypes); - Type[] argsTypes = (Type[])(*pArgsTypes)!; - Type retType = (Type)(*pRetType)!; - - *pResult = runtimeType.ForwardCallToInvokeMember( - memberName, + *pResult = pRuntimeType->ForwardCallToInvokeMember( + *pMemberName, (BindingFlags)flags, *pTarget, - args, - argsIsByRef, - argsWrapperTypes, - argsTypes, - retType); + *pArgs, + *pArgsIsByRef, + *pArgsWrapperTypes, + *pArgsTypes, + *pRetType); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index ca3f12cce9eed3..a913fca431da0a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -1494,7 +1494,7 @@ internal static void SetPendingExceptionObject(Exception? exception) [SupportedOSPlatform("windows")] [UnmanagedCallersOnly] - private static unsafe void GetIEnumeratorToEnumVariantMarshalerUco(object* pResult, Exception* pException) + private static unsafe void GetIEnumeratorToEnumVariantMarshaler(object* pResult, Exception* pException) { try { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs index a9fd89b9fefc39..0d2cb9c302c259 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -193,12 +193,11 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria } [UnmanagedCallersOnly] - private static unsafe void MarshalHelperConvertObjectToVariantUco(object* pObject, ComVariant* pOle, Exception* pException) + private static unsafe void MarshalHelperConvertObjectToVariant(object* pObject, ComVariant* pOle, Exception* pException) { try { - MarshalHelperConvertObjectToVariant(*pObject, out ComVariant tmp); - *pOle = tmp; + MarshalHelperConvertObjectToVariant(*pObject, out *pOle); } catch (Exception ex) { @@ -335,7 +334,7 @@ private static unsafe void MarshalHelperConvertObjectToVariantUco(object* pObjec } [UnmanagedCallersOnly] - private static unsafe void MarshalHelperConvertVariantToObjectUco(ComVariant* pOle, object* pResult, Exception* pException) + private static unsafe void MarshalHelperConvertVariantToObject(ComVariant* pOle, object* pResult, Exception* pException) { try { @@ -425,12 +424,11 @@ internal static void MarshalHelperCastVariant(object pValue, int vt, out ComVari } [UnmanagedCallersOnly] - private static unsafe void MarshalHelperCastVariantUco(object* pValue, int vt, ComVariant* pOle, Exception* pException) + private static unsafe void MarshalHelperCastVariant(object* pValue, int vt, ComVariant* pOle, Exception* pException) { try { - MarshalHelperCastVariant(*pValue!, vt, out ComVariant tmp); - *pOle = tmp; + MarshalHelperCastVariant(*pValue!, vt, out *pOle); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs index 3bccbcdbdc0e89..5ef7080d53b1bf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs @@ -128,13 +128,11 @@ internal object GetEventProvider( [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] - private static unsafe void GetEventProviderUco(object* pComObject, object* pProviderType, object* pResult, Exception* pException) + private static unsafe void GetEventProvider(__ComObject* pComObject, RuntimeType* pProviderType, object* pResult, Exception* pException) { try { - __ComObject comObject = (__ComObject)(*pComObject)!; - RuntimeType providerType = (RuntimeType)(*pProviderType)!; - *pResult = comObject.GetEventProvider(providerType); + *pResult = pComObject->GetEventProvider(*pProviderType); } catch (Exception ex) { diff --git a/src/coreclr/vm/clrtocomcall.cpp b/src/coreclr/vm/clrtocomcall.cpp index fdb1e1acdadeff..3a2373b8e8735b 100644 --- a/src/coreclr/vm/clrtocomcall.cpp +++ b/src/coreclr/vm/clrtocomcall.cpp @@ -316,7 +316,7 @@ UINT32 CLRToCOMEventCallWorker(CLRToCOMMethodFrame* pFrame, CLRToCOMCallMethodDe gc.EventProviderTypeObj = pEvProvMT->GetManagedClassObject(); gc.ThisObj = pFrame->GetThis(); - UnmanagedCallersOnlyCaller getEventProvider(METHOD__COM_OBJECT__GET_EVENT_PROVIDER_UCO); + 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); @@ -659,18 +659,18 @@ UINT32 CLRToCOMLateBoundWorker( } // Create a call site for the invoke - UnmanagedCallersOnlyCaller forwardCallToInvoke(METHOD__CLASS__FORWARD_CALL_TO_INVOKE_UCO); + UnmanagedCallersOnlyCaller forwardCallToInvoke(METHOD__CLASS__FORWARD_CALL_TO_INVOKE); // Invoke the method forwardCallToInvoke.InvokeThrowing( &gc.ItfTypeObj, - reinterpret_cast(&gc.MemberName), + &gc.MemberName, (INT32)binderFlags, &gc.ThisObj, - reinterpret_cast(&gc.Args), - reinterpret_cast(&gc.ArgsIsByRef), + &gc.Args, + &gc.ArgsIsByRef, &gc.ArgsWrapperTypes, - reinterpret_cast(&gc.ArgsTypes), + &gc.ArgsTypes, &gc.RetValType, &gc.RetVal); diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 984e5c97a666f2..03655015fe1e50 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -159,8 +159,7 @@ DEFINE_METHOD(CLASS, CTOR, .ctor, #endif // FOR_ILLINK #ifdef FEATURE_COMINTEROP -DEFINE_METHOD(CLASS, FORWARD_CALL_TO_INVOKE, ForwardCallToInvokeMember, IM_Str_BindingFlags_Obj_ArrObj_ArrBool_ArrInt_ArrType_Type_RetObj) -DEFINE_METHOD(CLASS, FORWARD_CALL_TO_INVOKE_UCO, ForwardCallToInvokeMemberUco, SM_PtrObj_PtrObj_Int_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrException_RetVoid) +DEFINE_METHOD(CLASS, FORWARD_CALL_TO_INVOKE, ForwardCallToInvokeMember, SM_PtrClass_PtrStr_Int_PtrObj_PtrArrObj_PtrArrBool_PtrArrInt_PtrArrType_PtrType_PtrObj_PtrException_RetVoid) #endif // FEATURE_COMINTEROP BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsSupported, true, true) @@ -180,15 +179,15 @@ DEFINE_CLASS_U(System, __ComObject, ComObject) DEFINE_FIELD_U(m_ObjectToDataMap, ComObject, m_ObjectToDataMap) DEFINE_CLASS(COM_OBJECT, System, __ComObject) DEFINE_METHOD(COM_OBJECT, RELEASE_ALL_DATA, ReleaseAllData, IM_RetVoid) -DEFINE_METHOD(COM_OBJECT, GET_EVENT_PROVIDER_UCO, GetEventProviderUco, SM_PtrObj_PtrObj_PtrObj_PtrException_RetVoid) +DEFINE_METHOD(COM_OBJECT, GET_EVENT_PROVIDER, GetEventProvider, SM_PtrComObject_PtrClass_PtrObj_PtrException_RetVoid) #ifdef FOR_ILLINK DEFINE_METHOD(COM_OBJECT, CTOR, .ctor, IM_RetVoid) #endif // FOR_ILLINK DEFINE_CLASS(LICENSE_INTEROP_PROXY, InternalInteropServices, LicenseInteropProxy) -DEFINE_METHOD(LICENSE_INTEROP_PROXY, CREATE_UCO, CreateUco, SM_PtrObj_PtrException_RetVoid) -DEFINE_METHOD(LICENSE_INTEROP_PROXY, GETCURRENTCONTEXTINFO_UCO, GetCurrentContextInfoUco, SM_PtrObj_PtrObj_PtrInt_PtrIntPtr_PtrException_RetVoid) -DEFINE_METHOD(LICENSE_INTEROP_PROXY, SAVEKEYINCURRENTCONTEXT_UCO, SaveKeyInCurrentContextUco, SM_PtrObj_IntPtr_PtrException_RetVoid) +DEFINE_METHOD(LICENSE_INTEROP_PROXY, CREATE, Create, SM_PtrObj_PtrException_RetVoid) +DEFINE_METHOD(LICENSE_INTEROP_PROXY, GETCURRENTCONTEXTINFO, GetCurrentContextInfo, SM_PtrLicenseInteropProxy_PtrType_PtrBool_PtrIntPtr_PtrException_RetVoid) +DEFINE_METHOD(LICENSE_INTEROP_PROXY, SAVEKEYINCURRENTCONTEXT, SaveKeyInCurrentContext, SM_PtrLicenseInteropProxy_IntPtr_PtrException_RetVoid) #endif // FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -385,9 +384,9 @@ DEFINE_CLASS(GUID, System, Guid) BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsSupported, true, true) #ifdef FEATURE_COMINTEROP DEFINE_CLASS(VARIANT, System, Variant) -DEFINE_METHOD(VARIANT, CONVERT_OBJECT_TO_VARIANT_UCO, MarshalHelperConvertObjectToVariantUco, SM_PtrObj_PtrComVariant_PtrException_RetVoid) -DEFINE_METHOD(VARIANT, CAST_VARIANT_UCO, MarshalHelperCastVariantUco, SM_PtrObj_Int_PtrComVariant_PtrException_RetVoid) -DEFINE_METHOD(VARIANT, CONVERT_VARIANT_TO_OBJECT_UCO, MarshalHelperConvertVariantToObjectUco, SM_PtrComVariant_PtrObj_PtrException_RetVoid) +DEFINE_METHOD(VARIANT, CONVERT_OBJECT_TO_VARIANT, MarshalHelperConvertObjectToVariant, SM_PtrObj_PtrComVariant_PtrException_RetVoid) +DEFINE_METHOD(VARIANT, CAST_VARIANT, MarshalHelperCastVariant, SM_PtrObj_Int_PtrComVariant_PtrException_RetVoid) +DEFINE_METHOD(VARIANT, CONVERT_VARIANT_TO_OBJECT, MarshalHelperConvertVariantToObject, SM_PtrComVariant_PtrObj_PtrException_RetVoid) #endif // FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -1046,7 +1045,7 @@ DEFINE_METHOD(STUBHELPERS, GET_HR_EXCEPTION_OBJECT, GetHRExceptionObjec DEFINE_METHOD(STUBHELPERS, GET_PENDING_EXCEPTION_OBJECT, GetPendingExceptionObject, SM_RetException) DEFINE_METHOD(STUBHELPERS, CREATE_CUSTOM_MARSHALER, CreateCustomMarshaler, SM_IntPtr_Int_IntPtr_RetObj) #ifdef FEATURE_COMINTEROP -DEFINE_METHOD(STUBHELPERS, GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER_UCO, GetIEnumeratorToEnumVariantMarshalerUco, SM_PtrObj_PtrException_RetVoid) +DEFINE_METHOD(STUBHELPERS, GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER, GetIEnumeratorToEnumVariantMarshaler, SM_PtrObj_PtrException_RetVoid) #endif // FEATURE_COMINTEROP DEFINE_METHOD(STUBHELPERS, CHECK_STRING_LENGTH, CheckStringLength, SM_Int_RetVoid) diff --git a/src/coreclr/vm/custommarshalerinfo.cpp b/src/coreclr/vm/custommarshalerinfo.cpp index bf3bee92a69a5a..6563aa99a10d43 100644 --- a/src/coreclr/vm/custommarshalerinfo.cpp +++ b/src/coreclr/vm/custommarshalerinfo.cpp @@ -120,7 +120,7 @@ CustomMarshalerInfo* CustomMarshalerInfo::CreateIEnumeratorMarshalerInfo(LoaderH GCX_COOP(); GCPROTECT_BEGIN(IEnumeratorMarshalerObj); - UnmanagedCallersOnlyCaller getMarshaler(METHOD__STUBHELPERS__GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER_UCO); + UnmanagedCallersOnlyCaller getMarshaler(METHOD__STUBHELPERS__GET_IENUMERATOR_TO_ENUM_VARIANT_MARSHALER); getMarshaler.InvokeThrowing(&IEnumeratorMarshalerObj); pInfo = new (pHeap) CustomMarshalerInfo(pLoaderAllocator, pLoaderAllocator->AllocateHandle(IEnumeratorMarshalerObj)); diff --git a/src/coreclr/vm/metasig.h b/src/coreclr/vm/metasig.h index 319492f4bb7529..87a7f81a40c16e 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -427,10 +427,17 @@ DEFINE_METASIG_T(SM(PtrResolver_Int_PtrArrByte_PtrVoid_PtrException_RetVoid, P(C DEFINE_METASIG_T(SM(PtrResolver_Int_PtrIntPtr_PtrIntPtr_PtrIntPtr_PtrException_RetVoid, P(C(RESOLVER)) i P(I) P(I) P(I) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrResolver_Int_Int_PtrArrByte_PtrException_RetVoid, P(C(RESOLVER)) i i P(a(b)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrResolver_Int_PtrStr_PtrException_RetVoid, P(C(RESOLVER)) i P(s) P(C(EXCEPTION)), v)) +#ifdef FEATURE_COMINTEROP +DEFINE_METASIG_T(SM(PtrClass_PtrStr_Int_PtrObj_PtrArrObj_PtrArrBool_PtrArrInt_PtrArrType_PtrType_PtrObj_PtrException_RetVoid, P(C(CLASS)) P(s) i P(j) P(a(j)) P(a(F)) P(a(i)) P(a(C(TYPE))) P(C(TYPE)) P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrComObject_PtrClass_PtrObj_PtrException_RetVoid, P(C(COM_OBJECT)) P(C(CLASS)) P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrLicenseInteropProxy_IntPtr_PtrException_RetVoid, P(C(LICENSE_INTEROP_PROXY)) I P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrLicenseInteropProxy_PtrType_PtrBool_PtrIntPtr_PtrException_RetVoid, P(C(LICENSE_INTEROP_PROXY)) P(C(TYPE)) P(F) P(I) P(C(EXCEPTION)), v)) +#endif // FEATURE_COMINTEROP DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrException_RetVoid, P(j) P(j) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrObj_PtrException_RetVoid, P(j) P(j) P(j) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrStr_PtrException_RetVoid, P(j) P(s) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrObj_Int_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrObj_PtrException_RetVoid, P(j) P(j) i P(j) P(j) P(j) P(j) P(j) P(j) P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrBool_PtrIntPtr_PtrException_RetVoid, P(j) P(j) P(F) P(I) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrObj_PtrInt_PtrIntPtr_PtrException_RetVoid, P(j) P(j) P(i) P(I) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_IntPtr_PtrException_RetVoid, P(j) I P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrComVariant_PtrException_RetVoid, P(j) P(g(COMVARIANT)) P(C(EXCEPTION)), v)) diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index bd410c2e831ce8..24a00ce910e887 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -2158,7 +2158,7 @@ void OleVariant::MarshalOleRefVariantForObject(OBJECTREF *pObj, VARIANT *pOle) } else { - UnmanagedCallersOnlyCaller castVariant(METHOD__VARIANT__CAST_VARIANT_UCO); + UnmanagedCallersOnlyCaller castVariant(METHOD__VARIANT__CAST_VARIANT); // MarshalOleRefVariantForObjectNoCast has checked that the variant is not an array // so we can use the marshal cast helper to coerce the object to the proper type. @@ -2756,7 +2756,7 @@ void OleVariant::MarshalObjectForOleVariantUncommon(const VARIANT *pOle, OBJECTR } else { - UnmanagedCallersOnlyCaller convertVariantToObject(METHOD__VARIANT__CONVERT_VARIANT_TO_OBJECT_UCO); + UnmanagedCallersOnlyCaller convertVariantToObject(METHOD__VARIANT__CONVERT_VARIANT_TO_OBJECT); convertVariantToObject.InvokeThrowing(pOle, pObj); } } @@ -2796,7 +2796,7 @@ void OleVariant::MarshalOleVariantForObjectUncommon(OBJECTREF * const & pObj, VA } else { - UnmanagedCallersOnlyCaller convertObjectToVariant(METHOD__VARIANT__CONVERT_OBJECT_TO_VARIANT_UCO); + UnmanagedCallersOnlyCaller convertObjectToVariant(METHOD__VARIANT__CONVERT_OBJECT_TO_VARIANT); convertObjectToVariant.InvokeThrowing(pObj, pOle); } diff --git a/src/coreclr/vm/runtimecallablewrapper.cpp b/src/coreclr/vm/runtimecallablewrapper.cpp index 8783200656b953..076a4a043fa7af 100644 --- a/src/coreclr/vm/runtimecallablewrapper.cpp +++ b/src/coreclr/vm/runtimecallablewrapper.cpp @@ -137,16 +137,16 @@ IUnknown *ComClassFactory::CreateInstanceFromClassFactory(IClassFactory *pClassF GCPROTECT_BEGIN(gc); // Create an instance of the object - UnmanagedCallersOnlyCaller createObj(METHOD__LICENSE_INTEROP_PROXY__CREATE_UCO); + UnmanagedCallersOnlyCaller createObj(METHOD__LICENSE_INTEROP_PROXY__CREATE); createObj.InvokeThrowing(&gc.pProxy); gc.pType = rth.GetManagedClassObject(); // Query the current licensing context - UnmanagedCallersOnlyCaller getCurrentContextInfo(METHOD__LICENSE_INTEROP_PROXY__GETCURRENTCONTEXTINFO_UCO); - INT32 fDesignTime = FALSE; - BSTR bstrKeyRaw = NULL; - getCurrentContextInfo.InvokeThrowing(&gc.pProxy, &gc.pType, &fDesignTime, reinterpret_cast(&bstrKeyRaw)); - bstrKey = bstrKeyRaw; + UnmanagedCallersOnlyCaller getCurrentContextInfo(METHOD__LICENSE_INTEROP_PROXY__GETCURRENTCONTEXTINFO); + CLR_BOOL fDesignTime = FALSE; + INT_PTR bstrKeyRaw = NULL; + getCurrentContextInfo.InvokeThrowing(&gc.pProxy, &gc.pType, &fDesignTime, &bstrKeyRaw); + bstrKey = (BSTR)bstrKeyRaw; if (fDesignTime) { @@ -177,7 +177,7 @@ IUnknown *ComClassFactory::CreateInstanceFromClassFactory(IClassFactory *pClassF // Store the requested license key if (SUCCEEDED(hr)) { - UnmanagedCallersOnlyCaller saveKeyInCurrentContext(METHOD__LICENSE_INTEROP_PROXY__SAVEKEYINCURRENTCONTEXT_UCO); + UnmanagedCallersOnlyCaller saveKeyInCurrentContext(METHOD__LICENSE_INTEROP_PROXY__SAVEKEYINCURRENTCONTEXT); BSTR bstrKeyValue = (BSTR)bstrKey; saveKeyInCurrentContext.InvokeThrowing(&gc.pProxy, reinterpret_cast(bstrKeyValue)); }