diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Byte.15.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Byte.15.cs
index 4902e3c0ff90f..942ceb8338e4a 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Byte.15.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Byte.15.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<Byte> op1, void* result, [CallerMemberName
             Byte[] outArray = new Byte[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Byte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Byte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Byte[] outArray = new Byte[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Byte>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Byte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Byte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Double.1.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Double.1.cs
index 17c63ff888d12..a357d8a2dd357 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Double.1.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Double.1.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<Double> op1, void* result, [CallerMemberNa
             Double[] outArray = new Double[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Double>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Double>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Double[] outArray = new Double[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Double>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Double>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Double, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Double>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int16.7.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int16.7.cs
index d0b0697cd943f..c0c8588acd2c9 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int16.7.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int16.7.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<Int16> op1, void* result, [CallerMemberNam
             Int16[] outArray = new Int16[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Int16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Int16[] outArray = new Int16[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Int16>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Int16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int32.3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int32.3.cs
index bb7cb3f5ddfb4..8807b76e6ab4d 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int32.3.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int32.3.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<Int32> op1, void* result, [CallerMemberNam
             Int32[] outArray = new Int32[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Int32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Int32[] outArray = new Int32[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Int32>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Int32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int64.1.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int64.1.cs
index 8b7ba34c8ee8e..2d8d4bdd4d5cb 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int64.1.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Int64.1.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<Int64> op1, void* result, [CallerMemberNam
             Int64[] outArray = new Int64[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Int64, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Int64>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Int64[] outArray = new Int64[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Int64>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Int64>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Int64>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.SByte.15.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.SByte.15.cs
index 70d743b11f4e7..856ea0abb6a55 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.SByte.15.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.SByte.15.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<SByte> op1, void* result, [CallerMemberNam
             SByte[] outArray = new SByte[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<SByte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<SByte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             SByte[] outArray = new SByte[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<SByte>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<SByte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<SByte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Single.3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Single.3.cs
index b367e5d4909ce..66f25e05903e1 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Single.3.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.Single.3.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<Single> op1, void* result, [CallerMemberNa
             Single[] outArray = new Single[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Single>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Single>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Single[] outArray = new Single[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<Single>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<Single>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Single>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt16.7.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt16.7.cs
index e3f2f9903cf46..24e151bfca30c 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt16.7.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt16.7.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<UInt16> op1, void* result, [CallerMemberNa
             UInt16[] outArray = new UInt16[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<UInt16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             UInt16[] outArray = new UInt16[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<UInt16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt32.3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt32.3.cs
index 15ea4619e92da..5f3f48e0f3891 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt32.3.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt32.3.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<UInt32> op1, void* result, [CallerMemberNa
             UInt32[] outArray = new UInt32[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<UInt32, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<UInt32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             UInt32[] outArray = new UInt32[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<UInt32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt64.1.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt64.1.cs
index a2256eee85857..e28b7e94258ef 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt64.1.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector128.UInt64.1.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector128<UInt64> op1, void* result, [CallerMemberNa
             UInt64[] outArray = new UInt64[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<UInt64, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<UInt64>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             UInt64[] outArray = new UInt64[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector128<UInt64>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt64, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<UInt64>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Byte.7.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Byte.7.cs
index 84ad6f0c200db..e12d2ee1cef42 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Byte.7.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Byte.7.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<Byte> op1, void* result, [CallerMemberName]
             Byte[] outArray = new Byte[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Byte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Byte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Byte[] outArray = new Byte[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Byte>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Byte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Byte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Byte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int16.3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int16.3.cs
index bc1dbfd3d1ba7..94e2d8d4ab64c 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int16.3.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int16.3.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<Int16> op1, void* result, [CallerMemberName
             Int16[] outArray = new Int16[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Int16, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Int16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Int16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Int16[] outArray = new Int16[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Int16>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Int16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Int16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int32.1.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int32.1.cs
index 8d4d914cc359e..a2b2908968e13 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int32.1.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Int32.1.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<Int32> op1, void* result, [CallerMemberName
             Int32[] outArray = new Int32[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Int32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Int32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Int32[] outArray = new Int32[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Int32>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Int32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Int32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Int32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.SByte.7.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.SByte.7.cs
index caeec009fc3cd..033cfde06e1a1 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.SByte.7.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.SByte.7.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<SByte> op1, void* result, [CallerMemberName
             SByte[] outArray = new SByte[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<SByte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<SByte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             SByte[] outArray = new SByte[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<SByte>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<SByte>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<SByte, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<SByte>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Single.1.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Single.1.cs
index 234926dc4d5ed..ac517d26d5378 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Single.1.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.Single.1.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<Single> op1, void* result, [CallerMemberNam
             Single[] outArray = new Single[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<Single>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             Single[] outArray = new Single[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<Single>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<Single>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<Single, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<Single>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt16.3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt16.3.cs
index 6db998a0b5290..64afd4eb7d01e 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt16.3.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt16.3.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<UInt16> op1, void* result, [CallerMemberNam
             UInt16[] outArray = new UInt16[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<UInt16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             UInt16[] outArray = new UInt16[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt16>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt16, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<UInt16>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt32.1.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt32.1.cs
index 46fc53118acb8..6627dc1000163 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt32.1.cs
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/StoreSelectedScalar.Vector64.UInt32.1.cs
@@ -417,7 +417,7 @@ private void ValidateResult(Vector64<UInt32> op1, void* result, [CallerMemberNam
             UInt32[] outArray = new UInt32[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<UInt32, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<UInt32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ private void ValidateResult(void* op1, void* result, [CallerMemberName] string m
             UInt32[] outArray = new UInt32[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<Vector64<UInt32>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<UInt32, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<UInt32>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template
index 3d38d1b4742b5..e7c0bf4b57f9c 100644
--- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template
+++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template
@@ -417,7 +417,7 @@ namespace JIT.HardwareIntrinsics.Arm
             {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.WriteUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), op1);
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result),(uint)(Unsafe.SizeOf<{RetBaseType}>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }
@@ -428,7 +428,7 @@ namespace JIT.HardwareIntrinsics.Arm
             {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount];
 
             Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef<byte>(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>());
-            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>());
+            Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef<byte>(result), (uint)(Unsafe.SizeOf<{RetBaseType}>() * RetElementCount));
 
             ValidateResult(inArray1, outArray[0], method);
         }