Expose an eeIsJitIntrinsic method for quickly determining if a method handle represents an intrinsic method

src/coreclr/ToolBox/superpmi/superpmi-shared/lwmlist.h

@@ -101,6 +101,7 @@ LWM(GetJustMyCodeHandle, DWORDLONG, DLDL)
 LWM(GetLazyStringLiteralHelper, DWORDLONG, DWORD)
 LWM(GetLikelyClass, Agnostic_GetLikelyClass, Agnostic_GetLikelyClassResult)
 LWM(GetLocationOfThisType, DWORDLONG, Agnostic_CORINFO_LOOKUP_KIND)
+LWM(IsJitIntrinsic, DWORDLONG, DWORD)
 LWM(GetMethodAttribs, DWORDLONG, DWORD)
 LWM(GetClassModule, DWORDLONG, DWORDLONG)
 LWM(GetModuleAssembly, DWORDLONG, DWORDLONG)

src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.cpp

@@ -771,6 +771,28 @@ DWORD MethodContext::repGetClassAttribs(CORINFO_CLASS_HANDLE classHandle)
     return value;
 }
 
+void MethodContext::recIsJitIntrinsic(CORINFO_METHOD_HANDLE ftn, bool result)
+{
+    if (IsJitIntrinsic == nullptr)
+        IsJitIntrinsic = new LightWeightMap<DWORDLONG, DWORD>();
+
+    IsJitIntrinsic->Add(CastHandle(ftn), (DWORD)result);
+    DEBUG_REC(dmpIsJitIntrinsic(CastHandle(ftn), (DWORD)result));
+}
+void MethodContext::dmpIsJitIntrinsic(DWORDLONG key, DWORD value)
+{
+    printf("IsJitIntrinsic key ftn-%016llX, value res-%u", key, value);
+}
+bool MethodContext::repIsJitIntrinsic(CORINFO_METHOD_HANDLE ftn)
+{
+    AssertCodeMsg((IsJitIntrinsic != nullptr) && (IsJitIntrinsic->GetIndex(CastHandle(ftn)) != -1), EXCEPTIONCODE_MC,
+                  "Didn't find %016llX", CastHandle(ftn));
+
+    bool result = (BOOL)IsJitIntrinsic->Get(CastHandle(ftn));
+    DEBUG_REP(dmpIsJitIntrinsic(CastHandle(ftn), (DWORD)result));
+    return result;
+}
+
 void MethodContext::recGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle, DWORD attribs)
 {
     if (GetMethodAttribs == nullptr)

src/coreclr/ToolBox/superpmi/superpmi-shared/methodcontext.h

@@ -119,6 +119,10 @@ class MethodContext
     void dmpGetClassAttribs(DWORDLONG key, DWORD value);
     DWORD repGetClassAttribs(CORINFO_CLASS_HANDLE classHandle);
 
+    void recIsJitIntrinsic(CORINFO_METHOD_HANDLE ftn, bool result);
+    void dmpIsJitIntrinsic(DWORDLONG key, DWORD value);
+    bool repIsJitIntrinsic(CORINFO_METHOD_HANDLE ftn);
+
     void recGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle, DWORD attribs);
     void dmpGetMethodAttribs(DWORDLONG key, DWORD value);
     DWORD repGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle);
@@ -898,7 +902,7 @@ class MethodContext
 };
 
 // ********************* Please keep this up-to-date to ease adding more ***************
