Move Untracked_Release to native code to avoid problems during shutdown (#115489)

jkoritzinsky · web-flow · commit c8465dd07904 · 2025-05-12T19:15:36.000-07:00
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
@@ -26,6 +26,15 @@ public static unsafe void GetIUnknownImpl(out IntPtr fpQueryInterface, out IntPt
         [SuppressGCTransition]
         private static partial void GetIUnknownImplInternal(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease);
 
+        internal static unsafe void GetUntrackedIUnknownImpl(out delegate* unmanaged[MemberFunction]<IntPtr, uint> fpAddRef, out delegate* unmanaged[MemberFunction]<IntPtr, uint> fpRelease)
+        {
+            fpAddRef = fpRelease = GetUntrackedAddRefRelease();
+        }
+
+        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "ComWrappers_GetUntrackedAddRefRelease")]
+        [SuppressGCTransition]
+        private static unsafe partial delegate* unmanaged[MemberFunction]<IntPtr, uint> GetUntrackedAddRefRelease();
+
         internal static IntPtr DefaultIUnknownVftblPtr { get; } = CreateDefaultIUnknownVftbl();
         internal static IntPtr TaggedImplVftblPtr { get; } = CreateTaggedImplVftbl();
         internal static IntPtr DefaultIReferenceTrackerTargetVftblPtr { get; } = CreateDefaultIReferenceTrackerTargetVftbl();
diff --git a/src/coreclr/nativeaot/Runtime/HandleTableHelpers.cpp b/src/coreclr/nativeaot/Runtime/HandleTableHelpers.cpp
@@ -134,3 +134,12 @@ EXTERN_C uint32_t __stdcall RhIUnknown_AddRef(void* pComThis)
     ManagedObjectWrapper* wrapper = ToManagedObjectWrapper(pComThis);
     return wrapper->AddRef();
 }
+
+//
+// Release is implemented in native code so that it does not need to synchronize with the GC. This is important because Xaml
+// can invoke this Release during shutdown, and we don't want to synchronize with the GC at that time.
+//
+EXTERN_C uint32_t __stdcall RhUntracked_AddRefRelease(void*)
+{
+    return 1;
+}
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.NativeAot.cs
@@ -51,19 +51,26 @@ private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder
         /// <param name="fpRelease">Function pointer to Release.</param>
         public static unsafe void GetIUnknownImpl(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease)
         {
-            fpQueryInterface = (IntPtr)(delegate* unmanaged<IntPtr, Guid*, IntPtr*, int>)&ComWrappers.IUnknown_QueryInterface;
+            fpQueryInterface = (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int>)&ComWrappers.IUnknown_QueryInterface;
             fpAddRef = (IntPtr)(delegate*<IntPtr, uint>)&RuntimeImports.RhIUnknown_AddRef; // Implemented in C/C++ to avoid GC transitions
-            fpRelease = (IntPtr)(delegate* unmanaged<IntPtr, uint>)&ComWrappers.IUnknown_Release;
+            fpRelease = (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, uint>)&ComWrappers.IUnknown_Release;
         }
 
