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

src/coreclr/jit/fgbasic.cpp

@@ -1145,6 +1145,12 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                                 break;
                             }
 
+                            case NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant:
+                                pushedStack.PushConstant();
+                                foldableIntrinsc = 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:

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,24 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                 break;
             }
 
+            case NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant:
+            {
+                GenTree* op1 = impPopStack().val;
+                if (op1->OperIsConst() || gtFoldExpr(op1)->OperIsConst())
+                {
+                    // op1 is a known constant, replace with 'true'.
+                    retNode = gtNewIconNode(1);
+                    // We can also consider FTN_ADDR and typeof(T) here
+                }
+                else
+                {
+                    // op1 is not a known constant, replace with 'false'.
+                    // TODO: delay till e.g. morph and try again, maybe op1 will become a const.
+                    retNode = gtNewIconNode(0);
+                }
+                break;
+            }
+
             case NI_System_Activator_AllocatorOf:
             case NI_System_Activator_DefaultConstructorOf:
             case NI_System_Object_MethodTableOf:
@@ -5352,6 +5376,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/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,11 @@ 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);
+
+        /// <summary>
+        /// Returns true if input is a compile-time constant
+        /// </summary>
+        [Intrinsic]
+        internal static bool IsKnownConstant<T>(T 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))
+            {
+                return _firstChar == value;
+            }
+            return Length != 0 && _firstChar == value;
+        }
 
         internal static void CheckStringComparison(StringComparison comparisonType)
         {