Fix GCStress failures

10 files changed, 185 insertions, 213 deletions

diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs
index 207dcff702..6f87416366 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest_DataTable.cs
@@ -24,27 +24,35 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle2;
         private GCHandle outHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public AlternatingBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int simdSize)
+        public AlternatingBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
-            this.outArray = new byte[simdSize * 2];
+            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)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
+            this.outArray = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
             this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -53,19 +61,9 @@ namespace JIT.HardwareIntrinsics.X86
             outHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs
index f3822fa09a..b2683ced77 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest_DataTable.cs
@@ -21,24 +21,31 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle1;
         private GCHandle inHandle2;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public BooleanBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int simdSize)
+        public BooleanBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
+            int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
+            int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>();
+            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -46,19 +53,9 @@ namespace JIT.HardwareIntrinsics.X86
             inHandle2.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs
index 051baa0f5d..557b560d54 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest_DataTable.cs
@@ -21,24 +21,31 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle1;
         private GCHandle inHandle2;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public BooleanComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int simdSize)
+        public BooleanComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
+            int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
+            int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>();
+            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -46,19 +53,9 @@ namespace JIT.HardwareIntrinsics.X86
             inHandle2.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs
index 618b284632..f2ab635c56 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest_DataTable.cs
@@ -21,24 +21,31 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle1;
         private GCHandle inHandle2;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public BooleanTwoComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int simdSize)
+        public BooleanTwoComparisonOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
+            int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
+            int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>();
+            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -46,19 +53,9 @@ namespace JIT.HardwareIntrinsics.X86
             inHandle2.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs
index cd478f3dca..a94532413d 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest_DataTable.cs
@@ -18,39 +18,34 @@ namespace JIT.HardwareIntrinsics.X86
 
         private GCHandle inHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public BooleanUnaryOpTest__DataTable(TOp1[] inArray, int simdSize)
+        public BooleanUnaryOpTest__DataTable(TOp1[] inArray, int alignment)
         {
-            this.inArray = new byte[simdSize * 2];
+            int sizeOfinArray = inArray.Length * Unsafe.SizeOf<TOp1>();
+            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+            this.inArray = new byte[alignment * 2];
 
             this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), (uint)sizeOfinArray);
         }
 
-        public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
             inHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs
index ac69cd8564..e9b6123066 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest_DataTable.cs
@@ -24,27 +24,35 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle2;
         private GCHandle outHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public HorizontalBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int simdSize)
+        public HorizontalBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
-            this.outArray = new byte[simdSize * 2];
+            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)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
+            this.outArray = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
             this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -53,19 +61,9 @@ namespace JIT.HardwareIntrinsics.X86
             outHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs
index b510aed999..2d5532d7ab 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest_DataTable.cs
@@ -18,37 +18,32 @@ namespace JIT.HardwareIntrinsics.X86
 
         private GCHandle outHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public SimpleScalarUnaryOpTest__DataTable(TResult[] outArray, int simdSize)
+        public SimpleScalarUnaryOpTest__DataTable(TResult[] outArray, int alignment)
         {
-            this.outArray = new byte[simdSize * 2];
+            int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
+            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfoutArray)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+            this.outArray = new byte[alignment * 2];
 
             this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
         }
 
-        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
             outHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs
index ff80da4e88..eae18a2368 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest_DataTable.cs
@@ -24,27 +24,35 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle2;
         private GCHandle outHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public SimpleBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int simdSize)
+        public SimpleBinaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TResult[] outArray, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
-            this.outArray = new byte[simdSize * 2];
+            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)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
+            this.outArray = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
             this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -53,19 +61,9 @@ namespace JIT.HardwareIntrinsics.X86
             outHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs
index 8c6014509a..dbc9ac1f90 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest_DataTable.cs
@@ -27,31 +27,41 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle3;
         private GCHandle outHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public SimpleTernaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TOp3[] inArray3, TResult[] outArray, int simdSize)
