Remove test coverage of FeatureSIMD=0 (#66670)

kunalspathak · web-flow · commit 05cb7f5a6eef · 2022-03-16T23:01:08.000-07:00
* Remove coverge of FeatureSIMD=0

* Remove COMPlus_FeatureSIMD flag

* Remove isSacalarIsa() condition

* Remove the flag from other places of VM
diff --git a/src/coreclr/inc/clrconfigvalues.h b/src/coreclr/inc/clrconfigvalues.h
@@ -348,7 +348,6 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_JitVNMapSelBudget, W("JitVNMapSelBudget"), 100
 #else // !(defined(TARGET_AMD64) || defined(TARGET_X86) || defined(TARGET_ARM64))
 #define EXTERNAL_FeatureSIMD_Default 0
 #endif // !(defined(TARGET_AMD64) || defined(TARGET_X86) || defined(TARGET_ARM64))
-RETAIL_CONFIG_DWORD_INFO(EXTERNAL_FeatureSIMD, W("FeatureSIMD"), EXTERNAL_FeatureSIMD_Default, "Enable SIMD intrinsics recognition in System.Numerics.dll and/or System.Numerics.Vectors.dll")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_SIMD16ByteOnly, W("SIMD16ByteOnly"), 0, "Limit maximum SIMD vector length to 16 bytes (used by x64_arm64_altjit)")
 RETAIL_CONFIG_DWORD_INFO(UNSUPPORTED_TrackDynamicMethodDebugInfo, W("TrackDynamicMethodDebugInfo"), 0, "Specifies whether debug info should be generated and tracked for dynamic methods")
 
diff --git a/src/coreclr/inc/corjitflags.h b/src/coreclr/inc/corjitflags.h
@@ -57,13 +57,7 @@ class CORJIT_FLAGS
         CORJIT_FLAG_ALT_JIT                 = 14, // JIT should consider itself an ALT_JIT
         CORJIT_FLAG_UNUSED8                 = 15,
         CORJIT_FLAG_UNUSED9                 = 16,
-
-
-    #if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM64)
-        CORJIT_FLAG_FEATURE_SIMD            = 17,
-    #else
         CORJIT_FLAG_UNUSED10                = 17,
-    #endif // !(defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM64))
 
         CORJIT_FLAG_MAKEFINALCODE           = 18, // Use the final code generator, i.e., not the interpreter.
         CORJIT_FLAG_READYTORUN              = 19, // Use version-resilient code generation
diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
@@ -2666,12 +2666,6 @@ void Compiler::compInitOptions(JitFlags* jitFlags)
 #endif // DEBUG
 
 #ifdef FEATURE_SIMD
-
-#ifndef TARGET_ARM64
-    // Minimum bar for availing SIMD benefits is SSE2 on AMD64/x86.
-    featureSIMD = jitFlags->IsSet(JitFlags::JIT_FLAG_FEATURE_SIMD);
-#endif
-
     setUsesSIMDTypes(false);
 #endif // FEATURE_SIMD
 
diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h
@@ -8878,23 +8878,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
     }
 
 #ifdef FEATURE_SIMD
-
-#ifndef TARGET_ARM64
-    // Should we support SIMD intrinsics?
-    bool featureSIMD;
-#endif
-
-    // Should we recognize SIMD types?
-    // We always do this on ARM64 to support HVA types.
-    bool supportSIMDTypes()
-    {
-#ifdef TARGET_ARM64
-        return true;
-#else
-        return featureSIMD;
-#endif
-    }
-
     // Have we identified any SIMD types?
     // This is currently used by struct promotion to avoid getting type information for a struct
     // field to see if it is a SIMD type, if we haven't seen any SIMD types or operations in
diff --git a/src/coreclr/jit/ee_il_dll.cpp b/src/coreclr/jit/ee_il_dll.cpp
@@ -332,7 +332,7 @@ unsigned CILJit::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)
 
 #ifdef FEATURE_SIMD
 #if defined(TARGET_XARCH)
