Fold bound checks for static readonly arrays/strings

src/coreclr/inc/corinfo.h

@@ -1056,6 +1056,7 @@ typedef struct CORINFO_DEPENDENCY_STRUCT_*  CORINFO_DEPENDENCY_HANDLE;
 typedef struct CORINFO_CLASS_STRUCT_*       CORINFO_CLASS_HANDLE;
 typedef struct CORINFO_METHOD_STRUCT_*      CORINFO_METHOD_HANDLE;
 typedef struct CORINFO_FIELD_STRUCT_*       CORINFO_FIELD_HANDLE;
+typedef struct CORINFO_OBJECT_STRUCT_*      CORINFO_OBJECT_HANDLE;
 typedef struct CORINFO_ARG_LIST_STRUCT_*    CORINFO_ARG_LIST_HANDLE;    // represents a list of argument types
 typedef struct CORINFO_JUST_MY_CODE_HANDLE_*CORINFO_JUST_MY_CODE_HANDLE;
 typedef struct CORINFO_PROFILING_STRUCT_*   CORINFO_PROFILING_HANDLE;   // a handle guaranteed to be unique per process
@@ -2729,6 +2730,8 @@ class ICorStaticInfo
     // Returns true iff "fldHnd" represents a static field.
     virtual bool isFieldStatic(CORINFO_FIELD_HANDLE fldHnd) = 0;
 
