Allocate Type objects on Frozen Heap

src/coreclr/inc/corinfo.h

@@ -2475,6 +2475,10 @@ class ICorStaticInfo
             CORINFO_CLASS_HANDLE        cls
             ) = 0;
 
+    virtual void* getRuntimeTypePointer(
+            CORINFO_CLASS_HANDLE        cls
+            ) = 0;
+
     virtual bool getReadyToRunHelper(
             CORINFO_RESOLVED_TOKEN *        pResolvedToken,
             CORINFO_LOOKUP_KIND *           pGenericLookupKind,

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -280,6 +280,9 @@ CorInfoHelpFunc getBoxHelper(
 CorInfoHelpFunc getUnBoxHelper(
           CORINFO_CLASS_HANDLE cls) override;
 
+void* getRuntimeTypePointer(
+          CORINFO_CLASS_HANDLE cls) override;
+
 bool getReadyToRunHelper(
           CORINFO_RESOLVED_TOKEN* pResolvedToken,
           CORINFO_LOOKUP_KIND* pGenericLookupKind,

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* 0cd8b9d4-04f4-45a7-b16b-7f24b7c0a454 */
-    0x0cd8b9d4,
-    0x04f4,
-    0x45a7,
-    {0xb1, 0x6b, 0x7f, 0x24, 0xb7, 0xc0, 0xa4, 0x54}
+constexpr GUID JITEEVersionIdentifier = { /* 104b5beb-d585-4d52-b08a-d5c6938603fc */
+    0x104b5beb,
+    0xd585,
+    0x4d52,
+    {0xb0, 0x8a, 0xd5, 0xc6, 0x93, 0x86, 0x3, 0xfc}
   };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_API_names.h

@@ -70,6 +70,7 @@ DEF_CLR_API(getSharedCCtorHelper)
 DEF_CLR_API(getTypeForBox)
 DEF_CLR_API(getBoxHelper)
 DEF_CLR_API(getUnBoxHelper)
+DEF_CLR_API(getRuntimeTypePointer)
 DEF_CLR_API(getReadyToRunHelper)
 DEF_CLR_API(getReadyToRunDelegateCtorHelper)
 DEF_CLR_API(getHelperName)

src/coreclr/jit/ICorJitInfo_API_wrapper.hpp

@@ -652,6 +652,15 @@ CorInfoHelpFunc WrapICorJitInfo::getUnBoxHelper(
     return temp;
 }
 
+void* WrapICorJitInfo::getRuntimeTypePointer(
+          CORINFO_CLASS_HANDLE cls)
+{
+    API_ENTER(getRuntimeTypePointer);
+    void* temp = wrapHnd->getRuntimeTypePointer(cls);
+    API_LEAVE(getRuntimeTypePointer);
+    return temp;
+}
+
 bool WrapICorJitInfo::getReadyToRunHelper(
           CORINFO_RESOLVED_TOKEN* pResolvedToken,
           CORINFO_LOOKUP_KIND* pGenericLookupKind,

src/coreclr/jit/importer.cpp

@@ -4046,7 +4046,22 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                     op1 = impPopStack().val;
                     // Replace helper with a more specialized helper that returns RuntimeType
                     if (typeHandleHelper == CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPEHANDLE)
-                    {
+                    { 
+                        CORINFO_CLASS_HANDLE hClass =
+                            gtGetHelperArgClassHandle(op1->AsCall()->gtArgs.GetArgByIndex(0)->GetEarlyNode());
+                        if (!opts.IsReadyToRun() && (hClass != NO_CLASS_HANDLE))
+                        {
+                            void* ptr = info.compCompHnd->getRuntimeTypePointer(hClass);
+                            if (ptr != nullptr)
+                            {
+                                // Temp Hack: pretend we're a string literal :-)
+                                setMethodHasFrozenString();
+                                retNode = gtNewIconEmbHndNode(ptr, nullptr, GTF_ICON_STR_HDL, nullptr);
+                                retNode->gtType = TYP_REF;
+                                INDEBUG(retNode->AsIntCon()->gtTargetHandle = (size_t)ptr);
+                                break;
+                            }
+                        }
                         typeHandleHelper = CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE;
                     }
                     else

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -2304,6 +2304,13 @@ private CorInfoHelpFunc getUnBoxHelper(CORINFO_CLASS_STRUCT_* cls)
             return type.IsNullable ? CorInfoHelpFunc.CORINFO_HELP_UNBOX_NULLABLE : CorInfoHelpFunc.CORINFO_HELP_UNBOX;
         }
 
+#pragma warning disable CA1822 // Mark members as static
+        private void* getRuntimeTypePointer(CORINFO_CLASS_STRUCT_* cls)
+#pragma warning restore CA1822 // Mark members as static
+        {
+            return (void*)IntPtr.Zero;
+        }
+
         private byte* getHelperName(CorInfoHelpFunc helpFunc)
         {
             return (byte*)GetPin(StringToUTF8(helpFunc.ToString()));

src/coreclr/tools/Common/JitInterface/ThunkGenerator/ThunkInput.txt

@@ -221,6 +221,7 @@ FUNCTIONS
     CORINFO_CLASS_HANDLE getTypeForBox(CORINFO_CLASS_HANDLE cls)
     CorInfoHelpFunc getBoxHelper(CORINFO_CLASS_HANDLE cls)
     CorInfoHelpFunc getUnBoxHelper(CORINFO_CLASS_HANDLE cls)
+    void* getRuntimeTypePointer(CORINFO_CLASS_HANDLE cls)
     bool getReadyToRunHelper(CORINFO_RESOLVED_TOKEN * pResolvedToken, CORINFO_LOOKUP_KIND * pGenericLookupKind, CorInfoHelpFunc id, CORINFO_CONST_LOOKUP *pLookup)
     void getReadyToRunDelegateCtorHelper(CORINFO_RESOLVED_TOKEN * pTargetMethod, mdToken targetConstraint, CORINFO_CLASS_HANDLE delegateType, CORINFO_LOOKUP *pLookup)
     const char* getHelperName(CorInfoHelpFunc helpFunc)

src/coreclr/tools/aot/jitinterface/jitinterface.h

@@ -77,6 +77,7 @@ struct JitInterfaceCallbacks
     CORINFO_CLASS_HANDLE (* getTypeForBox)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls);
     CorInfoHelpFunc (* getBoxHelper)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls);
     CorInfoHelpFunc (* getUnBoxHelper)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls);
+    void* (* getRuntimeTypePointer)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_CLASS_HANDLE cls);
     bool (* getReadyToRunHelper)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_LOOKUP_KIND* pGenericLookupKind, CorInfoHelpFunc id, CORINFO_CONST_LOOKUP* pLookup);
     void (* getReadyToRunDelegateCtorHelper)(void * thisHandle, CorInfoExceptionClass** ppException, CORINFO_RESOLVED_TOKEN* pTargetMethod, unsigned int targetConstraint, CORINFO_CLASS_HANDLE delegateType, CORINFO_LOOKUP* pLookup);
     const char* (* getHelperName)(void * thisHandle, CorInfoExceptionClass** ppException, CorInfoHelpFunc helpFunc);
