Fold "cns"[cns] for ROS<char>

src/coreclr/inc/corinfo.h

@@ -2518,6 +2518,23 @@ class ICorStaticInfo
             CORINFO_OBJECT_HANDLE       objPtr
             ) = 0;
 
+    //------------------------------------------------------------------------------
+    // getStringChar: returns char at the given index if the given object handle
+    //    represents String and index is not out of bounds.
+    //
+    // Arguments:
+    //    strObj - object handle
+    //    index  - index of the char to return
+    //    value  - output char
+    //
+    // Return Value:
+    //    Returns true if value was successfully obtained
+    //
+    virtual bool getStringChar(
+            CORINFO_OBJECT_HANDLE strObj,
+            int                   index,
+            uint16_t*             value) = 0;
+
     //------------------------------------------------------------------------------
     // getObjectType: obtains type handle for given object
     //

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -293,6 +293,11 @@ CORINFO_OBJECT_HANDLE getRuntimeTypePointer(
 bool isObjectImmutable(
           CORINFO_OBJECT_HANDLE objPtr) override;
 
+bool getStringChar(
+          CORINFO_OBJECT_HANDLE strObj,
+          int index,
+          uint16_t* value) override;
+
 CORINFO_CLASS_HANDLE getObjectType(
           CORINFO_OBJECT_HANDLE objPtr) override;
 

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* e3c98d96-6e67-459a-9750-ebe799cfb788 */
-    0xe3c98d96,
-    0x6e67,
-    0x459a,
-    {0x97, 0x50, 0xeb, 0xe7, 0x99, 0xcf, 0xb7, 0x88}
+constexpr GUID JITEEVersionIdentifier = { /* 6f8fc8da-0a65-4054-be5d-505108298910 */
+    0x6f8fc8da,
+    0xa65,
+    0x4054,
+    {0xbe, 0x5d, 0x50, 0x51, 0x8, 0x29, 0x89, 0x10}
   };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_names_generated.h

@@ -73,6 +73,7 @@ DEF_CLR_API(getBoxHelper)
 DEF_CLR_API(getUnBoxHelper)
 DEF_CLR_API(getRuntimeTypePointer)
 DEF_CLR_API(isObjectImmutable)
+DEF_CLR_API(getStringChar)
 DEF_CLR_API(getObjectType)
 DEF_CLR_API(getReadyToRunHelper)
 DEF_CLR_API(getReadyToRunDelegateCtorHelper)

src/coreclr/jit/ICorJitInfo_wrapper_generated.hpp

@@ -683,6 +683,17 @@ bool WrapICorJitInfo::isObjectImmutable(
     return temp;
 }
 
+bool WrapICorJitInfo::getStringChar(
+          CORINFO_OBJECT_HANDLE strObj,
+          int index,
+          uint16_t* value)
+{
+    API_ENTER(getStringChar);
+    bool temp = wrapHnd->getStringChar(strObj, index, value);
+    API_LEAVE(getStringChar);
+    return temp;
+}
+
 CORINFO_CLASS_HANDLE WrapICorJitInfo::getObjectType(
           CORINFO_OBJECT_HANDLE objPtr)
 {

src/coreclr/jit/compiler.h

@@ -4827,6 +4827,8 @@ class Compiler
     void fgValueNumberFieldStore(
         GenTree* storeNode, GenTree* baseAddr, FieldSeq* fieldSeq, ssize_t offset, unsigned storeSize, ValueNum value);
 
+    bool fgValueNumberConstStringElemLoad(GenTreeIndir* tree);
+
     // Compute the value number for a byref-exposed load of the given type via the given pointerVN.
     ValueNum fgValueNumberByrefExposedLoad(var_types type, ValueNum pointerVN);
 
@@ -4874,7 +4876,7 @@ class Compiler
     // Assumes that all inputs to "tree" have had value numbers assigned; assigns a VN to tree.
     // (With some exceptions: the VN of the lhs of an assignment is assigned as part of the
     // assignment.)
-    void fgValueNumberTree(GenTree* tree);
+    void fgValueNumberTree(GenTree* tree, Statement* stmt);
 
     void fgValueNumberAssignment(GenTreeOp* tree);
 

src/coreclr/jit/valuenum.cpp

@@ -7884,7 +7884,7 @@ void Compiler::fgValueNumberBlock(BasicBlock* blk)
         {
             // Set up ambient var referring to current tree.
             compCurTree = tree;
-            fgValueNumberTree(tree);
+            fgValueNumberTree(tree, stmt);
             compCurTree = nullptr;
         }
 
@@ -8492,7 +8492,98 @@ void Compiler::fgValueNumberSsaVarDef(GenTreeLclVarCommon* lcl)
     }
 }
 