+        public SimpleTernaryOpTest__DataTable(TOp1[] inArray1, TOp2[] inArray2, TOp3[] inArray3, TResult[] outArray, int alignment)
         {
-            this.inArray1 = new byte[simdSize * 2];
-            this.inArray2 = new byte[simdSize * 2];
-            this.inArray3 = new byte[simdSize * 2];
-            this.outArray = new byte[simdSize * 2];
+            int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<TOp1>();
+            int sizeOfinArray2 = inArray2.Length * Unsafe.SizeOf<TOp2>();
+            int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<TOp3>();
+            int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<TResult>();
+            if ((alignment != 32 && alignment != 16) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray2 || 
+                (alignment * 2) < sizeOfinArray3 || (alignment * 2) < sizeOfoutArray)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray1 = new byte[alignment * 2];
+            this.inArray2 = new byte[alignment * 2];
+            this.inArray3 = new byte[alignment * 2];
+            this.outArray = new byte[alignment * 2];
 
             this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned);
             this.inHandle2 = GCHandle.Alloc(this.inArray2, GCHandleType.Pinned);
             this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned);
             this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), this.simdSize);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<TOp3, byte>(ref inArray3[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray1Ptr), ref Unsafe.As<TOp1, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray2Ptr), ref Unsafe.As<TOp2, byte>(ref inArray2[0]), (uint)sizeOfinArray2);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArray3Ptr), ref Unsafe.As<TOp3, byte>(ref inArray3[0]), (uint)sizeOfinArray3);
         }
 
-        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray2Ptr => Align((byte*)(inHandle2.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -61,19 +71,9 @@ namespace JIT.HardwareIntrinsics.X86
             outHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
-
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs
index 5240a21919..efda580ad0 100644
--- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs
+++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest_DataTable.cs
@@ -21,23 +21,30 @@ namespace JIT.HardwareIntrinsics.X86
         private GCHandle inHandle;
         private GCHandle outHandle;
 
-        private byte simdSize;
+        private ulong alignment;
 
-        public SimpleUnaryOpTest__DataTable(TOp1[] inArray, TResult[] outArray, int simdSize)
+        public SimpleUnaryOpTest__DataTable(TOp1[] inArray, TResult[] outArray, int alignment)
         {
-            this.inArray = new byte[simdSize * 2];
-            this.outArray = new byte[simdSize * 2];
+            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)
+            {
+                throw new ArgumentException("Invalid value of alignment");
+            }
+
+            this.inArray = new byte[alignment * 2];
+            this.outArray = new byte[alignment * 2];
 
             this.inHandle = GCHandle.Alloc(this.inArray, GCHandleType.Pinned);
             this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned);
 
-            this.simdSize = unchecked((byte)(simdSize));
+            this.alignment = (ulong)alignment;
 
-            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), this.simdSize);
+            Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(inArrayPtr), ref Unsafe.As<TOp1, byte>(ref inArray[0]), (uint)sizeOfinArray);
         }
 
-        public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), simdSize);
-        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), simdSize);
+        public void* inArrayPtr => Align((byte*)(inHandle.AddrOfPinnedObject().ToPointer()), alignment);
+        public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment);
 
         public void Dispose()
         {
@@ -45,19 +52,9 @@ namespace JIT.HardwareIntrinsics.X86
             outHandle.Free();
         }
 
-        private static unsafe void* Align(byte* buffer, byte expectedAlignment)
+        private static unsafe void* Align(byte* buffer, ulong expectedAlignment)
         {
-            // Compute how bad the misalignment is, which is at most (expectedAlignment - 1).
-            // Then subtract that from the expectedAlignment and add it to the original address
-            // to compute the aligned address.
-
-            var misalignment = expectedAlignment - ((ulong)(buffer) % expectedAlignment);
-            var result = (void*)(buffer + misalignment);
-            
-            Debug.Assert(((ulong)(result) % expectedAlignment) == 0);
-            Debug.Assert((ulong)(result) <= ((ulong)(result) + expectedAlignment));
- 
-            return result;
+            return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1));
         }
     }
 }