Allocate boxed static structs on Frozen Object Heap

src/coreclr/vm/frozenobjectheap.cpp

@@ -37,6 +37,10 @@ Object* FrozenObjectHeapManager::TryAllocateObject(PTR_MethodTable type, size_t
     _ASSERT(type != nullptr);
     _ASSERT(FOH_COMMIT_SIZE >= MIN_OBJECT_SIZE);
 
+#ifdef FEATURE_64BIT_ALIGNMENT
+    _ASSERT(!type->RequiresAlign8());
+#endif
+
     // NOTE: objectSize is expected be the full size including header
     _ASSERT(objectSize >= MIN_OBJECT_SIZE);
 

src/coreclr/vm/jitinterface.cpp

@@ -1453,6 +1453,41 @@ static CorInfoHelpFunc getInstanceFieldHelper(FieldDesc * pField, CORINFO_ACCESS
     return (CorInfoHelpFunc)helper;
 }
 
+static OBJECTREF getFrozenBoxedStatic(FieldDesc* field)
+{
+    CONTRACTL {
+        THROWS;
+        GC_TRIGGERS;
+        MODE_COOPERATIVE;
+    } CONTRACTL_END;
+
+    // These fields never hold frozen boxed statics
+    if (!field->IsStatic() || !field->IsByValue() || field->IsSpecialStatic())
+    {
+        return NULL;
+    }
+
+    TypeHandle typeHandle = field->GetFieldTypeHandleThrowing();
+    MethodTable* pFieldMT = typeHandle.GetMethodTable();
+    if (typeHandle.IsCanonicalSubtype() || pFieldMT->IsSharedByGenericInstantiations() || pFieldMT->ContainsPointers())
+    {
+        return NULL;
+    }
+
+    PTR_BYTE basePtr = field->GetBase();
+    if (basePtr == nullptr)
+    {
+        return NULL;
+    }
+
+    Object** handle = (Object**)field->GetStaticAddressHandle(basePtr);
+    if (handle != nullptr && GCHeapUtilities::GetGCHeap()->IsInFrozenSegment(*handle))
+    {
+        return ObjectToOBJECTREF(*handle);
+    }
+    return NULL;
+}
+
 /*********************************************************************/
 void CEEInfo::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
                             CORINFO_METHOD_HANDLE  callerHandle,
@@ -1514,7 +1549,13 @@ void CEEInfo::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
             CORINFO_FIELD_ACCESSOR intrinsicAccessor;
 
             if (pField->GetFieldType() == ELEMENT_TYPE_VALUETYPE)
-                fieldFlags |= CORINFO_FLG_FIELD_STATIC_IN_HEAP;
+            {
+                GCX_COOP();
+                if (getFrozenBoxedStatic(pField) == NULL)
+                {
+                    fieldFlags |= CORINFO_FLG_FIELD_STATIC_IN_HEAP;
+                }
+            }
 
             if (pFieldMT->IsSharedByGenericInstantiations())
             {
@@ -11950,10 +11991,23 @@ void* CEEJitInfo::getFieldAddress(CORINFO_FIELD_HANDLE fieldHnd,
 
         GCX_COOP();
 
-        base = (void *) field->GetBase();
+        // Check if the field holds a frozen boxed static, return its content in that case
+        result = OBJECTREFToObject(getFrozenBoxedStatic(field));
+        if (result != NULL)
+        {
+            // Skip pMT
+            result = (uint8_t*)result + sizeof(void*);
+        }
+        else
+        {
+            base = (void*)field->GetBase();
+        }
     }
 
-    result = field->GetStaticAddressHandle(base);
+    if (result == NULL)
+    {
+        result = field->GetStaticAddressHandle(base);
+    }
 
     EE_TO_JIT_TRANSITION();
 

src/coreclr/vm/methodtable.cpp

@@ -58,6 +58,7 @@
 #include "array.h"
 #include "castcache.h"
 #include "dynamicinterfacecastable.h"
+#include "frozenobjectheap.h"
 
 #ifdef FEATURE_INTERPRETER
 #include "interpreter.h"
@@ -3499,7 +3500,18 @@ void MethodTable::AllocateRegularStaticBoxes()
                 MethodTable* pFieldMT = th.GetMethodTable();
 
                 LOG((LF_CLASSLOADER, LL_INFO10000, "\tInstantiating static of type %s\n", pFieldMT->GetDebugClassName()));
-                OBJECTREF obj = AllocateStaticBox(pFieldMT, HasFixedAddressVTStatics());
+
+                bool canBeFrozen = !pFieldMT->ContainsPointers() && !Collectible();
+
+#ifdef FEATURE_64BIT_ALIGNMENT
+                if (pFieldMT->RequiresAlign8())
+                {
+                    // 64bit alignment is not yet supported in FOH for 32bit targets
+                    canBeFrozen = false;
+                }
+#endif
+
+                OBJECTREF obj = AllocateStaticBox(pFieldMT, HasFixedAddressVTStatics(), NULL, canBeFrozen);
 
                 SetObjectReference( (OBJECTREF*)(pStaticBase + pField->GetOffset()), obj);
             }
@@ -3511,13 +3523,13 @@ void MethodTable::AllocateRegularStaticBoxes()
 }
 
 //==========================================================================================
-OBJECTREF MethodTable::AllocateStaticBox(MethodTable* pFieldMT, BOOL fPinned, OBJECTHANDLE* pHandle)
+OBJECTREF MethodTable::AllocateStaticBox(MethodTable* pFieldMT, BOOL fPinned, OBJECTHANDLE* pHandle, bool canBeFrozen)
 {
     CONTRACTL
     {
         THROWS;
         GC_TRIGGERS;
-        MODE_ANY;
+        MODE_COOPERATIVE;
         CONTRACTL_END;
     }
 
@@ -3526,7 +3538,21 @@ OBJECTREF MethodTable::AllocateStaticBox(MethodTable* pFieldMT, BOOL fPinned, OB
     // Activate any dependent modules if necessary
     pFieldMT->EnsureInstanceActive();
 
-    OBJECTREF obj = AllocateObject(pFieldMT);
+    OBJECTREF obj = NULL;
+    if (canBeFrozen)
+    {
+        // In case if we don't plan to collect this handle we may try to allocate it on FOH
+        _ASSERT(!pFieldMT->ContainsPointers());
+        FrozenObjectHeapManager* foh = SystemDomain::GetFrozenObjectHeapManager();
+        obj = ObjectToOBJECTREF(foh->TryAllocateObject(pFieldMT, pFieldMT->GetBaseSize()));
+        // obj can be null in case if struct is huge (>64kb)
+        if (obj != NULL)
+        {
+            return obj;
+        }
+    }
+
+    obj = AllocateObject(pFieldMT);
 
     // Pin the object if necessary
     if (fPinned)

src/coreclr/vm/methodtable.h

@@ -831,7 +831,7 @@ class MethodTable
     // instantiations of the superclass or interfaces e.g. System.Int32 : IComparable<System.Int32>
 
     void AllocateRegularStaticBoxes();
-    static OBJECTREF AllocateStaticBox(MethodTable* pFieldMT, BOOL fPinned, OBJECTHANDLE* pHandle = 0);
+    static OBJECTREF AllocateStaticBox(MethodTable* pFieldMT, BOOL fPinned, OBJECTHANDLE* pHandle = 0, bool canBeFrozen = false);
 
     void CheckRestore();