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..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,10 +762,17 @@ 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() + [UnmanagedCallersOnly] + private static unsafe void Create(object* pResult, Exception* pException) { - return new LicenseInteropProxy(); + try + { + *pResult = new LicenseInteropProxy(); + } + catch (Exception ex) + { + *pException = ex; + } } // Determine if the type supports licensing @@ -877,6 +884,19 @@ public void GetCurrentContextInfo(RuntimeTypeHandle rth, out bool isDesignTime, bstrKey = Marshal.StringToBSTR((string)key!); } + [UnmanagedCallersOnly] + private static unsafe void GetCurrentContextInfo(LicenseInteropProxy* pProxy, Type* pType, bool* pIsDesignTime, IntPtr* pBstrKey, Exception* pException) + { + try + { + pProxy->GetCurrentContextInfo(pType->TypeHandle, out *pIsDesignTime, out *pBstrKey); + } + 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 +912,18 @@ public void SaveKeyInCurrentContext(IntPtr bstrKey) SetSavedLicenseKey(_licContext!, _targetRcwType!, key); } + + [UnmanagedCallersOnly] + private static unsafe void SaveKeyInCurrentContext(LicenseInteropProxy* pProxy, IntPtr bstrKey, Exception* pException) + { + try + { + 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..3772691fc6a633 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,39 @@ private object InvokeDispMethod( return ret; } + [RequiresUnreferencedCode("The member might be removed")] + [UnmanagedCallersOnly] + private static unsafe void ForwardCallToInvokeMember( + RuntimeType* pRuntimeType, + string* pMemberName, + int flags, + object* pTarget, + object[]* pArgs, + bool[]* pArgsIsByRef, + int[]* pArgsWrapperTypes, + Type[]* pArgsTypes, + Type* pRetType, + object* pResult, + Exception* pException) + { + try + { + *pResult = pRuntimeType->ForwardCallToInvokeMember( + *pMemberName, + (BindingFlags)flags, + *pTarget, + *pArgs, + *pArgsIsByRef, + *pArgsWrapperTypes, + *pArgsTypes, + *pRetType); + } + 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..a913fca431da0a 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 GetIEnumeratorToEnumVariantMarshaler(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..0d2cb9c302c259 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Variant.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Variant.cs @@ -192,6 +192,19 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria } } + [UnmanagedCallersOnly] + private static unsafe void MarshalHelperConvertObjectToVariant(object* pObject, ComVariant* pOle, Exception* pException) + { + try + { + MarshalHelperConvertObjectToVariant(*pObject, out *pOle); + } + catch (Exception ex) + { + *pException = ex; + } + } + // Helper code for marshaling VARIANTS to managed objects internal static unsafe object? MarshalHelperConvertVariantToObject(ref readonly ComVariant pOle) { @@ -320,6 +333,19 @@ internal static void MarshalHelperConvertObjectToVariant(object? o, out ComVaria } } + [UnmanagedCallersOnly] + private static unsafe void MarshalHelperConvertVariantToObject(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 +422,18 @@ internal static void MarshalHelperCastVariant(object pValue, int vt, out ComVari }; } } + + [UnmanagedCallersOnly] + private static unsafe void MarshalHelperCastVariant(object* pValue, int vt, ComVariant* pOle, Exception* pException) + { + try + { + MarshalHelperCastVariant(*pValue!, vt, out *pOle); + } + 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..5ef7080d53b1bf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs @@ -126,6 +126,20 @@ 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 GetEventProvider(__ComObject* pComObject, RuntimeType* pProviderType, object* pResult, Exception* pException) + { + try + { + *pResult = pComObject->GetEventProvider(*pProviderType); + } + 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..3a2373b8e8735b 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); // 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); // Invoke the method - gc.RetVal = forwardCallToInvoke.CallWithValueTypes_RetOBJECTREF(invokeArgs); + forwardCallToInvoke.InvokeThrowing( + &gc.ItfTypeObj, + &gc.MemberName, + (INT32)binderFlags, + &gc.ThisObj, + &gc.Args, + &gc.ArgsIsByRef, + &gc.ArgsWrapperTypes, + &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..03655015fe1e50 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -159,7 +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, 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) @@ -179,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, GetEventProvider, IM_Class_RetObj) +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, 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, 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() @@ -384,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,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, 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() @@ -1045,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, GetIEnumeratorToEnumVariantMarshaler, SM_RetObj) +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 2638848324c723..6563aa99a10d43 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); + 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..87a7f81a40c16e 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -427,8 +427,22 @@ 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)) +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..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 { - MethodDescCallSite castVariant(METHOD__VARIANT__CAST_VARIANT); + 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. @@ -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); + 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); + convertObjectToVariant.InvokeThrowing(pObj, pOle); } veh.SuppressRelease(); diff --git a/src/coreclr/vm/runtimecallablewrapper.cpp b/src/coreclr/vm/runtimecallablewrapper.cpp index db58879480b80a..076a4a043fa7af 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); + createObj.InvokeThrowing(&gc.pProxy); gc.pType = rth.GetManagedClassObject(); // Query the current licensing context - MethodDescCallSite getCurrentContextInfo(METHOD__LICENSE_INTEROP_PROXY__GETCURRENTCONTEXTINFO, &gc.pProxy); + UnmanagedCallersOnlyCaller getCurrentContextInfo(METHOD__LICENSE_INTEROP_PROXY__GETCURRENTCONTEXTINFO); 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); + INT_PTR bstrKeyRaw = NULL; + getCurrentContextInfo.InvokeThrowing(&gc.pProxy, &gc.pType, &fDesignTime, &bstrKeyRaw); + bstrKey = (BSTR)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); + BSTR bstrKeyValue = (BSTR)bstrKey; + saveKeyInCurrentContext.InvokeThrowing(&gc.pProxy, reinterpret_cast(bstrKeyValue)); } }