Improve performance of IsCollectible reflection properties

jkotas · jkotas · commit 0d97cebf04fd · 2025-09-15T20:02:29.000-07:00
These properties are often used for non-collectible fast paths. It is important that they are cheap. Converted these proproperties to FCalls to reduce overhead. Fixes #119499
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeAssembly.cs
@@ -252,15 +252,16 @@ public override IEnumerable<TypeInfo> DefinedTypes
             get => GetManifestModule().GetDefinedTypes();
         }
 
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetIsCollectible")]
-        internal static partial Interop.BOOL GetIsCollectible(QCallAssembly assembly);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        private static extern bool GetIsCollectible(IntPtr assembly);
 
         public override bool IsCollectible
         {
             get
             {
-                RuntimeAssembly runtimeAssembly = this;
-                return GetIsCollectible(new QCallAssembly(ref runtimeAssembly)) != Interop.BOOL.FALSE;
+                bool isCollectible = GetIsCollectible(GetUnderlyingNativeHandle());
+                GC.KeepAlive(this); // We directly pass the native handle above - make sure this object stays alive for the call
+                return isCollectible;
             }
         }
 
diff --git a/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/Reflection/RuntimeMethodInfo.CoreCLR.cs
@@ -319,7 +319,15 @@ internal void InvokePropertySetter(object? obj, BindingFlags invokeAttr, Binder?
 
         public override ParameterInfo ReturnParameter => FetchReturnParameter();
 
-        public override bool IsCollectible => RuntimeMethodHandle.GetIsCollectible(new RuntimeMethodHandleInternal(m_handle)) != Interop.BOOL.FALSE;
+        public override bool IsCollectible
+        {
+            get
+            {
+                bool isCollectible = RuntimeMethodHandle.IsCollectible(new RuntimeMethodHandleInternal(m_handle));
+                GC.KeepAlive(this); // We directly pass the native handle above - make sure this object stays alive for the call
+                return isCollectible;
+            }
+        }
 
         public override MethodInfo GetBaseDefinition()
         {
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs
@@ -824,8 +824,8 @@ internal RuntimeType MakePointer()
             return type!;
         }
 
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_IsCollectible")]
-        internal static partial Interop.BOOL IsCollectible(QCallTypeHandle handle);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool IsCollectible(RuntimeType type);
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeTypeHandle_GetGenericTypeDefinition")]
         internal static partial void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType);
@@ -1053,8 +1053,8 @@ public IntPtr GetFunctionPointer()
             return ptr;
         }
 
