Allocate RuntimeType objects on Frozen Object Heap

src/coreclr/inc/corinfo.h

@@ -1855,6 +1855,13 @@ struct CORINFO_String : public CORINFO_Object
     char16_t                chars[1];       // actually of variable size
 };
 
+struct CORINFO_RuntimeType : public CORINFO_Object
+{
+    void*                m_keepalive;
+    void*                m_cache;
+    CORINFO_CLASS_HANDLE m_handle;
+};
+
 struct CORINFO_Array : public CORINFO_Object
 {
     unsigned                length;
@@ -2475,6 +2482,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/assertionprop.cpp

@@ -2149,7 +2149,7 @@ void Compiler::optDebugCheckAssertion(AssertionDsc* assertion)
                     break;
                 case O1K_LCLVAR:
                     assert((lvaGetDesc(assertion->op1.lcl.lclNum)->lvType != TYP_REF) ||
-                           (assertion->op2.u1.iconVal == 0) || doesMethodHaveFrozenString());
+                           (assertion->op2.u1.iconVal == 0) || doesMethodHaveFrozenObjects());
                     break;
                 case O1K_VALUE_NUMBER:
                     assert((vnStore->TypeOfVN(assertion->op1.vn) != TYP_REF) || (assertion->op2.u1.iconVal == 0));

src/coreclr/jit/compiler.cpp

@@ -9426,6 +9426,11 @@ void cTreeFlags(Compiler* comp, GenTree* tree)
                         chars += printf("[ICON_STR_HDL]");
                         break;
 
+                    case GTF_ICON_OBJ_HDL:
+
+                        chars += printf("[ICON_OBJ_HDL]");
+                        break;
+
                     case GTF_ICON_CONST_PTR:
 
                         chars += printf("[ICON_CONST_PTR]");

src/coreclr/jit/compiler.h

@@ -3522,6 +3522,7 @@ class Compiler
     CORINFO_CLASS_HANDLE impGetRuntimeArgumentHandle();
     CORINFO_CLASS_HANDLE impGetTypeHandleClass();
     CORINFO_CLASS_HANDLE impGetStringClass();
+    CORINFO_CLASS_HANDLE impGetRuntimeTypeClass();
     CORINFO_CLASS_HANDLE impGetObjectClass();
 
     // Returns underlying type of handles returned by ldtoken instruction
@@ -6808,7 +6809,7 @@ class Compiler
 #define OMF_HAS_EXPRUNTIMELOOKUP               0x00000080 // Method contains a runtime lookup to an expandable dictionary.
 #define OMF_HAS_PATCHPOINT                     0x00000100 // Method contains patchpoints
 #define OMF_NEEDS_GCPOLLS                      0x00000200 // Method needs GC polls
-#define OMF_HAS_FROZEN_STRING                  0x00000400 // Method has a frozen string (REF constant int), currently only on NativeAOT.
+#define OMF_HAS_FROZEN_OBJECTS                 0x00000400 // Method has a frozen string (REF constant int), currently only on NativeAOT.
 #define OMF_HAS_PARTIAL_COMPILATION_PATCHPOINT 0x00000800 // Method contains partial compilation patchpoints
 #define OMF_HAS_TAILCALL_SUCCESSOR             0x00001000 // Method has potential tail call in a non BBJ_RETURN block
 #define OMF_HAS_MDNEWARRAY                     0x00002000 // Method contains 'new' of an MD array
@@ -6833,14 +6834,14 @@ class Compiler
 
     void addFatPointerCandidate(GenTreeCall* call);
 
-    bool doesMethodHaveFrozenString() const
+    bool doesMethodHaveFrozenObjects() const
     {
-        return (optMethodFlags & OMF_HAS_FROZEN_STRING) != 0;
+        return (optMethodFlags & OMF_HAS_FROZEN_OBJECTS) != 0;
     }
 
-    void setMethodHasFrozenString()
+    void setMethodHasFrozenObjects()
     {
-        optMethodFlags |= OMF_HAS_FROZEN_STRING;
+        optMethodFlags |= OMF_HAS_FROZEN_OBJECTS;
     }
 
     bool doesMethodHaveGuardedDevirtualization() const