-        [UnmanagedCallersOnly]
+        internal static unsafe void GetUntrackedIUnknownImpl(out delegate* unmanaged[MemberFunction]<IntPtr, uint> fpAddRef, out delegate* unmanaged[MemberFunction]<IntPtr, uint> fpRelease)
+        {
+            // Implemented in C/C++ to avoid GC transitions during shutdown
+            fpAddRef = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)(void*)(delegate*<IntPtr, uint>)&RuntimeImports.RhUntracked_AddRefRelease;
+            fpRelease = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)(void*)(delegate*<IntPtr, uint>)&RuntimeImports.RhUntracked_AddRefRelease;
+        }
+
+        [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
         internal static unsafe int IUnknown_QueryInterface(IntPtr pThis, Guid* guid, IntPtr* ppObject)
         {
             ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
             return wrapper->QueryInterface(in *guid, out *ppObject);
         }
 
-        [UnmanagedCallersOnly]
+        [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
         internal static unsafe uint IUnknown_Release(IntPtr pThis)
         {
             ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
@@ -75,7 +82,7 @@ private static IntPtr GetTaggedImplCurrentVersion()
         {
             unsafe
             {
-                return (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, int>)&VtableImplementations.ITaggedImpl_IsCurrentVersion;
+                return (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)&VtableImplementations.ITaggedImpl_IsCurrentVersion;
             }
         }
 
@@ -95,28 +102,28 @@ private static class VtableImplementations
         {
             public unsafe struct IUnknownVftbl
             {
-                public delegate* unmanaged<IntPtr, Guid*, IntPtr*, int> QueryInterface;
-                public delegate* unmanaged<IntPtr, int> AddRef;
-                public delegate* unmanaged<IntPtr, uint> Release;
+                public delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int> QueryInterface;
+                public delegate* unmanaged[MemberFunction]<IntPtr, int> AddRef;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;
             }
 
             public unsafe struct IReferenceTrackerTargetVftbl
             {
-                public delegate* unmanaged<IntPtr, Guid*, IntPtr*, int> QueryInterface;
-                public delegate* unmanaged<IntPtr, int> AddRef;
-                public delegate* unmanaged<IntPtr, uint> Release;
-                public delegate* unmanaged<IntPtr, uint> AddRefFromReferenceTracker;
-                public delegate* unmanaged<IntPtr, uint> ReleaseFromReferenceTracker;
-                public delegate* unmanaged<IntPtr, uint> Peg;
-                public delegate* unmanaged<IntPtr, uint> Unpeg;
+                public delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int> QueryInterface;
+                public delegate* unmanaged[MemberFunction]<IntPtr, int> AddRef;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> AddRefFromReferenceTracker;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> ReleaseFromReferenceTracker;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> Peg;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> Unpeg;
             }
 
             public unsafe struct ITaggedImplVftbl
             {
-                public delegate* unmanaged<IntPtr, Guid*, IntPtr*, int> QueryInterface;
-                public delegate* unmanaged<IntPtr, int> AddRef;
-                public delegate* unmanaged<IntPtr, uint> Release;
-                public delegate* unmanaged<IntPtr, IntPtr, int> IsCurrentVersion;
+                public delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int> QueryInterface;
+                public delegate* unmanaged[MemberFunction]<IntPtr, int> AddRef;
+                public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;
+                public delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int> IsCurrentVersion;
             }
 
             [FixedAddressValueType]
@@ -128,45 +135,45 @@ public unsafe struct ITaggedImplVftbl
             [FixedAddressValueType]
             public static readonly ITaggedImplVftbl ITaggedImpl;
 
-            [UnmanagedCallersOnly]
+            [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
             internal static unsafe int IReferenceTrackerTarget_QueryInterface(IntPtr pThis, Guid* guid, IntPtr* ppObject)
             {
                 ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
                 return wrapper->QueryInterfaceForTracker(in *guid, out *ppObject);
             }
 
-            [UnmanagedCallersOnly]
+            [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
             internal static unsafe uint IReferenceTrackerTarget_AddRefFromReferenceTracker(IntPtr pThis)
             {
                 ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
                 return wrapper->AddRefFromReferenceTracker();
             }
 
-            [UnmanagedCallersOnly]
+            [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
             internal static unsafe uint IReferenceTrackerTarget_ReleaseFromReferenceTracker(IntPtr pThis)
             {
                 ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
                 return wrapper->ReleaseFromReferenceTracker();
             }
 
-            [UnmanagedCallersOnly]
+            [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
             internal static unsafe uint IReferenceTrackerTarget_Peg(IntPtr pThis)
             {
                 ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
                 return wrapper->Peg();
             }
 
-            [UnmanagedCallersOnly]
+            [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
             internal static unsafe uint IReferenceTrackerTarget_Unpeg(IntPtr pThis)
             {
                 ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);
                 return wrapper->Unpeg();
             }
 
-            [UnmanagedCallersOnly]
+            [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
             internal static unsafe int ITaggedImpl_IsCurrentVersion(IntPtr pThis, IntPtr version)
             {
-                return version == (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion
+                return version == (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion
                     ? HResults.S_OK
                     : HResults.E_FAIL;
             }
@@ -179,21 +186,21 @@ static unsafe VtableImplementations()
                     fpAddRef: out *(nint*)&((IUnknownVftbl*)Unsafe.AsPointer(ref IUnknown))->AddRef,
                     fpRelease: out *(nint*)&((IUnknownVftbl*)Unsafe.AsPointer(ref IUnknown))->Release);
 
-                IReferenceTrackerTarget.QueryInterface = (delegate* unmanaged<IntPtr, Guid*, IntPtr*, int>)&IReferenceTrackerTarget_QueryInterface;
+                IReferenceTrackerTarget.QueryInterface = (delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int>)&IReferenceTrackerTarget_QueryInterface;
                 GetIUnknownImpl(
                     fpQueryInterface: out _,
                     fpAddRef: out *(nint*)&((IReferenceTrackerTargetVftbl*)Unsafe.AsPointer(ref IReferenceTrackerTarget))->AddRef,
                     fpRelease: out *(nint*)&((IReferenceTrackerTargetVftbl*)Unsafe.AsPointer(ref IReferenceTrackerTarget))->Release);
-                IReferenceTrackerTarget.AddRefFromReferenceTracker = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_AddRefFromReferenceTracker;
-                IReferenceTrackerTarget.ReleaseFromReferenceTracker = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_ReleaseFromReferenceTracker;
-                IReferenceTrackerTarget.Peg = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_Peg;
-                IReferenceTrackerTarget.Unpeg = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_Unpeg;
+                IReferenceTrackerTarget.AddRefFromReferenceTracker = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_AddRefFromReferenceTracker;
+                IReferenceTrackerTarget.ReleaseFromReferenceTracker = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_ReleaseFromReferenceTracker;
+                IReferenceTrackerTarget.Peg = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_Peg;
+                IReferenceTrackerTarget.Unpeg = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_Unpeg;
 
                 GetIUnknownImpl(
                     fpQueryInterface: out *(nint*)&((ITaggedImplVftbl*)Unsafe.AsPointer(ref ITaggedImpl))->QueryInterface,
                     fpAddRef: out *(nint*)&((ITaggedImplVftbl*)Unsafe.AsPointer(ref ITaggedImpl))->AddRef,
                     fpRelease: out *(nint*)&((ITaggedImplVftbl*)Unsafe.AsPointer(ref ITaggedImpl))->Release);
-                ITaggedImpl.IsCurrentVersion = (delegate* unmanaged<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion;
+                ITaggedImpl.IsCurrentVersion = (delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion;
             }
         }
     }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.NativeAot.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/InteropServices/TrackerObjectManager.NativeAot.cs
@@ -204,7 +204,9 @@ internal static unsafe class FindReferenceTargetsCallback
     {
         internal static GCHandle s_currentRootObjectHandle;
 
-        [UnmanagedCallersOnly]
+#pragma warning disable CS3016
+        [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
+#pragma warning restore CS3016
         private static unsafe int IFindReferenceTargetsCallback_QueryInterface(IntPtr pThis, Guid* guid, IntPtr* ppObject)
         {
             if (*guid == IID_IFindReferenceTargetsCallback || *guid == IID_IUnknown)
@@ -218,7 +220,9 @@ private static unsafe int IFindReferenceTargetsCallback_QueryInterface(IntPtr pT
             }
         }
 
-        [UnmanagedCallersOnly]
+#pragma warning disable CS3016
+        [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]
+#pragma warning restore CS3016
         private static unsafe int IFindReferenceTargetsCallback_FoundTrackerTarget(IntPtr pThis, IntPtr referenceTrackerTarget)
         {
             if (referenceTrackerTarget == IntPtr.Zero)
@@ -235,22 +239,12 @@ private static unsafe int IFindReferenceTargetsCallback_FoundTrackerTarget(IntPt
             return HResults.S_OK;
         }
 
-        private static unsafe IntPtr CreateDefaultIFindReferenceTargetsCallbackVftbl()
-        {
-            IntPtr* vftbl = (IntPtr*)RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(FindReferenceTargetsCallback), 4 * sizeof(IntPtr));
-            vftbl[0] = (IntPtr)(delegate* unmanaged<IntPtr, Guid*, IntPtr*, int>)&IFindReferenceTargetsCallback_QueryInterface;
-            vftbl[1] = (IntPtr)(delegate* unmanaged<IntPtr, uint>)&ComWrappers.Untracked_AddRef;
-            vftbl[2] = (IntPtr)(delegate* unmanaged<IntPtr, uint>)&ComWrappers.Untracked_Release;
-            vftbl[3] = (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, int>)&IFindReferenceTargetsCallback_FoundTrackerTarget;
-            return (IntPtr)vftbl;
-        }
-
         internal struct ReferenceTargetsVftbl
         {
-            public delegate* unmanaged<IntPtr, Guid*, IntPtr*, int> QueryInterface;
-            public delegate* unmanaged<IntPtr, uint> AddRef;
-            public delegate* unmanaged<IntPtr, uint> Release;
-            public delegate* unmanaged<IntPtr, IntPtr, int> FoundTrackerTarget;
+            public delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int> QueryInterface;
+            public delegate* unmanaged[MemberFunction]<IntPtr, uint> AddRef;
+            public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;
+            public delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int> FoundTrackerTarget;
         }
 
         [FixedAddressValueType]
@@ -261,8 +255,7 @@ internal struct ReferenceTargetsVftbl
         static FindReferenceTargetsCallback()
 #pragma warning restore CA1810 // Initialize reference type static fields inline
         {
-            Vftbl.AddRef = &Untracked_AddRef;
-            Vftbl.Release = &Untracked_Release;
+            ComWrappers.GetUntrackedIUnknownImpl(out Vftbl.AddRef, out Vftbl.Release);
             Vftbl.QueryInterface = &IFindReferenceTargetsCallback_QueryInterface;
             Vftbl.FoundTrackerTarget = &IFindReferenceTargetsCallback_FoundTrackerTarget;
         }
diff --git a/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs b/src/coreclr/nativeaot/System.Private.CoreLib/src/System/Runtime/RuntimeImports.cs
@@ -510,6 +510,16 @@ internal enum GcRestrictedCalloutKind
         )]
         internal static extern uint RhIUnknown_AddRef(nint pThis);
 
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        [RuntimeImport(RuntimeLibrary,
+#if TARGET_WINDOWS && TARGET_X86
+            "_RhUntracked_AddRefRelease@4"
+#else
+            "RhUntracked_AddRefRelease"
+#endif
+        )]
+        internal static extern uint RhUntracked_AddRefRelease(nint pThis);
+
 #if FEATURE_OBJCMARSHAL
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         [RuntimeImport(RuntimeLibrary, "RhRegisterObjectiveCMarshalBeginEndCallback")]
diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.cpp b/src/coreclr/vm/interoplibinterface_comwrappers.cpp
@@ -614,4 +614,23 @@ extern "C" CLR_BOOL QCALLTYPE TrackerObjectManager_IsGlobalPeggingEnabled()
     return InteropLibImports::GetGlobalPeggingState();
 }
 
+// Some of our "Untracked" COM objects may be owned by static globals
+// in client code. We need to ensure that we don't try executing a managed
+// method for the first time when the process is shutting down.
+// Therefore, we need to provide unmanaged implementations of AddRef and Release.
+namespace
+{
+    int STDMETHODCALLTYPE Untracked_AddRefRelease(void*)
+    {
+        return 1;
+    }
+}
+
+extern "C" void* QCALLTYPE ComWrappers_GetUntrackedAddRefRelease()
+{
+    QCALL_CONTRACT_NO_GC_TRANSITION;
+
+    return (void*)Untracked_AddRefRelease;
+}
+
 #endif // FEATURE_COMWRAPPERS
diff --git a/src/coreclr/vm/interoplibinterface_comwrappers.h b/src/coreclr/vm/interoplibinterface_comwrappers.h
@@ -31,6 +31,8 @@ extern "C" void QCALLTYPE ComWrappers_GetIUnknownImpl(
     _Out_ void** fpAddRef,
     _Out_ void** fpRelease);
 
+extern "C" void* QCALLTYPE ComWrappers_GetUntrackedAddRefRelease();
+
 extern "C" void* QCALLTYPE ComWrappers_AllocateRefCountedHandle(_In_ QCall::ObjectHandleOnStack obj);
 
 extern "C" void const* QCALLTYPE ComWrappers_GetIReferenceTrackerTargetVftbl();
diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp
@@ -424,6 +424,7 @@ static const Entry s_QCall[] =
     DllImportEntry(ReflectionSerialization_GetCreateUninitializedObjectInfo)
 #if defined(FEATURE_COMWRAPPERS)
     DllImportEntry(ComWrappers_GetIUnknownImpl)
+    DllImportEntry(ComWrappers_GetUntrackedAddRefRelease)
     DllImportEntry(ComWrappers_AllocateRefCountedHandle)
     DllImportEntry(ComWrappers_GetIReferenceTrackerTargetVftbl)
     DllImportEntry(ComWrappers_GetTaggedImpl)
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs
@@ -965,7 +965,7 @@ public object GetOrRegisterObjectForComInstance(IntPtr externalComObject, Create
                 }
 
                 IntPtr currentVersion = GetTaggedImplCurrentVersion();
-                int hr = ((delegate* unmanaged<IntPtr, IntPtr, int>)(*(*(void***)implMaybe + 3 /* ITaggedImpl.IsCurrentVersion slot */)))(implMaybe, currentVersion);
+                int hr = ((delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)(*(*(void***)implMaybe + 3 /* ITaggedImpl.IsCurrentVersion slot */)))(implMaybe, currentVersion);
                 Marshal.Release(implMaybe);
                 if (hr != 0)
                 {
@@ -1445,26 +1445,13 @@ internal static IntPtr GetOrCreateTrackerTarget(IntPtr externalComObject)
             return s_globalInstanceForTrackerSupport.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.TrackerSupport);
         }
 
-        // Lifetime maintained by stack - we don't care about ref counts
-        [UnmanagedCallersOnly]
-        internal static unsafe uint Untracked_AddRef(IntPtr _)
-        {
-            return 1;
-        }
-
-        [UnmanagedCallersOnly]
-        internal static unsafe uint Untracked_Release(IntPtr _)
-        {
-            return 1;
-        }
-
         // Wrapper for IWeakReference
         private static unsafe class IWeakReference
         {
             public static int Resolve(IntPtr pThis, Guid guid, out IntPtr inspectable)
             {
                 fixed (IntPtr* inspectablePtr = &inspectable)
-                    return (*(delegate* unmanaged<IntPtr, Guid*, IntPtr*, int>**)pThis)[3](pThis, &guid, inspectablePtr);
+                    return (*(delegate* unmanaged[MemberFunction]<IntPtr, Guid*, IntPtr*, int>**)pThis)[3](pThis, &guid, inspectablePtr);
             }
         }
 
@@ -1474,7 +1461,7 @@ private static unsafe class IWeakReferenceSource
             public static int GetWeakReference(IntPtr pThis, out IntPtr weakReference)
             {
                 fixed (IntPtr* weakReferencePtr = &weakReference)
-                    return (*(delegate* unmanaged<IntPtr, IntPtr*, int>**)pThis)[3](pThis, weakReferencePtr);
+                    return (*(delegate* unmanaged[MemberFunction]<IntPtr, IntPtr*, int>**)pThis)[3](pThis, weakReferencePtr);
             }
         }
 
diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ReferenceTrackerHost.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ReferenceTrackerHost.cs

Original file line number	Diff line number	Diff line change
`@@ -51,19 +51,26 @@ private static IntPtr AllocateRefCountedHandle(ManagedObjectWrapperHolder holder`
`51`	`51`	`/// <param name="fpRelease">Function pointer to Release.</param>`
`52`	`52`	`public static unsafe void GetIUnknownImpl(out IntPtr fpQueryInterface, out IntPtr fpAddRef, out IntPtr fpRelease)`
`53`	`53`	`{`
`54`		`- fpQueryInterface = (IntPtr)(delegate* unmanaged<IntPtr, Guid, IntPtr, int>)&ComWrappers.IUnknown_QueryInterface;`
	`54`	`+ fpQueryInterface = (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int>)&ComWrappers.IUnknown_QueryInterface;`
`55`	`55`	`fpAddRef = (IntPtr)(delegate*<IntPtr, uint>)&RuntimeImports.RhIUnknown_AddRef; // Implemented in C/C++ to avoid GC transitions`
`56`		`- fpRelease = (IntPtr)(delegate* unmanaged<IntPtr, uint>)&ComWrappers.IUnknown_Release;`
	`56`	`+ fpRelease = (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, uint>)&ComWrappers.IUnknown_Release;`
`57`	`57`	`}`
`58`	`58`
`59`		`- [UnmanagedCallersOnly]`
	`59`	`+ internal static unsafe void GetUntrackedIUnknownImpl(out delegate* unmanaged[MemberFunction]<IntPtr, uint> fpAddRef, out delegate* unmanaged[MemberFunction]<IntPtr, uint> fpRelease)`
	`60`	`+ {`
	`61`	`+ // Implemented in C/C++ to avoid GC transitions during shutdown`
	`62`	`+ fpAddRef = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)(void)(delegate<IntPtr, uint>)&RuntimeImports.RhUntracked_AddRefRelease;`
	`63`	`+ fpRelease = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)(void)(delegate<IntPtr, uint>)&RuntimeImports.RhUntracked_AddRefRelease;`
	`64`	`+ }`
	`65`	`+`
	`66`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`60`	`67`	`internal static unsafe int IUnknown_QueryInterface(IntPtr pThis, Guid* guid, IntPtr* ppObject)`
`61`	`68`	`{`
`62`	`69`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`63`	`70`	`return wrapper->QueryInterface(in guid, out ppObject);`
`64`	`71`	`}`
`65`	`72`
`66`		`- [UnmanagedCallersOnly]`
	`73`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`67`	`74`	`internal static unsafe uint IUnknown_Release(IntPtr pThis)`
`68`	`75`	`{`
`69`	`76`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`@@ -75,7 +82,7 @@ private static IntPtr GetTaggedImplCurrentVersion()`
`75`	`82`	`{`
`76`	`83`	`unsafe`
`77`	`84`	`{`
`78`		`- return (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, int>)&VtableImplementations.ITaggedImpl_IsCurrentVersion;`
	`85`	`+ return (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)&VtableImplementations.ITaggedImpl_IsCurrentVersion;`
`79`	`86`	`}`
`80`	`87`	`}`
`81`	`88`
`@@ -95,28 +102,28 @@ private static class VtableImplementations`
`95`	`102`	`{`
`96`	`103`	`public unsafe struct IUnknownVftbl`
`97`	`104`	`{`
`98`		`- public delegate* unmanaged<IntPtr, Guid, IntPtr, int> QueryInterface;`
`99`		`- public delegate* unmanaged<IntPtr, int> AddRef;`
`100`		`- public delegate* unmanaged<IntPtr, uint> Release;`
	`105`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int> QueryInterface;`
	`106`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, int> AddRef;`
	`107`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;`
`101`	`108`	`}`
`102`	`109`
`103`	`110`	`public unsafe struct IReferenceTrackerTargetVftbl`
`104`	`111`	`{`
`105`		`- public delegate* unmanaged<IntPtr, Guid, IntPtr, int> QueryInterface;`
`106`		`- public delegate* unmanaged<IntPtr, int> AddRef;`
`107`		`- public delegate* unmanaged<IntPtr, uint> Release;`
`108`		`- public delegate* unmanaged<IntPtr, uint> AddRefFromReferenceTracker;`
`109`		`- public delegate* unmanaged<IntPtr, uint> ReleaseFromReferenceTracker;`
`110`		`- public delegate* unmanaged<IntPtr, uint> Peg;`
`111`		`- public delegate* unmanaged<IntPtr, uint> Unpeg;`
	`112`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int> QueryInterface;`
	`113`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, int> AddRef;`
	`114`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;`
	`115`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> AddRefFromReferenceTracker;`
	`116`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> ReleaseFromReferenceTracker;`
	`117`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> Peg;`
	`118`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> Unpeg;`
`112`	`119`	`}`
`113`	`120`
`114`	`121`	`public unsafe struct ITaggedImplVftbl`
`115`	`122`	`{`
`116`		`- public delegate* unmanaged<IntPtr, Guid, IntPtr, int> QueryInterface;`
`117`		`- public delegate* unmanaged<IntPtr, int> AddRef;`
`118`		`- public delegate* unmanaged<IntPtr, uint> Release;`
`119`		`- public delegate* unmanaged<IntPtr, IntPtr, int> IsCurrentVersion;`
	`123`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int> QueryInterface;`
	`124`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, int> AddRef;`
	`125`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;`
	`126`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int> IsCurrentVersion;`
`120`	`127`	`}`
`121`	`128`
`122`	`129`	`[FixedAddressValueType]`
`@@ -128,45 +135,45 @@ public unsafe struct ITaggedImplVftbl`
`128`	`135`	`[FixedAddressValueType]`
`129`	`136`	`public static readonly ITaggedImplVftbl ITaggedImpl;`
`130`	`137`
`131`		`- [UnmanagedCallersOnly]`
	`138`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`132`	`139`	`internal static unsafe int IReferenceTrackerTarget_QueryInterface(IntPtr pThis, Guid* guid, IntPtr* ppObject)`
`133`	`140`	`{`
`134`	`141`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`135`	`142`	`return wrapper->QueryInterfaceForTracker(in guid, out ppObject);`
`136`	`143`	`}`
`137`	`144`
`138`		`- [UnmanagedCallersOnly]`
	`145`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`139`	`146`	`internal static unsafe uint IReferenceTrackerTarget_AddRefFromReferenceTracker(IntPtr pThis)`
`140`	`147`	`{`
`141`	`148`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`142`	`149`	`return wrapper->AddRefFromReferenceTracker();`
`143`	`150`	`}`
`144`	`151`
`145`		`- [UnmanagedCallersOnly]`
	`152`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`146`	`153`	`internal static unsafe uint IReferenceTrackerTarget_ReleaseFromReferenceTracker(IntPtr pThis)`
`147`	`154`	`{`
`148`	`155`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`149`	`156`	`return wrapper->ReleaseFromReferenceTracker();`
`150`	`157`	`}`
`151`	`158`
`152`		`- [UnmanagedCallersOnly]`
	`159`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`153`	`160`	`internal static unsafe uint IReferenceTrackerTarget_Peg(IntPtr pThis)`
`154`	`161`	`{`
`155`	`162`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`156`	`163`	`return wrapper->Peg();`
`157`	`164`	`}`
`158`	`165`
`159`		`- [UnmanagedCallersOnly]`
	`166`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`160`	`167`	`internal static unsafe uint IReferenceTrackerTarget_Unpeg(IntPtr pThis)`
`161`	`168`	`{`
`162`	`169`	`ManagedObjectWrapper* wrapper = ComInterfaceDispatch.ToManagedObjectWrapper((ComInterfaceDispatch*)pThis);`
`163`	`170`	`return wrapper->Unpeg();`
`164`	`171`	`}`
`165`	`172`
`166`		`- [UnmanagedCallersOnly]`
	`173`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
`167`	`174`	`internal static unsafe int ITaggedImpl_IsCurrentVersion(IntPtr pThis, IntPtr version)`
`168`	`175`	`{`
`169`		`- return version == (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion`
	`176`	`+ return version == (IntPtr)(delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion`
`170`	`177`	`? HResults.S_OK`
`171`	`178`	`: HResults.E_FAIL;`
`172`	`179`	`}`
`@@ -179,21 +186,21 @@ static unsafe VtableImplementations()`
`179`	`186`	`fpAddRef: out (nint)&((IUnknownVftbl*)Unsafe.AsPointer(ref IUnknown))->AddRef,`
`180`	`187`	`fpRelease: out (nint)&((IUnknownVftbl*)Unsafe.AsPointer(ref IUnknown))->Release);`
`181`	`188`
`182`		`- IReferenceTrackerTarget.QueryInterface = (delegate* unmanaged<IntPtr, Guid, IntPtr, int>)&IReferenceTrackerTarget_QueryInterface;`
	`189`	`+ IReferenceTrackerTarget.QueryInterface = (delegate* unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int>)&IReferenceTrackerTarget_QueryInterface;`
`183`	`190`	`GetIUnknownImpl(`
`184`	`191`	`fpQueryInterface: out _,`
`185`	`192`	`fpAddRef: out (nint)&((IReferenceTrackerTargetVftbl*)Unsafe.AsPointer(ref IReferenceTrackerTarget))->AddRef,`
`186`	`193`	`fpRelease: out (nint)&((IReferenceTrackerTargetVftbl*)Unsafe.AsPointer(ref IReferenceTrackerTarget))->Release);`
`187`		`- IReferenceTrackerTarget.AddRefFromReferenceTracker = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_AddRefFromReferenceTracker;`
`188`		`- IReferenceTrackerTarget.ReleaseFromReferenceTracker = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_ReleaseFromReferenceTracker;`
`189`		`- IReferenceTrackerTarget.Peg = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_Peg;`
`190`		`- IReferenceTrackerTarget.Unpeg = (delegate* unmanaged<IntPtr, uint>)&IReferenceTrackerTarget_Unpeg;`
	`194`	`+ IReferenceTrackerTarget.AddRefFromReferenceTracker = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_AddRefFromReferenceTracker;`
	`195`	`+ IReferenceTrackerTarget.ReleaseFromReferenceTracker = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_ReleaseFromReferenceTracker;`
	`196`	`+ IReferenceTrackerTarget.Peg = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_Peg;`
	`197`	`+ IReferenceTrackerTarget.Unpeg = (delegate* unmanaged[MemberFunction]<IntPtr, uint>)&IReferenceTrackerTarget_Unpeg;`
`191`	`198`
`192`	`199`	`GetIUnknownImpl(`
`193`	`200`	`fpQueryInterface: out (nint)&((ITaggedImplVftbl*)Unsafe.AsPointer(ref ITaggedImpl))->QueryInterface,`
`194`	`201`	`fpAddRef: out (nint)&((ITaggedImplVftbl*)Unsafe.AsPointer(ref ITaggedImpl))->AddRef,`
`195`	`202`	`fpRelease: out (nint)&((ITaggedImplVftbl*)Unsafe.AsPointer(ref ITaggedImpl))->Release);`
`196`		`- ITaggedImpl.IsCurrentVersion = (delegate* unmanaged<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion;`
	`203`	`+ ITaggedImpl.IsCurrentVersion = (delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)&ITaggedImpl_IsCurrentVersion;`
`197`	`204`	`}`
`198`	`205`	`}`
`199`	`206`	`}`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,9 @@ internal static unsafe class FindReferenceTargetsCallback`
`204`	`204`	`{`
`205`	`205`	`internal static GCHandle s_currentRootObjectHandle;`
`206`	`206`
`207`		`- [UnmanagedCallersOnly]`
	`207`	`+#pragma warning disable CS3016`
	`208`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
	`209`	`+#pragma warning restore CS3016`
`208`	`210`	`private static unsafe int IFindReferenceTargetsCallback_QueryInterface(IntPtr pThis, Guid* guid, IntPtr* ppObject)`
`209`	`211`	`{`
`210`	`212`	`if (guid == IID_IFindReferenceTargetsCallback \|\| guid == IID_IUnknown)`
`@@ -218,7 +220,9 @@ private static unsafe int IFindReferenceTargetsCallback_QueryInterface(IntPtr pT`
`218`	`220`	`}`
`219`	`221`	`}`
`220`	`222`
`221`		`- [UnmanagedCallersOnly]`
	`223`	`+#pragma warning disable CS3016`
	`224`	`+ [UnmanagedCallersOnly(CallConvs = [typeof(CallConvMemberFunction)])]`
	`225`	`+#pragma warning restore CS3016`
`222`	`226`	`private static unsafe int IFindReferenceTargetsCallback_FoundTrackerTarget(IntPtr pThis, IntPtr referenceTrackerTarget)`
`223`	`227`	`{`
`224`	`228`	`if (referenceTrackerTarget == IntPtr.Zero)`
`@@ -235,22 +239,12 @@ private static unsafe int IFindReferenceTargetsCallback_FoundTrackerTarget(IntPt`
`235`	`239`	`return HResults.S_OK;`
`236`	`240`	`}`
`237`	`241`
`238`		`- private static unsafe IntPtr CreateDefaultIFindReferenceTargetsCallbackVftbl()`
`239`		`- {`
`240`		`- IntPtr* vftbl = (IntPtr)RuntimeHelpers.AllocateTypeAssociatedMemory(typeof(FindReferenceTargetsCallback), 4 sizeof(IntPtr));`
`241`		`- vftbl[0] = (IntPtr)(delegate* unmanaged<IntPtr, Guid, IntPtr, int>)&IFindReferenceTargetsCallback_QueryInterface;`
`242`		`- vftbl[1] = (IntPtr)(delegate* unmanaged<IntPtr, uint>)&ComWrappers.Untracked_AddRef;`
`243`		`- vftbl[2] = (IntPtr)(delegate* unmanaged<IntPtr, uint>)&ComWrappers.Untracked_Release;`
`244`		`- vftbl[3] = (IntPtr)(delegate* unmanaged<IntPtr, IntPtr, int>)&IFindReferenceTargetsCallback_FoundTrackerTarget;`
`245`		`- return (IntPtr)vftbl;`
`246`		`- }`
`247`		`-`
`248`	`242`	`internal struct ReferenceTargetsVftbl`
`249`	`243`	`{`
`250`		`- public delegate* unmanaged<IntPtr, Guid, IntPtr, int> QueryInterface;`
`251`		`- public delegate* unmanaged<IntPtr, uint> AddRef;`
`252`		`- public delegate* unmanaged<IntPtr, uint> Release;`
`253`		`- public delegate* unmanaged<IntPtr, IntPtr, int> FoundTrackerTarget;`
	`244`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int> QueryInterface;`
	`245`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> AddRef;`
	`246`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, uint> Release;`
	`247`	`+ public delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int> FoundTrackerTarget;`
`254`	`248`	`}`
`255`	`249`
`256`	`250`	`[FixedAddressValueType]`
`@@ -261,8 +255,7 @@ internal struct ReferenceTargetsVftbl`
`261`	`255`	`static FindReferenceTargetsCallback()`
`262`	`256`	`#pragma warning restore CA1810 // Initialize reference type static fields inline`
`263`	`257`	`{`
`264`		`- Vftbl.AddRef = &Untracked_AddRef;`
`265`		`- Vftbl.Release = &Untracked_Release;`
	`258`	`+ ComWrappers.GetUntrackedIUnknownImpl(out Vftbl.AddRef, out Vftbl.Release);`
`266`	`259`	`Vftbl.QueryInterface = &IFindReferenceTargetsCallback_QueryInterface;`
`267`	`260`	`Vftbl.FoundTrackerTarget = &IFindReferenceTargetsCallback_FoundTrackerTarget;`
`268`	`261`	`}`
Original file line number	Diff line number	Diff line change
`@@ -965,7 +965,7 @@ public object GetOrRegisterObjectForComInstance(IntPtr externalComObject, Create`
`965`	`965`	`}`
`966`	`966`
`967`	`967`	`IntPtr currentVersion = GetTaggedImplCurrentVersion();`
`968`		`- int hr = ((delegate* unmanaged<IntPtr, IntPtr, int>)(((void**)implMaybe + 3 / ITaggedImpl.IsCurrentVersion slot */)))(implMaybe, currentVersion);`
	`968`	`+ int hr = ((delegate* unmanaged[MemberFunction]<IntPtr, IntPtr, int>)(((void**)implMaybe + 3 / ITaggedImpl.IsCurrentVersion slot */)))(implMaybe, currentVersion);`
`969`	`969`	`Marshal.Release(implMaybe);`
`970`	`970`	`if (hr != 0)`
`971`	`971`	`{`
`@@ -1445,26 +1445,13 @@ internal static IntPtr GetOrCreateTrackerTarget(IntPtr externalComObject)`
`1445`	`1445`	`return s_globalInstanceForTrackerSupport.GetOrCreateComInterfaceForObject(obj, CreateComInterfaceFlags.TrackerSupport);`
`1446`	`1446`	`}`
`1447`	`1447`
`1448`		`- // Lifetime maintained by stack - we don't care about ref counts`
`1449`		`- [UnmanagedCallersOnly]`
`1450`		`- internal static unsafe uint Untracked_AddRef(IntPtr _)`
`1451`		`- {`
`1452`		`- return 1;`
`1453`		`- }`
`1454`		`-`
`1455`		`- [UnmanagedCallersOnly]`
`1456`		`- internal static unsafe uint Untracked_Release(IntPtr _)`
`1457`		`- {`
`1458`		`- return 1;`
`1459`		`- }`
`1460`		`-`
`1461`	`1448`	`// Wrapper for IWeakReference`
`1462`	`1449`	`private static unsafe class IWeakReference`
`1463`	`1450`	`{`
`1464`	`1451`	`public static int Resolve(IntPtr pThis, Guid guid, out IntPtr inspectable)`
`1465`	`1452`	`{`
`1466`	`1453`	`fixed (IntPtr* inspectablePtr = &inspectable)`
`1467`		`- return ((delegate unmanaged<IntPtr, Guid, IntPtr, int>**)pThis)[3](pThis, &guid, inspectablePtr);`
	`1454`	`+ return ((delegate unmanaged[MemberFunction]<IntPtr, Guid, IntPtr, int>**)pThis)[3](pThis, &guid, inspectablePtr);`
`1468`	`1455`	`}`
`1469`	`1456`	`}`
`1470`	`1457`
`@@ -1474,7 +1461,7 @@ private static unsafe class IWeakReferenceSource`
`1474`	`1461`	`public static int GetWeakReference(IntPtr pThis, out IntPtr weakReference)`
`1475`	`1462`	`{`
`1476`	`1463`	`fixed (IntPtr* weakReferencePtr = &weakReference)`
`1477`		`- return ((delegate unmanaged<IntPtr, IntPtr, int>*)pThis)[3](pThis, weakReferencePtr);`
	`1464`	`+ return ((delegate unmanaged[MemberFunction]<IntPtr, IntPtr, int>*)pThis)[3](pThis, weakReferencePtr);`
`1478`	`1465`	`}`
`1479`	`1466`	`}`
`1480`	`1467`