Move importervectorization to a late phase

Author: EgorBo

src/coreclr/jit/CMakeLists.txt

@@ -142,7 +142,6 @@ set( JIT_SOURCES
   ifconversion.cpp
   importer.cpp
   importercalls.cpp
-  importervectorization.cpp
   indirectcalltransformer.cpp
   inductionvariableopts.cpp
   inline.cpp

src/coreclr/jit/assertionprop.cpp

@@ -3960,6 +3960,7 @@ class Compiler
     //-------------------------------------------------------------------------
 
     GenTree* gtFoldExpr(GenTree* tree);
+    GenTree* gtFoldExprConstChain(GenTree* tree, int maxDepth = 10);
     GenTree* gtFoldExprConst(GenTree* tree);
 
     GenTree* gtFoldExprUnary(GenTreeUnOp* tree);
@@ -5184,32 +5185,6 @@ class Compiler
     GenTree* impTypeIsAssignable(GenTree* typeTo, GenTree* typeFrom);
     GenTree* impGetGenericTypeDefinition(GenTree* type);
 
-    // Mirrors StringComparison.cs
-    enum StringComparison
-    {
-        Ordinal           = 4,
-        OrdinalIgnoreCase = 5
-    };
-    enum class StringComparisonKind
-    {
-        Equals,
-        StartsWith,
-        EndsWith
-    };
-    GenTree* impUtf16StringComparison(StringComparisonKind kind, CORINFO_SIG_INFO* sig, unsigned methodFlags);
-    GenTree* impUtf16SpanComparison(StringComparisonKind kind, CORINFO_SIG_INFO* sig, unsigned methodFlags);
-    GenTree* impExpandHalfConstEquals(GenTreeLclVarCommon*   data,
-                                      GenTree*         lengthFld,
-                                      bool             checkForNull,
-                                      StringComparisonKind kind,
-                                      WCHAR*           cnsData,
-                                      int              len,
-                                      int              dataOffset,
-                                      StringComparison cmpMode);
-    GenTree* impExpandHalfConstEquals(
-        GenTreeLclVarCommon* data, WCHAR* cns, int len, int dataOffset, StringComparison cmpMode);
-    GenTreeStrCon* impGetStrConFromSpan(GenTree* span);
-
     GenTree* impIntrinsic(CORINFO_CLASS_HANDLE    clsHnd,
                           CORINFO_METHOD_HANDLE   method,
                           CORINFO_SIG_INFO*       sig,
@@ -9055,7 +9030,7 @@ class Compiler
     GenTree*     optVNConstantPropOnJTrue(BasicBlock* block, GenTree* test);
     GenTree*     optVNBasedFoldConstExpr(BasicBlock* block, GenTree* parent, GenTree* tree);
     GenTree*     optVNBasedFoldExpr(BasicBlock* block, GenTree* parent, GenTree* tree);
-    GenTree*     optVNBasedFoldExpr_Call(BasicBlock* block, GenTree* parent, GenTreeCall* call);
+    GenTree*     optVNBasedFoldExpr_Call(GenTreeCall* call);
     GenTree*     optVNBasedFoldExpr_Call_Memmove(GenTreeCall* call);
     GenTree*     optVNBasedFoldExpr_Call_Memset(GenTreeCall* call);
     GenTree*     optVNBasedFoldExpr_Call_Memcmp(GenTreeCall* call);

src/coreclr/jit/compiler.h

@@ -2545,6 +2545,7 @@ PhaseStatus Compiler::fgPrepareToInstrumentMethod()
             // These are marked as [Intrinsic] only to be handled (unrolled) for constant inputs.
             // In other cases they have large managed implementations we want to profile.
             case NI_System_String_Equals:
+            case NI_System_String_OrdinalEqualsIgnoreCase:
             case NI_System_SpanHelpers_Memmove:
             case NI_System_MemoryExtensions_Equals:
             case NI_System_MemoryExtensions_SequenceEqual:

src/coreclr/jit/fgprofile.cpp

@@ -14999,6 +14999,46 @@ GenTree* Compiler::gtFoldExpr(GenTree* tree)
     }
 }
 
