diff options
Diffstat (limited to 'tests/src/JIT/HardwareIntrinsics/X86')
23 files changed, 1230 insertions, 228 deletions
diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template index 5f152248ce..bee607a52b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingBinOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,33 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class AlternatingBinaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(AlternatingBinaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -242,7 +275,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new AlternatingBinaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -251,7 +284,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); @@ -259,6 +292,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template index 0fff775380..16823d9578 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/AlternatingTernOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,36 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class AlternatingTernaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + public {Op3VectorType}<{Op3BaseType}> _fld3; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref testStruct._fld3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(AlternatingTernaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2, _fld3); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -261,7 +297,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, secondOp, thirdOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new AlternatingTernaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); @@ -270,7 +306,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2, _fld3); @@ -278,6 +314,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template index 94adda7d95..2c5989f687 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanBinOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,31 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class BooleanBinaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(BooleanBinaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + testClass.ValidateResult(_fld1, _fld2, result); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -164,7 +195,7 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }); - + if (method != null) { var result = method.Invoke(null, new object[] { @@ -179,7 +210,7 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }); - + if (method != null) { var result = method.Invoke(null, new object[] { @@ -194,7 +225,7 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }); - + if (method != null) { var result = method.Invoke(null, new object[] { @@ -243,7 +274,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, result); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new BooleanBinaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -251,13 +282,26 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, result); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + ValidateResult(test._fld1, test._fld2, result); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template index f5674e8d2a..228991aebe 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanCmpOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,31 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class BooleanComparisonOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(BooleanComparisonOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + testClass.ValidateResult(_fld1, _fld2, result); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -231,7 +262,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, result); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new BooleanComparisonOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -239,13 +270,26 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, result); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + ValidateResult(test._fld1, test._fld2, result); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template index eb49edb9f9..cc9cdb7286 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanTwoCmpOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,31 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class BooleanTwoComparisonOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(BooleanTwoComparisonOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + testClass.ValidateResult(_fld1, _fld2, result); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -164,7 +195,7 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }); - + if (method != null) { var result = method.Invoke(null, new object[] { @@ -179,7 +210,7 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }); - + if (method != null) { var result = method.Invoke(null, new object[] { @@ -193,7 +224,7 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() {var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }); - + if (method != null) { var result = method.Invoke(null, new object[] { @@ -242,7 +273,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, result); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new BooleanTwoComparisonOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -250,13 +281,26 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, result); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + ValidateResult(test._fld1, test._fld2, result); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template index 551e51398c..daef5c7ec4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/BooleanUnOpTest.template @@ -22,7 +22,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}() { - var test = new BooleanComparisonOpTest__{Method}{RetBaseType}(); + var test = new BooleanUnaryOpTest__{Method}{RetBaseType}(); if (test.IsSupported) { @@ -65,11 +65,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -84,8 +90,30 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class BooleanComparisonOpTest__{Method}{RetBaseType} + public sealed unsafe class BooleanUnaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(BooleanUnaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld); + testClass.ValidateResult(_fld, result); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -98,7 +126,7 @@ namespace JIT.HardwareIntrinsics.X86 private BooleanUnaryOpTest__DataTable<{Op1BaseType}> _dataTable; - static BooleanComparisonOpTest__{Method}{RetBaseType}() + static BooleanUnaryOpTest__{Method}{RetBaseType}() { var random = new Random(); @@ -106,7 +134,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public BooleanComparisonOpTest__{Method}{RetBaseType}() + public BooleanUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -213,21 +241,34 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(value, result); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new BooleanComparisonOpTest__{Method}{RetBaseType}(); + var test = new BooleanUnaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld); ValidateResult(test._fld, result); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld); ValidateResult(_fld, result); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld); + ValidateResult(test._fld, result); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template index e1876a16b2..a13b2e66ac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template @@ -21,7 +21,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ExtractScalarTest__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -83,8 +89,32 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm} + public sealed unsafe class ExtractScalarTest__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(ExtractScalarTest__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -98,7 +128,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + static ExtractScalarTest__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -106,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + public ExtractScalarTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -230,16 +260,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ExtractScalarTest__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld, {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld, {Imm}); @@ -247,6 +277,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld, {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template index 3a1af15f42..480f373439 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractStoreTest.template @@ -22,7 +22,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}Store() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}Store(); + var test = new ExtractStoreTest__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -65,11 +65,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -84,8 +90,30 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}Store + public sealed unsafe class ExtractStoreTest__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(ExtractStoreTest__{Method}{RetBaseType}{Imm} testClass) + { + {Isa}.{Method}(({Op1BaseType}*)testClass._dataTable.outArrayPtr, _fld, {Imm}); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -99,7 +127,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}Store() + static ExtractStoreTest__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -107,7 +135,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}Store() + public ExtractStoreTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -200,35 +228,55 @@ namespace JIT.HardwareIntrinsics.X86 _clsVar, {Imm} ); + + ValidateResult(_clsVar, _dataTable.outArrayPtr); } public void RunLclVarScenario_UnsafeRead() { var firstOp = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArrayPtr); {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, firstOp, {Imm}); + ValidateResult(firstOp, _dataTable.outArrayPtr); } public void RunLclVarScenario_Load() { var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, firstOp, {Imm}); + ValidateResult(firstOp, _dataTable.outArrayPtr); } public void RunLclVarScenario_LoadAligned() { var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, firstOp, {Imm}); + ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}Store(); + var test = new ExtractStoreTest__{Method}{RetBaseType}{Imm}(); {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, test._fld, {Imm}); + ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, _fld, {Imm}); + ValidateResult(_fld, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, test._fld, {Imm}); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); } public void RunUnsupportedScenario() diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template index 49fb80e55f..247243a9e4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template @@ -21,7 +21,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ExtractVector128Test__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -83,8 +89,32 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm} + public sealed unsafe class ExtractVector128Test__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(ExtractVector128Test__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -98,7 +128,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + static ExtractVector128Test__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -106,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + public ExtractVector128Test__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -230,16 +260,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ExtractVector128Test__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld, {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld, {Imm}); @@ -247,6 +277,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld, {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx index 4f2ccdec92..d4d2ff5017 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenerateTests.csx @@ -162,15 +162,15 @@ private static readonly (string templateFileName, Dictionary<string, string> tem ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))", ["NextValueOp2"] = "(ushort)(random.Next(0, ushort.MaxValue))", ["ValidateFirstResult"] = "(ushort)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(ushort)(left[i] | right[i]) != result[i]"}), ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))", ["NextValueOp2"] = "(uint)(random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "(uint)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(uint)(left[i] | right[i]) != result[i]"}), ("SimpleBinOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "Or", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector128", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))", ["NextValueOp2"] = "(ulong)(random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "(ulong)(left[0] | right[0]) != result[0]", ["ValidateRemainingResults"] = "(ulong)(left[i] | right[i]) != result[i]"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(byte)(Random.Next(byte.MinValue, byte.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(Random.Next(sbyte.MinValue, sbyte.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(short)(Random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ushort)(Random.Next(ushort.MinValue, ushort.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(int)(Random.Next(int.MinValue, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(uint)(Random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(long)(Random.Next(int.MinValue, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ulong)(Random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), - ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "Random.NextDouble()", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(byte)(random.Next(byte.MinValue, byte.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(sbyte)(random.Next(sbyte.MinValue, sbyte.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(short.MinValue, short.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(ushort.MinValue, ushort.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(int.MinValue, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(uint)(random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(long)(random.Next(int.MinValue, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ulong)(random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), + ("ScalarSimdUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "SetAllVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Double", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "random.NextDouble()", ["ValidateFirstResult"] = "result[0] != firstOp", ["ValidateRemainingResults"] = "result[i] != firstOp"}), ("ImmUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["Imm"] = "1", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(short)(random.Next(0, short.MaxValue))", ["ValidateFirstResult"] = "(short)(firstOp[0] << 1) != result[0]", ["ValidateRemainingResults"] = "(short)(firstOp[i] << 1) != result[i]"}), ("ImmUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["Imm"] = "1", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(ushort)(random.Next(0, ushort.MaxValue))", ["ValidateFirstResult"] = "(ushort)(firstOp[0] << 1) != result[0]", ["ValidateRemainingResults"] = "(ushort)(firstOp[i] << 1) != result[i]"}), ("ImmUnOpTest.template", new Dictionary<string, string> { ["Isa"] = "Sse2", ["LoadIsa"] = "Sse2", ["Method"] = "ShiftLeftLogical", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["Imm"] = "1", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "(int)(random.Next(0, int.MaxValue))", ["ValidateFirstResult"] = "(int)(firstOp[0] << 1) != result[0]", ["ValidateRemainingResults"] = "(int)(firstOp[i] << 1) != result[i]"}), diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template index bfd71e722b..9ed3500ff4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template @@ -21,7 +21,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}(); + var test = new GenericUnaryOpTest__{Method}{RetBaseType}(); if (test.IsSupported) { @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -83,8 +89,32 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType} + public sealed unsafe class GenericUnaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(GenericUnaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}<{RetBaseType}>(_fld); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -98,7 +128,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpTest__{Method}{RetBaseType}() + static GenericUnaryOpTest__{Method}{RetBaseType}() { var random = new Random(); @@ -106,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public SimpleUnaryOpTest__{Method}{RetBaseType}() + public GenericUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -226,16 +256,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}(); + var test = new GenericUnaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}<{RetBaseType}>(test._fld); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}<{RetBaseType}>(_fld); @@ -243,6 +273,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template index a78e426316..d6e83b7b93 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/HorizontalBinOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,33 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class HorizontalBinaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(HorizontalBinaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -242,7 +275,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new HorizontalBinaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -251,7 +284,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); @@ -259,6 +292,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template index c8e2a864b9..f2acb74926 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template @@ -21,7 +21,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}() { - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ImmBinaryOpTest__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -83,8 +89,35 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleBinaryOpTest__{Method}{RetBaseType}{Imm} + public sealed unsafe class ImmBinaryOpTest__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(ImmBinaryOpTest__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -102,7 +135,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}() + static ImmBinaryOpTest__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -112,7 +145,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); } - public SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}() + public ImmBinaryOpTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -249,16 +282,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ImmBinaryOpTest__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld1, test._fld2, {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2, {Imm}); @@ -266,6 +299,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2, {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template index 49fb80e55f..5c593efdf9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template @@ -21,7 +21,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ImmUnaryOpTest__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -83,8 +89,32 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm} + public sealed unsafe class ImmUnaryOpTest__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(ImmUnaryOpTest__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -98,7 +128,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + static ImmUnaryOpTest__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -106,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + public ImmUnaryOpTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -230,16 +260,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new ImmUnaryOpTest__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld, {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld, {Imm}); @@ -247,6 +277,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld, {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template index eaf1b64df5..28d0e8a4a1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertLoadTest.template @@ -23,7 +23,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}Load() { - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}Load(); + var test = new InsertLoadTest__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -66,11 +66,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,8 +91,35 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}Load + public sealed unsafe class InsertLoadTest__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertLoadTest__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld1, ({Op2BaseType}*)testClass._dataTable.inArray2Ptr, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, ({Op2BaseType}*)testClass._dataTable.inArray2Ptr, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -104,7 +137,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}Load() + static InsertLoadTest__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -114,7 +147,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); } - public SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}Load() + public InsertLoadTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -251,16 +284,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}Load(); + var test = new InsertLoadTest__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld1, ({Op2BaseType}*)(_dataTable.inArray2Ptr), {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, ({Op2BaseType}*)(_dataTable.inArray2Ptr), _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, ({Op2BaseType}*)(_dataTable.inArray2Ptr), {Imm}); @@ -268,6 +301,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, ({Op2BaseType}*)(_dataTable.inArray2Ptr), _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, ({Op2BaseType}*)(_dataTable.inArray2Ptr), {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, ({Op2BaseType}*)(_dataTable.inArray2Ptr), _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template index c08700fbe8..e61ba655cc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template @@ -21,7 +21,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new InsertScalarTest__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -83,8 +89,32 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType}{Imm} + public sealed unsafe class InsertScalarTest__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertScalarTest__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld, {Data}, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -98,7 +128,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + static InsertScalarTest__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -106,7 +136,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); } - public SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}() + public InsertScalarTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -237,16 +267,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleUnaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new InsertScalarTest__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld, {Data}, {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld, {Data}, {Imm}); @@ -254,6 +284,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld, {Data}, {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template index 401980f9a2..ecbdcbb772 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template @@ -23,7 +23,7 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}{Imm}() { - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new InsertVector128Test__{Method}{RetBaseType}{Imm}(); if (test.IsSupported) { @@ -66,11 +66,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,8 +91,35 @@ namespace JIT.HardwareIntrinsics.X86 } } - public sealed unsafe class SimpleBinaryOpTest__{Method}{RetBaseType}{Imm} + public sealed unsafe class InsertVector128Test__{Method}{RetBaseType}{Imm} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(InsertVector128Test__{Method}{RetBaseType}{Imm} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2, {Imm}); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -104,7 +137,7 @@ namespace JIT.HardwareIntrinsics.X86 private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}() + static InsertVector128Test__{Method}{RetBaseType}{Imm}() { var random = new Random(); @@ -114,7 +147,7 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); } - public SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}() + public InsertVector128Test__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -251,16 +284,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}{Imm}(); + var test = new InsertVector128Test__{Method}{RetBaseType}{Imm}(); var result = {Isa}.{Method}(test._fld1, test._fld2, {Imm}); Unsafe.Write(_dataTable.outArrayPtr, result); ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2, {Imm}); @@ -268,6 +301,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2, {Imm}); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template index 572a18f45c..767ecb1a5f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template @@ -37,11 +37,17 @@ namespace JIT.HardwareIntrinsics.X86 // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -58,14 +64,37 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class ScalarBinaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1BaseType} _fld1; + public {Op2BaseType} _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + testStruct._fld1 = {NextValueOp1}; + testStruct._fld2 = {NextValueOp2}; + + return testStruct; + } + + public void RunStructFldScenario(ScalarBinaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + testClass.ValidateResult(_fld1, _fld2, result); + } + } + private static {Op1BaseType} _data1; - private static {Op1BaseType} _data2; + private static {Op2BaseType} _data2; private static {Op1BaseType} _clsVar1; - private static {Op1BaseType} _clsVar2; + private static {Op2BaseType} _clsVar2; private {Op1BaseType} _fld1; - private {Op1BaseType} _fld2; + private {Op2BaseType} _fld2; static ScalarBinaryOpTest__{Method}{RetBaseType}() { @@ -79,7 +108,7 @@ namespace JIT.HardwareIntrinsics.X86 Succeeded = true; var random = new Random(); - + _fld1 = {NextValueOp1}; _fld2 = {NextValueOp2}; @@ -131,7 +160,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data1, data2, result); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new ScalarBinaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -139,12 +168,26 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, result); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + + ValidateResult(test._fld1, test._fld2, result); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template index 0c61993f12..89095a08da 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template @@ -21,35 +21,33 @@ namespace JIT.HardwareIntrinsics.X86 { private static void {Method}{RetBaseType}() { - bool skipIf32Bit = (typeof({Op1BaseType}) == typeof(Int64)) || - (typeof({Op1BaseType}) == typeof(UInt64)); - - if (skipIf32Bit && !Environment.Is64BitProcess) - { - return; - } - var test = new ScalarSimdUnaryOpTest__{Method}{RetBaseType}(); if (test.IsSupported) { // Validates basic functionality works - test.RunBasicScenario(); + test.RunBasicScenario_UnsafeRead(); // Validates calling via reflection works - test.RunReflectionScenario(); + test.RunReflectionScenario_UnsafeRead(); // Validates passing a static member works test.RunClsVarScenario(); // Validates passing a local works - test.RunLclVarScenario(); + test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -66,11 +64,33 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class ScalarSimdUnaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1BaseType} _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + testStruct._fld = {NextValueOp1}; + return testStruct; + } + + public void RunStructFldScenario(ScalarSimdUnaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); - private static readonly Random Random = new Random(); + private static {Op1BaseType} _data; private static {Op1BaseType} _clsVar; @@ -80,6 +100,7 @@ namespace JIT.HardwareIntrinsics.X86 static ScalarSimdUnaryOpTest__{Method}{RetBaseType}() { + var random = new Random(); _clsVar = {NextValueOp1}; } @@ -87,33 +108,35 @@ namespace JIT.HardwareIntrinsics.X86 { Succeeded = true; + var random = new Random(); _fld = {NextValueOp1}; + _data = {NextValueOp1}; _dataTable = new ScalarSimdUnaryOpTest__DataTable<{RetBaseType}>(new {RetBaseType}[RetElementCount], LargestVectorSize); } - public bool IsSupported => {Isa}.IsSupported; + public bool IsSupported => {Isa}.IsSupported && (Environment.Is64BitProcess || ((typeof({RetBaseType}) != typeof(long)) && (typeof({RetBaseType}) != typeof(ulong)))); public bool Succeeded { get; set; } - public void RunBasicScenario() + public void RunBasicScenario_UnsafeRead() { - var firstOp = {NextValueOp1}; var result = {Isa}.{Method}( - firstOp + Unsafe.ReadUnaligned<{Op1BaseType}>(ref Unsafe.As<{Op1BaseType}, byte>(ref _data)) ); Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); + ValidateResult(_data, _dataTable.outArrayPtr); } - public void RunReflectionScenario() + public void RunReflectionScenario_UnsafeRead() { - var firstOp = {NextValueOp1}; - var method = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1BaseType}) }); - var result = method.Invoke(null, new object[] { firstOp }); + var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1BaseType}) }) + .Invoke(null, new object[] { + Unsafe.ReadUnaligned<{Op1BaseType}>(ref Unsafe.As<{Op1BaseType}, byte>(ref _data)) + }); Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(firstOp, _dataTable.outArrayPtr); + ValidateResult(_data, _dataTable.outArrayPtr); } public void RunClsVarScenario() @@ -126,16 +149,16 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_clsVar, _dataTable.outArrayPtr); } - public void RunLclVarScenario() + public void RunLclVarScenario_UnsafeRead() { - var firstOp = {NextValueOp1}; - var result = {Isa}.{Method}(firstOp); + var data = Unsafe.ReadUnaligned<{Op1BaseType}>(ref Unsafe.As<{Op1BaseType}, byte>(ref _data)); + var result = {Isa}.{Method}(data); Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); + ValidateResult(data, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new ScalarSimdUnaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld); @@ -144,7 +167,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld); @@ -152,13 +175,28 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; try { - RunBasicScenario(); + RunBasicScenario_UnsafeRead(); } catch (PlatformNotSupportedException) { diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template index 646f3ee1af..8e371a88d2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template @@ -37,11 +37,17 @@ namespace JIT.HardwareIntrinsics.X86 // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -58,6 +64,26 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class ScalarUnaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1BaseType} _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + testStruct._fld = {NextValueOp1}; + return testStruct; + } + + public void RunStructFldScenario(ScalarUnaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld); + testClass.ValidateResult(_fld, result); + } + } + private static {Op1BaseType} _data; private static {Op1BaseType} _clsVar; @@ -120,7 +146,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data, result); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new ScalarUnaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld); @@ -128,12 +154,26 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld, result); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld); ValidateResult(_fld, result); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld); + + ValidateResult(test._fld, result); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template index 1644045e8e..5088d80f51 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,33 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class SimpleBinaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(SimpleBinaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -242,7 +275,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new SimpleBinaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2); @@ -251,7 +284,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2); @@ -259,6 +292,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template index 703578ff2c..897a313a1f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleTernOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,36 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class SimpleTernaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + public {Op2VectorType}<{Op2BaseType}> _fld2; + public {Op3VectorType}<{Op3BaseType}> _fld3; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref testStruct._fld2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3VectorType}<{Op3BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op3VectorType}<{Op3BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(SimpleTernaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld1, _fld2, _fld3); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -261,7 +297,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, secondOp, thirdOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new SimpleTernaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); @@ -270,7 +306,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld1, _fld2, _fld3); @@ -278,6 +314,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template index d2bc824346..b786357121 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template +++ b/tests/src/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpTest.template @@ -64,11 +64,17 @@ namespace JIT.HardwareIntrinsics.X86 test.RunLclVarScenario_LoadAligned(); } - // Validates passing the field of a local works - test.RunLclFldScenario(); + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); - // Validates passing an instance member works - test.RunFldScenario(); + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); } else { @@ -85,6 +91,30 @@ namespace JIT.HardwareIntrinsics.X86 public sealed unsafe class SimpleUnaryOpTest__{Method}{RetBaseType} { + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + var random = new Random(); + + for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(SimpleUnaryOpTest__{Method}{RetBaseType} testClass) + { + var result = {Isa}.{Method}(_fld); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld, testClass._dataTable.outArrayPtr); + } + } + private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); @@ -223,7 +253,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclFldScenario() + public void RunClassLclFldScenario() { var test = new SimpleUnaryOpTest__{Method}{RetBaseType}(); var result = {Isa}.{Method}(test._fld); @@ -232,7 +262,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(test._fld, _dataTable.outArrayPtr); } - public void RunFldScenario() + public void RunClassFldScenario() { var result = {Isa}.{Method}(_fld); @@ -240,6 +270,21 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_fld, _dataTable.outArrayPtr); } + public void RunStructLclFldScenario() + { + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + var test = TestStruct.Create(); + test.RunStructFldScenario(this); + } + public void RunUnsupportedScenario() { Succeeded = false; |