Managed impl

Author: jkotas

src/coreclr/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.CoreCLR.cs

@@ -781,6 +781,7 @@ internal unsafe struct MethodTable
         private const uint enum_flag_HasTypeEquivalence = 0x02000000;
 #endif // FEATURE_TYPEEQUIVALENCE
         private const uint enum_flag_HasFinalizer = 0x00100000;
+        private const uint enum_flag_Collectible = 0x00200000;
         private const uint enum_flag_Category_Mask = 0x000F0000;
         private const uint enum_flag_Category_ValueType = 0x00040000;
         private const uint enum_flag_Category_Nullable = 0x00050000;
@@ -841,6 +842,8 @@ internal unsafe struct MethodTable
 
         public bool HasFinalizer => (Flags & enum_flag_HasFinalizer) != 0;
 
+        public bool IsCollectible => (Flags & enum_flag_Collectible) != 0;
+
         internal static bool AreSameType(MethodTable* mt1, MethodTable* mt2) => mt1 == mt2;
 
         public bool HasDefaultConstructor => (Flags & (enum_flag_HasComponentSize | enum_flag_HasDefaultCtor)) == enum_flag_HasDefaultCtor;
@@ -978,13 +981,23 @@ internal unsafe struct TypeDesc
         private uint _typeAndFlags;
         private nint _exposedClassObject;
 
+        private const uint enum_flag_IsCollectible = 0x00000100;
+
         public RuntimeType? ExposedClassObject
         {
             get
             {
                 return *(RuntimeType*)Unsafe.AsPointer(ref _exposedClassObject);
             }
         }
+
+        public bool IsCollectible
+        {
+            get
+            {
+                return (_typeAndFlags & enum_flag_IsCollectible) != 0;
+            }
+        }
     }
 
     [StructLayout(LayoutKind.Sequential)]

src/coreclr/System.Private.CoreLib/src/System/RuntimeHandles.cs

@@ -824,9 +824,6 @@ internal RuntimeType MakePointer()
             return type!;
         }
 
-        [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);
 

src/coreclr/System.Private.CoreLib/src/System/RuntimeType.CoreCLR.cs

