Better fix

Author: EgorBo

src/coreclr/jit/compiler.h

@@ -3571,14 +3571,18 @@ class Compiler
 
     // Return true if call is a recursive call; return false otherwise.
     // Note when inlining, this looks for calls back to the root method.
-    bool gtIsRecursiveCall(GenTreeCall* call)
+    bool gtIsRecursiveCall(GenTreeCall* call, bool inlineeOnly = false)
     {
-        return gtIsRecursiveCall(call->gtCallMethHnd);
+        return gtIsRecursiveCall(call->gtCallMethHnd, inlineeOnly);
     }
 
-    bool gtIsRecursiveCall(CORINFO_METHOD_HANDLE callMethodHandle)
+    bool gtIsRecursiveCall(CORINFO_METHOD_HANDLE callMethodHandle, bool inlineeOnly = false)
     {
-        return (callMethodHandle == impInlineRoot()->info.compMethodHnd);
+        if (inlineeOnly)
+        {
+            return callMethodHandle == info.compMethodHnd;
+        }
+        return callMethodHandle == impInlineRoot()->info.compMethodHnd;
     }
 
     //-------------------------------------------------------------------------
@@ -4539,7 +4543,8 @@ class Compiler
                             CORINFO_CLASS_HANDLE  clsHnd,
                             CORINFO_METHOD_HANDLE method,
                             CORINFO_SIG_INFO*     sig,
-                            bool                  mustExpand);
+                            bool                  mustExpand,
+                            bool*                 pLateExpansion);
     GenTree* impSimdAsHWIntrinsic(NamedIntrinsic        intrinsic,
                                   CORINFO_CLASS_HANDLE  clsHnd,
                                   CORINFO_METHOD_HANDLE method,

src/coreclr/jit/hwintrinsic.cpp

@@ -1036,20 +1036,23 @@ struct HWIntrinsicSignatureReader final
 // impHWIntrinsic: Import a hardware intrinsic as a GT_HWINTRINSIC node if possible
 //
 // Arguments:
-//    intrinsic  -- id of the intrinsic function.
-//    clsHnd     -- class handle containing the intrinsic function.
-//    method     -- method handle of the intrinsic function.
-//    sig        -- signature of the intrinsic call
-//    mustExpand -- true if the intrinsic must return a GenTree*; otherwise, false
-
+//    intrinsic      - id of the intrinsic function.
+//    clsHnd         - class handle containing the intrinsic function.
+//    method         - method handle of the intrinsic function.
+//    sig            - signature of the intrinsic call
+//    mustExpand     - true if the intrinsic must return a GenTree*; otherwise, false
+//    pLateExpansion - [OUT] set to true if the intrinsic must be expanded during codegen phase
+//                     (typically, via a jump table).
+//
 // Return Value:
 //    The GT_HWINTRINSIC node, or nullptr if not a supported intrinsic
 //
 GenTree* Compiler::impHWIntrinsic(NamedIntrinsic        intrinsic,
                                   CORINFO_CLASS_HANDLE  clsHnd,
                                   CORINFO_METHOD_HANDLE method,
                                   CORINFO_SIG_INFO*     sig,
-                                  bool                  mustExpand)
+                                  bool                  mustExpand,
+                                  bool*                 pLateExpansion)
 {
     // NextCallRetAddr requires a CALL, so return nullptr.
     if (!mustExpand && info.compHasNextCallRetAddr)
@@ -1225,7 +1228,8 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic        intrinsic,
 
         if ((immVal2 < immLowerBound2) || (immVal2 > immUpperBound2))
         {
-            assert(!mustExpand);
+            // Will be expanded as a jump table during codegen phase
+            *pLateExpansion = true;
             return nullptr;
         }
     }
@@ -1306,7 +1310,8 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic        intrinsic,
 
             if (immOutOfRange)
             {
-                assert(!mustExpand);
+                // Will be expanded as a jump table during codegen phase
+                *pLateExpansion = true;
                 // The imm-HWintrinsics that do not accept all imm8 values may throw
                 // ArgumentOutOfRangeException when the imm argument is not in the valid range
                 return nullptr;

src/coreclr/jit/importercalls.cpp

@@ -2871,7 +2871,7 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
     if (isIntrinsic)
     {
         // The recursive non-virtual calls to Jit intrinsics are must-expand by convention.
-        mustExpand = gtIsRecursiveCall(method) && !(methodFlags & CORINFO_FLG_VIRTUAL);
+        mustExpand = gtIsRecursiveCall(method, true) && !(methodFlags & CORINFO_FLG_VIRTUAL);
     }
     else
     {
@@ -3054,9 +3054,10 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
                 }
             }
 
-            GenTree* hwintrinsic = impHWIntrinsic(ni, clsHnd, method, sig, mustExpand);
+            bool     lateExpansion = false;
+            GenTree* hwintrinsic   = impHWIntrinsic(ni, clsHnd, method, sig, mustExpand, &lateExpansion);
 
-            if (mustExpand && (hwintrinsic == nullptr))
+            if (mustExpand && (hwintrinsic == nullptr) && !lateExpansion)
             {
                 return impUnsupportedNamedIntrinsic(CORINFO_HELP_THROW_NOT_IMPLEMENTED, method, sig, mustExpand);
             }
@@ -9611,7 +9612,7 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
                             assert(strcmp(className, "Vector`1") == 0);
                             result = NI_Vector_GetCount;
                         }
-                        else if (gtIsRecursiveCall(method))
+                        else if (gtIsRecursiveCall(method, true))
                         {
                             // For the framework itself, any recursive intrinsics will either be
                             // only supported on a single platform or will be guarded by a relevant
@@ -9835,7 +9836,7 @@ NamedIntrinsic Compiler::lookupNamedIntrinsic(CORINFO_METHOD_HANDLE method)
 
                             result = NI_Vector_GetCount;
                         }
-                        else if (gtIsRecursiveCall(method))
+                        else if (gtIsRecursiveCall(method, true))
                         {
                             // For the framework itself, any recursive intrinsics will either be
                             // only supported on a single platform or will be guarded by a relevant