Massively simplify getBaseJitTypeAndSizeOfSIMDType and the general SIMD handle...

Massively simplify getBaseJitTypeAndSizeOfSIMDType and the general SIMD handle caching/lookup (#83228)

src/coreclr/jit/compiler.h

@@ -2797,7 +2797,6 @@ public:
                                                    NamedIntrinsic hwIntrinsicID);
     GenTreeHWIntrinsic* gtNewScalarHWIntrinsicNode(
         var_types type, GenTree* op1, GenTree* op2, GenTree* op3, NamedIntrinsic hwIntrinsicID);
-    CORINFO_CLASS_HANDLE gtGetStructHandleForHWSIMD(var_types simdType, CorInfoType simdBaseJitType);
     CorInfoType getBaseJitTypeFromArgIfNeeded(NamedIntrinsic       intrinsic,
                                               CORINFO_CLASS_HANDLE clsHnd,
                                               CORINFO_SIG_INFO*    sig,
@@ -8408,80 +8407,28 @@ private:
 
     struct SIMDHandlesCache
     {
+        // BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG
+        // NATIVEINT, NATIVEUINT, FLOAT, and DOUBLE
+        static const uint32_t SupportedTypeCount = 12;
+
         // SIMD Types
-        CORINFO_CLASS_HANDLE SIMDFloatHandle;
-        CORINFO_CLASS_HANDLE SIMDDoubleHandle;
-        CORINFO_CLASS_HANDLE SIMDIntHandle;
-        CORINFO_CLASS_HANDLE SIMDUShortHandle;
-        CORINFO_CLASS_HANDLE SIMDUByteHandle;
-        CORINFO_CLASS_HANDLE SIMDShortHandle;
-        CORINFO_CLASS_HANDLE SIMDByteHandle;
-        CORINFO_CLASS_HANDLE SIMDLongHandle;
-        CORINFO_CLASS_HANDLE SIMDUIntHandle;
-        CORINFO_CLASS_HANDLE SIMDULongHandle;
-        CORINFO_CLASS_HANDLE SIMDNIntHandle;
-        CORINFO_CLASS_HANDLE SIMDNUIntHandle;
-
-        CORINFO_CLASS_HANDLE SIMDPlaneHandle;
-        CORINFO_CLASS_HANDLE SIMDQuaternionHandle;
-        CORINFO_CLASS_HANDLE SIMDVector2Handle;
-        CORINFO_CLASS_HANDLE SIMDVector3Handle;
-        CORINFO_CLASS_HANDLE SIMDVector4Handle;
-        CORINFO_CLASS_HANDLE SIMDVectorHandle;
+        CORINFO_CLASS_HANDLE VectorTHandles[SupportedTypeCount];
+
+        CORINFO_CLASS_HANDLE PlaneHandle;
+        CORINFO_CLASS_HANDLE QuaternionHandle;
+        CORINFO_CLASS_HANDLE Vector2Handle;
+        CORINFO_CLASS_HANDLE Vector3Handle;
+        CORINFO_CLASS_HANDLE Vector4Handle;
+        CORINFO_CLASS_HANDLE VectorHandle;
 
 #ifdef FEATURE_HW_INTRINSICS
 #if defined(TARGET_ARM64)
-        CORINFO_CLASS_HANDLE Vector64FloatHandle;
-        CORINFO_CLASS_HANDLE Vector64DoubleHandle;
-        CORINFO_CLASS_HANDLE Vector64IntHandle;
-        CORINFO_CLASS_HANDLE Vector64UShortHandle;
-        CORINFO_CLASS_HANDLE Vector64UByteHandle;
-        CORINFO_CLASS_HANDLE Vector64ShortHandle;
-        CORINFO_CLASS_HANDLE Vector64ByteHandle;
-        CORINFO_CLASS_HANDLE Vector64LongHandle;
-        CORINFO_CLASS_HANDLE Vector64UIntHandle;
-        CORINFO_CLASS_HANDLE Vector64ULongHandle;
-        CORINFO_CLASS_HANDLE Vector64NIntHandle;
-        CORINFO_CLASS_HANDLE Vector64NUIntHandle;
+        CORINFO_CLASS_HANDLE Vector64THandles[SupportedTypeCount];
 #endif // defined(TARGET_ARM64)
-        CORINFO_CLASS_HANDLE Vector128FloatHandle;
-        CORINFO_CLASS_HANDLE Vector128DoubleHandle;
-        CORINFO_CLASS_HANDLE Vector128IntHandle;
-        CORINFO_CLASS_HANDLE Vector128UShortHandle;
-        CORINFO_CLASS_HANDLE Vector128UByteHandle;
-        CORINFO_CLASS_HANDLE Vector128ShortHandle;
-        CORINFO_CLASS_HANDLE Vector128ByteHandle;
-        CORINFO_CLASS_HANDLE Vector128LongHandle;
-        CORINFO_CLASS_HANDLE Vector128UIntHandle;
-        CORINFO_CLASS_HANDLE Vector128ULongHandle;
-        CORINFO_CLASS_HANDLE Vector128NIntHandle;
-        CORINFO_CLASS_HANDLE Vector128NUIntHandle;
+        CORINFO_CLASS_HANDLE Vector128THandles[SupportedTypeCount];
 #if defined(TARGET_XARCH)
-        CORINFO_CLASS_HANDLE Vector256FloatHandle;
-        CORINFO_CLASS_HANDLE Vector256DoubleHandle;
-        CORINFO_CLASS_HANDLE Vector256IntHandle;
-        CORINFO_CLASS_HANDLE Vector256UShortHandle;
-        CORINFO_CLASS_HANDLE Vector256UByteHandle;
-        CORINFO_CLASS_HANDLE Vector256ShortHandle;
-        CORINFO_CLASS_HANDLE Vector256ByteHandle;
-        CORINFO_CLASS_HANDLE Vector256LongHandle;
-        CORINFO_CLASS_HANDLE Vector256UIntHandle;
-        CORINFO_CLASS_HANDLE Vector256ULongHandle;
-        CORINFO_CLASS_HANDLE Vector256NIntHandle;
-        CORINFO_CLASS_HANDLE Vector256NUIntHandle;
-
-        CORINFO_CLASS_HANDLE Vector512FloatHandle;
-        CORINFO_CLASS_HANDLE Vector512DoubleHandle;
-        CORINFO_CLASS_HANDLE Vector512IntHandle;
-        CORINFO_CLASS_HANDLE Vector512UShortHandle;
-        CORINFO_CLASS_HANDLE Vector512UByteHandle;
-        CORINFO_CLASS_HANDLE Vector512ShortHandle;
-        CORINFO_CLASS_HANDLE Vector512ByteHandle;
-        CORINFO_CLASS_HANDLE Vector512LongHandle;
-        CORINFO_CLASS_HANDLE Vector512UIntHandle;
-        CORINFO_CLASS_HANDLE Vector512ULongHandle;
-        CORINFO_CLASS_HANDLE Vector512NIntHandle;
-        CORINFO_CLASS_HANDLE Vector512NUIntHandle;
+        CORINFO_CLASS_HANDLE Vector256THandles[SupportedTypeCount];
+        CORINFO_CLASS_HANDLE Vector512THandles[SupportedTypeCount];
 #endif // defined(TARGET_XARCH)
 #endif // FEATURE_HW_INTRINSICS
 
@@ -8492,23 +8439,21 @@ private:
 
         SIMDHandlesCache()
         {
+            assert(SupportedTypeCount == static_cast<uint32_t>(CORINFO_TYPE_DOUBLE - CORINFO_TYPE_BYTE + 1));
             memset(this, 0, sizeof(*this));
         }
     };
 
     SIMDHandlesCache* m_simdHandleCache;
 
-    // Get the handle for a SIMD type.
+#if defined(FEATURE_HW_INTRINSICS)
     CORINFO_CLASS_HANDLE gtGetStructHandleForSIMD(var_types simdType, CorInfoType simdBaseJitType)
     {
         assert(varTypeIsSIMD(simdType));
+        assert((simdBaseJitType >= CORINFO_TYPE_BYTE) && (simdBaseJitType <= CORINFO_TYPE_DOUBLE));
 
-        if (m_simdHandleCache == nullptr)
-        {
-            // This may happen if the JIT generates SIMD node on its own, without importing them.
-            // Otherwise getBaseJitTypeAndSizeOfSIMDType should have created the cache.
-            return NO_CLASS_HANDLE;
-        }
+        // We should only be called from gtGetStructHandleForSimdOrHW and this should've been checked already
+        assert(m_simdHandleCache != nullptr);
 
         if (simdBaseJitType == CORINFO_TYPE_FLOAT)
         {
@@ -8516,95 +8461,133 @@ private:
             {
                 case TYP_SIMD8:
                 {
-                    return m_simdHandleCache->SIMDVector2Handle;
+                    return m_simdHandleCache->Vector2Handle;
                 }
 
                 case TYP_SIMD12:
                 {
-                    return m_simdHandleCache->SIMDVector3Handle;
+                    return m_simdHandleCache->Vector3Handle;
                 }
 
                 case TYP_SIMD16:
                 {
                     // We order the checks roughly by expected hit count so early exits are possible
 
-                    if (simdBaseJitType != CORINFO_TYPE_FLOAT)
+                    if (m_simdHandleCache->Vector4Handle != NO_CLASS_HANDLE)
                     {
-                        // We could be Vector<T>, so handle below
-                        assert(getSIMDVectorType() == TYP_SIMD16);
-                        break;
+                        return m_simdHandleCache->Vector4Handle;
                     }
 
-                    if (m_simdHandleCache->SIMDVector4Handle != NO_CLASS_HANDLE)
+                    if (m_simdHandleCache->QuaternionHandle != NO_CLASS_HANDLE)
                     {
-                        return m_simdHandleCache->SIMDVector4Handle;
+                        return m_simdHandleCache->QuaternionHandle;
                     }
 
-                    if (m_simdHandleCache->SIMDQuaternionHandle != NO_CLASS_HANDLE)
+                    if (m_simdHandleCache->PlaneHandle != NO_CLASS_HANDLE)
                     {
-                        return m_simdHandleCache->SIMDQuaternionHandle;
+                        return m_simdHandleCache->PlaneHandle;
                     }
 
-                    if (m_simdHandleCache->SIMDPlaneHandle != NO_CLASS_HANDLE)
-                    {
-                        return m_simdHandleCache->SIMDPlaneHandle;
-                    }
-
-                    return NO_CLASS_HANDLE;
+                    break;
                 }
 
 #if defined(TARGET_XARCH)
                 case TYP_SIMD32:
                 case TYP_SIMD64:
+                {
+                    // This should be handled by the Vector<T> path below
                     break;
+                }
 #endif // TARGET_XARCH
 
                 default:
+                {
                     unreached();
+                }
             }
         }
 
-        assert(emitTypeSize(simdType) <= largestEnregisterableStructSize());
-
-        switch (simdBaseJitType)
-        {
-            case CORINFO_TYPE_FLOAT:
-                return m_simdHandleCache->SIMDFloatHandle;
-            case CORINFO_TYPE_DOUBLE:
-                return m_simdHandleCache->SIMDDoubleHandle;
-            case CORINFO_TYPE_INT:
-                return m_simdHandleCache->SIMDIntHandle;
-            case CORINFO_TYPE_USHORT:
-                return m_simdHandleCache->SIMDUShortHandle;
-            case CORINFO_TYPE_UBYTE:
-                return m_simdHandleCache->SIMDUByteHandle;
-            case CORINFO_TYPE_SHORT:
-                return m_simdHandleCache->SIMDShortHandle;
-            case CORINFO_TYPE_BYTE:
-                return m_simdHandleCache->SIMDByteHandle;
-            case CORINFO_TYPE_LONG:
-                return m_simdHandleCache->SIMDLongHandle;
-            case CORINFO_TYPE_UINT:
-                return m_simdHandleCache->SIMDUIntHandle;
-            case CORINFO_TYPE_ULONG:
-                return m_simdHandleCache->SIMDULongHandle;
-            case CORINFO_TYPE_NATIVEINT:
-                return m_simdHandleCache->SIMDNIntHandle;
-            case CORINFO_TYPE_NATIVEUINT:
-                return m_simdHandleCache->SIMDNUIntHandle;
-            default:
-                assert(!"Didn't find a class handle for simdType");
+        if (emitTypeSize(simdType) != getSIMDVectorRegisterByteLength())
+        {
+            // We have scenarios, such as shifting Vector<T> by a non-constant
+            // which may introduce different sized vectors that are marked as
+            // isSimdAsHWIntrinsic.
+
+            return NO_CLASS_HANDLE;
         }
 
-        return NO_CLASS_HANDLE;
+        uint32_t handleIndex = static_cast<uint32_t>(simdBaseJitType - CORINFO_TYPE_BYTE);
+        assert(handleIndex < SIMDHandlesCache::SupportedTypeCount);
+
+        return m_simdHandleCache->VectorTHandles[handleIndex];
+    }
+
+    CORINFO_CLASS_HANDLE gtGetStructHandleForHWSIMD(var_types simdType, CorInfoType simdBaseJitType)
+    {
+        assert(varTypeIsSIMD(simdType));
+        assert((simdBaseJitType >= CORINFO_TYPE_BYTE) && (simdBaseJitType <= CORINFO_TYPE_DOUBLE));
+
+        // We should only be called from gtGetStructHandleForSimdOrHW and this should've been checked already
+        assert(m_simdHandleCache != nullptr);
+
+        uint32_t handleIndex = static_cast<uint32_t>(simdBaseJitType - CORINFO_TYPE_BYTE);
+        assert(handleIndex < SIMDHandlesCache::SupportedTypeCount);
+
+        switch (simdType)
+        {
+            case TYP_SIMD8:
+            {
+#if defined(TARGET_ARM64)
+                return m_simdHandleCache->Vector64THandles[handleIndex];
+#else
+                // This can only be Vector2 and should've been handled by gtGetStructHandleForSIMD
+                return NO_CLASS_HANDLE;
+#endif
+            }
+
+            case TYP_SIMD12:
+            {
+                // This can only be Vector3 and should've been handled by gtGetStructHandleForSIMD
+                return NO_CLASS_HANDLE;
+            }
+
+            case TYP_SIMD16:
+            {
+                return m_simdHandleCache->Vector128THandles[handleIndex];
+            }
+
+#if defined(TARGET_XARCH)
+            case TYP_SIMD32:
+            {
+                return m_simdHandleCache->Vector256THandles[handleIndex];
+            }
+
+            case TYP_SIMD64:
+            {
+                return m_simdHandleCache->Vector512THandles[handleIndex];
+            }
+#endif // TARGET_XARCH
+
+            default:
+            {
+                unreached();
+            }
+        }
     }
 
-#if defined(FEATURE_HW_INTRINSICS)
     CORINFO_CLASS_HANDLE gtGetStructHandleForSimdOrHW(var_types   simdType,
                                                       CorInfoType simdBaseJitType,
                                                       bool        isSimdAsHWIntrinsic = false)
     {
         assert(varTypeIsSIMD(simdType));
+        assert((simdBaseJitType >= CORINFO_TYPE_BYTE) && (simdBaseJitType <= CORINFO_TYPE_DOUBLE));
+
+        if (m_simdHandleCache == nullptr)
+        {
+            // This may happen if the JIT generates SIMD node on its own, without importing them.
+            // Otherwise getBaseJitTypeAndSizeOfSIMDType should have created the cache.
+            return NO_CLASS_HANDLE;
+        }
 
         CORINFO_CLASS_HANDLE clsHnd = NO_CLASS_HANDLE;
 
@@ -8612,16 +8595,15 @@ private:
         {
             clsHnd = gtGetStructHandleForSIMD(simdType, simdBaseJitType);
         }
-        else
+
+        if (clsHnd == NO_CLASS_HANDLE)
         {
             clsHnd = gtGetStructHandleForHWSIMD(simdType, simdBaseJitType);
         }
 
-        // Currently there are cases where isSimdAsHWIntrinsic is passed
-        // incorrectly. Fall back to the canonical SIMD handle in that case.
-        // TODO-cleanup: We can probably just always use the canonical handle.
         if (clsHnd == NO_CLASS_HANDLE)
         {
+            // TODO-cleanup: We can probably just always use the canonical handle.
             clsHnd = gtGetCanonicalStructHandleForSIMD(simdType);
         }
 
@@ -8657,7 +8639,7 @@ private:
             case TYP_SIMD8:
                 return m_simdHandleCache->CanonicalSimd8Handle;
             case TYP_SIMD12:
-                return m_simdHandleCache->SIMDVector3Handle;
+                return m_simdHandleCache->Vector3Handle;
             case TYP_SIMD16:
                 return m_simdHandleCache->CanonicalSimd16Handle;
 #if defined(TARGET_XARCH)
@@ -8685,27 +8667,27 @@ private:
             return false;
         }
 
-        if (structHandle == m_simdHandleCache->SIMDVector4Handle)
+        if (structHandle == m_simdHandleCache->Vector4Handle)
         {
             return false;
         }
 
-        if (structHandle == m_simdHandleCache->SIMDVector3Handle)
+        if (structHandle == m_simdHandleCache->Vector3Handle)
         {
             return false;
         }
 
-        if (structHandle == m_simdHandleCache->SIMDVector2Handle)
+        if (structHandle == m_simdHandleCache->Vector2Handle)
         {
             return false;
         }
 
-        if (structHandle == m_simdHandleCache->SIMDQuaternionHandle)
+        if (structHandle == m_simdHandleCache->QuaternionHandle)
         {
             return false;
         }
 
-        if (structHandle == m_simdHandleCache->SIMDPlaneHandle)
+        if (structHandle == m_simdHandleCache->PlaneHandle)
         {
             return false;
         }

src/coreclr/jit/hwintrinsic.cpp

@@ -86,150 +86,6 @@ CorInfoType Compiler::getBaseJitTypeFromArgIfNeeded(NamedIntrinsic       intrins
     return simdBaseJitType;
 }
 
-CORINFO_CLASS_HANDLE Compiler::gtGetStructHandleForHWSIMD(var_types simdType, CorInfoType simdBaseJitType)
-{
-    assert(varTypeIsSIMD(simdType));
-
-    if (m_simdHandleCache == nullptr)
-    {
-        return NO_CLASS_HANDLE;
-    }
-    if (simdType == TYP_SIMD16)
-    {
-        switch (simdBaseJitType)
-        {
-            case CORINFO_TYPE_FLOAT:
-                return m_simdHandleCache->Vector128FloatHandle;
-            case CORINFO_TYPE_DOUBLE:
-                return m_simdHandleCache->Vector128DoubleHandle;
-            case CORINFO_TYPE_INT:
-                return m_simdHandleCache->Vector128IntHandle;
-            case CORINFO_TYPE_USHORT:
-                return m_simdHandleCache->Vector128UShortHandle;
-            case CORINFO_TYPE_UBYTE:
-                return m_simdHandleCache->Vector128UByteHandle;
-            case CORINFO_TYPE_SHORT:
-                return m_simdHandleCache->Vector128ShortHandle;
-            case CORINFO_TYPE_BYTE:
-                return m_simdHandleCache->Vector128ByteHandle;
-            case CORINFO_TYPE_LONG:
-                return m_simdHandleCache->Vector128LongHandle;
-            case CORINFO_TYPE_UINT:
-                return m_simdHandleCache->Vector128UIntHandle;
-            case CORINFO_TYPE_ULONG:
-                return m_simdHandleCache->Vector128ULongHandle;
-            case CORINFO_TYPE_NATIVEINT:
-                return m_simdHandleCache->Vector128NIntHandle;
-            case CORINFO_TYPE_NATIVEUINT:
-                return m_simdHandleCache->Vector128NUIntHandle;
-            default:
-                assert(!"Didn't find a class handle for simdType");
-        }
-    }
-#if defined(TARGET_XARCH)
-    else if (simdType == TYP_SIMD32)
-    {
-        switch (simdBaseJitType)
-        {
-            case CORINFO_TYPE_FLOAT:
-                return m_simdHandleCache->Vector256FloatHandle;
-            case CORINFO_TYPE_DOUBLE:
-                return m_simdHandleCache->Vector256DoubleHandle;
-            case CORINFO_TYPE_INT:
-                return m_simdHandleCache->Vector256IntHandle;
-            case CORINFO_TYPE_USHORT:
-                return m_simdHandleCache->Vector256UShortHandle;
-            case CORINFO_TYPE_UBYTE:
-                return m_simdHandleCache->Vector256UByteHandle;
-            case CORINFO_TYPE_SHORT:
-                return m_simdHandleCache->Vector256ShortHandle;
-            case CORINFO_TYPE_BYTE:
-                return m_simdHandleCache->Vector256ByteHandle;
-            case CORINFO_TYPE_LONG:
-                return m_simdHandleCache->Vector256LongHandle;
-            case CORINFO_TYPE_UINT:
-                return m_simdHandleCache->Vector256UIntHandle;
-            case CORINFO_TYPE_ULONG:
-                return m_simdHandleCache->Vector256ULongHandle;
-            case CORINFO_TYPE_NATIVEINT:
-                return m_simdHandleCache->Vector256NIntHandle;
-            case CORINFO_TYPE_NATIVEUINT:
-                return m_simdHandleCache->Vector256NUIntHandle;
-            default:
-                assert(!"Didn't find a class handle for simdType");
-        }
-    }
-    else if (simdType == TYP_SIMD64)
-    {
-        switch (simdBaseJitType)
-        {
-            case CORINFO_TYPE_FLOAT:
-                return m_simdHandleCache->Vector512FloatHandle;
-            case CORINFO_TYPE_DOUBLE:
-                return m_simdHandleCache->Vector512DoubleHandle;
-            case CORINFO_TYPE_INT:
-                return m_simdHandleCache->Vector512IntHandle;
-            case CORINFO_TYPE_USHORT:
-                return m_simdHandleCache->Vector512UShortHandle;
-            case CORINFO_TYPE_UBYTE:
-                return m_simdHandleCache->Vector512UByteHandle;
-            case CORINFO_TYPE_SHORT:
-                return m_simdHandleCache->Vector512ShortHandle;
-            case CORINFO_TYPE_BYTE:
-                return m_simdHandleCache->Vector512ByteHandle;
-            case CORINFO_TYPE_LONG:
-                return m_simdHandleCache->Vector512LongHandle;
-            case CORINFO_TYPE_UINT:
-                return m_simdHandleCache->Vector512UIntHandle;
-            case CORINFO_TYPE_ULONG:
-                return m_simdHandleCache->Vector512ULongHandle;
-            case CORINFO_TYPE_NATIVEINT:
-                return m_simdHandleCache->Vector512NIntHandle;
-            case CORINFO_TYPE_NATIVEUINT:
-                return m_simdHandleCache->Vector512NUIntHandle;
-            default:
-                assert(!"Didn't find a class handle for simdType");
-        }
-    }
-#endif // TARGET_XARCH
-#ifdef TARGET_ARM64
-    else if (simdType == TYP_SIMD8)
-    {
-        switch (simdBaseJitType)
-        {
-            case CORINFO_TYPE_FLOAT:
-                return m_simdHandleCache->Vector64FloatHandle;
-            case CORINFO_TYPE_DOUBLE:
-                return m_simdHandleCache->Vector64DoubleHandle;
-            case CORINFO_TYPE_INT:
-                return m_simdHandleCache->Vector64IntHandle;
-            case CORINFO_TYPE_USHORT:
-                return m_simdHandleCache->Vector64UShortHandle;
-            case CORINFO_TYPE_UBYTE:
-                return m_simdHandleCache->Vector64UByteHandle;
-            case CORINFO_TYPE_SHORT:
-                return m_simdHandleCache->Vector64ShortHandle;
-            case CORINFO_TYPE_BYTE:
-                return m_simdHandleCache->Vector64ByteHandle;
-            case CORINFO_TYPE_UINT:
-                return m_simdHandleCache->Vector64UIntHandle;
-            case CORINFO_TYPE_LONG:
-                return m_simdHandleCache->Vector64LongHandle;
-            case CORINFO_TYPE_ULONG:
-                return m_simdHandleCache->Vector64ULongHandle;
-            case CORINFO_TYPE_NATIVEINT:
-                return m_simdHandleCache->Vector64NIntHandle;
-            case CORINFO_TYPE_NATIVEUINT:
-                return m_simdHandleCache->Vector64NUIntHandle;
-            default:
-                assert(!"Didn't find a class handle for simdType");
-        }
-    }
-#endif // TARGET_ARM64
-
-    return NO_CLASS_HANDLE;
-}
-
 //------------------------------------------------------------------------
 // vnEncodesResultTypeForHWIntrinsic(NamedIntrinsic hwIntrinsicID):
 //

src/coreclr/jit/hwintrinsicarm64.cpp

@@ -1056,7 +1056,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
 
             if (varTypeIsByte(simdBaseType) && (simdSize == 16))
             {
-                CORINFO_CLASS_HANDLE simdClsHnd = gtGetStructHandleForSIMD(simdType, simdBaseJitType);
+                CORINFO_CLASS_HANDLE simdClsHnd = gtGetStructHandleForSimdOrHW(simdType, simdBaseJitType);
 
                 op1 = impCloneExpr(op1, &op2, simdClsHnd, CHECK_SPILL_ALL,
                                    nullptr DEBUGARG("Clone op1 for vector extractmostsignificantbits"));
@@ -1091,7 +1091,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
                 {
                     if ((simdSize == 8) && ((simdBaseType == TYP_INT) || (simdBaseType == TYP_UINT)))
                     {
-                        CORINFO_CLASS_HANDLE simdClsHnd = gtGetStructHandleForSIMD(simdType, simdBaseJitType);
+                        CORINFO_CLASS_HANDLE simdClsHnd = gtGetStructHandleForSimdOrHW(simdType, simdBaseJitType);
 
                         op1 = impCloneExpr(op1, &op2, simdClsHnd, CHECK_SPILL_ALL,
                                            nullptr DEBUGARG("Clone op1 for vector extractmostsignificantbits"));

src/coreclr/jit/simdashwintrinsic.cpp

@@ -240,7 +240,7 @@ GenTree* Compiler::impSimdAsHWIntrinsic(NamedIntrinsic        intrinsic,
     // if it isn't the basis for anything carried on the node.
     simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(clsHnd, &simdSize);
 
-    if ((clsHnd != m_simdHandleCache->SIMDVectorHandle) &&
+    if ((clsHnd != m_simdHandleCache->VectorHandle) &&
         ((simdBaseJitType == CORINFO_TYPE_UNDEF) || !varTypeIsArithmetic(JitType2PreciseVarType(simdBaseJitType))))
     {
         // We want to exit early if the clsHnd should have a base type and it isn't one
@@ -286,7 +286,7 @@ GenTree* Compiler::impSimdAsHWIntrinsic(NamedIntrinsic        intrinsic,
             simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(clsHnd, &simdSize);
         }
     }
-    else if ((clsHnd == m_simdHandleCache->SIMDVectorHandle) && (numArgs != 0) &&
+    else if ((clsHnd == m_simdHandleCache->VectorHandle) && (numArgs != 0) &&
              !SimdAsHWIntrinsicInfo::KeepBaseTypeFromRet(intrinsic))
     {
         // We need to fixup the clsHnd in the case we are an intrinsic on Vector