Add IsKnownConstant jit helper and optimize 'str == ""' with str.StartsWith('c')

src/coreclr/jit/compiler.hpp

@@ -4504,11 +4504,12 @@ inline static bool StructHasNoPromotionFlagSet(DWORD attribs)
     return ((attribs & CORINFO_FLG_DONT_PROMOTE) != 0);
 }
 
-/*****************************************************************************
- * This node should not be referenced by anyone now. Set its values to garbage
- * to catch extra references
- */
-
+//------------------------------------------------------------------------------
+// DEBUG_DESTROY_NODE: sets value of tree to garbage to catch extra references
+//
+// Arguments:
+//    tree: This node should not be referenced by anyone now
+//
 inline void DEBUG_DESTROY_NODE(GenTree* tree)
 {
 #ifdef DEBUG
@@ -4529,6 +4530,19 @@ inline void DEBUG_DESTROY_NODE(GenTree* tree)
 #endif
 }
 
+//------------------------------------------------------------------------------
+// DEBUG_DESTROY_NODE: sets value of trees to garbage to catch extra references
+//
+// Arguments:
+//    tree, ...rest: These nodes should not be referenced by anyone now
+//
+template <typename... T>
+void DEBUG_DESTROY_NODE(GenTree* tree, T... rest)
+{
+    DEBUG_DESTROY_NODE(tree);
+    DEBUG_DESTROY_NODE(rest...);
+}
+
 //------------------------------------------------------------------------------
 // lvRefCnt: access reference count for this local var
 //

src/coreclr/jit/fgbasic.cpp

@@ -1113,12 +1113,12 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                 {
                     ni = lookupNamedIntrinsic(methodHnd);
 
-                    bool foldableIntrinsc = false;
+                    bool foldableIntrinsic = false;
 
                     if (IsMathIntrinsic(ni))
                     {
                         // Most Math(F) intrinsics have single arguments
-                        foldableIntrinsc = FgStack::IsConstantOrConstArg(pushedStack.Top(), impInlineInfo);
+                        foldableIntrinsic = FgStack::IsConstantOrConstArg(pushedStack.Top(), impInlineInfo);
                     }
                     else
                     {
@@ -1131,7 +1131,7 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                             case NI_System_GC_KeepAlive:
                             {
                                 pushedStack.PushUnknown();
-                                foldableIntrinsc = true;
+                                foldableIntrinsic = true;
                                 break;
                             }
 
@@ -1145,6 +1145,12 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                                 break;
                             }
 
+                            case NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant:
+                                pushedStack.PushConstant();
+                                foldableIntrinsic = true;
+                                // we can add an additional boost if arg is really a const
+                                break;
+
                             // These are foldable if the first argument is a constant
                             case NI_System_Type_get_IsValueType:
                             case NI_System_Type_GetTypeFromHandle:
@@ -1159,10 +1165,10 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                             case NI_Vector128_Create:
 #endif
                             {
-                                // Top() in order to keep it as is in case of foldableIntrinsc
+                                // Top() in order to keep it as is in case of foldableIntrinsic
                                 if (FgStack::IsConstantOrConstArg(pushedStack.Top(), impInlineInfo))
                                 {
-                                    foldableIntrinsc = true;
+                                    foldableIntrinsic = true;
                                 }
                                 break;
                             }
@@ -1177,7 +1183,7 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                                 if (FgStack::IsConstantOrConstArg(pushedStack.Top(0), impInlineInfo) &&
                                     FgStack::IsConstantOrConstArg(pushedStack.Top(1), impInlineInfo))
                                 {
-                                    foldableIntrinsc = true;
+                                    foldableIntrinsic = true;
                                     pushedStack.PushConstant();
                                 }
                                 break;
@@ -1186,31 +1192,31 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                             case NI_IsSupported_True:
                             case NI_IsSupported_False:
                             {
-                                foldableIntrinsc = true;
+                                foldableIntrinsic = true;
                                 pushedStack.PushConstant();
                                 break;
                             }
 #if defined(TARGET_XARCH) && defined(FEATURE_HW_INTRINSICS)
                             case NI_Vector128_get_Count:
                             case NI_Vector256_get_Count:
-                                foldableIntrinsc = true;
+                                foldableIntrinsic = true;
                                 pushedStack.PushConstant();
                                 // TODO: check if it's a loop condition - we unroll such loops.
                                 break;
                             case NI_Vector256_get_Zero:
                             case NI_Vector256_get_AllBitsSet:
-                                foldableIntrinsc = true;
+                                foldableIntrinsic = true;
                                 pushedStack.PushUnknown();
                                 break;
 #elif defined(TARGET_ARM64) && defined(FEATURE_HW_INTRINSICS)
                             case NI_Vector64_get_Count:
                             case NI_Vector128_get_Count:
-                                foldableIntrinsc = true;
+                                foldableIntrinsic = true;
                                 pushedStack.PushConstant();
                                 break;
                             case NI_Vector128_get_Zero:
                             case NI_Vector128_get_AllBitsSet:
-                                foldableIntrinsc = true;
+                                foldableIntrinsic = true;
                                 pushedStack.PushUnknown();
                                 break;
 #endif
@@ -1222,7 +1228,7 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                         }
                     }
 
