Allow 64-bit alignment in the test data table types and fix the AVX51…

…2 enablement check
dotnet · Mar 16, 2023 · 0fbec21 · 0fbec21
1 parent f509157
commit 0fbec21
Show file tree

Hide file tree

Showing 11 changed files with 23 additions and 18 deletions.
diff --git a/src/coreclr/jit/compiler.cpp b/src/coreclr/jit/compiler.cpp
@@ -2287,7 +2287,6 @@ void Compiler::compSetProcessor()
         instructionSetFlags.HasInstructionSet(InstructionSet_AVX512BW) &&
         instructionSetFlags.HasInstructionSet(InstructionSet_AVX512DQ))
     {
-#if defined(DEBUG)
         // Using JitStressEVEXEncoding flag will force instructions which would
         // otherwise use VEX encoding but can be EVEX encoded to use EVEX encoding
         // This requires AVX512VL support. JitForceEVEXEncoding forces this encoding, thus
@@ -2296,14 +2295,20 @@ void Compiler::compSetProcessor()
         // We can't use !DoJitStressEvexEncoding() yet because opts.compSupportsISA hasn't
         // been set yet as that's what we're trying to set here
 
-        bool disableAvx512 = !JitConfig.JitForceEVEXEncoding() && !JitConfig.JitStressEvexEncoding() &&
-                             !instructionSetFlags.HasInstructionSet(InstructionSet_AVX512F_VL);
-#else
-        // TODO-XARCH-AVX512: Allow AVX512 support by default
-        bool disableAvx512 = true;
+        bool enableAvx512 = false;
+
+#if defined(DEBUG)
+        if (JitConfig.JitForceEVEXEncoding())
+        {
+            enableAvx512 = true;
+        }
+        else if (JitConfig.JitStressEvexEncoding() && instructionSetFlags.HasInstructionSet(InstructionSet_AVX512F_VL))
+        {
+            enableAvx512 = true;
+        }
 #endif // DEBUG
 
-        if (disableAvx512)
+        if (!enableAvx512)
         {
             instructionSetFlags.RemoveInstructionSet(InstructionSet_AVX512F);
             instructionSetFlags.RemoveInstructionSet(InstructionSet_AVX512F_VL);

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest_DataTable.cs b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest_DataTable.cs
@@ -22,7 +22,7 @@ public unsafe struct ScalarSimdUnaryOpTest__DataTable<TResult> : IDisposable
         public ScalarSimdUnaryOpTest__DataTable(TResult[] outArray, int alignment)
         {
             int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
-            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfoutArray)
+            if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfoutArray)
             {
                 throw new ArgumentException("Invalid value of alignment");
             }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest_DataTable.cs b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest_DataTable.cs
@@ -22,7 +22,7 @@ public unsafe struct SimdScalarUnaryOpTest__DataTable<TOp1> : IDisposable
         public SimdScalarUnaryOpTest__DataTable(TOp1[] inArray, int alignment)
         {
             int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>();
-            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray)
+            if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray)
             {
                 throw new ArgumentException("Invalid value of alignment");
             }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpConvTest_DataTable.cs b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpConvTest_DataTable.cs
@@ -28,7 +28,7 @@ public SimpleBinaryOpConvTest__DataTable(TOp1[] inArray1, TOp2 inData2, TResult[
         {
             int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
             int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
-            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
+            if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
             {
                 throw new ArgumentException("Invalid value of alignment");
             }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs
@@ -30,7 +30,7 @@ public SimpleBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[]
             int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
             int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>();
             int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
-            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
+            if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
             {
                 throw new ArgumentException("Invalid value of alignment");
             }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs
@@ -26,7 +26,7 @@ public SimpleUnaryOpTest__DataTable(TOp1[] inArray, TResult[] outArray, int alig
         {
             int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>();
             int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
-            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray)
+            if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray || (alignment * 2) < sizeOfoutArray)
             {
                 throw new ArgumentException("Invalid value of alignment");
             }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BinaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BinaryOpTestTemplate.template
@@ -139,7 +139,7 @@ namespace JIT.HardwareIntrinsics.X86
                 int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
                 int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
                 int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>();
-                if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
+                if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfoutArray)
                 {
                     throw new ArgumentException("Invalid value of alignment");
                 }
@@ -487,7 +487,7 @@ namespace JIT.HardwareIntrinsics.X86
             Unsafe.Write(_dataTable.outArrayPtr, result);
             ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
         }
-        
+
         public void RunStructFldScenario()
         {
             TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario));

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanBinaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanBinaryOpTestTemplate.template
@@ -136,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86
             {
                 int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
                 int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
-                if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
+                if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
                 {
                     throw new ArgumentException("Invalid value of alignment");
                 }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanUnaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanUnaryOpTestTemplate.template
@@ -133,7 +133,7 @@ namespace JIT.HardwareIntrinsics.X86
             public DataTable({Op1BaseType}[] inArray1, int alignment)
             {
                 int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
-                if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1)
+                if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1)
                 {
                     throw new ArgumentException("Invalid value of alignment");
                 }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_TernaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_TernaryOpTestTemplate.template
@@ -142,7 +142,7 @@ namespace JIT.HardwareIntrinsics.X86
                 int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<{Op2BaseType}>();
                 int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op3BaseType}>();
                 int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>();
-                if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
+                if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
                 {
                     throw new ArgumentException("Invalid value of alignment");
                 }

diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_UnaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_UnaryOpTestTemplate.template
@@ -136,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86
             {
                 int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>();
                 int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>();
-                if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
+                if (((alignment != 64) && (alignment != 32) && (alignment != 16)) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray)
                 {
                     throw new ArgumentException("Invalid value of alignment");
                 }