@@ -841,6 +842,15 @@ class JitInterfaceWrapper : public ICorJitInfo
     return temp;
 }
 
+    virtual void* getRuntimeTypePointer(
+          CORINFO_CLASS_HANDLE cls)
+{
+    CorInfoExceptionClass* pException = nullptr;
+    void* temp = _callbacks->getRuntimeTypePointer(_thisHandle, &pException, cls);
+    if (pException != nullptr) throw pException;
+    return temp;
+}
+
     virtual bool getReadyToRunHelper(
           CORINFO_RESOLVED_TOKEN* pResolvedToken,
           CORINFO_LOOKUP_KIND* pGenericLookupKind,

src/coreclr/tools/superpmi/superpmi-shared/lwmlist.h

@@ -138,6 +138,7 @@ LWM(GetTypeForPrimitiveValueClass, DWORDLONG, DWORD)
 LWM(GetTypeForPrimitiveNumericClass, DWORDLONG, DWORD)
 LWM(GetUnboxedEntry, DWORDLONG, DLD);
 LWM(GetUnBoxHelper, DWORDLONG, DWORD)
+LWM(GetRuntimeTypePointer, DWORDLONG, DWORDLONG)
 LWM(GetVarArgsHandle, GetVarArgsHandleValue, DLDL)
 LWM(GetVars, DWORDLONG, Agnostic_GetVars)
 LWM(InitClass, Agnostic_InitClass, DWORD)

src/coreclr/tools/superpmi/superpmi-shared/methodcontext.cpp

@@ -2186,6 +2186,29 @@ CorInfoHelpFunc MethodContext::repGetUnBoxHelper(CORINFO_CLASS_HANDLE cls)
     return result;
 }
 