@@ -7800,7 +7801,7 @@ class Compiler
     const char* eeGetFieldName(CORINFO_FIELD_HANDLE fieldHnd, const char** classNamePtr = nullptr);
 
 #if defined(DEBUG)
-    const WCHAR* eeGetCPString(size_t stringHandle);
+    void eePrintFrozenObjectDescription(const char* prefix, size_t handle);
     unsigned eeTryGetClassSize(CORINFO_CLASS_HANDLE clsHnd);
     const char16_t* eeGetShortClassName(CORINFO_CLASS_HANDLE clsHnd);
 #endif

src/coreclr/jit/ee_il_dll.cpp

@@ -1615,45 +1615,45 @@ const char16_t* Compiler::eeGetShortClassName(CORINFO_CLASS_HANDLE clsHnd)
     return param.classNameWidePtr;
 }
 
-const WCHAR* Compiler::eeGetCPString(size_t strHandle)
+void Compiler::eePrintFrozenObjectDescription(const char* prefix, size_t handle)
 {
-#ifdef HOST_UNIX
-    return nullptr;
-#else
-    char buff[512 + sizeof(CORINFO_String)];
-
-    // make this bulletproof, so it works even if we are wrong.
-    if (ReadProcessMemory(GetCurrentProcess(), (void*)strHandle, buff, 4, nullptr) == 0)
+    auto typeOfHandle = *((CORINFO_CLASS_HANDLE*)handle);
+    if (impGetStringClass() == typeOfHandle)
     {
-        return (nullptr);
-    }
+        auto asString = (CORINFO_String*)handle;
 
-    CORINFO_String* asString = nullptr;
-    if (impGetStringClass() == *((CORINFO_CLASS_HANDLE*)strHandle))
-    {
-        // strHandle is a frozen string
-        // We assume strHandle is never an "interior" pointer in a frozen string
-        // (jit is not expected to perform such foldings)
-        asString = (CORINFO_String*)strHandle;
-    }
-    else
-    {
-        // strHandle is a pinned handle to a string object
-        asString = *((CORINFO_String**)strHandle);
-    }
+        const size_t maxLength = 63;
+        const size_t newLen    = min(maxLength, asString->stringLen);
 
-    if (ReadProcessMemory(GetCurrentProcess(), asString, buff, sizeof(buff), nullptr) == 0)
+        // +1 for null terminator
+        WCHAR buf[maxLength + 1] = {0};
+        wcsncpy(buf, (WCHAR*)asString->chars, newLen);
+        for (size_t i = 0; i < newLen; i++)
+        {
+            // Escape \n and \r symbols
+            if (buf[i] == L'\n' || buf[i] == L'\r')
+            {
+                buf[i] = L' ';
+            }
+        }
+        if (asString->stringLen > maxLength)
+        {
+            // Append "..." for long strings
+            buf[maxLength - 3] = L'.';
+            buf[maxLength - 2] = L'.';
+            buf[maxLength - 1] = L'.';
+        }
+        printf("%s \"%S\"", prefix, buf);
+    }
+    else if (impGetRuntimeTypeClass() == typeOfHandle)
     {
-        return (nullptr);
+        auto asType = (CORINFO_RuntimeType*)handle;
+        printf("%s %s", prefix, eeGetClassName(asType->m_handle));
     }
-
-    if (asString->stringLen >= 255 || asString->chars[asString->stringLen] != 0)
+    else
     {
-        return nullptr;
+        printf("%s unknown frozen object handle", prefix);
     }
-
-    return (WCHAR*)(asString->chars);
-#endif // HOST_UNIX
 }
 #else  // DEBUG
 void jitprintf(const char* fmt, ...)

src/coreclr/jit/emit.cpp