-    if (!jitFlags.IsSet(JitFlags::JIT_FLAG_PREJIT) && jitFlags.IsSet(JitFlags::JIT_FLAG_FEATURE_SIMD) &&
+    if (!jitFlags.IsSet(JitFlags::JIT_FLAG_PREJIT) &&
         jitFlags.GetInstructionSetFlags().HasInstructionSet(InstructionSet_AVX2))
     {
         if (GetJitTls() != nullptr && JitTls::GetCompiler() != nullptr)
diff --git a/src/coreclr/jit/hwintrinsic.cpp b/src/coreclr/jit/hwintrinsic.cpp
@@ -574,12 +574,11 @@ GenTree* Compiler::addRangeCheckForHWIntrinsic(GenTree* immOp, int immLowerBound
 //    true iff the given instruction set is enabled via configuration (environment variables, etc.).
 bool Compiler::compSupportsHWIntrinsic(CORINFO_InstructionSet isa)
 {
-    return compHWIntrinsicDependsOn(isa) && (supportSIMDTypes() || HWIntrinsicInfo::isScalarIsa(isa)) &&
-           (
+    return compHWIntrinsicDependsOn(isa) && (
 #ifdef DEBUG
-               JitConfig.EnableIncompleteISAClass() ||
+                                                JitConfig.EnableIncompleteISAClass() ||
 #endif
-               HWIntrinsicInfo::isFullyImplementedIsa(isa));
+                                                HWIntrinsicInfo::isFullyImplementedIsa(isa));
 }
 
 //------------------------------------------------------------------------
@@ -766,7 +765,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic        intrinsic,
     var_types              retType         = JITtype2varType(sig->retType);
     CorInfoType            simdBaseJitType = CORINFO_TYPE_UNDEF;
 
-    if ((retType == TYP_STRUCT) && supportSIMDTypes())
+    if (retType == TYP_STRUCT)
     {
         unsigned int sizeBytes;
         simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(sig->retTypeSigClass, &sizeBytes);
@@ -805,7 +804,6 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic        intrinsic,
         }
         else
         {
-            assert(supportSIMDTypes());
             unsigned int sizeBytes;
 
             simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(clsHnd, &sizeBytes);
diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp
@@ -325,7 +325,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic        intrinsic,
     assert(category != HW_Category_Scalar);
     assert(!HWIntrinsicInfo::isScalarIsa(HWIntrinsicInfo::lookupIsa(intrinsic)));
 
-    if (!supportSIMDTypes() || !IsBaselineSimdIsaSupported())
+    if (!IsBaselineSimdIsaSupported())
     {
         return nullptr;
     }
diff --git a/src/coreclr/jit/hwintrinsicxarch.cpp b/src/coreclr/jit/hwintrinsicxarch.cpp
@@ -537,7 +537,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic        intrinsic,
     GenTree* op3     = nullptr;
     GenTree* op4     = nullptr;
 
-    if (!featureSIMD || !IsBaselineSimdIsaSupported())
+    if (!IsBaselineSimdIsaSupported())
     {
         return nullptr;
     }
diff --git a/src/coreclr/jit/importer.cpp b/src/coreclr/jit/importer.cpp
@@ -1709,30 +1709,27 @@ var_types Compiler::impNormStructType(CORINFO_CLASS_HANDLE structHnd, CorInfoTyp
     var_types structType = TYP_STRUCT;
 
 #ifdef FEATURE_SIMD
-    if (supportSIMDTypes())
+    const DWORD structFlags = info.compCompHnd->getClassAttribs(structHnd);
+
+    // Don't bother if the struct contains GC references of byrefs, it can't be a SIMD type.
+    if ((structFlags & (CORINFO_FLG_CONTAINS_GC_PTR | CORINFO_FLG_BYREF_LIKE)) == 0)
     {
-        const DWORD structFlags = info.compCompHnd->getClassAttribs(structHnd);
+        unsigned originalSize = info.compCompHnd->getClassSize(structHnd);
 
-        // Don't bother if the struct contains GC references of byrefs, it can't be a SIMD type.
-        if ((structFlags & (CORINFO_FLG_CONTAINS_GC_PTR | CORINFO_FLG_BYREF_LIKE)) == 0)
+        if (structSizeMightRepresentSIMDType(originalSize))
         {
-            unsigned originalSize = info.compCompHnd->getClassSize(structHnd);
-
-            if (structSizeMightRepresentSIMDType(originalSize))
+            unsigned int sizeBytes;
+            CorInfoType  simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(structHnd, &sizeBytes);
+            if (simdBaseJitType != CORINFO_TYPE_UNDEF)
             {
-                unsigned int sizeBytes;
-                CorInfoType  simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(structHnd, &sizeBytes);
-                if (simdBaseJitType != CORINFO_TYPE_UNDEF)
+                assert(sizeBytes == originalSize);
+                structType = getSIMDTypeForSize(sizeBytes);
+                if (pSimdBaseJitType != nullptr)
                 {
-                    assert(sizeBytes == originalSize);
-                    structType = getSIMDTypeForSize(sizeBytes);
-                    if (pSimdBaseJitType != nullptr)
-                    {
-                        *pSimdBaseJitType = simdBaseJitType;
-                    }
-                    // Also indicate that we use floating point registers.
-                    compFloatingPointUsed = true;
+                    *pSimdBaseJitType = simdBaseJitType;
                 }
+                // Also indicate that we use floating point registers.
+                compFloatingPointUsed = true;
             }
         }
     }
@@ -4439,7 +4436,7 @@ GenTree* Compiler::impIntrinsic(GenTree*                newobjThis,
             case NI_System_Math_FusedMultiplyAdd:
             {
 #ifdef TARGET_XARCH
-                if (compExactlyDependsOn(InstructionSet_FMA) && supportSIMDTypes())
+                if (compExactlyDependsOn(InstructionSet_FMA))
                 {
                     assert(varTypeIsFloating(callType));
 
@@ -8916,14 +8913,11 @@ var_types Compiler::impImportCall(OPCODE                  opcode,
         }
 
 #ifdef FEATURE_SIMD
-        if (supportSIMDTypes())
+        call = impSIMDIntrinsic(opcode, newobjThis, clsHnd, methHnd, sig, mflags, pResolvedToken->token);
+        if (call != nullptr)
         {
-            call = impSIMDIntrinsic(opcode, newobjThis, clsHnd, methHnd, sig, mflags, pResolvedToken->token);
-            if (call != nullptr)
-            {
-                bIntrinsicImported = true;
-                goto DONE_CALL;
-            }
+            bIntrinsicImported = true;
+            goto DONE_CALL;
         }
 #endif // FEATURE_SIMD
 
@@ -19951,7 +19945,7 @@ void Compiler::impInlineInitVars(InlineInfo* pInlineInfo)
         if ((!foundSIMDType || (type == TYP_STRUCT)) && isSIMDorHWSIMDClass(&(lclVarInfo[i + argCnt].lclVerTypeInfo)))
         {
             foundSIMDType = true;
-            if (supportSIMDTypes() && type == TYP_STRUCT)
+            if (type == TYP_STRUCT)
             {
                 var_types structType = impNormStructType(lclVarInfo[i + argCnt].lclVerTypeInfo.GetClassHandle());
                 lclVarInfo[i + argCnt].lclTypeInfo = structType;
diff --git a/src/coreclr/jit/jitee.h b/src/coreclr/jit/jitee.h
@@ -187,13 +187,6 @@ class JitFlags
 #endif
 
         FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_ALT_JIT, JIT_FLAG_ALT_JIT);
-
-#if defined(TARGET_X86) || defined(TARGET_AMD64) || defined(TARGET_ARM64)
-
-        FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_FEATURE_SIMD, JIT_FLAG_FEATURE_SIMD);
-
-#endif
-
         FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE, JIT_FLAG_MAKEFINALCODE);
         FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_READYTORUN, JIT_FLAG_READYTORUN);
         FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE, JIT_FLAG_PROF_ENTERLEAVE);
diff --git a/src/coreclr/jit/lclvars.cpp b/src/coreclr/jit/lclvars.cpp
@@ -123,7 +123,7 @@ void Compiler::lvaInitTypeRef()
     info.compILargsCount = info.compArgsCount;
 
 #ifdef FEATURE_SIMD
-    if (supportSIMDTypes() && (info.compRetNativeType == TYP_STRUCT))
+    if (info.compRetNativeType == TYP_STRUCT)
     {
         var_types structType = impNormStructType(info.compMethodInfo->args.retTypeClass);
         info.compRetType     = structType;
@@ -471,17 +471,14 @@ void Compiler::lvaInitThisPtr(InitVarDscInfo* varDscInfo)
         {
             varDsc->lvType = TYP_BYREF;
 #ifdef FEATURE_SIMD
-            if (supportSIMDTypes())
+            CorInfoType simdBaseJitType = CORINFO_TYPE_UNDEF;
+            var_types   type            = impNormStructType(info.compClassHnd, &simdBaseJitType);
+            if (simdBaseJitType != CORINFO_TYPE_UNDEF)
             {
-                CorInfoType simdBaseJitType = CORINFO_TYPE_UNDEF;
-                var_types   type            = impNormStructType(info.compClassHnd, &simdBaseJitType);
-                if (simdBaseJitType != CORINFO_TYPE_UNDEF)
-                {
-                    assert(varTypeIsSIMD(type));
-                    varDsc->lvSIMDType = true;
-                    varDsc->SetSimdBaseJitType(simdBaseJitType);
-                    varDsc->lvExactSize = genTypeSize(type);
-                }
+                assert(varTypeIsSIMD(type));
+                varDsc->lvSIMDType = true;
+                varDsc->SetSimdBaseJitType(simdBaseJitType);
+                varDsc->lvExactSize = genTypeSize(type);
             }
 #endif // FEATURE_SIMD
         }
@@ -552,7 +549,7 @@ void Compiler::lvaInitRetBuffArg(InitVarDscInfo* varDscInfo, bool useFixedRetBuf
         varDsc->lvOnFrame = true; // The final home for this incoming register might be our local stack frame
 
 #ifdef FEATURE_SIMD
-        if (supportSIMDTypes() && varTypeIsSIMD(info.compRetType))
+        if (varTypeIsSIMD(info.compRetType))
         {
             varDsc->lvSIMDType = true;
 
diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp
@@ -5254,7 +5254,7 @@ GenTree* Compiler::fgMorphArrayIndex(GenTree* tree)
     }
 
 #ifdef FEATURE_SIMD
-    if (supportSIMDTypes() && varTypeIsStruct(elemTyp) && structSizeMightRepresentSIMDType(elemSize))
+    if (varTypeIsStruct(elemTyp) && structSizeMightRepresentSIMDType(elemSize))
     {
         // If this is a SIMD type, this is the point at which we lose the type information,
         // so we need to set the correct type on the GT_IND.
diff --git a/src/coreclr/jit/rationalize.cpp b/src/coreclr/jit/rationalize.cpp
@@ -119,12 +119,6 @@ void Rationalizer::RewriteIndir(LIR::Use& use)
 void Rationalizer::RewriteSIMDIndir(LIR::Use& use)
 {
 #ifdef FEATURE_SIMD
-    // No lowering is needed for non-SIMD nodes, so early out if SIMD types are not supported.
-    if (!comp->supportSIMDTypes())
-    {
-        return;
-    }
-
     GenTreeIndir* indir = use.Def()->AsIndir();
     assert(indir->OperIs(GT_IND));
     var_types simdType = indir->TypeGet();
@@ -724,7 +718,6 @@ Compiler::fgWalkResult Rationalizer::RewriteNode(GenTree** useEdge, Compiler::Ge
 #ifdef FEATURE_SIMD
         case GT_SIMD:
         {
-            noway_assert(comp->supportSIMDTypes());
             GenTreeSIMD* simdNode = node->AsSIMD();
             unsigned     simdSize = simdNode->GetSimdSize();
             var_types    simdType = comp->getSIMDTypeForSize(simdSize);
@@ -790,8 +783,6 @@ Compiler::fgWalkResult Rationalizer::RewriteNode(GenTree** useEdge, Compiler::Ge
                 break;
             }
 
-            noway_assert(comp->supportSIMDTypes());
-
             // TODO-1stClassStructs: This should be handled more generally for enregistered or promoted
             // structs that are passed or returned in a different register type than their enregistered
             // type(s).
diff --git a/src/coreclr/jit/simd.cpp b/src/coreclr/jit/simd.cpp
@@ -155,8 +155,6 @@ unsigned Compiler::getSIMDInitTempVarNum(var_types simdType)
 //         product.
 CorInfoType Compiler::getBaseJitTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, unsigned* sizeBytes /*= nullptr */)
 {
-    assert(supportSIMDTypes());
-
     if (m_simdHandleCache == nullptr)
     {
         if (impInlineInfo == nullptr)
@@ -950,7 +948,6 @@ const SIMDIntrinsicInfo* Compiler::getSIMDIntrinsicInfo(CORINFO_CLASS_HANDLE* in
                                                         CorInfoType*          simdBaseJitType,
                                                         unsigned*             sizeBytes)
 {
-    assert(supportSIMDTypes());
     assert(simdBaseJitType != nullptr);
     assert(sizeBytes != nullptr);
 
@@ -1798,7 +1795,7 @@ GenTree* Compiler::createAddressNodeForSIMDInit(GenTree* tree, unsigned simdSize
 
 void Compiler::impMarkContiguousSIMDFieldAssignments(Statement* stmt)
 {
-    if (!supportSIMDTypes() || opts.OptimizationDisabled())
+    if (opts.OptimizationDisabled())
     {
         return;
     }
@@ -1891,8 +1888,6 @@ GenTree* Compiler::impSIMDIntrinsic(OPCODE                opcode,
                                     unsigned              methodFlags,
                                     int                   memberRef)
 {
-    assert(supportSIMDTypes());
-
     // Exit early if we are not in one of the SIMD types.
     if (!isSIMDClass(clsHnd))
     {
diff --git a/src/coreclr/jit/simdashwintrinsic.cpp b/src/coreclr/jit/simdashwintrinsic.cpp
@@ -170,12 +170,6 @@ GenTree* Compiler::impSimdAsHWIntrinsic(NamedIntrinsic        intrinsic,
                                         CORINFO_SIG_INFO*     sig,
                                         GenTree*              newobjThis)
 {
-    if (!supportSIMDTypes())
-    {
-        // We can't support SIMD intrinsics if the JIT doesn't support the feature
-        return nullptr;
-    }
-
     if (!IsBaselineSimdIsaSupported())
     {
         // The user disabled support for the baseline ISA so
@@ -356,7 +350,6 @@ GenTree* Compiler::impSimdAsHWIntrinsicSpecial(NamedIntrinsic       intrinsic,
 {
     var_types simdBaseType = JitType2PreciseVarType(simdBaseJitType);
 
-    assert(supportSIMDTypes());
     assert(retType != TYP_UNKNOWN);
     assert(varTypeIsArithmetic(simdBaseType));
     assert(simdSize != 0);
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs b/src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs
@@ -3744,17 +3744,11 @@ private uint getJitFlags(ref CORJIT_FLAGS flags, uint sizeInBytes)
                 case TargetArchitecture.X64:
                 case TargetArchitecture.X86:
                     Debug.Assert(InstructionSet.X86_SSE2 == InstructionSet.X64_SSE2);
-                    if (_compilation.InstructionSetSupport.IsInstructionSetSupported(InstructionSet.X86_SSE2))
-                    {
-                        flags.Set(CorJitFlag.CORJIT_FLAG_FEATURE_SIMD);
-                    }
+                    Debug.Assert(_compilation.InstructionSetSupport.IsInstructionSetSupported(InstructionSet.X86_SSE2));
                     break;
 
                 case TargetArchitecture.ARM64:
-                    if (_compilation.InstructionSetSupport.IsInstructionSetSupported(InstructionSet.ARM64_AdvSimd))
-                    {
-                        flags.Set(CorJitFlag.CORJIT_FLAG_FEATURE_SIMD);
-                    }
+                    Debug.Assert(_compilation.InstructionSetSupport.IsInstructionSetSupported(InstructionSet.ARM64_AdvSimd));
                     break;
             }
 
diff --git a/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs b/src/coreclr/tools/Common/JitInterface/CorInfoTypes.cs
@@ -1333,7 +1333,7 @@ public enum CorJitFlag : uint
         CORJIT_FLAG_UNUSED6 = 12,
         CORJIT_FLAG_OSR = 13, // Generate alternate version for On Stack Replacement
         CORJIT_FLAG_ALT_JIT = 14, // JIT should consider itself an ALT_JIT
-        CORJIT_FLAG_FEATURE_SIMD = 17,
+        CORJIT_FLAG_UNUSED10 = 17,
         CORJIT_FLAG_MAKEFINALCODE = 18, // Use the final code generator, i.e., not the interpreter.
         CORJIT_FLAG_READYTORUN = 19, // Use version-resilient code generation
         CORJIT_FLAG_PROF_ENTERLEAVE = 20, // Instrument prologues/epilogues
diff --git a/src/coreclr/vm/codeman.cpp b/src/coreclr/vm/codeman.cpp
diff --git a/src/coreclr/vm/interpreter.cpp b/src/coreclr/vm/interpreter.cpp
diff --git a/src/coreclr/vm/methodtablebuilder.cpp b/src/coreclr/vm/methodtablebuilder.cpp
diff --git a/src/tests/Common/testenvironment.proj b/src/tests/Common/testenvironment.proj

Original file line number	Diff line number	Diff line change
`@@ -332,7 +332,7 @@ unsigned CILJit::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)`
`332`	`332`
`333`	`333`	`#ifdef FEATURE_SIMD`
`334`	`334`	`#if defined(TARGET_XARCH)`
`335`		`- if (!jitFlags.IsSet(JitFlags::JIT_FLAG_PREJIT) && jitFlags.IsSet(JitFlags::JIT_FLAG_FEATURE_SIMD) &&`
	`335`	`+ if (!jitFlags.IsSet(JitFlags::JIT_FLAG_PREJIT) &&`
`336`	`336`	`jitFlags.GetInstructionSetFlags().HasInstructionSet(InstructionSet_AVX2))`
`337`	`337`	`{`
`338`	`338`	`if (GetJitTls() != nullptr && JitTls::GetCompiler() != nullptr)`
Original file line number	Diff line number	Diff line change
`@@ -574,12 +574,11 @@ GenTree* Compiler::addRangeCheckForHWIntrinsic(GenTree* immOp, int immLowerBound`
`574`	`574`	`// true iff the given instruction set is enabled via configuration (environment variables, etc.).`
`575`	`575`	`bool Compiler::compSupportsHWIntrinsic(CORINFO_InstructionSet isa)`
`576`	`576`	`{`
`577`		`- return compHWIntrinsicDependsOn(isa) && (supportSIMDTypes() \|\| HWIntrinsicInfo::isScalarIsa(isa)) &&`
`578`		`- (`
	`577`	`+ return compHWIntrinsicDependsOn(isa) && (`
`579`	`578`	`#ifdef DEBUG`
`580`		`- JitConfig.EnableIncompleteISAClass() \|\|`
	`579`	`+ JitConfig.EnableIncompleteISAClass() \|\|`
`581`	`580`	`#endif`
`582`		`- HWIntrinsicInfo::isFullyImplementedIsa(isa));`
	`581`	`+ HWIntrinsicInfo::isFullyImplementedIsa(isa));`
`583`	`582`	`}`
`584`	`583`
`585`	`584`	`//------------------------------------------------------------------------`
`@@ -766,7 +765,7 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic,`
`766`	`765`	`var_types retType = JITtype2varType(sig->retType);`
`767`	`766`	`CorInfoType simdBaseJitType = CORINFO_TYPE_UNDEF;`
`768`	`767`
`769`		`- if ((retType == TYP_STRUCT) && supportSIMDTypes())`
	`768`	`+ if (retType == TYP_STRUCT)`
`770`	`769`	`{`
`771`	`770`	`unsigned int sizeBytes;`
`772`	`771`	`simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(sig->retTypeSigClass, &sizeBytes);`
`@@ -805,7 +804,6 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic,`
`805`	`804`	`}`
`806`	`805`	`else`
`807`	`806`	`{`
`808`		`- assert(supportSIMDTypes());`
`809`	`807`	`unsigned int sizeBytes;`
`810`	`808`
`811`	`809`	`simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(clsHnd, &sizeBytes);`
Original file line number	Diff line number	Diff line change
`@@ -325,7 +325,7 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic,`
`325`	`325`	`assert(category != HW_Category_Scalar);`
`326`	`326`	`assert(!HWIntrinsicInfo::isScalarIsa(HWIntrinsicInfo::lookupIsa(intrinsic)));`
`327`	`327`
`328`		`- if (!supportSIMDTypes() \|\| !IsBaselineSimdIsaSupported())`
	`328`	`+ if (!IsBaselineSimdIsaSupported())`
`329`	`329`	`{`
`330`	`330`	`return nullptr;`
`331`	`331`	`}`
Original file line number	Diff line number	Diff line change
`@@ -537,7 +537,7 @@ GenTree* Compiler::impBaseIntrinsic(NamedIntrinsic intrinsic,`
`537`	`537`	`GenTree* op3 = nullptr;`
`538`	`538`	`GenTree* op4 = nullptr;`
`539`	`539`
`540`		`- if (!featureSIMD \|\| !IsBaselineSimdIsaSupported())`
	`540`	`+ if (!IsBaselineSimdIsaSupported())`
`541`	`541`	`{`
`542`	`542`	`return nullptr;`
`543`	`543`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1709,30 +1709,27 @@ var_types Compiler::impNormStructType(CORINFO_CLASS_HANDLE structHnd, CorInfoTyp`
`1709`	`1709`	`var_types structType = TYP_STRUCT;`
`1710`	`1710`
`1711`	`1711`	`#ifdef FEATURE_SIMD`
`1712`		`- if (supportSIMDTypes())`
	`1712`	`+ const DWORD structFlags = info.compCompHnd->getClassAttribs(structHnd);`
	`1713`	`+`
	`1714`	`+ // Don't bother if the struct contains GC references of byrefs, it can't be a SIMD type.`
	`1715`	`+ if ((structFlags & (CORINFO_FLG_CONTAINS_GC_PTR \| CORINFO_FLG_BYREF_LIKE)) == 0)`
`1713`	`1716`	`{`
`1714`		`- const DWORD structFlags = info.compCompHnd->getClassAttribs(structHnd);`
	`1717`	`+ unsigned originalSize = info.compCompHnd->getClassSize(structHnd);`
`1715`	`1718`
`1716`		`- // Don't bother if the struct contains GC references of byrefs, it can't be a SIMD type.`
`1717`		`- if ((structFlags & (CORINFO_FLG_CONTAINS_GC_PTR \| CORINFO_FLG_BYREF_LIKE)) == 0)`
	`1719`	`+ if (structSizeMightRepresentSIMDType(originalSize))`
`1718`	`1720`	`{`
`1719`		`- unsigned originalSize = info.compCompHnd->getClassSize(structHnd);`
`1720`		`-`
`1721`		`- if (structSizeMightRepresentSIMDType(originalSize))`
	`1721`	`+ unsigned int sizeBytes;`
	`1722`	`+ CorInfoType simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(structHnd, &sizeBytes);`
	`1723`	`+ if (simdBaseJitType != CORINFO_TYPE_UNDEF)`
`1722`	`1724`	`{`
`1723`		`- unsigned int sizeBytes;`
`1724`		`- CorInfoType simdBaseJitType = getBaseJitTypeAndSizeOfSIMDType(structHnd, &sizeBytes);`
`1725`		`- if (simdBaseJitType != CORINFO_TYPE_UNDEF)`
	`1725`	`+ assert(sizeBytes == originalSize);`
	`1726`	`+ structType = getSIMDTypeForSize(sizeBytes);`
	`1727`	`+ if (pSimdBaseJitType != nullptr)`
`1726`	`1728`	`{`
`1727`		`- assert(sizeBytes == originalSize);`
`1728`		`- structType = getSIMDTypeForSize(sizeBytes);`
`1729`		`- if (pSimdBaseJitType != nullptr)`
`1730`		`- {`
`1731`		`- *pSimdBaseJitType = simdBaseJitType;`
`1732`		`- }`
`1733`		`- // Also indicate that we use floating point registers.`
`1734`		`- compFloatingPointUsed = true;`
	`1729`	`+ *pSimdBaseJitType = simdBaseJitType;`
`1735`	`1730`	`}`
	`1731`	`+ // Also indicate that we use floating point registers.`
	`1732`	`+ compFloatingPointUsed = true;`
`1736`	`1733`	`}`
`1737`	`1734`	`}`
`1738`	`1735`	`}`
`@@ -4439,7 +4436,7 @@ GenTree* Compiler::impIntrinsic(GenTree* newobjThis,`
`4439`	`4436`	`case NI_System_Math_FusedMultiplyAdd:`
`4440`	`4437`	`{`
`4441`	`4438`	`#ifdef TARGET_XARCH`
`4442`		`- if (compExactlyDependsOn(InstructionSet_FMA) && supportSIMDTypes())`
	`4439`	`+ if (compExactlyDependsOn(InstructionSet_FMA))`
`4443`	`4440`	`{`
`4444`	`4441`	`assert(varTypeIsFloating(callType));`
`4445`	`4442`
`@@ -8916,14 +8913,11 @@ var_types Compiler::impImportCall(OPCODE opcode,`
`8916`	`8913`	`}`
`8917`	`8914`
`8918`	`8915`	`#ifdef FEATURE_SIMD`
`8919`		`- if (supportSIMDTypes())`
	`8916`	`+ call = impSIMDIntrinsic(opcode, newobjThis, clsHnd, methHnd, sig, mflags, pResolvedToken->token);`
	`8917`	`+ if (call != nullptr)`
`8920`	`8918`	`{`
`8921`		`- call = impSIMDIntrinsic(opcode, newobjThis, clsHnd, methHnd, sig, mflags, pResolvedToken->token);`
`8922`		`- if (call != nullptr)`
`8923`		`- {`
`8924`		`- bIntrinsicImported = true;`
`8925`		`- goto DONE_CALL;`
`8926`		`- }`
	`8919`	`+ bIntrinsicImported = true;`
	`8920`	`+ goto DONE_CALL;`
`8927`	`8921`	`}`
`8928`	`8922`	`#endif // FEATURE_SIMD`
`8929`	`8923`
`@@ -19951,7 +19945,7 @@ void Compiler::impInlineInitVars(InlineInfo* pInlineInfo)`
`19951`	`19945`	`if ((!foundSIMDType \|\| (type == TYP_STRUCT)) && isSIMDorHWSIMDClass(&(lclVarInfo[i + argCnt].lclVerTypeInfo)))`
`19952`	`19946`	`{`
`19953`	`19947`	`foundSIMDType = true;`
`19954`		`- if (supportSIMDTypes() && type == TYP_STRUCT)`
	`19948`	`+ if (type == TYP_STRUCT)`
`19955`	`19949`	`{`
`19956`	`19950`	`var_types structType = impNormStructType(lclVarInfo[i + argCnt].lclVerTypeInfo.GetClassHandle());`
`19957`	`19951`	`lclVarInfo[i + argCnt].lclTypeInfo = structType;`