+void MethodContext::recGetRuntimeTypePointer(CORINFO_CLASS_HANDLE cls, void* result)
+{
+    if (GetRuntimeTypePointer == nullptr)
+        GetRuntimeTypePointer = new LightWeightMap<DWORDLONG, DWORDLONG>();
+
+    DWORDLONG key = CastHandle(cls);
+    DWORDLONG value = (DWORDLONG)result;
+    GetRuntimeTypePointer->Add(key, value);
+    DEBUG_REC(dmpGetRuntimeTypePointer(key, value));
+}
+void MethodContext::dmpGetRuntimeTypePointer(DWORDLONG key, DWORDLONG value)
+{
+    printf("GetRuntimeTypePointer key cls-%016llX, value res-%016llX", key, value);
+}
+void* MethodContext::repGetRuntimeTypePointer(CORINFO_CLASS_HANDLE cls)
+{
+    DWORDLONG key = CastHandle(cls);
+    AssertMapAndKeyExist(GetRuntimeTypePointer, key, ": key %016llX", key);
+    DWORDLONG value = GetRuntimeTypePointer->Get(key);
+    DEBUG_REP(dmpGetRuntimeTypePointer(key, value));
+    return (void*)value;
+}
+
 void MethodContext::recGetReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
                                            CORINFO_LOOKUP_KIND*    pGenericLookupKind,
                                            CorInfoHelpFunc         id,

src/coreclr/tools/superpmi/superpmi-shared/methodcontext.h

@@ -310,6 +310,10 @@ class MethodContext
     void dmpGetUnBoxHelper(DWORDLONG key, DWORD value);
     CorInfoHelpFunc repGetUnBoxHelper(CORINFO_CLASS_HANDLE cls);
 
+    void recGetRuntimeTypePointer(CORINFO_CLASS_HANDLE cls, void* result);
+    void dmpGetRuntimeTypePointer(DWORDLONG key, DWORDLONG value);
+    void* repGetRuntimeTypePointer(CORINFO_CLASS_HANDLE cls);
+
     void recGetReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
                                 CORINFO_LOOKUP_KIND*    pGenericLookupKind,
                                 CorInfoHelpFunc         id,
@@ -1129,6 +1133,7 @@ enum mcPackets
     Packet_UpdateEntryPointForTailCall = 193,
     Packet_GetLoongArch64PassStructInRegisterFlags = 194,
     Packet_GetExactClasses = 195,
+    Packet_GetRuntimeTypePointer = 196,
 };
 
 void SetDebugDumpVariables();

src/coreclr/tools/superpmi/superpmi-shim-collector/icorjitinfo.cpp

@@ -779,6 +779,14 @@ CorInfoHelpFunc interceptor_ICJI::getUnBoxHelper(CORINFO_CLASS_HANDLE cls)
     return temp;
 }
 
+void* interceptor_ICJI::getRuntimeTypePointer(CORINFO_CLASS_HANDLE cls)
+{
+    mc->cr->AddCall("getRuntimeTypePointer");
+    void* temp = original_ICorJitInfo->getRuntimeTypePointer(cls);
+    mc->recGetRuntimeTypePointer(cls, temp);
+    return temp;
+}
+
 bool interceptor_ICJI::getReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
                                            CORINFO_LOOKUP_KIND*    pGenericLookupKind,
                                            CorInfoHelpFunc         id,

