Address some of the feedback [WIP]

src/coreclr/inc/clrconfigvalues.h

@@ -405,11 +405,6 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_CodeHeapReserveForJumpStubs, W("CodeHeapReserv
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_NGenReserveForJumpStubs, W("NGenReserveForJumpStubs"), 0, "Percentage of ngen image size to reserve for jump stubs")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_BreakOnOutOfMemoryWithinRange, W("BreakOnOutOfMemoryWithinRange"), 0, "Break before out of memory within range exception is thrown")
 
-///
-/// Frozen segments (aka Frozen Object Heap)
-///
-RETAIL_CONFIG_DWORD_INFO(INTERNAL_UseFrozenObjectHeap, W("UseFrozenObjectHeap"), 1, "Use frozen object heap for certain types of objects (e.g. string literals) as an optimization.")
-
 ///
 /// Log
 ///

src/coreclr/jit/assertionprop.cpp

@@ -3423,7 +3423,7 @@ GenTree* Compiler::optConstantAssertionProp(AssertionDsc*        curAssertion,
 
                 // Make sure we don't retype const gc handles to TYP_I_IMPL
                 // Although, it's possible for e.g. GTF_ICON_STATIC_HDL
-                if (!newTree->IsIntegralConst(0) && newTree->IsIconHandle(GTF_ICON_STR_HDL))
+                if (!newTree->IsIntegralConst(0) && newTree->IsIconHandle(GTF_ICON_OBJ_HDL))
                 {
                     if (tree->TypeIs(TYP_BYREF))
                     {

src/coreclr/jit/gentree.cpp

@@ -11120,7 +11120,7 @@ void Compiler::gtDispConst(GenTree* tree)
                     }
                     else
                     {
-                        assert(doesMethodHaveFrozenString());
+                        assert(doesMethodHaveFrozenObjects());
                         printf(" 0x%llx", dspIconVal);
                     }
                 }

src/coreclr/jit/valuenum.cpp

@@ -8163,7 +8163,7 @@ void Compiler::fgValueNumberTreeConst(GenTree* tree)
             }
             else
             {
-                assert(doesMethodHaveFrozenString()); // Constant object can be only frozen string.
+                assert(doesMethodHaveFrozenObjects());
                 tree->gtVNPair.SetBoth(
                     vnStore->VNForHandle(ssize_t(tree->AsIntConCommon()->IconValue()), tree->GetIconHandleFlag()));
             }

src/coreclr/vm/frozenobjectheap.cpp

@@ -11,15 +11,12 @@
 
 FrozenObjectHeapManager::FrozenObjectHeapManager():
     m_Crst(CrstFrozenObjectHeap, CRST_UNSAFE_COOPGC),
-    m_CurrentSegment(nullptr),
-    m_Enabled(CLRConfig::GetConfigValue(CLRConfig::INTERNAL_UseFrozenObjectHeap) != 0)
+    m_CurrentSegment(nullptr)
 {
 }
 
 // Allocates an object of the give size (including header) on a frozen segment.
-// May return nullptr in the following cases:
-//   1) DOTNET_UseFrozenObjectHeap is 0 (disabled)
-//   2) Object is too large (large than FOH_COMMIT_SIZE)
+// May return nullptr if object is too large (larger than FOH_COMMIT_SIZE)
 // in such cases caller is responsible to find a more appropriate heap to allocate it
 Object* FrozenObjectHeapManager::TryAllocateObject(PTR_MethodTable type, size_t objectSize)
 {
@@ -37,12 +34,6 @@ Object* FrozenObjectHeapManager::TryAllocateObject(PTR_MethodTable type, size_t
 
     CrstHolder ch(&m_Crst);
 
-    if (!m_Enabled)
-    {
-        // Disabled via DOTNET_UseFrozenObjectHeap=0
-        return nullptr;
-    }
-
     _ASSERT(type != nullptr);
     _ASSERT(FOH_COMMIT_SIZE >= MIN_OBJECT_SIZE);
     _ASSERT(FOH_SEGMENT_SIZE > FOH_COMMIT_SIZE);
@@ -85,16 +76,6 @@ 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),
     m_pCurrent(nullptr),

src/coreclr/vm/frozenobjectheap.h

@@ -28,13 +28,11 @@ class FrozenObjectHeapManager
 public:
     FrozenObjectHeapManager();
     Object* TryAllocateObject(PTR_MethodTable type, size_t objectSize);
-    bool IsFromFrozenSegment(Object* object);
 
 private:
     Crst m_Crst;
     SArray<FrozenObjectSegment*> m_FrozenSegments;
     FrozenObjectSegment* m_CurrentSegment;
-    bool m_Enabled;
 };
 
 class FrozenObjectSegment

src/coreclr/vm/methodtable.cpp

@@ -4232,14 +4232,14 @@ OBJECTREF MethodTable::GetManagedClassObject()
             size_t objSize = g_pRuntimeTypeClass->GetBaseSize();
             refClass = (REFLECTCLASSBASEREF)ObjectToOBJECTREF(foh->TryAllocateObject(g_pRuntimeTypeClass, objSize));
         }
-
-        if (refClass == NULL)
+        else
         {
             refClass = (REFLECTCLASSBASEREF)AllocateObject(g_pRuntimeTypeClass);
+            ((ReflectClassBaseObject*)OBJECTREFToObject(refClass))->SetKeepAlive(pLoaderAllocator->GetExposedObject());
         }
+        _ASSERT(refClass != NULL);
 
         ((ReflectClassBaseObject*)OBJECTREFToObject(refClass))->SetType(TypeHandle(this));
-        ((ReflectClassBaseObject*)OBJECTREFToObject(refClass))->SetKeepAlive(pLoaderAllocator->GetExposedObject());
 
         // Let all threads fight over who wins using InterlockedCompareExchange.
         // Only the winner can set m_ExposedClassObject from NULL.
@@ -4272,8 +4272,9 @@ OBJECTREF MethodTable::GetManagedClassObject(bool* pIsPinned)
     GCPROTECT_BEGIN(objRef);
 
     objRef = GetManagedClassObject();
-    FrozenObjectHeapManager* foh = SystemDomain::GetFrozenObjectHeapManager();
-    *pIsPinned = foh->IsFromFrozenSegment(OBJECTREFToObject(objRef));
+
+    // Type objects in non-unloadable contexts are always "pinned" (allocated on FOH)
+    *pIsPinned = this->GetLoaderAllocator()->IsUnloaded();
 
     GCPROTECT_END();