Fold static readonly struct X = <zero> to a jit-time const, e.g. Guid.Empty (#77354)

Author: EgorBo

src/coreclr/jit/importer.cpp

@@ -4154,6 +4154,8 @@ GenTree* Compiler::impImportStaticReadOnlyField(CORINFO_FIELD_HANDLE field, CORI
         return nullptr;
     }
 
+    JITDUMP("\nChecking if we can import 'static readonly' as a jit-time constant... ")
+
     CORINFO_CLASS_HANDLE fieldClsHnd;
     var_types            fieldType = JITtype2varType(info.compCompHnd->getFieldType(field, &fieldClsHnd, ownerCls));
 
@@ -4167,20 +4169,64 @@ GenTree* Compiler::impImportStaticReadOnlyField(CORINFO_FIELD_HANDLE field, CORI
             GenTree* cnsValue = impImportCnsTreeFromBuffer(buffer, fieldType);
             if (cnsValue != nullptr)
             {
+                JITDUMP("... success! The value is:\n");
+                DISPTREE(cnsValue);
                 return cnsValue;
             }
         }
     }
     else if (fieldType == TYP_STRUCT)
     {
+        unsigned totalSize = info.compCompHnd->getClassSize(fieldClsHnd);
+        unsigned fieldsCnt = info.compCompHnd->getClassNumInstanceFields(fieldClsHnd);
 
-        if (info.compCompHnd->getClassNumInstanceFields(fieldClsHnd) != 1)
+        // For large structs we only want to handle "initialized with zero" case
+        // e.g. Guid.Empty and decimal.Zero static readonly fields.
+        if ((totalSize > TARGET_POINTER_SIZE) || (fieldsCnt != 1))
         {
-            // Only single-field structs are supported here to avoid potential regressions where
-            // Metadata-driven struct promotion leads to regressions.
+            JITDUMP("checking if we can do anything for a large struct ...");
+            const int MaxStructSize = 64;
+            if ((totalSize == 0) || (totalSize > MaxStructSize))
+            {
+                // Limit to 64 bytes for better throughput
+                JITDUMP("struct is larger than 64 bytes - bail out.");
+                return nullptr;
+            }
+
+            uint8_t buffer[MaxStructSize] = {0};
+            if (info.compCompHnd->getReadonlyStaticFieldValue(field, buffer, totalSize))
+            {
+                for (unsigned i = 0; i < totalSize; i++)
+                {
+                    if (buffer[i] != 0)
+                    {
+                        // Value is not all zeroes - bail out.
+                        // Although, We might eventually support that too.
+                        JITDUMP("value is not all zeros - bail out.");
+                        return nullptr;
+                    }
+                }
+
+                JITDUMP("success! Optimizing to ASG(struct, 0).");
+                unsigned structTempNum = lvaGrabTemp(true DEBUGARG("folding static ro fld empty struct"));
+                lvaSetStruct(structTempNum, fieldClsHnd, false);
+
+                // realType is either struct or SIMD
+                var_types      realType  = lvaGetRealType(structTempNum);
+                GenTreeLclVar* structLcl = gtNewLclvNode(structTempNum, realType);
+                impAppendTree(gtNewBlkOpNode(structLcl, gtNewIconNode(0), false, false), CHECK_SPILL_NONE,
+                              impCurStmtDI);
+
+                return gtNewLclvNode(structTempNum, realType);
+            }
+
+            JITDUMP("getReadonlyStaticFieldValue returned false - bail out.");
             return nullptr;
         }
 
+        // Only single-field structs are supported here to avoid potential regressions where
+        // Metadata-driven struct promotion leads to regressions.
+
         CORINFO_FIELD_HANDLE innerField = info.compCompHnd->getFieldInClass(fieldClsHnd, 0);
         CORINFO_CLASS_HANDLE innerFieldClsHnd;
         var_types            fieldVarType =
@@ -4189,15 +4235,16 @@ GenTree* Compiler::impImportStaticReadOnlyField(CORINFO_FIELD_HANDLE field, CORI
         // Technically, we can support frozen gc refs here and maybe floating point in future
         if (!varTypeIsIntegral(fieldVarType))
         {
+            JITDUMP("struct has non-primitive fields - bail out.");
             return nullptr;
         }
 
-        unsigned totalSize = info.compCompHnd->getClassSize(fieldClsHnd);
         unsigned fldOffset = info.compCompHnd->getFieldOffset(innerField);
 
-        if ((fldOffset != 0) || (totalSize != info.compCompHnd->getClassSize(fieldClsHnd)) || (totalSize == 0))
+        if ((fldOffset != 0) || (totalSize != genTypeSize(fieldVarType)) || (totalSize == 0))
         {
             // The field is expected to be of the exact size as the struct with 0 offset
+            JITDUMP("struct has complex layout - bail out.");
             return nullptr;
         }
 

src/libraries/System.Private.CoreLib/src/System/Guid.cs

@@ -868,6 +868,7 @@ public override int GetHashCode()
 
         public bool Equals(Guid g) => EqualsCore(this, g);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool EqualsCore(in Guid left, in Guid right)
         {
             if (Vector128.IsHardwareAccelerated)