-void Compiler::fgValueNumberTree(GenTree* tree)
+//------------------------------------------------------------------------
+// fgValueNumberConstStringElemLoad: Try to match "cns_str"[cns_index] tree
+//    and apply a constant VN representing given char at cns_index in that string.
+//
+// Arguments:
+//    tree - the GT_IND node
+//
+// Return Value:
+//    true if the pattern was recognized and a new VN is assigned
+//
+bool Compiler::fgValueNumberConstStringElemLoad(GenTreeIndir* tree)
+{
+    ValueNum  addrVN = tree->gtGetOp1()->gtVNPair.GetLiberal();
+    VNFuncApp funcApp;
+    if (!varTypeIsShort(tree) || !vnStore->GetVNFunc(addrVN, &funcApp))
+    {
+        return false;
+    }
+
+    // Is given VN representing a frozen object handle
+    auto isCnsObjHandle = [](ValueNumStore* vnStore, ValueNum vn, CORINFO_OBJECT_HANDLE* handle) -> bool {
+        if (vnStore->IsVNHandle(vn) && (vnStore->GetHandleFlags(vn) == GTF_ICON_OBJ_HDL))
+        {
+            const size_t obj = vnStore->CoercedConstantValue<size_t>(vn);
+            *handle          = reinterpret_cast<CORINFO_OBJECT_HANDLE>(obj);
+            return true;
+        }
+        return false;
+    };
+
+    CORINFO_OBJECT_HANDLE objHandle = nullptr;
+    int                   index     = -1;
+
+    // First, let see if we have PtrToArrElem
+    ValueNum addr = funcApp.m_args[0];
+    if (funcApp.m_func == VNF_PtrToArrElem)
+    {
+        ValueNum arrVN  = funcApp.m_args[1];
+        ValueNum inxVN  = funcApp.m_args[2];
+        ssize_t  offset = vnStore->ConstantValue<ssize_t>(funcApp.m_args[3]);
+
+        if (isCnsObjHandle(vnStore, arrVN, &objHandle) && offset == 0 && vnStore->IsVNConstant(inxVN))
+        {
+            index = (int)vnStore->CoercedConstantValue<size_t>(inxVN);
+        }
+    }
+    else if (((genTreeOps)funcApp.m_func == GT_ADD) && vnStore->IsVNConstant(funcApp.m_args[0]))
+    {
+        // Here we try to match these two patterns:
+        //
+        //  1) (objHandle + firstCharOffset)
+        //  2) ((objHandle + firstCharOffset) + byteIndex)
+        //
+        size_t dataOffset = 0;
+        if (vnStore->IsVNConstant(funcApp.m_args[1]) && isCnsObjHandle(vnStore, funcApp.m_args[0], &objHandle))
+        {
+            dataOffset = vnStore->CoercedConstantValue<size_t>(funcApp.m_args[1]);
+        }
+        else
+        {
+            assert(vnStore->IsVNConstant(funcApp.m_args[0]));
+            const size_t byteDataIndex = vnStore->CoercedConstantValue<size_t>(funcApp.m_args[0]);
+            if (vnStore->GetVNFunc(funcApp.m_args[1], &funcApp) && ((genTreeOps)funcApp.m_func == GT_ADD) &&
+                vnStore->IsVNConstant(funcApp.m_args[1]) && isCnsObjHandle(vnStore, funcApp.m_args[0], &objHandle))
+            {
+                dataOffset = vnStore->CoercedConstantValue<size_t>(funcApp.m_args[1]) + byteDataIndex;
+            }
+        }
+
+        // Convert dataOffset (that also includes offset to firstChar field) into char index
+        if ((dataOffset >= OFFSETOF__CORINFO_String__chars) && ((dataOffset % 2) == 0))
+        {
+            index = (int)(dataOffset - OFFSETOF__CORINFO_String__chars) / 2;
+        }
+    }
+
+    if ((objHandle != nullptr) && (index >= 0))
+    {
+        assert(objHandle != nullptr);
+        USHORT charValue;
+        if (info.compCompHnd->getStringChar(objHandle, index, &charValue))
+        {
+            JITDUMP("Folding \"cns_str\"[%d] into %u\n", index, (unsigned)charValue);
+            // NOTE: we need to sign-extend it here in case if it's a negative Int16
+            tree->gtVNPair.SetBoth(vnStore->VNForIntCon((SHORT)charValue));
+            return true;
+        }
+    }
+    return false;
+}
+
+void Compiler::fgValueNumberTree(GenTree* tree, Statement* stmt)
 {
     genTreeOps oper = tree->OperGet();
     var_types  typ  = tree->TypeGet();
@@ -8743,6 +8834,13 @@ void Compiler::fgValueNumberTree(GenTree* tree)
                     // Note VNF_PtrToStatic statics are currently always "simple".
                     fgValueNumberFieldLoad(tree, /* baseAddr */ nullptr, fldSeq, offset);
                 }
+                else if (tree->OperIs(GT_IND) && fgValueNumberConstStringElemLoad(tree->AsIndir()))
+                {
+                    tree->gtFlags |= GTF_IND_NONFAULTING | GTF_IND_INVARIANT;
+                    tree->gtFlags &= ~GTF_EXCEPT;
+                    // Update side-effect flags of parent trees if needed
+                    gtUpdateStmtSideEffects(stmt);
+                }
                 else if (vnStore->GetVNFunc(addrNvnp.GetLiberal(), &funcApp) && (funcApp.m_func == VNF_PtrToArrElem))
                 {
                     fgValueNumberArrayElemLoad(tree, &funcApp);