-                    if (foldableIntrinsc)
+                    if (foldableIntrinsic)
                     {
                         compInlineResult->Note(InlineObservation::CALLSITE_FOLDABLE_INTRINSIC);
                         handled = true;

src/coreclr/jit/gentree.cpp

@@ -10827,6 +10827,9 @@ void Compiler::gtDispTree(GenTree*     tree,
                 case NI_System_Object_GetType:
                     printf(" objGetType");
                     break;
+                case NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant:
+                    printf(" isKnownConst");
+                    break;
 
                 default:
                     unreached();

src/coreclr/jit/importer.cpp

@@ -3879,19 +3879,25 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
         return new (this, GT_LABEL) GenTree(GT_LABEL, TYP_I_IMPL);
     }
 
-    if (((ni == NI_System_Runtime_CompilerServices_RuntimeHelpers_CreateSpan) ||
-         (ni == NI_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray)) &&
-        IsTargetAbi(CORINFO_CORERT_ABI))
+    switch (ni)
     {
         // CreateSpan must be expanded for NativeAOT
-        mustExpand = true;
-    }
+        case NI_System_Runtime_CompilerServices_RuntimeHelpers_CreateSpan:
+        case NI_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray:
+            mustExpand = IsTargetAbi(CORINFO_CORERT_ABI);
+            break;
 
-    if ((ni == NI_System_ByReference_ctor) || (ni == NI_System_ByReference_get_Value) ||
-        (ni == NI_System_Activator_AllocatorOf) || (ni == NI_System_Activator_DefaultConstructorOf) ||
-        (ni == NI_System_Object_MethodTableOf) || (ni == NI_System_EETypePtr_EETypePtrOf))
-    {
-        mustExpand = true;
+        case NI_System_ByReference_ctor:
+        case NI_System_ByReference_get_Value:
+        case NI_System_Activator_AllocatorOf:
+        case NI_System_Activator_DefaultConstructorOf:
+        case NI_System_Object_MethodTableOf:
+        case NI_System_EETypePtr_EETypePtrOf:
+            mustExpand = true;
+            break;
+
+        default:
+            break;
     }
 
     GenTree* retNode = nullptr;
@@ -4007,6 +4013,26 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                 break;
             }
 
+            case NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant:
+            {
+                GenTree* op1 = impPopStack().val;
+                if (op1->OperIsConst())
+                {
+                    // op1 is a known constant, replace with 'true'.
+                    retNode = gtNewIconNode(1);
+                    JITDUMP("\nExpanding RuntimeHelpers.IsKnownConstant to true early\n");
+                    // We can also consider FTN_ADDR and typeof(T) here
+                }
+                else
+                {
+                    // op1 is not a known constant, we'll do the expansion in morph
+                    retNode = new (this, GT_INTRINSIC) GenTreeIntrinsic(TYP_INT, op1, ni, method);
+                    JITDUMP("\nConverting RuntimeHelpers.IsKnownConstant to:\n");
+                    DISPTREE(retNode);
+                }
+                break;
+            }
+
             case NI_System_Activator_AllocatorOf:
             case NI_System_Activator_DefaultConstructorOf:
             case NI_System_Object_MethodTableOf:
@@ -5352,6 +5378,10 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
         {
             result = NI_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray;
         }
+        else if (strcmp(methodName, "IsKnownConstant") == 0)
+        {
+            result = NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant;
+        }
     }
     else if (strncmp(namespaceName, "System.Runtime.Intrinsics", 25) == 0)
     {

src/coreclr/jit/morph.cpp

@@ -13223,6 +13223,45 @@ GenTree* Compiler::fgMorphSmpOp(GenTree* tree, MorphAddrContext* mac)
             }
             break;
 