+//------------------------------------------------------------------------
+// gtFoldExprConstChain: fold a tree into a constant when possible, recursing
+//    into operands first.
+//
+// Arguments:
+//    tree     - the tree to fold (mutated in place)
+//    maxDepth - remaining recursion budget; folding stops (and the subtree is
+//               returned unfolded) once it is exhausted
+//
+// Returns:
+//    The folded tree; a constant node if the whole chain folded to a constant.
+//
+GenTree* Compiler::gtFoldExprConstChain(GenTree* tree, int maxDepth)
+{
+    if (maxDepth <= 0)
+    {
+        return tree;
+    }
+
+    if (tree->OperIsUnary())
+    {
+        if (tree->AsOp()->gtOp1 != nullptr)
+        {
+            tree->AsOp()->gtOp1 = gtFoldExprConstChain(tree->AsOp()->gtOp1, maxDepth - 1);
+        }
+    }
+    else if (tree->OperIsBinary())
+    {
+        if (tree->AsOp()->gtOp1 != nullptr)
+        {
+            tree->AsOp()->gtOp1 = gtFoldExprConstChain(tree->AsOp()->gtOp1, maxDepth - 1);
+        }
+        if (tree->AsOp()->gtOp2 != nullptr)
+        {
+            tree->AsOp()->gtOp2 = gtFoldExprConstChain(tree->AsOp()->gtOp2, maxDepth - 1);
+        }
+    }
+    return gtFoldExpr(tree);
+}
+
 //------------------------------------------------------------------------
 // gtFoldExprUnary: see if a unary operation is foldable
 //

src/coreclr/jit/gentree.cpp

@@ -3566,51 +3566,6 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE    clsHnd,
                 retNode = impArrayAccessIntrinsic(clsHnd, sig, memberRef, readonlyCall, ni);
                 break;
 
-            case NI_System_String_Equals:
-            {
-                retNode = impUtf16StringComparison(StringComparisonKind::Equals, sig, methodFlags);
-                break;
-            }
-
-            case NI_System_MemoryExtensions_Equals:
-            case NI_System_MemoryExtensions_SequenceEqual:
-            {
-                retNode = impUtf16SpanComparison(StringComparisonKind::Equals, sig, methodFlags);
-                break;
-            }
-
-            case NI_System_String_StartsWith:
-            {
-                retNode = impUtf16StringComparison(StringComparisonKind::StartsWith, sig, methodFlags);
-                break;
-            }
-
-            case NI_System_String_EndsWith:
-            {
-                retNode = impUtf16StringComparison(StringComparisonKind::EndsWith, sig, methodFlags);
-                break;
-            }
-
-            case NI_System_MemoryExtensions_StartsWith:
-            {
-                retNode = impUtf16SpanComparison(StringComparisonKind::StartsWith, sig, methodFlags);
-                break;
-            }
-
-            case NI_System_MemoryExtensions_EndsWith:
-            {
-                retNode = impUtf16SpanComparison(StringComparisonKind::EndsWith, sig, methodFlags);
-                break;
-            }
-
-            case NI_System_MemoryExtensions_AsSpan:
-            case NI_System_String_op_Implicit:
-            {
-                assert(sig->numArgs == 1);
-                isSpecial = impStackTop().val->OperIs(GT_CNS_STR);
-                break;
-            }
-
             case NI_System_String_get_Chars:
             {
                 GenTree* op2  = impPopStack().val;
@@ -4908,6 +4863,13 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE    clsHnd,
                 break;
             }
 
+            case NI_System_String_OrdinalEqualsIgnoreCase:
+            {
+                // We'll try to fold/unroll this in VN for constant input.
+                isSpecial = true;
+                break;
+            }
+
             case NI_System_SpanHelpers_Fill:
             {
                 if (sig->sigInst.methInstCount == 1)
@@ -10937,6 +10899,16 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                         }
                     }
                 }
+                else if (strcmp(namespaceName, "Globalization") == 0)
+                {
+                    if (strcmp(className, "Ordinal") == 0)
+                    {
+                        if (strcmp(methodName, "EqualsIgnoreCase") == 0)
+                        {
+                            result = NI_System_String_OrdinalEqualsIgnoreCase;
+                        }
+                    }
+                }
                 else if (strcmp(namespaceName, "Numerics") == 0)
                 {
                     if (strcmp(className, "BitOperations") == 0)