src/coreclr/tools/superpmi/superpmi-shim-counter/icorjitinfo.cpp

@@ -535,6 +535,13 @@ CorInfoHelpFunc interceptor_ICJI::getUnBoxHelper(
     return original_ICorJitInfo->getUnBoxHelper(cls);
 }
 
+void* interceptor_ICJI::getRuntimeTypePointer(
+          CORINFO_CLASS_HANDLE cls)
+{
+    mcs->AddCall("getRuntimeTypePointer");
+    return original_ICorJitInfo->getRuntimeTypePointer(cls);
+}
+
 bool interceptor_ICJI::getReadyToRunHelper(
           CORINFO_RESOLVED_TOKEN* pResolvedToken,
           CORINFO_LOOKUP_KIND* pGenericLookupKind,

src/coreclr/tools/superpmi/superpmi-shim-simple/icorjitinfo.cpp

@@ -469,6 +469,12 @@ CorInfoHelpFunc interceptor_ICJI::getUnBoxHelper(
     return original_ICorJitInfo->getUnBoxHelper(cls);
 }
 
+void* interceptor_ICJI::getRuntimeTypePointer(
+          CORINFO_CLASS_HANDLE cls)
+{
+    return original_ICorJitInfo->getRuntimeTypePointer(cls);
+}
+
 bool interceptor_ICJI::getReadyToRunHelper(
           CORINFO_RESOLVED_TOKEN* pResolvedToken,
           CORINFO_LOOKUP_KIND* pGenericLookupKind,

src/coreclr/tools/superpmi/superpmi/icorjitinfo.cpp

@@ -663,6 +663,13 @@ CorInfoHelpFunc MyICJI::getUnBoxHelper(CORINFO_CLASS_HANDLE cls)
     return result;
 }
 
+void* MyICJI::getRuntimeTypePointer(CORINFO_CLASS_HANDLE cls)
+{
+    jitInstance->mc->cr->AddCall("getRuntimeTypePointer");
+    void* result = jitInstance->mc->repGetRuntimeTypePointer(cls);
+    return result;
+}
+
 bool MyICJI::getReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
                                  CORINFO_LOOKUP_KIND*    pGenericLookupKind,
                                  CorInfoHelpFunc         id,

src/coreclr/vm/frozenobjectheap.cpp

@@ -85,6 +85,15 @@ Object* FrozenObjectHeapManager::TryAllocateObject(PTR_MethodTable type, size_t
 #endif // !FEATURE_BASICFREEZE
 }
 
+// Does object belong to a frozen segment?
+bool FrozenObjectHeapManager::IsFromFrozenSegment(Object* object)
+{
+#ifdef FEATURE_BASICFREEZE
+    return GCHeapUtilities::GetGCHeap()->IsInFrozenSegment(object);
+#else
+    return false;
+#endif
+}
 
 FrozenObjectSegment::FrozenObjectSegment():
     m_pStart(nullptr),

src/coreclr/vm/frozenobjectheap.h

@@ -28,6 +28,7 @@ class FrozenObjectHeapManager
 public:
     FrozenObjectHeapManager();
     Object* TryAllocateObject(PTR_MethodTable type, size_t objectSize);
+    bool IsFromFrozenSegment(Object* object);
 
 private:
     Crst m_Crst;

src/coreclr/vm/jitinterface.cpp

@@ -5945,6 +5945,38 @@ CorInfoHelpFunc CEEInfo::getUnBoxHelper(CORINFO_CLASS_HANDLE clsHnd)
     return CORINFO_HELP_UNBOX;
 }
 