-        [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_GetIsCollectible")]
-        internal static partial Interop.BOOL GetIsCollectible(RuntimeMethodHandleInternal handle);
+        [MethodImpl(MethodImplOptions.InternalCall)]
+        internal static extern bool IsCollectible(RuntimeMethodHandleInternal method);
 
         [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "RuntimeMethodHandle_IsCAVisibleFromDecoratedType")]
         internal static partial Interop.BOOL IsCAVisibleFromDecoratedType(
diff --git a/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs b/src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs
@@ -3227,14 +3227,7 @@ public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo memb
 
         #region Identity
 
-        public sealed override bool IsCollectible
-        {
-            get
-            {
-                RuntimeType thisType = this;
-                return RuntimeTypeHandle.IsCollectible(new QCallTypeHandle(ref thisType)) != Interop.BOOL.FALSE;
-            }
-        }
+        public sealed override bool IsCollectible => RuntimeTypeHandle.IsCollectible(this);
 
         public override MethodBase? DeclaringMethod
         {
diff --git a/src/coreclr/vm/assemblynative.cpp b/src/coreclr/vm/assemblynative.cpp
@@ -742,20 +742,18 @@ extern "C" void QCALLTYPE AssemblyNative_GetModules(QCall::AssemblyHandle pAssem
     END_QCALL;
 }
 
-extern "C" BOOL QCALLTYPE AssemblyNative_GetIsCollectible(QCall::AssemblyHandle pAssembly)
+FCIMPL1(FC_BOOL_RET, AssemblyNative::GetIsCollectible, Assembly* pAssembly)
 {
-    QCALL_CONTRACT;
-
-    BOOL retVal = FALSE;
-
-    BEGIN_QCALL;
-
-    retVal = pAssembly->IsCollectible();
-
-    END_QCALL;
+    CONTRACTL
+    {
+        FCALL_CHECK;
+        PRECONDITION(CheckPointer(pAssembly));
+    }
+    CONTRACTL_END;
 
-    return retVal;
+    FC_RETURN_BOOL(pAssembly->IsCollectible());
 }
+FCIMPLEND
 
 extern volatile uint32_t g_cAssemblies;
 
diff --git a/src/coreclr/vm/assemblynative.hpp b/src/coreclr/vm/assemblynative.hpp
@@ -32,6 +32,9 @@ class AssemblyNative
 
     static
     FCDECL1(FC_BOOL_RET, GetIsDynamic, Assembly* pAssembly);
+
+    static
+    FCDECL1(FC_BOOL_RET, GetIsCollectible, Assembly* pAssembly);
 };
 
 extern "C" uint32_t QCALLTYPE AssemblyNative_GetAssemblyCount();
@@ -108,8 +111,6 @@ extern "C" void QCALLTYPE AssemblyNative_GetEntryPoint(QCall::AssemblyHandle pAs
 extern "C" void QCALLTYPE AssemblyNative_GetImageRuntimeVersion(QCall::AssemblyHandle pAssembly, QCall::StringHandleOnStack retString);
 
 
-extern "C" BOOL QCALLTYPE AssemblyNative_GetIsCollectible(QCall::AssemblyHandle pAssembly);
-
 extern "C" INT_PTR QCALLTYPE AssemblyNative_InitializeAssemblyLoadContext(INT_PTR ptrAssemblyLoadContext, BOOL fRepresentsTPALoadContext, BOOL fIsCollectible);
 
 extern "C" void QCALLTYPE AssemblyNative_PrepareForAssemblyLoadContextRelease(INT_PTR ptrNativeAssemblyBinder, INT_PTR ptrManagedStrongAssemblyLoadContext);
diff --git a/src/coreclr/vm/ecalllist.h b/src/coreclr/vm/ecalllist.h
@@ -94,6 +94,7 @@ FCFuncStart(gCOMTypeHandleFuncs)
     FCFuncElement("IsGenericVariable", RuntimeTypeHandle::IsGenericVariable)
     FCFuncElement("ContainsGenericVariables", RuntimeTypeHandle::ContainsGenericVariables)
     FCFuncElement("IsUnmanagedFunctionPointer", RuntimeTypeHandle::IsUnmanagedFunctionPointer)
+    FCFuncElement("IsCollectible", RuntimeTypeHandle::IsCollectible)
     FCFuncElement("CompareCanonicalHandles", RuntimeTypeHandle::CompareCanonicalHandles)
     FCFuncElement("InternalAllocNoChecks_FastPath", RuntimeTypeHandle::InternalAllocNoChecks_FastPath)
 FCFuncEnd()
@@ -134,6 +135,7 @@ FCFuncEnd()
 
 FCFuncStart(gRuntimeMethodHandle)
     FCFuncElement("GetImplAttributes", RuntimeMethodHandle::GetImplAttributes)
+    FCFuncElement("IsCollectible", RuntimeMethodHandle::IsCollectible)
     FCFuncElement("GetAttributes", RuntimeMethodHandle::GetAttributes)
     FCFuncElement("GetMethodTable", RuntimeMethodHandle::GetMethodTable)
     FCFuncElement("GetSlot", RuntimeMethodHandle::GetSlot)
@@ -166,6 +168,7 @@ FCFuncEnd()
 
 FCFuncStart(gRuntimeAssemblyFuncs)
     FCFuncElement("GetIsDynamic", AssemblyNative::GetIsDynamic)
+    FCFuncElement("GetIsCollectible", AssemblyNative::GetIsCollectible)
     FCFuncElement("GetManifestModule", AssemblyHandle::GetManifestModule)
     FCFuncElement("GetTokenInternal", AssemblyHandle::GetTokenInternal)
 FCFuncEnd()
diff --git a/src/coreclr/vm/method.cpp b/src/coreclr/vm/method.cpp
@@ -3856,9 +3856,15 @@ MethodDesc *MethodDesc::GetInterfaceMD()
 }
 #endif // !DACCESS_COMPILE
 
+bool MethodDesc::IsCollectible()
+{
+    LIMITED_METHOD_DAC_CONTRACT;
+    return HasMethodInstantiation() ? GetLoaderAllocator()->IsCollectible() : GetMethodTable()->Collectible();
+}
+
 PTR_LoaderAllocator MethodDesc::GetLoaderAllocator()
 {
-    WRAPPER_NO_CONTRACT;
+    LIMITED_METHOD_DAC_CONTRACT;
     return GetLoaderModule()->GetLoaderAllocator();
 }
 
diff --git a/src/coreclr/vm/method.hpp b/src/coreclr/vm/method.hpp
@@ -595,6 +595,8 @@ class MethodDesc
 
     MethodDescBackpatchInfoTracker* GetBackpatchInfoTracker();
 
+    bool IsCollectible();
+
     PTR_LoaderAllocator GetLoaderAllocator();
 
     Module* GetLoaderModule();
diff --git a/src/coreclr/vm/qcallentrypoints.cpp b/src/coreclr/vm/qcallentrypoints.cpp
@@ -122,7 +122,6 @@ static const Entry s_QCall[] =
     DllImportEntry(RuntimeTypeHandle_MakeByRef)
     DllImportEntry(RuntimeTypeHandle_MakeSZArray)
     DllImportEntry(RuntimeTypeHandle_MakeArray)
-    DllImportEntry(RuntimeTypeHandle_IsCollectible)
     DllImportEntry(RuntimeTypeHandle_GetConstraints)
     DllImportEntry(RuntimeTypeHandle_GetArgumentTypesFromFunctionPointer)
     DllImportEntry(RuntimeTypeHandle_GetAssemblySlow)
@@ -159,7 +158,6 @@ static const Entry s_QCall[] =
     DllImportEntry(RuntimeMethodHandle_InvokeMethod)
     DllImportEntry(RuntimeMethodHandle_ConstructInstantiation)
     DllImportEntry(RuntimeMethodHandle_GetFunctionPointer)
-    DllImportEntry(RuntimeMethodHandle_GetIsCollectible)
     DllImportEntry(RuntimeMethodHandle_GetMethodInstantiation)
     DllImportEntry(RuntimeMethodHandle_GetTypicalMethodDefinition)
     DllImportEntry(RuntimeMethodHandle_StripMethodInstantiation)
@@ -249,7 +247,6 @@ static const Entry s_QCall[] =
     DllImportEntry(AssemblyNative_GetExportedTypes)
     DllImportEntry(AssemblyNative_GetEntryPoint)
     DllImportEntry(AssemblyNative_GetImageRuntimeVersion)
-    DllImportEntry(AssemblyNative_GetIsCollectible)
     DllImportEntry(AssemblyNative_InternalTryGetRawMetadata)
     DllImportEntry(AssemblyNative_ApplyUpdate)
     DllImportEntry(AssemblyNative_IsApplyUpdateSupported)
diff --git a/src/coreclr/vm/runtimehandles.cpp b/src/coreclr/vm/runtimehandles.cpp
@@ -1092,18 +1092,14 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan
     return;
 }
 
-extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsCollectible(QCall::TypeHandle pTypeHandle)
+FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsCollectible, PTR_ReflectClassBaseObject pTypeUNSAFE)
 {
-    QCALL_CONTRACT;
-
-    BOOL retVal = FALSE;
-
-    BEGIN_QCALL;
-    retVal = pTypeHandle.AsTypeHandle().GetLoaderAllocator()->IsCollectible();
-    END_QCALL;
+    FCALL_CONTRACT;
 
-    return retVal;
+    REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(pTypeUNSAFE);
+    FC_RETURN_BOOL(refType->GetType().IsCollectible());
 }
+FCIMPLEND
 
 extern "C" void QCALLTYPE RuntimeTypeHandle_Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType)
 {
@@ -1292,21 +1288,6 @@ extern "C" void * QCALLTYPE RuntimeMethodHandle_GetFunctionPointer(MethodDesc *
     return funcPtr;
 }
 
-extern "C" BOOL QCALLTYPE RuntimeMethodHandle_GetIsCollectible(MethodDesc* pMethod)
-{
-    QCALL_CONTRACT;
-
-    BOOL isCollectible = FALSE;
-
-    BEGIN_QCALL;
-
-    isCollectible = pMethod->GetLoaderAllocator()->IsCollectible();
-
-    END_QCALL;
-
-    return isCollectible;
-}
-
 FCIMPL1(LPCUTF8, RuntimeMethodHandle::GetUtf8Name, MethodDesc* pMethod)
 {
     CONTRACTL
@@ -1320,6 +1301,14 @@ FCIMPL1(LPCUTF8, RuntimeMethodHandle::GetUtf8Name, MethodDesc* pMethod)
 }
 FCIMPLEND
 
+FCIMPL1(FC_BOOL_RET, RuntimeMethodHandle::IsCollectible, MethodDesc *pMethod)
+{
+    FCALL_CONTRACT;
+    _ASSERTE(pMethod != NULL);
+    FC_RETURN_BOOL(pMethod->IsCollectible());
+}
+FCIMPLEND
+
 FCIMPL1(INT32, RuntimeMethodHandle::GetAttributes, MethodDesc *pMethod)
 {
     FCALL_CONTRACT;
diff --git a/src/coreclr/vm/runtimehandles.h b/src/coreclr/vm/runtimehandles.h
@@ -113,6 +113,9 @@ class RuntimeTypeHandle
 
     static FCDECL1(FC_BOOL_RET, IsUnmanagedFunctionPointer, ReflectClassBaseObject *pTypeUNSAFE);
 
+    static
+    FCDECL1(FC_BOOL_RET, IsCollectible, PTR_ReflectClassBaseObject pType);
+
     static
     FCDECL1(FC_BOOL_RET, IsGenericVariable, PTR_ReflectClassBaseObject pType);
 
@@ -159,7 +162,6 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan
 extern "C" void QCALLTYPE RuntimeTypeHandle_MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 extern "C" void QCALLTYPE RuntimeTypeHandle_MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
 extern "C" void QCALLTYPE RuntimeTypeHandle_MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType);
-extern "C" BOOL QCALLTYPE RuntimeTypeHandle_IsCollectible(QCall::TypeHandle pTypeHandle);
 extern "C" void QCALLTYPE RuntimeTypeHandle_PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache);
 extern "C" void QCALLTYPE RuntimeTypeHandle_ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString);
 extern "C" void QCALLTYPE RuntimeTypeHandle_GetInterfaces(MethodTable* pMT, QCall::ObjectHandleOnStack result);
