From 2328241457d714a918bba634fedb7747380e786c Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 17 Mar 2026 18:11:28 +0000 Subject: [PATCH 1/7] Initial plan From 01b95ce1d5d6072f3aa451bf5c64e74cadb64225 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 17 Mar 2026 19:03:07 +0000 Subject: [PATCH 2/7] =?UTF-8?q?Partial:=20Update=20corelib.h=20and=20metas?= =?UTF-8?q?ig.h=20for=20PREPARE=5FNONVIRTUAL=5FCALLSITE=20=E2=86=92=20Unma?= =?UTF-8?q?nagedCallersOnlyCaller=20conversion?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: jkoritzinsky <1571408+jkoritzinsky@users.noreply.github.com> --- src/coreclr/vm/corelib.h | 42 ++++++++++++++++++++-------------------- src/coreclr/vm/metasig.h | 21 ++++++++++++++++++++ 2 files changed, 42 insertions(+), 21 deletions(-) diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 4c865c7aea2b41..95549c0f0ef93c 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -117,8 +117,8 @@ DEFINE_FIELD(ARRAY_WITH_OFFSET, M_OFFSET, m_offset) DEFINE_FIELD(ARRAY_WITH_OFFSET, M_COUNT, m_count) DEFINE_CLASS(ASSEMBLY_NAME, Reflection, AssemblyName) -DEFINE_METHOD(ASSEMBLY_NAME, CTOR, .ctor, IM_PtrNativeAssemblyNameParts) -DEFINE_METHOD(ASSEMBLY_NAME, PARSE_AS_ASSEMBLYSPEC, ParseAsAssemblySpec, SM_PtrCharPtrVoid) +DEFINE_METHOD(ASSEMBLY_NAME, CTOR, CreateAssemblyName, SM_PtrAssemblyName_PtrNativeAssemblyNameParts_PtrException_RetVoid) +DEFINE_METHOD(ASSEMBLY_NAME, PARSE_AS_ASSEMBLYSPEC, ParseAsAssemblySpec, SM_PtrChar_PtrVoid_PtrException_RetVoid) DEFINE_CLASS(NATIVE_ASSEMBLY_NAME_PARTS, Reflection, NativeAssemblyNameParts) // ASSEMBLYBASE is System.ReflectionAssembly while ASSEMBLY is System.Reflection.RuntimeAssembly @@ -178,7 +178,7 @@ BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsS 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, RELEASE_ALL_DATA, ReleaseAllData, SM_PtrComObject_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) @@ -278,7 +278,7 @@ DEFINE_CLASS(ENUM, System, Enum) DEFINE_CLASS(ENVIRONMENT, System, Environment) DEFINE_METHOD(ENVIRONMENT, GET_RESOURCE_STRING, GetResourceString, SM_PtrChar_PtrStr_PtrException_RetVoid) -DEFINE_METHOD(ENVIRONMENT, INITIALIZE_COMMAND_LINE_ARGS, InitializeCommandLineArgs, SM_PtrChar_Int_PtrPtrChar_RetArrStr) +DEFINE_METHOD(ENVIRONMENT, INITIALIZE_COMMAND_LINE_ARGS, InitializeCommandLineArgs, SM_PtrChar_Int_PtrPtrChar_PtrArrStr_PtrException_RetVoid) DEFINE_CLASS(EVENT, Reflection, RuntimeEventInfo) @@ -350,7 +350,7 @@ DEFINE_FIELD(RT_TYPE_HANDLE, M_TYPE, m_type) DEFINE_METHOD(TYPED_REFERENCE, GETREFANY, GetRefAny, NoSig) DEFINE_CLASS(TYPE_NAME_RESOLVER, Reflection, TypeNameResolver) -DEFINE_METHOD(TYPE_NAME_RESOLVER, GET_TYPE_HELPER, GetTypeHelper, SM_Type_CharPtr_RuntimeAssembly_Bool_Bool_IntPtr_RetRuntimeType) +DEFINE_METHOD(TYPE_NAME_RESOLVER, GET_TYPE_HELPER, GetTypeHelper, SM_PtrChar_PtrAssembly_CLR_BOOL_CLR_BOOL_IntPtr_PtrClass_PtrException_RetVoid) DEFINE_CLASS_U(Reflection, RtFieldInfo, NoClass) DEFINE_FIELD_U(m_fieldHandle, ReflectFieldObject, m_pFD) @@ -402,8 +402,8 @@ DEFINE_CLASS(ICUSTOMADAPTER, Interop, ICustomAdapter) DEFINE_CLASS(IDYNAMICINTERFACECASTABLE, Interop, IDynamicInterfaceCastable) DEFINE_CLASS(DYNAMICINTERFACECASTABLEHELPERS, Interop, DynamicInterfaceCastableHelpers) -DEFINE_METHOD(DYNAMICINTERFACECASTABLEHELPERS, IS_INTERFACE_IMPLEMENTED, IsInterfaceImplemented, SM_IDynamicInterfaceCastable_RuntimeType_Bool_RetBool) -DEFINE_METHOD(DYNAMICINTERFACECASTABLEHELPERS, GET_INTERFACE_IMPLEMENTATION, GetInterfaceImplementation, SM_IDynamicInterfaceCastable_RuntimeType_RetRtType) +DEFINE_METHOD(DYNAMICINTERFACECASTABLEHELPERS, IS_INTERFACE_IMPLEMENTED, IsInterfaceImplemented, SM_PtrIDynamicInterfaceCastable_PtrClass_CLR_BOOL_PtrCLR_BOOL_PtrException_RetVoid) +DEFINE_METHOD(DYNAMICINTERFACECASTABLEHELPERS, GET_INTERFACE_IMPLEMENTATION, GetInterfaceImplementation, SM_PtrIDynamicInterfaceCastable_PtrClass_PtrClass_PtrException_RetVoid) BEGIN_ILLINK_FEATURE_SWITCH(System.Runtime.InteropServices.BuiltInComInterop.IsSupported, true, true) #ifdef FEATURE_COMINTEROP @@ -412,7 +412,7 @@ DEFINE_METHOD(ICUSTOM_QUERYINTERFACE, GET_INTERFACE, GetInterface, DEFINE_CLASS(CUSTOMQUERYINTERFACERESULT, Interop, CustomQueryInterfaceResult) DEFINE_CLASS(ENUMERATORTOENUMVARIANTMARSHALER, CustomMarshalers, EnumeratorToEnumVariantMarshaler) -DEFINE_METHOD(ENUMERATORTOENUMVARIANTMARSHALER, INTERNALMARSHALNATIVETOMANAGED, InternalMarshalNativeToManaged, SM_IntPtr_RetObj) +DEFINE_METHOD(ENUMERATORTOENUMVARIANTMARSHALER, INTERNALMARSHALNATIVETOMANAGED, InternalMarshalNativeToManaged, SM_IntPtr_PtrObj_PtrException_RetVoid) #endif //FEATURE_COMINTEROP END_ILLINK_FEATURE_SWITCH() @@ -421,9 +421,9 @@ DEFINE_CLASS(COMWRAPPERS, Interop, ComWrappers) DEFINE_CLASS(CREATEOBJECTFLAGS, Interop, CreateObjectFlags) DEFINE_CLASS(MANAGED_OBJECT_WRAPPER_HOLDER,Interop, ComWrappers+ManagedObjectWrapperHolder) DEFINE_CLASS(NATIVE_OBJECT_WRAPPER, Interop, ComWrappers+NativeObjectWrapper) // cDAC depends on the exact namespace and name -DEFINE_METHOD(COMWRAPPERS, CALL_ICUSTOMQUERYINTERFACE, CallICustomQueryInterface, SM_ManagedObjectWrapperHolder_RefGuid_RefIntPtr_RetInt) -DEFINE_METHOD(COMWRAPPERS, GET_OR_CREATE_COM_INTERFACE_FOR_OBJECT_WITH_GLOBAL_MARSHALLING_INSTANCE, GetOrCreateComInterfaceForObjectWithGlobalMarshallingInstance, SM_Obj_RetIntPtr) -DEFINE_METHOD(COMWRAPPERS, GET_OR_CREATE_OBJECT_FOR_COM_INSTANCE_WITH_GLOBAL_MARSHALLING_INSTANCE, GetOrCreateObjectForComInstanceWithGlobalMarshallingInstance, SM_IntPtr_CreateObjectFlags_RetObj) +DEFINE_METHOD(COMWRAPPERS, CALL_ICUSTOMQUERYINTERFACE, CallICustomQueryInterface, SM_PtrManagedObjectWrapperHolder_PtrGuid_PtrIntPtr_PtrInt_PtrException_RetVoid) +DEFINE_METHOD(COMWRAPPERS, GET_OR_CREATE_COM_INTERFACE_FOR_OBJECT_WITH_GLOBAL_MARSHALLING_INSTANCE, GetOrCreateComInterfaceForObjectWithGlobalMarshallingInstance, SM_PtrObj_PtrIntPtr_PtrException_RetVoid) +DEFINE_METHOD(COMWRAPPERS, GET_OR_CREATE_OBJECT_FOR_COM_INSTANCE_WITH_GLOBAL_MARSHALLING_INSTANCE, GetOrCreateObjectForComInstanceWithGlobalMarshallingInstance, SM_IntPtr_Int_PtrObj_PtrException_RetVoid) DEFINE_FIELD(COMWRAPPERS, NAITVE_OBJECT_WRAPPER_TABLE, s_nativeObjectWrapperTable) DEFINE_FIELD(COMWRAPPERS, ALL_MANAGED_OBJECT_WRAPPER_TABLE, s_allManagedObjectWrapperTable) @@ -494,7 +494,7 @@ DEFINE_METHOD(MARSHAL, DESTROY_STRUCTURE, DestroySt DEFINE_METHOD(MARSHAL, SIZEOF_TYPE, SizeOf, SM_Type_RetInt) DEFINE_CLASS(NATIVELIBRARY, Interop, NativeLibrary) -DEFINE_METHOD(NATIVELIBRARY, LOADLIBRARYCALLBACKSTUB, LoadLibraryCallbackStub, SM_Str_AssemblyBase_Bool_UInt_RetIntPtr) +DEFINE_METHOD(NATIVELIBRARY, LOADLIBRARYCALLBACKSTUB, LoadLibraryCallbackStub, SM_PtrStr_PtrAssemblyBase_CLR_BOOL_UInt_PtrIntPtr_PtrException_RetVoid) DEFINE_CLASS(VECTOR64T, Intrinsics, Vector64`1) DEFINE_CLASS(VECTOR128T, Intrinsics, Vector128`1) @@ -629,7 +629,7 @@ DEFINE_FIELD(LOCK, OWNING_THREAD_ID, _owningThreadId) DEFINE_FIELD(LOCK, STATE, _state) DEFINE_FIELD(LOCK, RECURSION_COUNT, _recursionCount) DEFINE_METHOD(LOCK, CTOR, .ctor, IM_RetVoid) -DEFINE_METHOD(LOCK, INITIALIZE_FOR_MONITOR, InitializeForMonitor, NoSig) +DEFINE_METHOD(LOCK, INITIALIZE_FOR_MONITOR, InitializeForMonitor, SM_PtrLock_Int_UInt_PtrException_RetVoid) DEFINE_CLASS(CONDITION, Threading, Condition) DEFINE_FIELD(CONDITION, WAITERS_HEAD, _waitersHead) @@ -965,9 +965,9 @@ DEFINE_FIELD(EXECUTIONCONTEXT, DEFAULT_FLOW_SUPPRESSED, DefaultFlowSu DEFINE_CLASS(DIRECTONTHREADLOCALDATA, Threading, Thread+DirectOnThreadLocalData) DEFINE_CLASS(THREAD, Threading, Thread) -DEFINE_METHOD(THREAD, START_CALLBACK, StartCallback, IM_RetVoid) +DEFINE_METHOD(THREAD, START_CALLBACK, StartCallback, SM_PtrThread_PtrException_RetVoid) DEFINE_METHOD(THREAD, POLLGC, PollGC, NoSig) -DEFINE_METHOD(THREAD, ON_THREAD_EXITING, OnThreadExiting, IM_RetVoid) +DEFINE_METHOD(THREAD, ON_THREAD_EXITING, OnThreadExiting, SM_PtrThread_PtrException_RetVoid) #ifdef FOR_ILLINK DEFINE_METHOD(THREAD, CTOR, .ctor, IM_RetVoid) #endif // FOR_ILLINK @@ -999,8 +999,8 @@ DEFINE_FIELD_U(_state, AssemblyLoadContextBaseObject, _stat DEFINE_FIELD_U(_isCollectible, AssemblyLoadContextBaseObject, _isCollectible) DEFINE_CLASS(ASSEMBLYLOADCONTEXT, Loader, AssemblyLoadContext) DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVE, Resolve, SM_IntPtr_PtrAssemblyName_PtrAssemblyBase_PtrException_RetVoid) -DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVEUNMANAGEDDLL, ResolveUnmanagedDll, SM_Str_IntPtr_RetIntPtr) -DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVEUNMANAGEDDLLUSINGEVENT, ResolveUnmanagedDllUsingEvent, SM_Str_AssemblyBase_IntPtr_RetIntPtr) +DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVEUNMANAGEDDLL, ResolveUnmanagedDll, SM_PtrStr_IntPtr_PtrIntPtr_PtrException_RetVoid) +DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVEUNMANAGEDDLLUSINGEVENT, ResolveUnmanagedDllUsingEvent, SM_PtrStr_PtrAssemblyBase_IntPtr_PtrIntPtr_PtrException_RetVoid) DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVEUSINGEVENT, ResolveUsingEvent, SM_IntPtr_PtrAssemblyName_PtrAssemblyBase_PtrException_RetVoid) DEFINE_METHOD(ASSEMBLYLOADCONTEXT, RESOLVESATELLITEASSEMBLY, ResolveSatelliteAssembly, SM_IntPtr_PtrAssemblyName_PtrAssemblyBase_PtrException_RetVoid) DEFINE_FIELD(ASSEMBLYLOADCONTEXT, ASSEMBLY_LOAD, AssemblyLoad) @@ -1008,9 +1008,9 @@ DEFINE_METHOD(ASSEMBLYLOADCONTEXT, ON_ASSEMBLY_LOAD, OnAssemblyLoad, DEFINE_METHOD(ASSEMBLYLOADCONTEXT, ON_RESOURCE_RESOLVE, OnResourceResolve, SM_PtrAssembly_PtrByte_PtrAssembly_PtrException_RetVoid) DEFINE_METHOD(ASSEMBLYLOADCONTEXT, ON_TYPE_RESOLVE, OnTypeResolve, SM_PtrAssembly_PtrByte_PtrAssembly_PtrException_RetVoid) DEFINE_METHOD(ASSEMBLYLOADCONTEXT, ON_ASSEMBLY_RESOLVE, OnAssemblyResolve, SM_PtrAssembly_PtrChar_PtrAssembly_PtrException_RetVoid) -DEFINE_METHOD(ASSEMBLYLOADCONTEXT, START_ASSEMBLY_LOAD, StartAssemblyLoad, SM_RefGuid_RefGuid_RetVoid) -DEFINE_METHOD(ASSEMBLYLOADCONTEXT, STOP_ASSEMBLY_LOAD, StopAssemblyLoad, SM_RefGuid_RetVoid) -DEFINE_METHOD(ASSEMBLYLOADCONTEXT, INITIALIZE_DEFAULT_CONTEXT, InitializeDefaultContext, SM_RetVoid) +DEFINE_METHOD(ASSEMBLYLOADCONTEXT, START_ASSEMBLY_LOAD, StartAssemblyLoad, SM_PtrGuid_PtrGuid_PtrException_RetVoid) +DEFINE_METHOD(ASSEMBLYLOADCONTEXT, STOP_ASSEMBLY_LOAD, StopAssemblyLoad, SM_PtrGuid_PtrException_RetVoid) +DEFINE_METHOD(ASSEMBLYLOADCONTEXT, INITIALIZE_DEFAULT_CONTEXT, InitializeDefaultContext, SM_PtrException_RetVoid) DEFINE_CLASS(VALUE_TYPE, System, ValueType) DEFINE_METHOD(VALUE_TYPE, GET_HASH_CODE, GetHashCode, IM_RetInt) @@ -1018,7 +1018,7 @@ DEFINE_METHOD(VALUE_TYPE, EQUALS, Equals, DEFINE_CLASS(GC, System, GC) DEFINE_METHOD(GC, KEEP_ALIVE, KeepAlive, SM_Obj_RetVoid) -DEFINE_METHOD(GC, RUN_FINALIZERS, RunFinalizers, SM_RetUInt) +DEFINE_METHOD(GC, RUN_FINALIZERS, RunFinalizers, SM_PtrException_RetUInt) DEFINE_CLASS_U(System, WeakReference, WeakReferenceObject) DEFINE_FIELD_U(_taggedHandle, WeakReferenceObject, m_taggedHandle) diff --git a/src/coreclr/vm/metasig.h b/src/coreclr/vm/metasig.h index 1f7c410c9d083b..b5805d8062171e 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -448,6 +448,27 @@ DEFINE_METASIG_T(SM(PtrException_PtrException_RetVoid, P(C(EXCEPTION)) P(C(EXCEP 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)) +DEFINE_METASIG_T(SM(PtrException_RetUInt, P(C(EXCEPTION)), K)) +DEFINE_METASIG_T(SM(PtrGuid_PtrException_RetVoid, P(C(GUID)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrGuid_PtrGuid_PtrException_RetVoid, P(C(GUID)) P(C(GUID)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrLock_Int_UInt_PtrException_RetVoid, P(C(LOCK)) i K P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrThread_PtrException_RetVoid, P(C(THREAD)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrChar_PtrVoid_PtrException_RetVoid, P(u) P(v) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrAssemblyName_PtrNativeAssemblyNameParts_PtrException_RetVoid, P(C(ASSEMBLY_NAME)) P(g(NATIVE_ASSEMBLY_NAME_PARTS)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrComObject_PtrException_RetVoid, P(C(COM_OBJECT)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrChar_Int_PtrPtrChar_PtrArrStr_PtrException_RetVoid, P(u) i P(P(u)) P(a(s)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrIDynamicInterfaceCastable_PtrClass_CLR_BOOL_PtrCLR_BOOL_PtrException_RetVoid, P(C(IDYNAMICINTERFACECASTABLE)) P(C(CLASS)) F P(F) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrIDynamicInterfaceCastable_PtrClass_PtrClass_PtrException_RetVoid, P(C(IDYNAMICINTERFACECASTABLE)) P(C(CLASS)) P(C(CLASS)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrChar_PtrAssembly_CLR_BOOL_CLR_BOOL_IntPtr_PtrClass_PtrException_RetVoid, P(u) P(C(ASSEMBLY)) F F I P(C(CLASS)) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(IntPtr_PtrStr_PtrException_RetVoid, I P(s) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrStr_IntPtr_PtrIntPtr_PtrException_RetVoid, P(s) I P(I) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(IntPtr_PtrObj_PtrException_RetVoid, I P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrManagedObjectWrapperHolder_PtrGuid_PtrIntPtr_PtrInt_PtrException_RetVoid, P(C(MANAGED_OBJECT_WRAPPER_HOLDER)) P(C(GUID)) P(I) P(i) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrObj_PtrIntPtr_PtrException_RetVoid, P(j) P(I) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(IntPtr_Int_PtrObj_PtrException_RetVoid, I i P(j) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrStr_PtrAssemblyBase_CLR_BOOL_UInt_PtrIntPtr_PtrException_RetVoid, P(s) P(C(ASSEMBLYBASE)) F K P(I) P(C(EXCEPTION)), v)) +DEFINE_METASIG_T(SM(PtrStr_PtrAssemblyBase_IntPtr_PtrIntPtr_PtrException_RetVoid, P(s) P(C(ASSEMBLYBASE)) I P(I) P(C(EXCEPTION)), v)) + // fields - e.g.: // DEFINE_METASIG(Fld(PtrVoid, P(v))) From f8d8e47d9f94fb63d8790755379af208f290d71b Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 17 Mar 2026 21:35:10 +0000 Subject: [PATCH 3/7] Implement C# UCO wrappers and C++ UnmanagedCallersOnlyCaller call site conversions Co-authored-by: jkoritzinsky <1571408+jkoritzinsky@users.noreply.github.com> --- .../src/System/Environment.CoreCLR.cs | 13 ++++ .../src/System/GC.CoreCLR.cs | 14 ++++ .../System/Reflection/AssemblyName.CoreCLR.cs | 26 ++++++++ .../Reflection/TypeNameResolver.CoreCLR.cs | 13 ++++ .../InteropServices/ComWrappers.CoreCLR.cs | 39 +++++++++++ .../EnumeratorToEnumVariantMarshaler.cs | 13 ++++ .../DynamicInterfaceCastableHelpers.cs | 26 ++++++++ .../InteropServices/NativeLibrary.CoreCLR.cs | 14 ++++ .../Loader/AssemblyLoadContext.CoreCLR.cs | 65 +++++++++++++++++++ .../src/System/StubHelpers.cs | 26 ++++++++ .../src/System/Threading/Thread.CoreCLR.cs | 26 ++++++++ .../src/System/__ComObject.cs | 13 ++++ src/coreclr/binder/activitytracker.cpp | 15 ++--- src/coreclr/binder/defaultassemblybinder.cpp | 5 +- src/coreclr/vm/appdomain.cpp | 3 - src/coreclr/vm/assemblynative.cpp | 2 +- src/coreclr/vm/assemblyspec.cpp | 7 +- src/coreclr/vm/comsynchronizable.cpp | 10 +-- src/coreclr/vm/coreassemblyspec.cpp | 7 +- src/coreclr/vm/corelib.h | 6 +- src/coreclr/vm/corhost.cpp | 12 ++-- src/coreclr/vm/dynamicinterfacecastable.cpp | 52 ++++++++------- src/coreclr/vm/finalizerthread.cpp | 7 +- .../vm/interoplibinterface_comwrappers.cpp | 25 +++---- src/coreclr/vm/interoputil.cpp | 11 ++-- src/coreclr/vm/nativelibrary.cpp | 34 +++------- src/coreclr/vm/olevariant.cpp | 18 ++--- src/coreclr/vm/runtimecallablewrapper.cpp | 10 +-- src/coreclr/vm/syncblk.cpp | 11 ++-- src/coreclr/vm/threads.cpp | 19 +++--- src/coreclr/vm/typeparse.cpp | 28 ++++---- .../src/System/Threading/AutoreleasePool.cs | 28 ++++++++ .../src/System/Threading/Lock.cs | 15 +++++ 33 files changed, 446 insertions(+), 167 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs index 1ecbcb87a4d026..15aa59a9b0100e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Environment.CoreCLR.cs @@ -103,6 +103,19 @@ private static unsafe string[] InitializeCommandLineArgs(char* exePath, int argc return mainMethodArgs; } + [UnmanagedCallersOnly] + private static unsafe void InitializeCommandLineArgs(char* exePath, int argc, char** argv, string[]* pResult, Exception* pException) + { + try + { + *pResult = InitializeCommandLineArgs(exePath, argc, argv); + } + catch (Exception ex) + { + *pException = ex; + } + } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "Environment_GetProcessorCount")] internal static partial int GetProcessorCount(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index 4222b730e73e6e..283c132346aa60 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -337,6 +337,20 @@ private static unsafe uint RunFinalizers() return count; } + [UnmanagedCallersOnly] + private static unsafe uint RunFinalizers(Exception* pException) + { + try + { + return RunFinalizers(); + } + catch (Exception ex) + { + *pException = ex; + return 0; + } + } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForPendingFinalizers")] private static partial void _WaitForPendingFinalizers(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs index 48396e6dd42ef9..a16ee2089e5f5b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs @@ -167,6 +167,32 @@ private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssem } } + [UnmanagedCallersOnly] + private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssemblySpec, Exception* pException) + { + try + { + ParseAsAssemblySpec(pAssemblyName, pAssemblySpec); + } + catch (Exception ex) + { + *pException = ex; + } + } + + [UnmanagedCallersOnly] + private static unsafe void CreateAssemblyName(AssemblyName* pResult, NativeAssemblyNameParts* pParts, Exception* pException) + { + try + { + *pResult = new AssemblyName(pParts); + } + catch (Exception ex) + { + *pException = ex; + } + } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyName_InitializeAssemblySpec")] private static unsafe partial void InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, void* pAssemblySpec); } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index 7fba80eb553206..9ef7bf809d8cdb 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -138,6 +138,19 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName, return GetTypeHelper(typeName, requestingAssembly, throwOnError, requireAssemblyQualifiedName, unsafeAccessorMethod); } + [UnmanagedCallersOnly] + private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequestingAssembly, byte throwOnError, byte requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod, RuntimeType* pResult, Exception* pException) + { + try + { + *pResult = GetTypeHelper(pTypeName, *pRequestingAssembly, throwOnError != 0, requireAssemblyQualifiedName != 0, unsafeAccessorMethod); + } + catch (Exception ex) + { + *pException = ex; + } + } + internal static RuntimeType? GetTypeHelper(ReadOnlySpan typeName, RuntimeAssembly? requestingAssembly, bool throwOnError, bool requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod = 0) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs index 728be79fcf4e5b..069f1a821ed450 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.CoreCLR.cs @@ -65,6 +65,19 @@ internal static int CallICustomQueryInterface(ManagedObjectWrapperHolder holder, return -1; // See TryInvokeICustomQueryInterfaceResult } + [UnmanagedCallersOnly] + private static unsafe void CallICustomQueryInterface(ManagedObjectWrapperHolder* pHolder, Guid* pIid, IntPtr* ppObject, int* pResult, Exception* pException) + { + try + { + *pResult = CallICustomQueryInterface(*pHolder, ref *pIid, out *ppObject); + } + catch (Exception ex) + { + *pException = ex; + } + } + internal static IntPtr GetOrCreateComInterfaceForObjectWithGlobalMarshallingInstance(object obj) { if (s_globalInstanceForMarshalling == null) @@ -84,6 +97,19 @@ internal static IntPtr GetOrCreateComInterfaceForObjectWithGlobalMarshallingInst } } + [UnmanagedCallersOnly] + private static unsafe void GetOrCreateComInterfaceForObjectWithGlobalMarshallingInstance(object* pObj, IntPtr* pResult, Exception* pException) + { + try + { + *pResult = GetOrCreateComInterfaceForObjectWithGlobalMarshallingInstance(*pObj); + } + catch (Exception ex) + { + *pException = ex; + } + } + internal static object? GetOrCreateObjectForComInstanceWithGlobalMarshallingInstance(IntPtr comObject, CreateObjectFlags flags) { if (s_globalInstanceForMarshalling == null) @@ -103,6 +129,19 @@ internal static IntPtr GetOrCreateComInterfaceForObjectWithGlobalMarshallingInst } } + [UnmanagedCallersOnly] + private static unsafe void GetOrCreateObjectForComInstanceWithGlobalMarshallingInstance(IntPtr comObject, int flags, object* pResult, Exception* pException) + { + try + { + *pResult = GetOrCreateObjectForComInstanceWithGlobalMarshallingInstance(comObject, (CreateObjectFlags)flags); + } + catch (Exception ex) + { + *pException = ex; + } + } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_GetIReferenceTrackerTargetVftbl")] [SuppressGCTransition] private static partial IntPtr GetDefaultIReferenceTrackerTargetVftbl(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs index 05d1d8108042e5..46cf6fb33a8c0b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs @@ -50,6 +50,19 @@ public IntPtr MarshalManagedToNative(object ManagedObj) internal static object InternalMarshalNativeToManaged(IntPtr pNativeData) => GetInstance(null).MarshalNativeToManaged(pNativeData); + [System.Runtime.InteropServices.UnmanagedCallersOnly] + private static unsafe void InternalMarshalNativeToManaged(IntPtr pNativeData, object* pResult, Exception* pException) + { + try + { + *pResult = InternalMarshalNativeToManaged(pNativeData); + } + catch (Exception ex) + { + *pException = ex; + } + } + public object MarshalNativeToManaged(IntPtr pNativeData) { ArgumentNullException.ThrowIfNull(pNativeData); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs index 260534b1ce799a..2408919707a52a 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs @@ -22,6 +22,19 @@ internal static bool IsInterfaceImplemented(IDynamicInterfaceCastable castable, return isImplemented; } + [UnmanagedCallersOnly] + private static unsafe void IsInterfaceImplemented(IDynamicInterfaceCastable* pCastable, RuntimeType* pInterfaceType, byte throwIfNotImplemented, byte* pResult, Exception* pException) + { + try + { + *pResult = IsInterfaceImplemented(*pCastable, *pInterfaceType, throwIfNotImplemented != 0) ? (byte)1 : (byte)0; + } + catch (Exception ex) + { + *pException = ex; + } + } + [StackTraceHidden] internal static RuntimeType? GetInterfaceImplementation(IDynamicInterfaceCastable castable, RuntimeType interfaceType) { @@ -41,5 +54,18 @@ internal static bool IsInterfaceImplemented(IDynamicInterfaceCastable castable, return implType; } + + [UnmanagedCallersOnly] + private static unsafe void GetInterfaceImplementation(IDynamicInterfaceCastable* pCastable, RuntimeType* pInterfaceType, RuntimeType* pResult, Exception* pException) + { + try + { + *pResult = GetInterfaceImplementation(*pCastable, *pInterfaceType); + } + catch (Exception ex) + { + *pException = ex; + } + } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index 75d0bf2c2c5b63..3b3976002c5389 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -3,6 +3,7 @@ using System.Reflection; using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; namespace System.Runtime.InteropServices { @@ -24,5 +25,18 @@ internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, internal static partial IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly, [MarshalAs(UnmanagedType.Bool)] bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag, [MarshalAs(UnmanagedType.Bool)] bool throwOnError); + + [UnmanagedCallersOnly] + private static unsafe void LoadLibraryCallbackStub(string* pLibraryName, Assembly* pAssembly, byte hasDllImportSearchPathFlags, uint dllImportSearchPathFlags, IntPtr* pResult, Exception* pException) + { + try + { + *pResult = LoadLibraryCallbackStub(*pLibraryName, *pAssembly, hasDllImportSearchPathFlags != 0, dllImportSearchPathFlags); + } + catch (Exception ex) + { + *pException = ex; + } + } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index 5334448667167e..c34bdbf3898552 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -116,6 +116,19 @@ private static IntPtr ResolveUnmanagedDll(string unmanagedDllName, IntPtr gchAss return context.LoadUnmanagedDll(unmanagedDllName); } + [UnmanagedCallersOnly] + private static unsafe void ResolveUnmanagedDll(string* pUnmanagedDllName, IntPtr gchAssemblyLoadContext, IntPtr* pResult, Exception* pException) + { + try + { + *pResult = ResolveUnmanagedDll(*pUnmanagedDllName, gchAssemblyLoadContext); + } + catch (Exception ex) + { + *pException = ex; + } + } + // This method is invoked by the VM to resolve a native library using the ResolvingUnmanagedDll event // after trying all other means of resolution. private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchAssemblyLoadContext) @@ -124,6 +137,19 @@ private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Ass return context.GetResolvedUnmanagedDll(assembly, unmanagedDllName); } + [UnmanagedCallersOnly] + private static unsafe void ResolveUnmanagedDllUsingEvent(string* pUnmanagedDllName, Assembly* pAssembly, IntPtr gchAssemblyLoadContext, IntPtr* pResult, Exception* pException) + { + try + { + *pResult = ResolveUnmanagedDllUsingEvent(*pUnmanagedDllName, *pAssembly, gchAssemblyLoadContext); + } + catch (Exception ex) + { + *pException = ex; + } + } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetLoadContextForAssembly")] private static partial IntPtr GetLoadContextForAssembly(QCallAssembly assembly); @@ -191,6 +217,19 @@ private static void StartAssemblyLoad(ref Guid activityId, ref Guid relatedActiv ActivityTracker.Instance.OnStart(NativeRuntimeEventSource.Log.Name, AssemblyLoadName, 0, ref activityId, ref relatedActivityId, EventActivityOptions.Recursive, useTplSource: false); } + [UnmanagedCallersOnly] + private static unsafe void StartAssemblyLoad(Guid* activityId, Guid* relatedActivityId, Exception* pException) + { + try + { + StartAssemblyLoad(ref *activityId, ref *relatedActivityId); + } + catch (Exception ex) + { + *pException = ex; + } + } + /// /// Called by the runtime to stop an assembly load activity for tracing /// @@ -200,6 +239,19 @@ private static void StopAssemblyLoad(ref Guid activityId) ActivityTracker.Instance.OnStop(NativeRuntimeEventSource.Log.Name, AssemblyLoadName, 0, ref activityId, useTplSource: false); } + [UnmanagedCallersOnly] + private static unsafe void StopAssemblyLoad(Guid* activityId, Exception* pException) + { + try + { + StopAssemblyLoad(ref *activityId); + } + catch (Exception ex) + { + *pException = ex; + } + } + /// /// Called by the runtime to make sure the default ALC is initialized /// @@ -207,5 +259,18 @@ private static void InitializeDefaultContext() { _ = Default; } + + [UnmanagedCallersOnly] + private static unsafe void InitializeDefaultContext(Exception* pException) + { + try + { + InitializeDefaultContext(); + } + catch (Exception ex) + { + *pException = ex; + } + } } } diff --git a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs index a913fca431da0a..cdd31d4bfb5ad1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/StubHelpers.cs @@ -319,6 +319,19 @@ internal static unsafe IntPtr ConvertToNative(string strManaged, IntPtr pNativeB } } + [UnmanagedCallersOnly] + private static unsafe void ConvertToNative(string* pStr, IntPtr pNativeBuffer, IntPtr* pResult, Exception* pException) + { + try + { + *pResult = ConvertToNative(*pStr, pNativeBuffer); + } + catch (Exception ex) + { + *pException = ex; + } + } + internal static unsafe string? ConvertToManaged(IntPtr bstr) { if (IntPtr.Zero == bstr) @@ -362,6 +375,19 @@ internal static unsafe IntPtr ConvertToNative(string strManaged, IntPtr pNativeB } } + [UnmanagedCallersOnly] + private static unsafe void ConvertToManaged(IntPtr bstr, string* pResult, Exception* pException) + { + try + { + *pResult = ConvertToManaged(bstr); + } + catch (Exception ex) + { + *pException = ex; + } + } + internal static void ClearNative(IntPtr pNative) { Marshal.FreeBSTR(pNative); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index f4348e33595760..fec29b68a663bf 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -125,6 +125,19 @@ private void StartCallback() OnThreadExiting(); } + [UnmanagedCallersOnly] + private static unsafe void StartCallback(Thread* pThread, Exception* pException) + { + try + { + pThread->StartCallback(); + } + catch (Exception ex) + { + *pException = ex; + } + } + // Max iterations to be done in SpinWait without switching GC modes. private const int SpinWaitCoopThreshold = 1024; @@ -583,6 +596,19 @@ private void OnThreadExiting() #endif } + [UnmanagedCallersOnly] + private static unsafe void OnThreadExiting(Thread* pThread, Exception* pException) + { + try + { + pThread->OnThreadExiting(); + } + catch (Exception ex) + { + *pException = ex; + } + } + [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ThreadNative_ReentrantWaitAny")] internal static unsafe partial int ReentrantWaitAny([MarshalAs(UnmanagedType.Bool)] bool alertable, int timeout, int count, IntPtr* handles); diff --git a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs index 5ef7080d53b1bf..c2ff578e231c30 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/__ComObject.cs @@ -109,6 +109,19 @@ internal void ReleaseAllData() } } + [UnmanagedCallersOnly] + private static unsafe void ReleaseAllData(__ComObject* pComObject, Exception* pException) + { + try + { + pComObject->ReleaseAllData(); + } + catch (Exception ex) + { + *pException = ex; + } + } + /// /// Called from within the EE and is used to handle calls on methods of event interfaces. /// diff --git a/src/coreclr/binder/activitytracker.cpp b/src/coreclr/binder/activitytracker.cpp index b7287d3afa9180..f3b59e5056016e 100644 --- a/src/coreclr/binder/activitytracker.cpp +++ b/src/coreclr/binder/activitytracker.cpp @@ -20,12 +20,8 @@ void ActivityTracker::Start(/*out*/ GUID *activityId, /*out*/ GUID *relatedActiv OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLYLOADCONTEXT__START_ASSEMBLY_LOAD); - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(activityId); - args[ARGNUM_1] = PTR_TO_ARGHOLDER(relatedActivityId); - - CALL_MANAGED_METHOD_NORET(args) + UnmanagedCallersOnlyCaller startAssemblyLoad(METHOD__ASSEMBLYLOADCONTEXT__START_ASSEMBLY_LOAD); + startAssemblyLoad.InvokeThrowing(activityId, relatedActivityId); } void ActivityTracker::Stop(/*out*/ GUID *activityId) @@ -34,9 +30,6 @@ void ActivityTracker::Stop(/*out*/ GUID *activityId) OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLYLOADCONTEXT__STOP_ASSEMBLY_LOAD); - DECLARE_ARGHOLDER_ARRAY(args, 1); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(activityId); - - CALL_MANAGED_METHOD_NORET(args) + UnmanagedCallersOnlyCaller stopAssemblyLoad(METHOD__ASSEMBLYLOADCONTEXT__STOP_ASSEMBLY_LOAD); + stopAssemblyLoad.InvokeThrowing(activityId); } diff --git a/src/coreclr/binder/defaultassemblybinder.cpp b/src/coreclr/binder/defaultassemblybinder.cpp index 9900da40a7d263..730618d0a43dfa 100644 --- a/src/coreclr/binder/defaultassemblybinder.cpp +++ b/src/coreclr/binder/defaultassemblybinder.cpp @@ -73,9 +73,8 @@ HRESULT DefaultAssemblyBinder::BindUsingAssemblyName(BINDER_SPACE::AssemblyName { // Make sure the managed default ALC is initialized. GCX_COOP(); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLYLOADCONTEXT__INITIALIZE_DEFAULT_CONTEXT); - DECLARE_ARGHOLDER_ARRAY(args, 0); - CALL_MANAGED_METHOD_NORET(args) + UnmanagedCallersOnlyCaller initializeDefaultContext(METHOD__ASSEMBLYLOADCONTEXT__INITIALIZE_DEFAULT_CONTEXT); + initializeDefaultContext.InvokeThrowing(); pAssemblyLoadContext = GetAssemblyLoadContext(); _ASSERTE(pAssemblyLoadContext != (INT_PTR)NULL); diff --git a/src/coreclr/vm/appdomain.cpp b/src/coreclr/vm/appdomain.cpp index 4b519cb48aa8e9..5ffe69065668b3 100644 --- a/src/coreclr/vm/appdomain.cpp +++ b/src/coreclr/vm/appdomain.cpp @@ -4093,9 +4093,6 @@ HRESULT RuntimeInvokeHostAssemblyResolver(INT_PTR pAssemblyLoadContextToBindWith bool fResolvedAssembly = false; BinderTracing::ResolutionAttemptedOperation tracer{pAssemblyName, 0 /*binderID*/, pAssemblyLoadContextToBindWithin, hr}; - // Allocate an AssemblyName managed object - _gcRefs.oRefAssemblyName = (ASSEMBLYNAMEREF) AllocateObject(CoreLibBinder::GetClass(CLASS__ASSEMBLY_NAME)); - // Initialize the AssemblyName object AssemblySpec::InitializeAssemblyNameRef(pAssemblyName, &_gcRefs.oRefAssemblyName); diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp index 383918fcc91965..ce938e9549ff38 100644 --- a/src/coreclr/vm/assemblynative.cpp +++ b/src/coreclr/vm/assemblynative.cpp @@ -1062,7 +1062,7 @@ extern "C" void QCALLTYPE AssemblyNative_GetReferencedAssemblies(QCall::Assembly AssemblySpec spec; spec.InitializeSpec(mdAssemblyRef, pImport); - gc.pObj = (ASSEMBLYNAMEREF) AllocateObject(pAsmNameClass); + gc.pObj = NULL; spec.AssemblyNameInit(&gc.pObj); gc.ItemArray->SetAt(i, (OBJECTREF) gc.pObj); diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp index 4650b95691e0f2..0e56405ce674a5 100644 --- a/src/coreclr/vm/assemblyspec.cpp +++ b/src/coreclr/vm/assemblyspec.cpp @@ -246,11 +246,8 @@ void AssemblySpec::AssemblyNameInit(ASSEMBLYNAMEREF* pAsmName) OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLY_NAME__CTOR); - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*pAsmName); - args[ARGNUM_1] = PTR_TO_ARGHOLDER(&nameParts); - CALL_MANAGED_METHOD_NORET(args); + UnmanagedCallersOnlyCaller createAssemblyName(METHOD__ASSEMBLY_NAME__CTOR); + createAssemblyName.InvokeThrowing(pAsmName, &nameParts); } /* static */ diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index 6a99fa6cee2a95..ea2c1395eace00 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -130,11 +130,13 @@ static void KickOffThread_Worker(LPVOID ptr) } CONTRACTL_END; - PREPARE_NONVIRTUAL_CALLSITE(METHOD__THREAD__START_CALLBACK); - DECLARE_ARGHOLDER_ARRAY(args, 1); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(GetThread()->GetExposedObjectRaw()); + OBJECTREF exposedObj = GetThread()->GetExposedObjectRaw(); + GCPROTECT_BEGIN(exposedObj); - CALL_MANAGED_METHOD_NORET(args); + UnmanagedCallersOnlyCaller startCallback(METHOD__THREAD__START_CALLBACK); + startCallback.InvokeThrowing(&exposedObj); + + GCPROTECT_END(); } // When an exposed thread is started by Win32, this is where it starts. diff --git a/src/coreclr/vm/coreassemblyspec.cpp b/src/coreclr/vm/coreassemblyspec.cpp index 58a5d1ab56789a..8e98f6729088e3 100644 --- a/src/coreclr/vm/coreassemblyspec.cpp +++ b/src/coreclr/vm/coreassemblyspec.cpp @@ -159,11 +159,8 @@ void BaseAssemblySpec::Init(SString& assemblyDisplayName) OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLY_NAME__PARSE_AS_ASSEMBLYSPEC); - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(pAssemblyDisplayName); - args[ARGNUM_1] = PTR_TO_ARGHOLDER(this); - CALL_MANAGED_METHOD_NORET(args); + UnmanagedCallersOnlyCaller parseAsAssemblySpec(METHOD__ASSEMBLY_NAME__PARSE_AS_ASSEMBLYSPEC); + parseAsAssemblySpec.InvokeThrowing(pAssemblyDisplayName, (void*)this); } extern "C" void QCALLTYPE AssemblyName_InitializeAssemblySpec(NativeAssemblyNameParts* pAssemblyNameParts, BaseAssemblySpec* pAssemblySpec) diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 95549c0f0ef93c..e6b8a325126369 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -974,8 +974,8 @@ DEFINE_METHOD(THREAD, CTOR, .ctor, IM_ #ifdef FEATURE_OBJCMARSHAL DEFINE_CLASS(AUTORELEASEPOOL, Threading, AutoreleasePool) -DEFINE_METHOD(AUTORELEASEPOOL, CREATEAUTORELEASEPOOL, CreateAutoreleasePool, SM_RetVoid) -DEFINE_METHOD(AUTORELEASEPOOL, DRAINAUTORELEASEPOOL, DrainAutoreleasePool, SM_RetVoid) +DEFINE_METHOD(AUTORELEASEPOOL, CREATEAUTORELEASEPOOL, CreateAutoreleasePool, SM_PtrException_RetVoid) +DEFINE_METHOD(AUTORELEASEPOOL, DRAINAUTORELEASEPOOL, DrainAutoreleasePool, SM_PtrException_RetVoid) #endif // FEATURE_OBJCMARSHAL DEFINE_CLASS(TYPE, System, Type) @@ -1092,6 +1092,8 @@ DEFINE_METHOD(FIXEDWSTRMARSHALER, CONVERT_TO_MANAGED, ConvertToManaged, DEFINE_CLASS(BSTRMARSHALER, StubHelpers, BSTRMarshaler) DEFINE_METHOD(BSTRMARSHALER, CONVERT_TO_NATIVE, ConvertToNative, SM_Str_IntPtr_RetIntPtr) DEFINE_METHOD(BSTRMARSHALER, CONVERT_TO_MANAGED, ConvertToManaged, SM_IntPtr_RetStr) +DEFINE_METHOD(BSTRMARSHALER, CONVERT_TO_NATIVE_UCO, ConvertToNative, SM_PtrStr_IntPtr_PtrIntPtr_PtrException_RetVoid) +DEFINE_METHOD(BSTRMARSHALER, CONVERT_TO_MANAGED_UCO, ConvertToManaged, SM_IntPtr_PtrStr_PtrException_RetVoid) DEFINE_METHOD(BSTRMARSHALER, CLEAR_NATIVE, ClearNative, SM_IntPtr_RetVoid) DEFINE_CLASS(ANSIBSTRMARSHALER, StubHelpers, AnsiBSTRMarshaler) diff --git a/src/coreclr/vm/corhost.cpp b/src/coreclr/vm/corhost.cpp index cf6ce72115a701..8a6eb65cede3ff 100644 --- a/src/coreclr/vm/corhost.cpp +++ b/src/coreclr/vm/corhost.cpp @@ -244,13 +244,11 @@ static PTRARRAYREF SetCommandLineArgs(PCWSTR pwzAssemblyPath, int argc, PCWSTR* PCWSTR exePath = Bundle::AppIsBundle() ? static_cast(Bundle::AppBundle->Path()) : pwzAssemblyPath; - PTRARRAYREF result; - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ENVIRONMENT__INITIALIZE_COMMAND_LINE_ARGS); - DECLARE_ARGHOLDER_ARRAY(args, 3); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(exePath); - args[ARGNUM_1] = DWORD_TO_ARGHOLDER(argc); - args[ARGNUM_2] = PTR_TO_ARGHOLDER(argv); - CALL_MANAGED_METHOD_RETREF(result, PTRARRAYREF, args); + PTRARRAYREF result = NULL; + GCPROTECT_BEGIN(result); + UnmanagedCallersOnlyCaller initializeCommandLineArgs(METHOD__ENVIRONMENT__INITIALIZE_COMMAND_LINE_ARGS); + initializeCommandLineArgs.InvokeThrowing(exePath, argc, argv, &result); + GCPROTECT_END(); return result; } diff --git a/src/coreclr/vm/dynamicinterfacecastable.cpp b/src/coreclr/vm/dynamicinterfacecastable.cpp index bf2bf5af00d015..744b88da3f0115 100644 --- a/src/coreclr/vm/dynamicinterfacecastable.cpp +++ b/src/coreclr/vm/dynamicinterfacecastable.cpp @@ -18,18 +18,18 @@ namespace POSTCONDITION(!throwIfNotImplemented || RETVAL); } CONTRACT_END; - PREPARE_NONVIRTUAL_CALLSITE(METHOD__DYNAMICINTERFACECASTABLEHELPERS__IS_INTERFACE_IMPLEMENTED); - - OBJECTREF managedType = interfaceTypeHandle.GetManagedClassObject(); // GC triggers - - DECLARE_ARGHOLDER_ARRAY(args, 3); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*objPROTECTED); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(managedType); - args[ARGNUM_2] = BOOL_TO_ARGHOLDER(throwIfNotImplemented); - - BOOL isImplemented; - CALL_MANAGED_METHOD(isImplemented, CLR_BOOL, args); - INDEBUG(managedType = NULL); // managedType wasn't protected during the call + struct { + OBJECTREF obj; + OBJECTREF managedType; + } gc; + gc.obj = *objPROTECTED; + gc.managedType = interfaceTypeHandle.GetManagedClassObject(); // GC triggers + + CLR_BOOL isImplemented = FALSE; + GCPROTECT_BEGIN(gc); + UnmanagedCallersOnlyCaller isInterfaceImplemented(METHOD__DYNAMICINTERFACECASTABLEHELPERS__IS_INTERFACE_IMPLEMENTED); + isInterfaceImplemented.InvokeThrowing(&gc.obj, &gc.managedType, CLR_BOOL_ARG(throwIfNotImplemented), &isImplemented); + GCPROTECT_END(); RETURN isImplemented; } @@ -45,19 +45,21 @@ namespace POSTCONDITION(RETVAL != NULL); } CONTRACT_END; - PREPARE_NONVIRTUAL_CALLSITE(METHOD__DYNAMICINTERFACECASTABLEHELPERS__GET_INTERFACE_IMPLEMENTATION); - - OBJECTREF managedType = interfaceTypeHandle.GetManagedClassObject(); // GC triggers - - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*objPROTECTED); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(managedType); - - OBJECTREF implTypeRef; - CALL_MANAGED_METHOD_RETREF(implTypeRef, OBJECTREF, args); - INDEBUG(managedType = NULL); // managedType wasn't protected during the call - - RETURN implTypeRef; + struct { + OBJECTREF obj; + OBJECTREF managedType; + OBJECTREF result; + } gc; + gc.obj = *objPROTECTED; + gc.managedType = interfaceTypeHandle.GetManagedClassObject(); // GC triggers + gc.result = NULL; + + GCPROTECT_BEGIN(gc); + UnmanagedCallersOnlyCaller getInterfaceImplementation(METHOD__DYNAMICINTERFACECASTABLEHELPERS__GET_INTERFACE_IMPLEMENTATION); + getInterfaceImplementation.InvokeThrowing(&gc.obj, &gc.managedType, &gc.result); + GCPROTECT_END(); + + RETURN gc.result; } } diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index 0126fc0e0527a6..499c0af0f287f0 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -292,11 +292,8 @@ void FinalizerThread::FinalizeAllObjects() FireEtwGCFinalizersBegin_V1(GetClrInstanceId()); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__GC__RUN_FINALIZERS); - DECLARE_ARGHOLDER_ARRAY(args, 0); - - uint32_t count; - CALL_MANAGED_METHOD(count, uint32_t, args); + UnmanagedCallersOnlyCaller runFinalizers(METHOD__GC__RUN_FINALIZERS); + uint32_t count = runFinalizers.InvokeThrowing_Ret(); FireEtwGCFinalizersEnd_V1(count, GetClrInstanceId()); } diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp index 7b984171ff6715..e815cf31a3b52f 100644 --- a/src/coreclr/vm/interoplibinterface_comwrappers.cpp +++ b/src/coreclr/vm/interoplibinterface_comwrappers.cpp @@ -36,14 +36,10 @@ namespace } CONTRACTL_END; - int result; + int result = 0; - PREPARE_NONVIRTUAL_CALLSITE(METHOD__COMWRAPPERS__CALL_ICUSTOMQUERYINTERFACE); - DECLARE_ARGHOLDER_ARRAY(args, 3); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(*implPROTECTED); - args[ARGNUM_1] = PTR_TO_ARGHOLDER(&iid); - args[ARGNUM_2] = PTR_TO_ARGHOLDER(ppObject); - CALL_MANAGED_METHOD(result, int, args); + UnmanagedCallersOnlyCaller callICustomQueryInterface(METHOD__COMWRAPPERS__CALL_ICUSTOMQUERYINTERFACE); + callICustomQueryInterface.InvokeThrowing(implPROTECTED, &iid, ppObject, &result); return result; } @@ -95,14 +91,12 @@ bool GlobalComWrappersForMarshalling::TryGetOrCreateComInterfaceForObject( } CONTRACTL_END; - void* wrapper; + void* wrapper = nullptr; GCPROTECT_BEGIN(instance); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__COMWRAPPERS__GET_OR_CREATE_COM_INTERFACE_FOR_OBJECT_WITH_GLOBAL_MARSHALLING_INSTANCE); - DECLARE_ARGHOLDER_ARRAY(args, 1); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(instance); - CALL_MANAGED_METHOD(wrapper, void*, args); + UnmanagedCallersOnlyCaller getOrCreateComInterface(METHOD__COMWRAPPERS__GET_OR_CREATE_COM_INTERFACE_FOR_OBJECT_WITH_GLOBAL_MARSHALLING_INSTANCE); + getOrCreateComInterface.InvokeThrowing(&instance, &wrapper); GCPROTECT_END(); @@ -131,11 +125,8 @@ bool GlobalComWrappersForMarshalling::TryGetOrCreateObjectForComInstance( OBJECTREF obj = NULL; GCPROTECT_BEGIN(obj); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__COMWRAPPERS__GET_OR_CREATE_OBJECT_FOR_COM_INSTANCE_WITH_GLOBAL_MARSHALLING_INSTANCE); - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(externalComObject); - args[ARGNUM_1] = DWORD_TO_ARGHOLDER(flags); - CALL_MANAGED_METHOD_RETREF(obj, OBJECTREF, args); + UnmanagedCallersOnlyCaller getOrCreateObjectForComInstance(METHOD__COMWRAPPERS__GET_OR_CREATE_OBJECT_FOR_COM_INSTANCE_WITH_GLOBAL_MARSHALLING_INSTANCE); + getOrCreateObjectForComInstance.InvokeThrowing(externalComObject, flags, &obj); GCPROTECT_END(); diff --git a/src/coreclr/vm/interoputil.cpp b/src/coreclr/vm/interoputil.cpp index 204cca19abf0bc..3bd9c9ad7531b4 100644 --- a/src/coreclr/vm/interoputil.cpp +++ b/src/coreclr/vm/interoputil.cpp @@ -2984,12 +2984,11 @@ static OBJECTREF ConvertEnumVariantToMngEnum(IEnumVARIANT* pNativeEnum) } CONTRACTL_END; - OBJECTREF retObjRef; - - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ENUMERATORTOENUMVARIANTMARSHALER__INTERNALMARSHALNATIVETOMANAGED); - DECLARE_ARGHOLDER_ARRAY(args, 1); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(pNativeEnum); - CALL_MANAGED_METHOD_RETREF(retObjRef, OBJECTREF, args); + OBJECTREF retObjRef = NULL; + GCPROTECT_BEGIN(retObjRef); + UnmanagedCallersOnlyCaller internalMarshalNativeToManaged(METHOD__ENUMERATORTOENUMVARIANTMARSHALER__INTERNALMARSHALNATIVETOMANAGED); + internalMarshalNativeToManaged.InvokeThrowing((INT_PTR)pNativeEnum, &retObjRef); + GCPROTECT_END(); return retObjRef; } diff --git a/src/coreclr/vm/nativelibrary.cpp b/src/coreclr/vm/nativelibrary.cpp index c8ee99667a45b7..f8764357013334 100644 --- a/src/coreclr/vm/nativelibrary.cpp +++ b/src/coreclr/vm/nativelibrary.cpp @@ -294,14 +294,9 @@ namespace // Get the pointer to the managed assembly load context INT_PTR ptrAssemblyLoadContext = pCurrentBinder->GetAssemblyLoadContext(); - // Prepare to invoke System.Runtime.Loader.AssemblyLoadContext.ResolveUnmanagedDll method. - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLYLOADCONTEXT__RESOLVEUNMANAGEDDLL); - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = STRINGREF_TO_ARGHOLDER(pUnmanagedDllName); - args[ARGNUM_1] = PTR_TO_ARGHOLDER(ptrAssemblyLoadContext); - - // Make the call - CALL_MANAGED_METHOD(hmod, NATIVE_LIBRARY_HANDLE, args); + // Invoke System.Runtime.Loader.AssemblyLoadContext.ResolveUnmanagedDll method. + UnmanagedCallersOnlyCaller resolveUnmanagedDll(METHOD__ASSEMBLYLOADCONTEXT__RESOLVEUNMANAGEDDLL); + resolveUnmanagedDll.InvokeThrowing(&pUnmanagedDllName, ptrAssemblyLoadContext, &hmod); GCPROTECT_END(); @@ -341,18 +336,12 @@ namespace gc.DllName = StringObject::NewString(wszLibName); gc.AssemblyRef = pAssembly->GetExposedObject(); - // Prepare to invoke System.Runtime.Loader.AssemblyLoadContext.ResolveUnmanagedDllUsingEvent method + // Invoke System.Runtime.Loader.AssemblyLoadContext.ResolveUnmanagedDllUsingEvent method // While ResolveUnmanagedDllUsingEvent() could compute the AssemblyLoadContext using the AssemblyRef // argument, it will involve another pInvoke to the runtime. So AssemblyLoadContext is passed in // as an additional argument. - PREPARE_NONVIRTUAL_CALLSITE(METHOD__ASSEMBLYLOADCONTEXT__RESOLVEUNMANAGEDDLLUSINGEVENT); - DECLARE_ARGHOLDER_ARRAY(args, 3); - args[ARGNUM_0] = STRINGREF_TO_ARGHOLDER(gc.DllName); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.AssemblyRef); - args[ARGNUM_2] = PTR_TO_ARGHOLDER(ptrAssemblyLoadContext); - - // Make the call - CALL_MANAGED_METHOD(hmod, NATIVE_LIBRARY_HANDLE, args); + UnmanagedCallersOnlyCaller resolveUnmanagedDllUsingEvent(METHOD__ASSEMBLYLOADCONTEXT__RESOLVEUNMANAGEDDLLUSINGEVENT); + resolveUnmanagedDllUsingEvent.InvokeThrowing(&gc.DllName, &gc.AssemblyRef, ptrAssemblyLoadContext, &hmod); GCPROTECT_END(); @@ -390,15 +379,8 @@ namespace gc.libNameRef = StringObject::NewString(wszLibName); gc.assemblyRef = pAssembly->GetExposedObject(); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__NATIVELIBRARY__LOADLIBRARYCALLBACKSTUB); - DECLARE_ARGHOLDER_ARRAY(args, 4); - args[ARGNUM_0] = STRINGREF_TO_ARGHOLDER(gc.libNameRef); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(gc.assemblyRef); - args[ARGNUM_2] = BOOL_TO_ARGHOLDER(hasDllImportSearchPathFlags); - args[ARGNUM_3] = DWORD_TO_ARGHOLDER(dllImportSearchPathFlags); - - // Make the call - CALL_MANAGED_METHOD(handle, NATIVE_LIBRARY_HANDLE, args); + UnmanagedCallersOnlyCaller loadLibraryCallbackStub(METHOD__NATIVELIBRARY__LOADLIBRARYCALLBACKSTUB); + loadLibraryCallbackStub.InvokeThrowing(&gc.libNameRef, &gc.assemblyRef, CLR_BOOL_ARG(hasDllImportSearchPathFlags), dllImportSearchPathFlags, (INT_PTR*)&handle); GCPROTECT_END(); return handle; diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 24a00ce910e887..0027ee8171f03b 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -4197,10 +4197,10 @@ void OleVariant::ConvertBSTRToString(BSTR bstr, STRINGREF *pStringObj) if (bstr == NULL) return; - PREPARE_NONVIRTUAL_CALLSITE(METHOD__BSTRMARSHALER__CONVERT_TO_MANAGED); - DECLARE_ARGHOLDER_ARRAY(args, 1); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(bstr); - CALL_MANAGED_METHOD_RETREF(*pStringObj, STRINGREF, args); + GCPROTECT_BEGIN(*pStringObj); + UnmanagedCallersOnlyCaller convertToManaged(METHOD__BSTRMARSHALER__CONVERT_TO_MANAGED_UCO); + convertToManaged.InvokeThrowing((INT_PTR)bstr, pStringObj); + GCPROTECT_END(); } BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) @@ -4225,11 +4225,11 @@ BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) RETURN NULL; } - PREPARE_NONVIRTUAL_CALLSITE(METHOD__BSTRMARSHALER__CONVERT_TO_NATIVE); - DECLARE_ARGHOLDER_ARRAY(args, 2); - args[ARGNUM_0] = STRINGREF_TO_ARGHOLDER(*pStringObj); - args[ARGNUM_1] = PTR_TO_ARGHOLDER(nullptr); - CALL_MANAGED_METHOD(bstr, BSTR, args); + GCPROTECT_BEGIN(*pStringObj); + UnmanagedCallersOnlyCaller convertToNative(METHOD__BSTRMARSHALER__CONVERT_TO_NATIVE_UCO); + BSTR bstr = NULL; + convertToNative.InvokeThrowing(pStringObj, (INT_PTR)nullptr, (INT_PTR*)&bstr); + GCPROTECT_END(); RETURN bstr; } diff --git a/src/coreclr/vm/runtimecallablewrapper.cpp b/src/coreclr/vm/runtimecallablewrapper.cpp index 076a4a043fa7af..29537d101b2536 100644 --- a/src/coreclr/vm/runtimecallablewrapper.cpp +++ b/src/coreclr/vm/runtimecallablewrapper.cpp @@ -2514,14 +2514,10 @@ void ComObject::ReleaseAllData(OBJECTREF oref) } CONTRACTL_END; - GCPROTECT_BEGIN(oref) + GCPROTECT_BEGIN(oref); { - PREPARE_NONVIRTUAL_CALLSITE(METHOD__COM_OBJECT__RELEASE_ALL_DATA); - - DECLARE_ARGHOLDER_ARRAY(ReleaseAllDataArgs, 1); - ReleaseAllDataArgs[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(oref); - - CALL_MANAGED_METHOD_NORET(ReleaseAllDataArgs); + UnmanagedCallersOnlyCaller releaseAllData(METHOD__COM_OBJECT__RELEASE_ALL_DATA); + releaseAllData.InvokeThrowing(&oref); } GCPROTECT_END(); } diff --git a/src/coreclr/vm/syncblk.cpp b/src/coreclr/vm/syncblk.cpp index c210092c685fdb..bffd9d2d69c318 100644 --- a/src/coreclr/vm/syncblk.cpp +++ b/src/coreclr/vm/syncblk.cpp @@ -1782,16 +1782,15 @@ bool SyncBlock::TryUpgradeThinLockToFullLock(OBJECTHANDLE lockHandle) DWORD lockThreadId = thinLock & SBLK_MASK_LOCK_THREADID; DWORD recursionLevel = (thinLock & SBLK_MASK_LOCK_RECLEVEL) >> SBLK_RECLEVEL_SHIFT; _ASSERTE(lockThreadId != 0); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__LOCK__INITIALIZE_FOR_MONITOR); // We have thin-lock info that needs to be transferred to the lock object. OBJECTREF lockObj = ObjectFromHandle(lockHandle); + GCPROTECT_BEGIN(lockObj); + + UnmanagedCallersOnlyCaller initializeForMonitor(METHOD__LOCK__INITIALIZE_FOR_MONITOR); + initializeForMonitor.InvokeThrowing(&lockObj, (int32_t)lockThreadId, (uint32_t)recursionLevel); - DECLARE_ARGHOLDER_ARRAY(args, 3); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(lockObj); - args[ARGNUM_1] = DWORD_TO_ARGHOLDER(lockThreadId); - args[ARGNUM_2] = DWORD_TO_ARGHOLDER(recursionLevel); - CALL_MANAGED_METHOD_NORET(args); + GCPROTECT_END(); } VolatileStore(&m_Lock, lockHandle); diff --git a/src/coreclr/vm/threads.cpp b/src/coreclr/vm/threads.cpp index e51ca6c5bd8667..f0cf759e010cbf 100644 --- a/src/coreclr/vm/threads.cpp +++ b/src/coreclr/vm/threads.cpp @@ -1811,9 +1811,8 @@ void Thread::InitializationForManagedThreadInNative(_In_ Thread* pThread) #ifdef FEATURE_OBJCMARSHAL { GCX_COOP_THREAD_EXISTS(pThread); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__AUTORELEASEPOOL__CREATEAUTORELEASEPOOL); - DECLARE_ARGHOLDER_ARRAY(args, 0); - CALL_MANAGED_METHOD_NORET(args); + UnmanagedCallersOnlyCaller createAutoreleasePool(METHOD__AUTORELEASEPOOL__CREATEAUTORELEASEPOOL); + createAutoreleasePool.InvokeThrowing(); } #endif // FEATURE_OBJCMARSHAL } @@ -1832,9 +1831,8 @@ void Thread::CleanUpForManagedThreadInNative(_In_ Thread* pThread) #ifdef FEATURE_OBJCMARSHAL { GCX_COOP_THREAD_EXISTS(pThread); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__AUTORELEASEPOOL__DRAINAUTORELEASEPOOL); - DECLARE_ARGHOLDER_ARRAY(args, 0); - CALL_MANAGED_METHOD_NORET(args); + UnmanagedCallersOnlyCaller drainAutoreleasePool(METHOD__AUTORELEASEPOOL__DRAINAUTORELEASEPOOL); + drainAutoreleasePool.InvokeThrowing(); } #endif // FEATURE_OBJCMARSHAL } @@ -2466,10 +2464,11 @@ void Thread::CleanupDetachedThreads() // Instead, run that clean up here when the Thread is detached, // which is definitely after the thread has exited. PTR_Thread pThread = (PTR_Thread)iter.GetElement(); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__THREAD__ON_THREAD_EXITING); - DECLARE_ARGHOLDER_ARRAY(args, 1); - args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(pThread->GetExposedObject()); - CALL_MANAGED_METHOD_NORET(args); + OBJECTREF exposedObj = pThread->GetExposedObject(); + GCPROTECT_BEGIN(exposedObj); + UnmanagedCallersOnlyCaller onThreadExiting(METHOD__THREAD__ON_THREAD_EXITING); + onThreadExiting.InvokeThrowing(&exposedObj); + GCPROTECT_END(); pThread->DecExternalCount(FALSE); } diff --git a/src/coreclr/vm/typeparse.cpp b/src/coreclr/vm/typeparse.cpp index ae3fdf778f76a2..06ab120b1f7def 100644 --- a/src/coreclr/vm/typeparse.cpp +++ b/src/coreclr/vm/typeparse.cpp @@ -21,30 +21,28 @@ static TypeHandle GetTypeHelper(LPCWSTR szTypeName, Assembly* pRequestingAssembl GCX_COOP(); - OBJECTREF objRequestingAssembly = NULL; - GCPROTECT_BEGIN(objRequestingAssembly); + struct { + OBJECTREF objRequestingAssembly; + OBJECTREF objType; + } gc; + gc.objRequestingAssembly = NULL; + gc.objType = NULL; + + GCPROTECT_BEGIN(gc); if (pRequestingAssembly != NULL) { - objRequestingAssembly = pRequestingAssembly->GetExposedObject(); + gc.objRequestingAssembly = pRequestingAssembly->GetExposedObject(); } OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED); - PREPARE_NONVIRTUAL_CALLSITE(METHOD__TYPE_NAME_RESOLVER__GET_TYPE_HELPER); - DECLARE_ARGHOLDER_ARRAY(args, 5); - args[ARGNUM_0] = PTR_TO_ARGHOLDER(szTypeName); - args[ARGNUM_1] = OBJECTREF_TO_ARGHOLDER(objRequestingAssembly); - args[ARGNUM_2] = BOOL_TO_ARGHOLDER(bThrowIfNotFound); - args[ARGNUM_3] = BOOL_TO_ARGHOLDER(bRequireAssemblyQualifiedName); - args[ARGNUM_4] = PTR_TO_ARGHOLDER(unsafeAccessorMethod); - - REFLECTCLASSBASEREF objType = NULL; - CALL_MANAGED_METHOD_RETREF(objType, REFLECTCLASSBASEREF, args); + UnmanagedCallersOnlyCaller getTypeHelper(METHOD__TYPE_NAME_RESOLVER__GET_TYPE_HELPER); + getTypeHelper.InvokeThrowing(szTypeName, &gc.objRequestingAssembly, CLR_BOOL_ARG(bThrowIfNotFound), CLR_BOOL_ARG(bRequireAssemblyQualifiedName), (INT_PTR)unsafeAccessorMethod, &gc.objType); - if (objType != NULL) + if (gc.objType != NULL) { - type = objType->GetType(); + type = ((REFLECTCLASSBASEREF)gc.objType)->GetType(); } GCPROTECT_END(); diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs index 59cabf533971c4..70328afaa50237 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/AutoreleasePool.cs @@ -51,5 +51,33 @@ internal static void DrainAutoreleasePool() s_AutoreleasePoolInstance = IntPtr.Zero; } } + +#if CORECLR + [System.Runtime.InteropServices.UnmanagedCallersOnly] + private static unsafe void CreateAutoreleasePool(Exception* pException) + { + try + { + CreateAutoreleasePool(); + } + catch (Exception ex) + { + *pException = ex; + } + } + + [System.Runtime.InteropServices.UnmanagedCallersOnly] + private static unsafe void DrainAutoreleasePool(Exception* pException) + { + try + { + DrainAutoreleasePool(); + } + catch (Exception ex) + { + *pException = ex; + } + } +#endif } } diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs index b27d337e23fabb..dc3adef95a696e 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Threading/Lock.cs @@ -876,6 +876,21 @@ internal void InitializeForMonitor(int managedThreadId, uint recursionCount) Debug.Assert(!new State(this).UseTrivialWaits); } +#if CORECLR + [System.Runtime.InteropServices.UnmanagedCallersOnly] + private static unsafe void InitializeForMonitor(Lock* pLock, int managedThreadId, uint recursionCount, Exception* pException) + { + try + { + pLock->InitializeForMonitor(managedThreadId, recursionCount); + } + catch (Exception ex) + { + *pException = ex; + } + } +#endif + private static short DetermineMaxSpinCount() { if (IsSingleProcessor) From 34f0b6c0a8386af088f232fbacd97e998f002ae6 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 17 Mar 2026 21:57:20 +0000 Subject: [PATCH 4/7] Fix metasig.h: wrap COM_OBJECT and MANAGED_OBJECT_WRAPPER_HOLDER entries in feature guards Co-authored-by: jkoritzinsky <1571408+jkoritzinsky@users.noreply.github.com> --- src/coreclr/vm/metasig.h | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/coreclr/vm/metasig.h b/src/coreclr/vm/metasig.h index b5805d8062171e..81ba770b7fd7b3 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -455,7 +455,6 @@ DEFINE_METASIG_T(SM(PtrLock_Int_UInt_PtrException_RetVoid, P(C(LOCK)) i K P(C(EX DEFINE_METASIG_T(SM(PtrThread_PtrException_RetVoid, P(C(THREAD)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrChar_PtrVoid_PtrException_RetVoid, P(u) P(v) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrAssemblyName_PtrNativeAssemblyNameParts_PtrException_RetVoid, P(C(ASSEMBLY_NAME)) P(g(NATIVE_ASSEMBLY_NAME_PARTS)) P(C(EXCEPTION)), v)) -DEFINE_METASIG_T(SM(PtrComObject_PtrException_RetVoid, P(C(COM_OBJECT)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrChar_Int_PtrPtrChar_PtrArrStr_PtrException_RetVoid, P(u) i P(P(u)) P(a(s)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrIDynamicInterfaceCastable_PtrClass_CLR_BOOL_PtrCLR_BOOL_PtrException_RetVoid, P(C(IDYNAMICINTERFACECASTABLE)) P(C(CLASS)) F P(F) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrIDynamicInterfaceCastable_PtrClass_PtrClass_PtrException_RetVoid, P(C(IDYNAMICINTERFACECASTABLE)) P(C(CLASS)) P(C(CLASS)) P(C(EXCEPTION)), v)) @@ -463,11 +462,16 @@ DEFINE_METASIG_T(SM(PtrChar_PtrAssembly_CLR_BOOL_CLR_BOOL_IntPtr_PtrClass_PtrExc DEFINE_METASIG_T(SM(IntPtr_PtrStr_PtrException_RetVoid, I P(s) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrStr_IntPtr_PtrIntPtr_PtrException_RetVoid, P(s) I P(I) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(IntPtr_PtrObj_PtrException_RetVoid, I P(j) P(C(EXCEPTION)), v)) -DEFINE_METASIG_T(SM(PtrManagedObjectWrapperHolder_PtrGuid_PtrIntPtr_PtrInt_PtrException_RetVoid, P(C(MANAGED_OBJECT_WRAPPER_HOLDER)) P(C(GUID)) P(I) P(i) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrObj_PtrIntPtr_PtrException_RetVoid, P(j) P(I) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(IntPtr_Int_PtrObj_PtrException_RetVoid, I i P(j) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrStr_PtrAssemblyBase_CLR_BOOL_UInt_PtrIntPtr_PtrException_RetVoid, P(s) P(C(ASSEMBLYBASE)) F K P(I) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrStr_PtrAssemblyBase_IntPtr_PtrIntPtr_PtrException_RetVoid, P(s) P(C(ASSEMBLYBASE)) I P(I) P(C(EXCEPTION)), v)) +#ifdef FEATURE_COMINTEROP +DEFINE_METASIG_T(SM(PtrComObject_PtrException_RetVoid, P(C(COM_OBJECT)) P(C(EXCEPTION)), v)) +#endif // FEATURE_COMINTEROP +#ifdef FEATURE_COMWRAPPERS +DEFINE_METASIG_T(SM(PtrManagedObjectWrapperHolder_PtrGuid_PtrIntPtr_PtrInt_PtrException_RetVoid, P(C(MANAGED_OBJECT_WRAPPER_HOLDER)) P(C(GUID)) P(I) P(i) P(C(EXCEPTION)), v)) +#endif // FEATURE_COMWRAPPERS // fields - e.g.: // DEFINE_METASIG(Fld(PtrVoid, P(v))) From e3279865de6a2a52ecc480e3a11914c59899eb5c Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 17 Mar 2026 23:14:58 +0000 Subject: [PATCH 5/7] Rename ASSEMBLY_NAME CTOR to CREATE_ASSEMBLY_SPEC, remove redundant using Co-authored-by: jkoritzinsky <1571408+jkoritzinsky@users.noreply.github.com> --- .../src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs | 1 - src/coreclr/vm/assemblyspec.cpp | 2 +- src/coreclr/vm/corelib.h | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index 3b3976002c5389..d0ea5b4f9f1791 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -3,7 +3,6 @@ using System.Reflection; using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; namespace System.Runtime.InteropServices { diff --git a/src/coreclr/vm/assemblyspec.cpp b/src/coreclr/vm/assemblyspec.cpp index 0e56405ce674a5..eec10de149a933 100644 --- a/src/coreclr/vm/assemblyspec.cpp +++ b/src/coreclr/vm/assemblyspec.cpp @@ -246,7 +246,7 @@ void AssemblySpec::AssemblyNameInit(ASSEMBLYNAMEREF* pAsmName) OVERRIDE_TYPE_LOAD_LEVEL_LIMIT(CLASS_LOADED); - UnmanagedCallersOnlyCaller createAssemblyName(METHOD__ASSEMBLY_NAME__CTOR); + UnmanagedCallersOnlyCaller createAssemblyName(METHOD__ASSEMBLY_NAME__CREATE_ASSEMBLY_SPEC); createAssemblyName.InvokeThrowing(pAsmName, &nameParts); } diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index e6b8a325126369..4904fadcff8347 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -117,7 +117,7 @@ DEFINE_FIELD(ARRAY_WITH_OFFSET, M_OFFSET, m_offset) DEFINE_FIELD(ARRAY_WITH_OFFSET, M_COUNT, m_count) DEFINE_CLASS(ASSEMBLY_NAME, Reflection, AssemblyName) -DEFINE_METHOD(ASSEMBLY_NAME, CTOR, CreateAssemblyName, SM_PtrAssemblyName_PtrNativeAssemblyNameParts_PtrException_RetVoid) +DEFINE_METHOD(ASSEMBLY_NAME, CREATE_ASSEMBLY_SPEC, CreateAssemblyName, SM_PtrAssemblyName_PtrNativeAssemblyNameParts_PtrException_RetVoid) DEFINE_METHOD(ASSEMBLY_NAME, PARSE_AS_ASSEMBLYSPEC, ParseAsAssemblySpec, SM_PtrChar_PtrVoid_PtrException_RetVoid) DEFINE_CLASS(NATIVE_ASSEMBLY_NAME_PARTS, Reflection, NativeAssemblyNameParts) From d4653335ea10e823ffa5186e13e4ef05de4be1c4 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 18 Mar 2026 02:24:53 +0000 Subject: [PATCH 6/7] Address reviewer feedback: fix bool/byte mismatches, GC holes, and duplicate bstr declaration Co-authored-by: jkoritzinsky <1571408+jkoritzinsky@users.noreply.github.com> --- .../src/System/Reflection/TypeNameResolver.CoreCLR.cs | 4 ++-- .../InteropServices/DynamicInterfaceCastableHelpers.cs | 4 ++-- .../Runtime/InteropServices/NativeLibrary.CoreCLR.cs | 4 ++-- src/coreclr/vm/dynamicinterfacecastable.cpp | 10 +++++++--- src/coreclr/vm/olevariant.cpp | 1 - 5 files changed, 13 insertions(+), 10 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index 9ef7bf809d8cdb..48d002702c6483 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -139,11 +139,11 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName, } [UnmanagedCallersOnly] - private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequestingAssembly, byte throwOnError, byte requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod, RuntimeType* pResult, Exception* pException) + private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequestingAssembly, bool throwOnError, bool requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod, RuntimeType* pResult, Exception* pException) { try { - *pResult = GetTypeHelper(pTypeName, *pRequestingAssembly, throwOnError != 0, requireAssemblyQualifiedName != 0, unsafeAccessorMethod); + *pResult = GetTypeHelper(pTypeName, *pRequestingAssembly, throwOnError, requireAssemblyQualifiedName, unsafeAccessorMethod); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs index 2408919707a52a..e33ea480619a55 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/DynamicInterfaceCastableHelpers.cs @@ -23,11 +23,11 @@ internal static bool IsInterfaceImplemented(IDynamicInterfaceCastable castable, } [UnmanagedCallersOnly] - private static unsafe void IsInterfaceImplemented(IDynamicInterfaceCastable* pCastable, RuntimeType* pInterfaceType, byte throwIfNotImplemented, byte* pResult, Exception* pException) + private static unsafe void IsInterfaceImplemented(IDynamicInterfaceCastable* pCastable, RuntimeType* pInterfaceType, bool throwIfNotImplemented, bool* pResult, Exception* pException) { try { - *pResult = IsInterfaceImplemented(*pCastable, *pInterfaceType, throwIfNotImplemented != 0) ? (byte)1 : (byte)0; + *pResult = IsInterfaceImplemented(*pCastable, *pInterfaceType, throwIfNotImplemented); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs index d0ea5b4f9f1791..3b2e99627feec1 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/NativeLibrary.CoreCLR.cs @@ -26,11 +26,11 @@ internal static partial IntPtr LoadByName(string libraryName, QCallAssembly call [MarshalAs(UnmanagedType.Bool)] bool throwOnError); [UnmanagedCallersOnly] - private static unsafe void LoadLibraryCallbackStub(string* pLibraryName, Assembly* pAssembly, byte hasDllImportSearchPathFlags, uint dllImportSearchPathFlags, IntPtr* pResult, Exception* pException) + private static unsafe void LoadLibraryCallbackStub(string* pLibraryName, Assembly* pAssembly, bool hasDllImportSearchPathFlags, uint dllImportSearchPathFlags, IntPtr* pResult, Exception* pException) { try { - *pResult = LoadLibraryCallbackStub(*pLibraryName, *pAssembly, hasDllImportSearchPathFlags != 0, dllImportSearchPathFlags); + *pResult = LoadLibraryCallbackStub(*pLibraryName, *pAssembly, hasDllImportSearchPathFlags, dllImportSearchPathFlags); } catch (Exception ex) { diff --git a/src/coreclr/vm/dynamicinterfacecastable.cpp b/src/coreclr/vm/dynamicinterfacecastable.cpp index 744b88da3f0115..aa1591fe45c886 100644 --- a/src/coreclr/vm/dynamicinterfacecastable.cpp +++ b/src/coreclr/vm/dynamicinterfacecastable.cpp @@ -22,11 +22,13 @@ namespace OBJECTREF obj; OBJECTREF managedType; } gc; + gc.obj = NULL; + gc.managedType = NULL; + GCPROTECT_BEGIN(gc); gc.obj = *objPROTECTED; gc.managedType = interfaceTypeHandle.GetManagedClassObject(); // GC triggers CLR_BOOL isImplemented = FALSE; - GCPROTECT_BEGIN(gc); UnmanagedCallersOnlyCaller isInterfaceImplemented(METHOD__DYNAMICINTERFACECASTABLEHELPERS__IS_INTERFACE_IMPLEMENTED); isInterfaceImplemented.InvokeThrowing(&gc.obj, &gc.managedType, CLR_BOOL_ARG(throwIfNotImplemented), &isImplemented); GCPROTECT_END(); @@ -50,11 +52,13 @@ namespace OBJECTREF managedType; OBJECTREF result; } gc; + gc.obj = NULL; + gc.managedType = NULL; + gc.result = NULL; + GCPROTECT_BEGIN(gc); gc.obj = *objPROTECTED; gc.managedType = interfaceTypeHandle.GetManagedClassObject(); // GC triggers - gc.result = NULL; - GCPROTECT_BEGIN(gc); UnmanagedCallersOnlyCaller getInterfaceImplementation(METHOD__DYNAMICINTERFACECASTABLEHELPERS__GET_INTERFACE_IMPLEMENTATION); getInterfaceImplementation.InvokeThrowing(&gc.obj, &gc.managedType, &gc.result); GCPROTECT_END(); diff --git a/src/coreclr/vm/olevariant.cpp b/src/coreclr/vm/olevariant.cpp index 0027ee8171f03b..269963960625c5 100644 --- a/src/coreclr/vm/olevariant.cpp +++ b/src/coreclr/vm/olevariant.cpp @@ -4227,7 +4227,6 @@ BSTR OleVariant::ConvertStringToBSTR(STRINGREF *pStringObj) GCPROTECT_BEGIN(*pStringObj); UnmanagedCallersOnlyCaller convertToNative(METHOD__BSTRMARSHALER__CONVERT_TO_NATIVE_UCO); - BSTR bstr = NULL; convertToNative.InvokeThrowing(pStringObj, (INT_PTR)nullptr, (INT_PTR*)&bstr); GCPROTECT_END(); RETURN bstr; From 473e86e079136a3891afb92c5b3d0e914d30ce8f Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 19 Mar 2026 21:44:51 +0000 Subject: [PATCH 7/7] Revert RunFinalizers/StartCallback UCO; inline simple VM-only managed helpers Co-authored-by: jkoritzinsky <1571408+jkoritzinsky@users.noreply.github.com> --- .../src/System/GC.CoreCLR.cs | 14 ------ .../System/Reflection/AssemblyName.CoreCLR.cs | 39 +++++++-------- .../Reflection/TypeNameResolver.CoreCLR.cs | 11 +---- .../EnumeratorToEnumVariantMarshaler.cs | 5 +- .../Loader/AssemblyLoadContext.CoreCLR.cs | 49 +++++-------------- .../src/System/Threading/Thread.CoreCLR.cs | 13 ----- src/coreclr/vm/comsynchronizable.cpp | 6 ++- src/coreclr/vm/corelib.h | 4 +- src/coreclr/vm/finalizerthread.cpp | 6 ++- src/coreclr/vm/metasig.h | 1 - 10 files changed, 42 insertions(+), 106 deletions(-) diff --git a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs index 283c132346aa60..4222b730e73e6e 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/GC.CoreCLR.cs @@ -337,20 +337,6 @@ private static unsafe uint RunFinalizers() return count; } - [UnmanagedCallersOnly] - private static unsafe uint RunFinalizers(Exception* pException) - { - try - { - return RunFinalizers(); - } - catch (Exception ex) - { - *pException = ex; - return 0; - } - } - [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "GCInterface_WaitForPendingFinalizers")] private static partial void _WaitForPendingFinalizers(); diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs index a16ee2089e5f5b..125b0e8177bd81 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/AssemblyName.CoreCLR.cs @@ -144,35 +144,30 @@ private static ProcessorArchitecture CalculateProcArch(PortableExecutableKinds p return ProcessorArchitecture.None; } - private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssemblySpec) + [UnmanagedCallersOnly] + private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssemblySpec, Exception* pException) { - AssemblyNameParser.AssemblyNameParts parts = AssemblyNameParser.Parse(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pAssemblyName)); - - fixed (char* pName = parts._name) - fixed (char* pCultureName = parts._cultureName) - fixed (byte* pPublicKeyOrToken = parts._publicKeyOrToken) + try { - NativeAssemblyNameParts nameParts = default; + AssemblyNameParser.AssemblyNameParts parts = AssemblyNameParser.Parse(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pAssemblyName)); - nameParts._flags = parts._flags; - nameParts._pName = pName; - nameParts._pCultureName = pCultureName; + fixed (char* pName = parts._name) + fixed (char* pCultureName = parts._cultureName) + fixed (byte* pPublicKeyOrToken = parts._publicKeyOrToken) + { + NativeAssemblyNameParts nameParts = default; - nameParts._pPublicKeyOrToken = pPublicKeyOrToken; - nameParts._cbPublicKeyOrToken = (parts._publicKeyOrToken != null) ? parts._publicKeyOrToken.Length : 0; + nameParts._flags = parts._flags; + nameParts._pName = pName; + nameParts._pCultureName = pCultureName; - nameParts.SetVersion(parts._version, defaultValue: ushort.MaxValue); + nameParts._pPublicKeyOrToken = pPublicKeyOrToken; + nameParts._cbPublicKeyOrToken = (parts._publicKeyOrToken != null) ? parts._publicKeyOrToken.Length : 0; - InitializeAssemblySpec(&nameParts, pAssemblySpec); - } - } + nameParts.SetVersion(parts._version, defaultValue: ushort.MaxValue); - [UnmanagedCallersOnly] - private static unsafe void ParseAsAssemblySpec(char* pAssemblyName, void* pAssemblySpec, Exception* pException) - { - try - { - ParseAsAssemblySpec(pAssemblyName, pAssemblySpec); + InitializeAssemblySpec(&nameParts, pAssemblySpec); + } } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs index 48d002702c6483..fb79062fe8f54b 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Reflection/TypeNameResolver.CoreCLR.cs @@ -130,20 +130,13 @@ internal static RuntimeType GetTypeReferencedByCustomAttribute(string typeName, return type; } - // Used by VM - internal static unsafe RuntimeType? GetTypeHelper(char* pTypeName, RuntimeAssembly? requestingAssembly, - bool throwOnError, bool requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod) - { - ReadOnlySpan typeName = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pTypeName); - return GetTypeHelper(typeName, requestingAssembly, throwOnError, requireAssemblyQualifiedName, unsafeAccessorMethod); - } - [UnmanagedCallersOnly] private static unsafe void GetTypeHelper(char* pTypeName, RuntimeAssembly* pRequestingAssembly, bool throwOnError, bool requireAssemblyQualifiedName, IntPtr unsafeAccessorMethod, RuntimeType* pResult, Exception* pException) { try { - *pResult = GetTypeHelper(pTypeName, *pRequestingAssembly, throwOnError, requireAssemblyQualifiedName, unsafeAccessorMethod); + ReadOnlySpan typeName = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pTypeName); + *pResult = GetTypeHelper(typeName, *pRequestingAssembly, throwOnError, requireAssemblyQualifiedName, unsafeAccessorMethod); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs index 46cf6fb33a8c0b..c44c01083ea748 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/InteropServices/CustomMarshalers/EnumeratorToEnumVariantMarshaler.cs @@ -47,15 +47,12 @@ public IntPtr MarshalManagedToNative(object ManagedObj) return Marshal.GetComInterfaceForObject(nativeView); } - internal static object InternalMarshalNativeToManaged(IntPtr pNativeData) - => GetInstance(null).MarshalNativeToManaged(pNativeData); - [System.Runtime.InteropServices.UnmanagedCallersOnly] private static unsafe void InternalMarshalNativeToManaged(IntPtr pNativeData, object* pResult, Exception* pException) { try { - *pResult = InternalMarshalNativeToManaged(pNativeData); + *pResult = GetInstance(null).MarshalNativeToManaged(pNativeData); } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs index c34bdbf3898552..d9748b2acde0c3 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Runtime/Loader/AssemblyLoadContext.CoreCLR.cs @@ -110,18 +110,13 @@ internal Assembly LoadFromInMemoryModule(IntPtr moduleHandle) // This method is invoked by the VM when using the host-provided assembly load context // implementation. - private static IntPtr ResolveUnmanagedDll(string unmanagedDllName, IntPtr gchAssemblyLoadContext) - { - AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!; - return context.LoadUnmanagedDll(unmanagedDllName); - } - [UnmanagedCallersOnly] private static unsafe void ResolveUnmanagedDll(string* pUnmanagedDllName, IntPtr gchAssemblyLoadContext, IntPtr* pResult, Exception* pException) { try { - *pResult = ResolveUnmanagedDll(*pUnmanagedDllName, gchAssemblyLoadContext); + AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!; + *pResult = context.LoadUnmanagedDll(*pUnmanagedDllName); } catch (Exception ex) { @@ -131,18 +126,13 @@ private static unsafe void ResolveUnmanagedDll(string* pUnmanagedDllName, IntPtr // This method is invoked by the VM to resolve a native library using the ResolvingUnmanagedDll event // after trying all other means of resolution. - private static IntPtr ResolveUnmanagedDllUsingEvent(string unmanagedDllName, Assembly assembly, IntPtr gchAssemblyLoadContext) - { - AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!; - return context.GetResolvedUnmanagedDll(assembly, unmanagedDllName); - } - [UnmanagedCallersOnly] private static unsafe void ResolveUnmanagedDllUsingEvent(string* pUnmanagedDllName, Assembly* pAssembly, IntPtr gchAssemblyLoadContext, IntPtr* pResult, Exception* pException) { try { - *pResult = ResolveUnmanagedDllUsingEvent(*pUnmanagedDllName, *pAssembly, gchAssemblyLoadContext); + AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!; + *pResult = context.GetResolvedUnmanagedDll(*pAssembly, *pUnmanagedDllName); } catch (Exception ex) { @@ -208,21 +198,16 @@ public void StartProfileOptimization(string? profile) /// /// Called by the runtime to start an assembly load activity for tracing /// - private static void StartAssemblyLoad(ref Guid activityId, ref Guid relatedActivityId) - { - // Make sure ActivityTracker is enabled - ActivityTracker.Instance.Enable(); - - // Don't use trace to TPL event source in ActivityTracker - that event source is a singleton and its instantiation may have triggered the load. - ActivityTracker.Instance.OnStart(NativeRuntimeEventSource.Log.Name, AssemblyLoadName, 0, ref activityId, ref relatedActivityId, EventActivityOptions.Recursive, useTplSource: false); - } - [UnmanagedCallersOnly] private static unsafe void StartAssemblyLoad(Guid* activityId, Guid* relatedActivityId, Exception* pException) { try { - StartAssemblyLoad(ref *activityId, ref *relatedActivityId); + // Make sure ActivityTracker is enabled + ActivityTracker.Instance.Enable(); + + // Don't use trace to TPL event source in ActivityTracker - that event source is a singleton and its instantiation may have triggered the load. + ActivityTracker.Instance.OnStart(NativeRuntimeEventSource.Log.Name, AssemblyLoadName, 0, ref *activityId, ref *relatedActivityId, EventActivityOptions.Recursive, useTplSource: false); } catch (Exception ex) { @@ -233,18 +218,13 @@ private static unsafe void StartAssemblyLoad(Guid* activityId, Guid* relatedActi /// /// Called by the runtime to stop an assembly load activity for tracing /// - private static void StopAssemblyLoad(ref Guid activityId) - { - // Don't use trace to TPL event source in ActivityTracker - that event source is a singleton and its instantiation may have triggered the load. - ActivityTracker.Instance.OnStop(NativeRuntimeEventSource.Log.Name, AssemblyLoadName, 0, ref activityId, useTplSource: false); - } - [UnmanagedCallersOnly] private static unsafe void StopAssemblyLoad(Guid* activityId, Exception* pException) { try { - StopAssemblyLoad(ref *activityId); + // Don't use trace to TPL event source in ActivityTracker - that event source is a singleton and its instantiation may have triggered the load. + ActivityTracker.Instance.OnStop(NativeRuntimeEventSource.Log.Name, AssemblyLoadName, 0, ref *activityId, useTplSource: false); } catch (Exception ex) { @@ -255,17 +235,12 @@ private static unsafe void StopAssemblyLoad(Guid* activityId, Exception* pExcept /// /// Called by the runtime to make sure the default ALC is initialized /// - private static void InitializeDefaultContext() - { - _ = Default; - } - [UnmanagedCallersOnly] private static unsafe void InitializeDefaultContext(Exception* pException) { try { - InitializeDefaultContext(); + _ = Default; } catch (Exception ex) { diff --git a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs index fec29b68a663bf..18e69e9a75a153 100644 --- a/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs +++ b/src/coreclr/System.Private.CoreLib/src/System/Threading/Thread.CoreCLR.cs @@ -125,19 +125,6 @@ private void StartCallback() OnThreadExiting(); } - [UnmanagedCallersOnly] - private static unsafe void StartCallback(Thread* pThread, Exception* pException) - { - try - { - pThread->StartCallback(); - } - catch (Exception ex) - { - *pException = ex; - } - } - // Max iterations to be done in SpinWait without switching GC modes. private const int SpinWaitCoopThreshold = 1024; diff --git a/src/coreclr/vm/comsynchronizable.cpp b/src/coreclr/vm/comsynchronizable.cpp index ea2c1395eace00..64b4a288db7964 100644 --- a/src/coreclr/vm/comsynchronizable.cpp +++ b/src/coreclr/vm/comsynchronizable.cpp @@ -133,8 +133,10 @@ static void KickOffThread_Worker(LPVOID ptr) OBJECTREF exposedObj = GetThread()->GetExposedObjectRaw(); GCPROTECT_BEGIN(exposedObj); - UnmanagedCallersOnlyCaller startCallback(METHOD__THREAD__START_CALLBACK); - startCallback.InvokeThrowing(&exposedObj); + PREPARE_NONVIRTUAL_CALLSITE(METHOD__THREAD__START_CALLBACK); + DECLARE_ARGHOLDER_ARRAY(args, 1); + args[ARGNUM_0] = OBJECTREF_TO_ARGHOLDER(exposedObj); + CALL_MANAGED_METHOD_NORET(args); GCPROTECT_END(); } diff --git a/src/coreclr/vm/corelib.h b/src/coreclr/vm/corelib.h index 4904fadcff8347..2e7ffa33fc40c9 100644 --- a/src/coreclr/vm/corelib.h +++ b/src/coreclr/vm/corelib.h @@ -965,7 +965,7 @@ DEFINE_FIELD(EXECUTIONCONTEXT, DEFAULT_FLOW_SUPPRESSED, DefaultFlowSu DEFINE_CLASS(DIRECTONTHREADLOCALDATA, Threading, Thread+DirectOnThreadLocalData) DEFINE_CLASS(THREAD, Threading, Thread) -DEFINE_METHOD(THREAD, START_CALLBACK, StartCallback, SM_PtrThread_PtrException_RetVoid) +DEFINE_METHOD(THREAD, START_CALLBACK, StartCallback, IM_RetVoid) DEFINE_METHOD(THREAD, POLLGC, PollGC, NoSig) DEFINE_METHOD(THREAD, ON_THREAD_EXITING, OnThreadExiting, SM_PtrThread_PtrException_RetVoid) #ifdef FOR_ILLINK @@ -1018,7 +1018,7 @@ DEFINE_METHOD(VALUE_TYPE, EQUALS, Equals, DEFINE_CLASS(GC, System, GC) DEFINE_METHOD(GC, KEEP_ALIVE, KeepAlive, SM_Obj_RetVoid) -DEFINE_METHOD(GC, RUN_FINALIZERS, RunFinalizers, SM_PtrException_RetUInt) +DEFINE_METHOD(GC, RUN_FINALIZERS, RunFinalizers, SM_RetUInt) DEFINE_CLASS_U(System, WeakReference, WeakReferenceObject) DEFINE_FIELD_U(_taggedHandle, WeakReferenceObject, m_taggedHandle) diff --git a/src/coreclr/vm/finalizerthread.cpp b/src/coreclr/vm/finalizerthread.cpp index 499c0af0f287f0..bc0a730b91f0d0 100644 --- a/src/coreclr/vm/finalizerthread.cpp +++ b/src/coreclr/vm/finalizerthread.cpp @@ -292,8 +292,10 @@ void FinalizerThread::FinalizeAllObjects() FireEtwGCFinalizersBegin_V1(GetClrInstanceId()); - UnmanagedCallersOnlyCaller runFinalizers(METHOD__GC__RUN_FINALIZERS); - uint32_t count = runFinalizers.InvokeThrowing_Ret(); + PREPARE_NONVIRTUAL_CALLSITE(METHOD__GC__RUN_FINALIZERS); + DECLARE_ARGHOLDER_ARRAY(args, 0); + uint32_t count = 0; + CALL_MANAGED_METHOD(count, uint32_t, args); FireEtwGCFinalizersEnd_V1(count, GetClrInstanceId()); } diff --git a/src/coreclr/vm/metasig.h b/src/coreclr/vm/metasig.h index 81ba770b7fd7b3..d719655fe919b5 100644 --- a/src/coreclr/vm/metasig.h +++ b/src/coreclr/vm/metasig.h @@ -448,7 +448,6 @@ DEFINE_METASIG_T(SM(PtrException_PtrException_RetVoid, P(C(EXCEPTION)) P(C(EXCEP 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)) -DEFINE_METASIG_T(SM(PtrException_RetUInt, P(C(EXCEPTION)), K)) DEFINE_METASIG_T(SM(PtrGuid_PtrException_RetVoid, P(C(GUID)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrGuid_PtrGuid_PtrException_RetVoid, P(C(GUID)) P(C(GUID)) P(C(EXCEPTION)), v)) DEFINE_METASIG_T(SM(PtrLock_Int_UInt_PtrException_RetVoid, P(C(LOCK)) i K P(C(EXCEPTION)), v))