@@ -4129,42 +4129,15 @@ void emitter::emitDispCommentForHandle(size_t handle, size_t cookie, GenTreeFlag
 
     const char* str = nullptr;
     if (flag == GTF_ICON_STR_HDL)
+    {
+        str = "string handle";
+    }
+    else if (flag == GTF_ICON_OBJ_HDL)
     {
 #ifdef DEBUG
-        const WCHAR* wstr = emitComp->eeGetCPString(handle);
-        // NOTE: eGetCPString always returns nullptr on Linux/ARM
-        if (wstr == nullptr)
-        {
-            str = "string handle";
-        }
-        else
-        {
-            const size_t actualLen = wcslen(wstr);
-            const size_t maxLength = 63;
-            const size_t newLen    = min(maxLength, actualLen);
-
-            // +1 for null terminator
-            WCHAR buf[maxLength + 1] = {0};
-            wcsncpy(buf, wstr, newLen);
-            for (size_t i = 0; i < newLen; i++)
-            {
-                // Escape \n and \r symbols
-                if (buf[i] == L'\n' || buf[i] == L'\r')
-                {
-                    buf[i] = L' ';
-                }
-            }
-            if (actualLen > maxLength)
-            {
-                // Append "..." for long strings
-                buf[maxLength - 3] = L'.';
-                buf[maxLength - 2] = L'.';
-                buf[maxLength - 1] = L'.';
-            }
-            printf("%s \"%S\"", commentPrefix, buf);
-        }
+        emitComp->eePrintFrozenObjectDescription(commentPrefix, handle);
 #else
-        str                   = "string handle";
+        str                   = "frozen object handle";
 #endif
     }
     else if (flag == GTF_ICON_CLASS_HDL)

src/coreclr/jit/emitxarch.cpp

@@ -8756,18 +8756,6 @@ void emitter::emitDispAddrMode(instrDesc* id, bool noDetail)
 
     printf("]");
 
-// pretty print string if it looks like one
-#ifdef DEBUG
-    if ((id->idGCref() == GCT_GCREF) && (id->idIns() == INS_mov) && (id->idAddr()->iiaAddrMode.amBaseReg == REG_NA))
-    {
-        const WCHAR* str = emitComp->eeGetCPString(disp);
-        if (str != nullptr)
-        {
-            printf("      '%S'", str);
-        }
-    }
-#endif
-
     if (jdsc && !noDetail)
     {
         unsigned     cnt = (jdsc->dsSize - 1) / TARGET_POINTER_SIZE;

src/coreclr/jit/gentree.cpp

@@ -6911,9 +6911,9 @@ GenTree* Compiler::gtNewIndOfIconHandleNode(var_types indType, size_t addr, GenT
         // This indirection also is invariant.
         indNode->gtFlags |= GTF_IND_INVARIANT;
 
-        if (iconFlags == GTF_ICON_STR_HDL)
+        if ((iconFlags == GTF_ICON_STR_HDL) || (iconFlags == GTF_ICON_OBJ_HDL))
         {
-            // String literals are never null
+            // String literals and frozen type objects are never null
             indNode->gtFlags |= GTF_IND_NONNULL;
         }
     }
@@ -6990,8 +6990,8 @@ GenTree* Compiler::gtNewStringLiteralNode(InfoAccessType iat, void* pValue)
     switch (iat)
     {
         case IAT_VALUE:
-            setMethodHasFrozenString();
-            tree         = gtNewIconEmbHndNode(pValue, nullptr, GTF_ICON_STR_HDL, nullptr);
+            setMethodHasFrozenObjects();
+            tree         = gtNewIconEmbHndNode(pValue, nullptr, GTF_ICON_OBJ_HDL, nullptr);
             tree->gtType = TYP_REF;
 #ifdef DEBUG
             tree->AsIntCon()->gtTargetHandle = (size_t)pValue;
@@ -11101,18 +11101,11 @@ void Compiler::gtDispConst(GenTree* tree)
         case GT_CNS_INT:
             if (tree->IsIconHandle(GTF_ICON_STR_HDL))
             {
-                const WCHAR* str = eeGetCPString(tree->AsIntCon()->gtIconVal);
-                // If *str points to a '\0' then don't print the string's values
-                if ((str != nullptr) && (*str != '\0'))
-                {
-                    printf(" 0x%X \"%S\"", dspPtr(tree->AsIntCon()->gtIconVal), str);
-                }
-                else // We can't print the value of the string
-                {
-                    // Note that eeGetCPString isn't currently implemented on Linux/ARM
-                    // and instead always returns nullptr
-                    printf(" 0x%X [ICON_STR_HDL]", dspPtr(tree->AsIntCon()->gtIconVal));
-                }
+                printf(" 0x%X [ICON_STR_HDL]", dspPtr(tree->AsIntCon()->gtIconVal));
+            }
+            else if (tree->IsIconHandle(GTF_ICON_OBJ_HDL))
+            {
+                eePrintFrozenObjectDescription(" ", tree->AsIntCon()->gtIconVal);
             }
             else
             {
@@ -11172,8 +11165,9 @@ void Compiler::gtDispConst(GenTree* tree)
                         case GTF_ICON_STATIC_HDL:
                             printf(" static");
                             break;
+                        case GTF_ICON_OBJ_HDL:
                         case GTF_ICON_STR_HDL:
-                            unreached(); // This case is handled above
+                            unreached(); // These cases are handled above
                             break;
                         case GTF_ICON_CONST_PTR:
                             printf(" const ptr");

src/coreclr/jit/gentree.h

@@ -554,7 +554,8 @@ enum GenTreeFlags : unsigned int
     GTF_ICON_METHOD_HDL         = 0x03000000, // GT_CNS_INT -- constant is a method handle
     GTF_ICON_FIELD_HDL          = 0x04000000, // GT_CNS_INT -- constant is a field handle
     GTF_ICON_STATIC_HDL         = 0x05000000, // GT_CNS_INT -- constant is a handle to static data
-    GTF_ICON_STR_HDL            = 0x06000000, // GT_CNS_INT -- constant is a string handle
+    GTF_ICON_STR_HDL            = 0x06000000, // GT_CNS_INT -- constant is a pinned handle pointing to a string object
+    GTF_ICON_OBJ_HDL            = 0x12000000, // GT_CNS_INT -- constant is an object handle (e.g. frozen string or Type object)
     GTF_ICON_CONST_PTR          = 0x07000000, // GT_CNS_INT -- constant is a pointer to immutable data, (e.g. IAT_PPVALUE)
     GTF_ICON_GLOBAL_PTR         = 0x08000000, // GT_CNS_INT -- constant is a pointer to mutable data (e.g. from the VM state)
     GTF_ICON_VARG_HDL           = 0x09000000, // GT_CNS_INT -- constant is a var arg cookie handle

src/coreclr/jit/importer.cpp

@@ -3034,6 +3034,13 @@ CORINFO_CLASS_HANDLE Compiler::impGetStringClass()
     return stringClass;
 }
 
+CORINFO_CLASS_HANDLE Compiler::impGetRuntimeTypeClass()
+{
+    CORINFO_CLASS_HANDLE stringClass = info.compCompHnd->getBuiltinClass(CLASSID_RUNTIME_TYPE);
+    assert(stringClass != (CORINFO_CLASS_HANDLE) nullptr);
+    return stringClass;
+}
+
 CORINFO_CLASS_HANDLE Compiler::impGetObjectClass()
 {
     CORINFO_CLASS_HANDLE objectClass = info.compCompHnd->getBuiltinClass(CLASSID_SYSTEM_OBJECT);
@@ -22944,9 +22951,9 @@ bool Compiler::impCanSkipCovariantStoreCheck(GenTree* value, GenTree* array)
             return true;
         }
         // Non-0 const refs can only occur with frozen objects
-        assert(value->IsIconHandle(GTF_ICON_STR_HDL));
-        assert(doesMethodHaveFrozenString() ||
-               (compIsForInlining() && impInlineInfo->InlinerCompiler->doesMethodHaveFrozenString()));
+        assert(value->IsIconHandle(GTF_ICON_OBJ_HDL));
+        assert(doesMethodHaveFrozenObjects() ||
+               (compIsForInlining() && impInlineInfo->InlinerCompiler->doesMethodHaveFrozenObjects()));
     }
 
     // Try and get a class handle for the array