+        case GT_INTRINSIC:
+            if (tree->AsIntrinsic()->gtIntrinsicName ==
+                NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant)
+            {
+                // Should be expanded by the time it reaches CSE phase
+                assert(!optValnumCSE_phase);
+
+                JITDUMP("\nExpanding RuntimeHelpers.IsKnownConstant to ");
+                if (op1->OperIsConst())
+                {
+                    // We're lucky to catch a constant here while importer was not
+                    JITDUMP("true\n");
+                    DEBUG_DESTROY_NODE(tree, op1);
+                    tree = gtNewIconNode(1);
+                }
+                else
+                {
+                    GenTree* op1SideEffects = nullptr;
+                    gtExtractSideEffList(op1, &op1SideEffects, GTF_ALL_EFFECT);
+                    if (op1SideEffects != nullptr)
+                    {
+                        DEBUG_DESTROY_NODE(tree);
+                        // Keep side-effects of op1
+                        tree = gtNewOperNode(GT_COMMA, TYP_INT, op1SideEffects, gtNewIconNode(0));
+                        JITDUMP("false with side effects:\n")
+                        DISPTREE(tree);
+                    }
+                    else
+                    {
+                        JITDUMP("false\n");
+                        DEBUG_DESTROY_NODE(tree, op1);
+                        tree = gtNewIconNode(0);
+                    }
+                }
+                INDEBUG(tree->gtDebugFlags |= GTF_DEBUG_NODE_MORPHED);
+                return tree;
+            }
+            break;
+
         default:
             break;
     }

src/coreclr/jit/namedintrinsiclist.h

@@ -78,6 +78,7 @@ enum NamedIntrinsic : unsigned short
 
     NI_System_Runtime_CompilerServices_RuntimeHelpers_CreateSpan,
     NI_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray,
+    NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant,
 
     NI_System_String_get_Chars,
     NI_System_String_get_Length,

src/libraries/System.Private.CoreLib/src/System/Runtime/CompilerServices/RuntimeHelpers.cs

@@ -117,5 +117,15 @@ internal static bool IsPrimitiveType(this CorElementType et)
         /// <remarks>This method is intended for compiler use rather than use directly in code. T must be one of byte, sbyte, char, short, ushort, int, long, ulong, float, or double.</remarks>
         [Intrinsic]
         public static unsafe ReadOnlySpan<T> CreateSpan<T>(RuntimeFieldHandle fldHandle) => new ReadOnlySpan<T>(GetSpanDataFrom(fldHandle, typeof(T).TypeHandle, out int length), length);
+
+
+        // The following intrinsics return true if input is a compile-time constant
+        // Feel free to add more overloads on demand
+
+        [Intrinsic]
+        internal static bool IsKnownConstant(string? t) => false;
+
+        [Intrinsic]
+        internal static bool IsKnownConstant(char t) => false;
     }
 }

src/libraries/System.Private.CoreLib/src/System/String.Comparison.cs

@@ -681,8 +681,21 @@ public bool Equals([NotNullWhen(true)] string? value, StringComparison compariso
         }
 
         // Determines whether two Strings match.
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool Equals(string? a, string? b)
         {
+            // if either a or b are "" - optimize Equals to just 'str?.Length == 0'
+            // Otherwise, these two blocks are eliminated since IsKnownConstant is a jit-time constant
+            if (RuntimeHelpers.IsKnownConstant(a) && a?.Length == 0)
+            {
+                return b?.Length == 0;
+            }
+
+            if (RuntimeHelpers.IsKnownConstant(b) && b?.Length == 0)
+            {
+                return a?.Length == 0;
+            }
+
             if (object.ReferenceEquals(a, b))
             {
                 return true;
@@ -1013,7 +1026,15 @@ public bool StartsWith(string value, bool ignoreCase, CultureInfo? culture)
             return referenceCulture.CompareInfo.IsPrefix(this, value, ignoreCase ? CompareOptions.IgnoreCase : CompareOptions.None);
         }
 
-        public bool StartsWith(char value) => Length != 0 && _firstChar == value;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool StartsWith(char value)
+        {
+            if (RuntimeHelpers.IsKnownConstant(value) && value != '\0')
+            {
+                return _firstChar == value;
+            }
+            return Length != 0 && _firstChar == value;
+        }
 
         internal static void CheckStringComparison(StringComparison comparisonType)
         {