+    virtual int getArrayLength(CORINFO_OBJECT_HANDLE objHnd) = 0;
+
     /*********************************************************************************/
     //
     // ICorDebugInfo

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -404,6 +404,9 @@ void getFieldInfo(
 bool isFieldStatic(
           CORINFO_FIELD_HANDLE fldHnd) override;
 
+int getArrayLength(
+          CORINFO_OBJECT_HANDLE objHnd) override;
+
 void getBoundaries(
           CORINFO_METHOD_HANDLE ftn,
           unsigned int* cILOffsets,

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* 2ed4cd12-48ed-4a0e-892e-d24d004a5e4c */
-    0x2ed4cd12,
-    0x48ed,
-    0x4a0e,
-    {0x89, 0x2e, 0xd2, 0x4d, 0x00, 0x4a, 0x5e, 0x4c}
+constexpr GUID JITEEVersionIdentifier = { /* 77b6df16-d27f-4118-9dfd-d8073ff20fb6 */
+    0x77b6df16,
+    0xd27f,
+    0x4118,
+    {0x9d, 0xfd, 0xd8, 0x7, 0x3f, 0xf2, 0xf, 0xb6}
   };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -102,6 +102,7 @@ DEF_CLR_API(getFieldType)
 DEF_CLR_API(getFieldOffset)
 DEF_CLR_API(getFieldInfo)
 DEF_CLR_API(isFieldStatic)
+DEF_CLR_API(getArrayLength)
 DEF_CLR_API(getBoundaries)
 DEF_CLR_API(setBoundaries)
 DEF_CLR_API(getVars)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -965,6 +965,15 @@ bool WrapICorJitInfo::isFieldStatic(
     return temp;
 }
 
+int WrapICorJitInfo::getArrayLength(
+          CORINFO_OBJECT_HANDLE objHnd)
+{
+    API_ENTER(getArrayLength);
+    int temp = wrapHnd->getArrayLength(objHnd);
+    API_LEAVE(getArrayLength);
+    return temp;
+}
+
 void WrapICorJitInfo::getBoundaries(
           CORINFO_METHOD_HANDLE ftn,
           unsigned int* cILOffsets,

src/coreclr/jit/assertionprop.cpp

@@ -6127,6 +6127,7 @@ Compiler::fgWalkResult Compiler::optVNConstantPropCurStmt(BasicBlock* block, Sta
         case GT_NEG:
         case GT_CAST:
         case GT_INTRINSIC:
+        case GT_ARR_LENGTH:
             break;
 
         case GT_IND:

src/coreclr/jit/importer.cpp

@@ -4344,19 +4344,23 @@ GenTree* Compiler::impImportCnsTreeFromBuffer(uint8_t* buffer, var_types valueTy
         }
         case TYP_REF:
         {
-            void* ptr;
+            size_t ptr;
             memcpy(&ptr, buffer, sizeof(ssize_t));
 
             if (ptr == 0)
             {
                 tree = gtNewNull();
             }
-            else
+            else if ((ptr & 1) == 0) // Check the lowest bit for "Is frozen" mark
             {
                 setMethodHasFrozenObjects();
-                tree         = gtNewIconEmbHndNode(ptr, nullptr, GTF_ICON_OBJ_HDL, nullptr);
+                tree         = gtNewIconEmbHndNode((void*)ptr, nullptr, GTF_ICON_OBJ_HDL, nullptr);
                 tree->gtType = TYP_REF;
-                INDEBUG(tree->AsIntCon()->gtTargetHandle = (size_t)ptr);
+                INDEBUG(tree->AsIntCon()->gtTargetHandle = ptr);
+            }
+            else
+            {
+                return nullptr;
             }
             break;
         }

src/coreclr/jit/valuenum.cpp

@@ -8685,7 +8685,21 @@ void Compiler::fgValueNumberTree(GenTree* tree)
                         VNFunc loadFunc =
                             ((tree->gtFlags & GTF_IND_NONNULL) != 0) ? VNF_InvariantNonNullLoad : VNF_InvariantLoad;
 
-                        tree->gtVNPair = vnStore->VNPairForFunc(tree->TypeGet(), loadFunc, addrNvnp);
+                        // Special case: for initialized non-null 'static readonly' fields we want to keep field
+                        // sequence
+                        // to be able to fold their value
+                        ValueNum fieldSeqVN;
+                        if ((loadFunc == VNF_InvariantNonNullLoad) && addr->IsIconHandle(GTF_ICON_CONST_PTR))
+                        {
+                            fieldSeqVN = vnStore->VNForFieldSeq(addr->AsIntCon()->gtFieldSeq);
+                        }
+                        else
+                        {
+                            fieldSeqVN = vnStore->VNForNull();
+                        }
+
+                        tree->gtVNPair = vnStore->VNPairForFunc(tree->TypeGet(), loadFunc, addrNvnp,
+                                                                ValueNumPair(fieldSeqVN, fieldSeqVN));
                         tree->gtVNPair = vnStore->VNPWithExc(tree->gtVNPair, addrXvnp);
                     }
                 }
@@ -8774,6 +8788,40 @@ void Compiler::fgValueNumberTree(GenTree* tree)
         }
         else // Look up the VNFunc for the node
         {
+            if (tree->OperIs(GT_ARR_LENGTH))
+            {
+                ValueNum  addressVN = tree->gtGetOp1()->gtVNPair.GetLiberal();
+                VNFuncApp funcApp;
+                if (vnStore->GetVNFunc(addressVN, &funcApp) && (funcApp.m_func == VNF_InvariantNonNullLoad))
+                {
+                    ValueNum fieldSeqVN = funcApp.m_args[1];
+                    if ((fieldSeqVN != vnStore->VNForNull()) && (fieldSeqVN != ValueNumStore::NoVN))
+                    {
+                        FieldSeq* fieldSeq = vnStore->FieldSeqVNToFieldSeq(fieldSeqVN);
+                        if (fieldSeq != nullptr)
+                        {
+                            CORINFO_FIELD_HANDLE field = fieldSeq->GetFieldHandle();
+                            if (field != NULL)
+                            {
+                                uint8_t buffer[TARGET_POINTER_SIZE] = {0};
+                                if (this->info.compCompHnd->getReadonlyStaticFieldValue(field, buffer,
+                                                                                        TARGET_POINTER_SIZE))
+                                {
+                                    CORINFO_OBJECT_HANDLE objHandle;
+                                    memcpy(&objHandle, buffer, TARGET_POINTER_SIZE);
+                                    int len = this->info.compCompHnd->getArrayLength(objHandle);
+                                    if (len >= 0)
+                                    {
+                                        tree->gtVNPair.SetBoth(vnStore->VNForIntCon(len));
+                                        return;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
             VNFunc vnf = GetVNFuncForNode(tree);
 
             if (ValueNumStore::VNFuncIsLegal(vnf))

src/coreclr/jit/valuenumfuncs.h

@@ -144,8 +144,8 @@ ValueNumFuncDef(Box, 3, false, false, false)
 ValueNumFuncDef(BoxNullable, 3, false, false, false)
 
 ValueNumFuncDef(LazyStrCns, 2, false, true, false)            // Lazy-initialized string literal (helper)
-ValueNumFuncDef(InvariantLoad, 1, false, false, false)        // Args: 0: (VN of) the address.
-ValueNumFuncDef(InvariantNonNullLoad, 1, false, true, false)  // Args: 0: (VN of) the address.
+ValueNumFuncDef(InvariantLoad, 2, false, false, false)        // Args: 0: (VN of) the address, 1: field sequence (if any).
+ValueNumFuncDef(InvariantNonNullLoad, 2, false, true, false)  // Args: 0: (VN of) the address, 1: field sequence (if any).
 ValueNumFuncDef(Unbox, 2, false, true, false)
 
 ValueNumFuncDef(LT_UN, 2, false, false, false)      // unsigned or unordered comparisons

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

@@ -2881,6 +2881,16 @@ private bool isFieldStatic(CORINFO_FIELD_STRUCT_* fldHnd)
             return HandleToObject(fldHnd).IsStatic;
         }
 
+#pragma warning disable CA1822 // Mark members as static
+        private int getArrayLength(CORINFO_FIELD_STRUCT_* objHnd)
+#pragma warning restore CA1822 // Mark members as static
+        {
+            // This is not used on crossgen and NativeAOT.
+            // For NativeAOT we'll need a different API, e.g. "getArrayLength(void* frozenObjPtr)"
+            // We'll add it as part of "allocate static arrays on FOH" effort for CoreCLR
+            return -1;
+        }
+
         private void getBoundaries(CORINFO_METHOD_STRUCT_* ftn, ref uint cILOffsets, ref uint* pILOffsets, BoundaryTypes* implicitBoundaries)
         {
             // TODO: Debugging