Allow some intrinsics in Tier0

src/coreclr/jit/compiler.h

@@ -9037,6 +9037,12 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
         COUNT_OPT_CODE
     };
 
+    enum OptimizationsKind
+    {
+        OPT_Lightweight,
+        OPT_All
+    };
+
     struct Options
     {
         JitFlags* jitFlags; // all flags passed from the EE
@@ -9106,8 +9112,25 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
         {
             return MinOpts() || compDbgCode;
         }
-        bool OptimizationEnabled() const
+
+        //------------------------------------------------------------------------
+        // OptimizationEnabled: Are optimizations of the specified kind allowed?
+        //
+        // Arguments:
+        //    kind - there are two kinds of optimizations:
+        //      OPT_All:         all kinds of optimizations
+        //      OPT_Lightweight: only those which won't regress JIT throughput
+        //
+        // Return Value:
+        //    true if JIT is alowed to perform optimizations of the given kind.
+        //
+        bool OptimizationEnabled(OptimizationsKind kind = OPT_All) const
         {
+            if (kind == OPT_Lightweight)
+            {
+                // Quick optimizations are allowed for all cases except debug code mode
+                return !compDbgCode;
+            }
             return !OptimizationDisabled();
         }
 

src/coreclr/jit/importer.cpp

@@ -3791,7 +3791,7 @@ void Compiler::impImportAndPushBox(CORINFO_RESOLVED_TOKEN* pResolvedToken)
         // and the other you get
         //    *(temp+4) = expr
 
-        if (opts.OptimizationDisabled())
+        if (!opts.OptimizationEnabled(OPT_Lightweight))
         {
             // For minopts/debug code, try and minimize the total number
             // of box temps by reusing an existing temp when possible.

src/coreclr/jit/importercalls.cpp

@@ -2476,14 +2476,41 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
             break;
     }
 
+    // Allow some lighweight intrinsics in Tier0 which can improve throughput
+    // we introduced betterToExpand here because we're fine if intrinsic decides to not expand itself
+    // in this case unlike mustExpand.
+    bool betterToExpand = mustExpand;
+    if (!mustExpand && opts.OptimizationEnabled(OPT_Lightweight))
+    {
+        switch (ni)
+        {
+            // HasFlag allocates in Tier0 and produces a fairly large IR tree
+            case NI_System_Enum_HasFlag:
+
+            // This one is just `return true/false`
+            case NI_System_Runtime_CompilerServices_RuntimeHelpers_IsKnownConstant:
+
+            // This is faster to expand than emitting get_Length call
+            case NI_System_String_get_Length:
+
+                betterToExpand = true;
+                break;
+
+            default:
+                // Unsafe.* are all small enough to prefer expansions.
+                betterToExpand = ni >= NI_SRCS_UNSAFE_START && ni <= NI_SRCS_UNSAFE_END;
+                break;
+        }
+    }
+
     GenTree* retNode = nullptr;
 
     // Under debug and minopts, only expand what is required.
     // NextCallReturnAddress intrinsic returns the return address of the next call.
     // If that call is an intrinsic and is expanded, codegen for NextCallReturnAddress will fail.
     // To avoid that we conservatively expand only required intrinsics in methods that call
     // the NextCallReturnAddress intrinsic.
-    if (!mustExpand && (opts.OptimizationDisabled() || info.compHasNextCallRetAddr))
+    if (!betterToExpand && !mustExpand && (opts.OptimizationDisabled() || info.compHasNextCallRetAddr))
     {
         *pIntrinsicName = NI_Illegal;
         return retNode;