@@ -185,6 +187,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QC
 class RuntimeMethodHandle
 {
 public:
+    static FCDECL1(FC_BOOL_RET, IsCollectible, MethodDesc *pMethod);
     static FCDECL1(INT32, GetAttributes, MethodDesc *pMethod);
     static FCDECL1(INT32, GetImplAttributes, ReflectMethodObject *pMethodUNSAFE);
     static FCDECL1(MethodTable*, GetMethodTable, MethodDesc *pMethod);
diff --git a/src/coreclr/vm/typehandle.cpp b/src/coreclr/vm/typehandle.cpp
@@ -256,10 +256,7 @@ PTR_Module TypeHandle::GetLoaderModule() const
 
 PTR_LoaderAllocator TypeHandle::GetLoaderAllocator() const
 {
-    STATIC_CONTRACT_NOTHROW;
-    STATIC_CONTRACT_GC_NOTRIGGER;
-    STATIC_CONTRACT_FORBID_FAULT;
-    STATIC_CONTRACT_SUPPORTS_DAC;
+    LIMITED_METHOD_DAC_CONTRACT;
 
     if (IsTypeDesc())
     {
@@ -271,6 +268,20 @@ PTR_LoaderAllocator TypeHandle::GetLoaderAllocator() const
     }
 }
 
+bool TypeHandle::IsCollectible() const
+{
+    LIMITED_METHOD_DAC_CONTRACT;
+
+    if (IsTypeDesc())
+    {
+        return AsTypeDesc()->GetLoaderAllocator()->IsCollectible();
+    }
+    else
+    {
+        return AsMethodTable()->Collectible();
+    }
+}
+
 BOOL TypeHandle::IsSharedByGenericInstantiations() const
 {
     LIMITED_METHOD_DAC_CONTRACT;
diff --git a/src/coreclr/vm/typehandle.h b/src/coreclr/vm/typehandle.h
@@ -414,6 +414,8 @@ class TypeHandle
 
     PTR_LoaderAllocator GetLoaderAllocator() const;
 
+    bool IsCollectible() const;
+
     // Get the class token, assuming the type handle represents a named type,
     // i.e. a class, a value type, a generic instantiation etc.
     inline mdTypeDef GetCl() const;

Original file line number	Diff line number	Diff line change
`@@ -252,15 +252,16 @@ public override IEnumerable<TypeInfo> DefinedTypes`
`252`	`252`	`get => GetManifestModule().GetDefinedTypes();`
`253`	`253`	`}`
`254`	`254`
`255`		`- [LibraryImport(RuntimeHelpers.QCall, EntryPoint = "AssemblyNative_GetIsCollectible")]`
`256`		`- internal static partial Interop.BOOL GetIsCollectible(QCallAssembly assembly);`
	`255`	`+ [MethodImpl(MethodImplOptions.InternalCall)]`
	`256`	`+ private static extern bool GetIsCollectible(IntPtr assembly);`
`257`	`257`
`258`	`258`	`public override bool IsCollectible`
`259`	`259`	`{`
`260`	`260`	`get`
`261`	`261`	`{`
`262`		`- RuntimeAssembly runtimeAssembly = this;`
`263`		`- return GetIsCollectible(new QCallAssembly(ref runtimeAssembly)) != Interop.BOOL.FALSE;`
	`262`	`+ bool isCollectible = GetIsCollectible(GetUnderlyingNativeHandle());`
	`263`	`+ GC.KeepAlive(this); // We directly pass the native handle above - make sure this object stays alive for the call`
	`264`	`+ return isCollectible;`
`264`	`265`	`}`
`265`	`266`	`}`
`266`	`267`
Original file line number	Diff line number	Diff line change
`@@ -3856,9 +3856,15 @@ MethodDesc *MethodDesc::GetInterfaceMD()`
`3856`	`3856`	`}`
`3857`	`3857`	`#endif // !DACCESS_COMPILE`
`3858`	`3858`
	`3859`	`+bool MethodDesc::IsCollectible()`
	`3860`	`+{`
	`3861`	`+ LIMITED_METHOD_DAC_CONTRACT;`
	`3862`	`+ return HasMethodInstantiation() ? GetLoaderAllocator()->IsCollectible() : GetMethodTable()->Collectible();`
	`3863`	`+}`
	`3864`	`+`
`3859`	`3865`	`PTR_LoaderAllocator MethodDesc::GetLoaderAllocator()`
`3860`	`3866`	`{`
`3861`		`- WRAPPER_NO_CONTRACT;`
	`3867`	`+ LIMITED_METHOD_DAC_CONTRACT;`
`3862`	`3868`	`return GetLoaderModule()->GetLoaderAllocator();`
`3863`	`3869`	`}`
`3864`	`3870`