+/***********************************************************************/
+void* CEEInfo::getRuntimeTypePointer(CORINFO_CLASS_HANDLE clsHnd)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    void* pointer = nullptr;
+
+    JIT_TO_EE_TRANSITION();
+
+    GCX_COOP();
+
+    TypeHandle typeHnd(clsHnd);
+    if (!typeHnd.IsNull() && !typeHnd.IsTypeDesc() && typeHnd.IsFullyLoaded())
+    {
+        MethodTable* pMT = typeHnd.AsMethodTable();
+        if (!typeHnd.IsCanonicalSubtype())
+        {
+            // We probably don't want to allocate a RuntimeHelper as part of this query
+            // hence, use IfExists
+            bool isPinned;
+            Object* obj = OBJECTREFToObject(pMT->GetManagedClassObjectIfExists(&isPinned));
+            if (obj != nullptr && isPinned)
+            {
+                pointer = (void*)obj;
+            }
+        }
+    }
+    EE_TO_JIT_TRANSITION();
+
+    return pointer;
+}
+
 /***********************************************************************/
 bool CEEInfo::getReadyToRunHelper(
         CORINFO_RESOLVED_TOKEN *        pResolvedToken,

src/coreclr/vm/methodtable.cpp

@@ -4222,9 +4222,20 @@ OBJECTREF MethodTable::GetManagedClassObject()
 
         REFLECTCLASSBASEREF  refClass = NULL;
         GCPROTECT_BEGIN(refClass);
-        refClass = (REFLECTCLASSBASEREF) AllocateObject(g_pRuntimeTypeClass);
 
-        LoaderAllocator *pLoaderAllocator = GetLoaderAllocator();
+        LoaderAllocator* pLoaderAllocator = GetLoaderAllocator();
+        if (!pLoaderAllocator->CanUnload())
+        {
+            // Allocate RuntimeType on a frozen segment
+            FrozenObjectHeapManager* foh = SystemDomain::GetFrozenObjectHeapManager();
+            size_t objSize = g_pRuntimeTypeClass->GetBaseSize();
+            refClass = ObjectToOBJECTREF(foh->TryAllocateObject(g_pRuntimeTypeClass, objSize));
+        }
+
+        if (refClass == NULL)
+        {
+            refClass = (REFLECTCLASSBASEREF)AllocateObject(g_pRuntimeTypeClass);
+        }
 
         ((ReflectClassBaseObject*)OBJECTREFToObject(refClass))->SetType(TypeHandle(this));
         ((ReflectClassBaseObject*)OBJECTREFToObject(refClass))->SetKeepAlive(pLoaderAllocator->GetExposedObject());

src/coreclr/vm/methodtable.h

@@ -2716,7 +2716,7 @@ class MethodTable
     //  method will get the class object.  If it doesn't exist it will be created.
     //  GetManagedClassObjectIfExists() will return null if the Type object doesn't exist.
     OBJECTREF GetManagedClassObject();
-    OBJECTREF GetManagedClassObjectIfExists();
+    OBJECTREF GetManagedClassObjectIfExists(bool* pIsPinned = nullptr);
 
 
     // ------------------------------------------------------------------

src/coreclr/vm/methodtable.inl

@@ -16,6 +16,7 @@
 #include "methodtable.h"
 #include "genericdict.h"
 #include "threadstatics.h"
+#include "frozenobjectheap.h"
 
 //==========================================================================================
 FORCEINLINE PTR_EEClass MethodTable::GetClass_NoLogging()
@@ -1335,7 +1336,7 @@ inline OBJECTHANDLE MethodTable::GetLoaderAllocatorObjectHandle()
 }
 
 //==========================================================================================
-FORCEINLINE OBJECTREF MethodTable::GetManagedClassObjectIfExists()
+FORCEINLINE OBJECTREF MethodTable::GetManagedClassObjectIfExists(bool* pIsPinned)
 {
     LIMITED_METHOD_CONTRACT;
 
@@ -1353,6 +1354,15 @@ FORCEINLINE OBJECTREF MethodTable::GetManagedClassObjectIfExists()
     }
 
     COMPILER_ASSUME(retVal != NULL);
+
+#ifndef DACCESS_COMPILE
+    if (pIsPinned != nullptr)
+    {
+        FrozenObjectHeapManager* foh = SystemDomain::GetFrozenObjectHeapManager();
+        *pIsPinned = foh->IsFromFrozenSegment(OBJECTREFToObject(retVal));
+    }
+#endif
+
     return retVal;
 }