-// Highest packet number: 191
+// Highest packet number: 192
 // *************************************************************************************
 enum mcPackets
 {
@@ -1000,6 +1004,7 @@ enum mcPackets
     Packet_GetJustMyCodeHandle                           = 68,
     Packet_GetLikelyClass                                = 182, // Added 9/27/2020
     Packet_GetLocationOfThisType                         = 69,
+    Packet_IsJitIntrinsic                                = 192,
     Packet_GetMethodAttribs                              = 70,
     Packet_GetMethodClass                                = 71,
     Packet_GetMethodModule                               = 181, // Added 11/20/2020

src/coreclr/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp

@@ -17,6 +17,17 @@
 // ICorMethodInfo
 //
 /**********************************************************************************/
+
+// Quick check whether the method is a jit intrinsic. Returns the same value as getMethodAttribs(ftn) &
+// CORINFO_FLG_JIT_INTRINSIC, except faster.
+bool interceptor_ICJI::isJitIntrinsic(CORINFO_METHOD_HANDLE ftn)
+{
+    mc->cr->AddCall("isJitIntrinsic");
+    bool temp = original_ICorJitInfo->isJitIntrinsic(ftn);
+    mc->recIsJitIntrinsic(ftn, temp);
+    return temp;
+}
+
 // return flags (defined above, CORINFO_FLG_PUBLIC ...)
 uint32_t interceptor_ICJI::getMethodAttribs(CORINFO_METHOD_HANDLE ftn /* IN */)
 {

src/coreclr/ToolBox/superpmi/superpmi-shim-counter/icorjitinfo.cpp

@@ -12,6 +12,13 @@
 #include "spmiutil.h"
 
 
+bool interceptor_ICJI::isJitIntrinsic(
+          CORINFO_METHOD_HANDLE ftn)
+{
+    mcs->AddCall("isJitIntrinsic");
+    return original_ICorJitInfo->isJitIntrinsic(ftn);
+}
+
 uint32_t interceptor_ICJI::getMethodAttribs(
           CORINFO_METHOD_HANDLE ftn)
 {

src/coreclr/ToolBox/superpmi/superpmi-shim-simple/icorjitinfo.cpp

@@ -12,6 +12,12 @@
 #include "spmiutil.h"
 
 
+bool interceptor_ICJI::isJitIntrinsic(
+          CORINFO_METHOD_HANDLE ftn)
+{
+    return original_ICorJitInfo->isJitIntrinsic(ftn);
+}
+
 uint32_t interceptor_ICJI::getMethodAttribs(
           CORINFO_METHOD_HANDLE ftn)
 {

src/coreclr/ToolBox/superpmi/superpmi/icorjitinfo.cpp

@@ -23,6 +23,14 @@ ICorJitInfo* InitICorJitInfo(JitInstance* jitInstance)
 //
 /**********************************************************************************/
 
+// Quick check whether the method is a jit intrinsic. Returns the same value as getMethodAttribs(ftn) &
+// CORINFO_FLG_JIT_INTRINSIC, except faster.
+bool MyICJI::isJitIntrinsic(CORINFO_METHOD_HANDLE ftn)
+{
+    jitInstance->mc->cr->AddCall("isJitIntrinsic");
+    return jitInstance->mc->repIsJitIntrinsic(ftn);
+}
+
 // return flags (defined above, CORINFO_FLG_PUBLIC ...)
 uint32_t MyICJI::getMethodAttribs(CORINFO_METHOD_HANDLE ftn /* IN */)
 {

src/coreclr/inc/corinfo.h

@@ -1953,6 +1953,9 @@ class ICorStaticInfo
     //
     /**********************************************************************************/
 
+    // Quick check whether the method is a jit intrinsic. Returns the same value as getMethodAttribs(ftn) & CORINFO_FLG_JIT_INTRINSIC, except faster.
+    virtual bool isJitIntrinsic(CORINFO_METHOD_HANDLE ftn) = 0;
+
     // return flags (a bitfield of CorInfoFlags values)
     virtual uint32_t getMethodAttribs (
             CORINFO_METHOD_HANDLE       ftn         /* IN */

src/coreclr/inc/icorjitinfoimpl_generated.h

@@ -21,6 +21,9 @@
 
 public:
 
+bool isJitIntrinsic(
+          CORINFO_METHOD_HANDLE ftn) override;
+
 uint32_t getMethodAttribs(
           CORINFO_METHOD_HANDLE ftn) override;
 

src/coreclr/inc/jiteeversionguid.h

@@ -43,11 +43,11 @@ typedef const GUID *LPCGUID;
 #define GUID_DEFINED
 #endif // !GUID_DEFINED
 
-constexpr GUID JITEEVersionIdentifier = { /* 1776ab48-edfa-49be-a11f-ec216b28174c */
-    0x1776ab48,
-    0xedfa,
-    0x49be,
-    {0xa1, 0x1f, 0xec, 0x21, 0x6b, 0x28, 0x17, 0x4c}
+constexpr GUID JITEEVersionIdentifier = { /* a33f2f79-dd8d-49dd-b4c3-ac86f34f6a87 */
+    0xa33f2f79,
+    0xdd8d,
+    0x49dd,
+    {0xb4, 0xc3, 0xac, 0x86, 0xf3, 0x4f, 0x6a, 0x87}
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////

src/coreclr/jit/ICorJitInfo_API_names.h

@@ -4,6 +4,7 @@
 // DO NOT EDIT THIS FILE! IT IS AUTOGENERATED
 // To regenerate run the gen script in src/coreclr/tools/Common/JitInterface/ThunkGenerator
 // and follow the instructions in docs/project/updating-jitinterface.md
+DEF_CLR_API(isJitIntrinsic)
 DEF_CLR_API(getMethodAttribs)
 DEF_CLR_API(setMethodAttribs)
 DEF_CLR_API(getMethodSig)

src/coreclr/jit/ICorJitInfo_API_wrapper.hpp

@@ -12,6 +12,15 @@
 // clang-format off
 /**********************************************************************************/
 
+bool WrapICorJitInfo::isJitIntrinsic(
+          CORINFO_METHOD_HANDLE ftn)
+{
+    API_ENTER(isJitIntrinsic);
+    bool temp = wrapHnd->isJitIntrinsic(ftn);
+    API_LEAVE(isJitIntrinsic);
+    return temp;
+}
+
 uint32_t WrapICorJitInfo::getMethodAttribs(
           CORINFO_METHOD_HANDLE ftn)
 {

src/coreclr/jit/compiler.h

@@ -7542,6 +7542,7 @@ class Compiler
     // Get the flags
 
     bool eeIsValueClass(CORINFO_CLASS_HANDLE clsHnd);
+    bool eeIsJitIntrinsic(CORINFO_METHOD_HANDLE ftn);
 
 #if defined(DEBUG) || defined(FEATURE_JIT_METHOD_PERF) || defined(FEATURE_SIMD) || defined(TRACK_LSRA_STATS)
 

src/coreclr/jit/ee_il_dll.hpp

@@ -53,6 +53,12 @@ bool Compiler::eeIsValueClass(CORINFO_CLASS_HANDLE clsHnd)
     return info.compCompHnd->isValueClass(clsHnd);
 }
 
+FORCEINLINE
+bool Compiler::eeIsJitIntrinsic(CORINFO_METHOD_HANDLE ftn)
+{
+    return info.compCompHnd->isJitIntrinsic(ftn);
+}
+
 FORCEINLINE
 void Compiler::eeGetSig(unsigned               sigTok,
                         CORINFO_MODULE_HANDLE  scope,

src/coreclr/jit/fgbasic.cpp

@@ -893,8 +893,6 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
     }
 
     CORINFO_RESOLVED_TOKEN resolvedToken;
-    CORINFO_RESOLVED_TOKEN constrainedResolvedToken;
-    CORINFO_CALL_INFO      callInfo;
 
     while (codeAddr < codeEndp)
     {
@@ -958,54 +956,35 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                     break;
                 }
 
-                CORINFO_METHOD_HANDLE methodHnd   = nullptr;
-                unsigned              methodFlags = 0;
-                bool                  mustExpand  = false;
-                CorInfoIntrinsics     intrinsicID = CORINFO_INTRINSIC_Illegal;
-                NamedIntrinsic        ni          = NI_Illegal;
+                CORINFO_METHOD_HANDLE methodHnd      = nullptr;
+                bool                  isJitIntrinsic = false;
+                bool                  mustExpand     = false;
+                NamedIntrinsic        ni             = NI_Illegal;
 
                 if (resolveTokens)
                 {
                     impResolveToken(codeAddr, &resolvedToken, CORINFO_TOKENKIND_Method);
-                    eeGetCallInfo(&resolvedToken,
-                                  (prefixFlags & PREFIX_CONSTRAINED) ? &constrainedResolvedToken : nullptr,
-                                  combine(combine(CORINFO_CALLINFO_KINDONLY, CORINFO_CALLINFO_ALLOWINSTPARAM),
-                                          (opcode == CEE_CALLVIRT) ? CORINFO_CALLINFO_CALLVIRT : CORINFO_CALLINFO_NONE),
-                                  &callInfo);
-
-                    methodHnd   = callInfo.hMethod;
-                    methodFlags = callInfo.methodFlags;
+                    methodHnd      = resolvedToken.hMethod;
+                    isJitIntrinsic = eeIsJitIntrinsic(methodHnd);
                 }
 
-                if ((methodFlags & (CORINFO_FLG_INTRINSIC | CORINFO_FLG_JIT_INTRINSIC)) != 0)
+                if (isJitIntrinsic)
                 {
                     intrinsicCalls++;
+                    ni = lookupNamedIntrinsic(methodHnd);
 
-                    if ((methodFlags & CORINFO_FLG_INTRINSIC) != 0)
+                    switch (ni)
                     {
-                        intrinsicID = info.compCompHnd->getIntrinsicID(methodHnd, &mustExpand);
-                    }
+                        case NI_IsSupported_True:
+                        case NI_IsSupported_False:
+                        {
+                            pushedStack.PushConstant();
+                            break;
+                        }
 
-                    if ((methodFlags & CORINFO_FLG_JIT_INTRINSIC) != 0)
-                    {
-                        if (intrinsicID == CORINFO_INTRINSIC_Illegal)
+                        default:
                         {
-                            ni = lookupNamedIntrinsic(methodHnd);
-
-                            switch (ni)
-                            {
-                                case NI_IsSupported_True:
-                                case NI_IsSupported_False:
-                                {
-                                    pushedStack.PushConstant();
-                                    break;
-                                }
-
-                                default:
-                                {
-                                    break;
-                                }
-                            }
+                            break;
                         }
                     }
                 }
@@ -1162,10 +1141,6 @@ void Compiler::fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, Fixed
                 noway_assert(sz == sizeof(unsigned));
                 prefixFlags |= PREFIX_CONSTRAINED;
 
-                if (resolveTokens)
-                {
-                    impResolveToken(codeAddr, &constrainedResolvedToken, CORINFO_TOKENKIND_Constrained);
-                }
                 codeAddr += sizeof(unsigned);
 
                 {