@@ -3227,7 +3227,17 @@ public override MemberInfo GetMemberWithSameMetadataDefinitionAs(MemberInfo memb
 
         #region Identity
 
-        public sealed override bool IsCollectible => RuntimeTypeHandle.IsCollectible(this);
+        public sealed override unsafe bool IsCollectible
+        {
+            get
+            {
+                TypeHandle th = GetNativeTypeHandle();
+
+                bool isCollectible = th.IsTypeDesc ? th.AsTypeDesc()->IsCollectible : th.AsMethodTable()->IsCollectible;
+                GC.KeepAlive(this);
+                return isCollectible;
+            }
+        }
 
         public override MethodBase? DeclaringMethod
         {

src/coreclr/vm/dynamicmethod.cpp

@@ -129,7 +129,7 @@ void DynamicMethodTable::Destroy()
     // DynamicMethodTable yet (from the DynamicMethodTable::CreateDynamicMethodTable in case
     // there were two threads racing to construct the instance for the thread that lost
     // the race)
-    if (m_pMethodTable != NULL && !m_pMethodTable->GetLoaderAllocator()->IsCollectible())
+    if (m_pMethodTable != NULL && !m_pMethodTable->Collectible())
     {
         MethodTable::IntroducedMethodIterator it(m_pMethodTable);
         _ASSERTE(!it.IsValid());

src/coreclr/vm/ecalllist.h

@@ -94,7 +94,6 @@ 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()

src/coreclr/vm/method.cpp

@@ -3859,7 +3859,7 @@ MethodDesc *MethodDesc::GetInterfaceMD()
 bool MethodDesc::IsCollectible()
 {
     LIMITED_METHOD_DAC_CONTRACT;
-    return HasMethodInstantiation() ? GetLoaderAllocator()->IsCollectible() : GetMethodTable()->Collectible();
+    return GetLoaderAllocator()->IsCollectible();
 }
 
 PTR_LoaderAllocator MethodDesc::GetLoaderAllocator()

src/coreclr/vm/methodtable.cpp

@@ -3731,7 +3731,7 @@ void MethodTable::DoRunClassInitThrowing()
                         // subsequent attempts to run the .cctor.
                         pEntry->AddRef();
                         // For collectible types, register the entry for cleanup.
-                        if (GetLoaderAllocator()->IsCollectible())
+                        if (Collectible())
                         {
                             GetLoaderAllocator()->RegisterFailedTypeInitForCleanup(pEntry);
                         }

src/coreclr/vm/runtimehandles.cpp

@@ -1092,15 +1092,6 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_MakeByRef(QCall::TypeHandle pTypeHan
     return;
 }
 
-FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsCollectible, PTR_ReflectClassBaseObject pTypeUNSAFE)
-{
-    FCALL_CONTRACT;
-
-    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)
 {
     QCALL_CONTRACT;
@@ -1253,7 +1244,7 @@ extern "C" void QCALLTYPE RuntimeTypeHandle_RegisterCollectibleTypeDependency(QC
 
     if (pLoaderAllocator->IsCollectible())
     {
-        if ((pAssembly == NULL) || !pAssembly->GetLoaderAllocator()->IsCollectible())
+        if ((pAssembly == NULL) || !pAssembly->IsCollectible())
         {
             COMPlusThrow(kNotSupportedException, W("NotSupported_CollectibleBoundNonCollectible"));
         }

src/coreclr/vm/runtimehandles.h

@@ -113,9 +113,6 @@ 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);
 

src/coreclr/vm/typedesc.h

@@ -32,10 +32,10 @@ class TypeDesc
 {
 public:
 #ifndef DACCESS_COMPILE
-    TypeDesc(CorElementType type) {
+    TypeDesc(CorElementType type, bool isCollectible) {
         LIMITED_METHOD_CONTRACT;
 
-        _typeAndFlags = type;
+        _typeAndFlags = type | (isCollectible ? enum_flag_IsCollectible : 0);
     }
 #endif
 
@@ -112,14 +112,19 @@ class TypeDesc
     // Is actually ParamTypeDesc (BYREF, PTR)
     BOOL HasTypeParam();
 
+    bool IsCollectible() const
+    {
+        LIMITED_METHOD_CONTRACT;
+        return (_typeAndFlags & TypeDesc::enum_flag_IsCollectible) != 0;
+    }
 
-    BOOL HasTypeEquivalence() const
+    bool HasTypeEquivalence() const
     {
         LIMITED_METHOD_CONTRACT;
         return (_typeAndFlags & TypeDesc::enum_flag_HasTypeEquivalence) != 0;
     }
 
-    BOOL IsFullyLoaded() const
+    bool IsFullyLoaded() const
     {
         LIMITED_METHOD_CONTRACT;
 
@@ -186,7 +191,7 @@ class TypeDesc
     // See methodtable.h for details of the flags with the same name there
     enum
     {
-        // unused                        = 0x00000100,
+        enum_flag_IsCollectible          = 0x00000100,
         // unused                        = 0x00000200,
         // unused                        = 0x00000400,
         // unused                        = 0x00000800,
@@ -228,7 +233,7 @@ class ParamTypeDesc : public TypeDesc {
 public:
 #ifndef DACCESS_COMPILE
     ParamTypeDesc(CorElementType type, TypeHandle arg)
-        : TypeDesc(type), m_Arg(arg) {
+        : TypeDesc(type, arg.IsCollectible()), m_Arg(arg) {
 
         LIMITED_METHOD_CONTRACT;
 
@@ -291,7 +296,7 @@ class TypeVarTypeDesc : public TypeDesc
 #ifndef DACCESS_COMPILE
 
     TypeVarTypeDesc(PTR_Module pModule, mdToken typeOrMethodDef, unsigned int index, mdGenericParam token) :
-        TypeDesc(TypeFromToken(typeOrMethodDef) == mdtTypeDef ? ELEMENT_TYPE_VAR : ELEMENT_TYPE_MVAR)
+        TypeDesc(TypeFromToken(typeOrMethodDef) == mdtTypeDef ? ELEMENT_TYPE_VAR : ELEMENT_TYPE_MVAR, pModule->IsCollectible())
     {
         CONTRACTL
         {
@@ -416,7 +421,7 @@ class FnPtrTypeDesc : public TypeDesc
 public:
 #ifndef DACCESS_COMPILE
     FnPtrTypeDesc(BYTE callConv, DWORD numArgs, TypeHandle * retAndArgTypes, PTR_Module pLoaderModule)
-        : TypeDesc(ELEMENT_TYPE_FNPTR), m_pLoaderModule(pLoaderModule), m_NumArgs(numArgs), m_CallConv(callConv)
+        : TypeDesc(ELEMENT_TYPE_FNPTR, pLoaderModule->IsCollectible()), m_pLoaderModule(pLoaderModule), m_NumArgs(numArgs), m_CallConv(callConv)
     {
         LIMITED_METHOD_CONTRACT;
         for (DWORD i = 0; i <= numArgs; i++)