diff --git a/src/coreclr/jit/emitxarch.cpp b/src/coreclr/jit/emitxarch.cpp index d76be519adc951..4e25a445bbaa80 100644 --- a/src/coreclr/jit/emitxarch.cpp +++ b/src/coreclr/jit/emitxarch.cpp @@ -35,7 +35,7 @@ bool emitter::IsSSEOrAVXInstruction(instruction ins) } //------------------------------------------------------------------------ -// IsKInstruction: Does this instruction require K register. +// IsKInstruction: Does this instruction require K register? // // Arguments: // ins - The instruction to check. diff --git a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp index ae0879e4ba4730..772b8439ba65d5 100644 --- a/src/coreclr/jit/hwintrinsiccodegenxarch.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenxarch.cpp @@ -1786,12 +1786,22 @@ void CodeGen::genAvxFamilyIntrinsic(GenTreeHWIntrinsic* node) break; } + case NI_AVX512F_ConvertToVector256Int32: + { + if (varTypeIsFloating(baseType)) + { + instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType); + genHWIntrinsic_R_RM(node, ins, attr, targetReg, op1); + break; + } + FALLTHROUGH; + } + case NI_AVX512F_ConvertToVector128Int16: case NI_AVX512F_ConvertToVector128Int32: case NI_AVX512F_ConvertToVector128UInt16: case NI_AVX512F_ConvertToVector128UInt32: case NI_AVX512F_ConvertToVector256Int16: - case NI_AVX512F_ConvertToVector256Int32: case NI_AVX512F_ConvertToVector256UInt16: case NI_AVX512F_ConvertToVector256UInt32: case NI_AVX512BW_ConvertToVector128Byte: @@ -1801,18 +1811,11 @@ void CodeGen::genAvxFamilyIntrinsic(GenTreeHWIntrinsic* node) { instruction ins = HWIntrinsicInfo::lookupIns(intrinsicId, baseType); - if (varTypeIsFloating(baseType)) - { - genHWIntrinsic_R_RM(node, ins, attr, targetReg, op1); - } - else - { - // These instructions are RM_R and so we need to ensure the targetReg - // is passed in as the RM register and op1 is passed as the R register + // These instructions are RM_R and so we need to ensure the targetReg + // is passed in as the RM register and op1 is passed as the R register - op1Reg = op1->GetRegNum(); - emit->emitIns_R_R(ins, attr, op1Reg, targetReg); - } + op1Reg = op1->GetRegNum(); + emit->emitIns_R_R(ins, attr, op1Reg, targetReg); break; } diff --git a/src/coreclr/jit/hwintrinsiclistxarch.h b/src/coreclr/jit/hwintrinsiclistxarch.h index 3e81d3f3da3f36..57476944fed88d 100644 --- a/src/coreclr/jit/hwintrinsiclistxarch.h +++ b/src/coreclr/jit/hwintrinsiclistxarch.h @@ -801,7 +801,7 @@ HARDWARE_INTRINSIC(AVX512F, ConvertToVector128UInt16, HARDWARE_INTRINSIC(AVX512F, ConvertToVector128UInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpmovqd, INS_vpmovqd, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AVX512F, ConvertToVector256Int16, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpmovdw, INS_vpmovdw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AVX512F, ConvertToVector256Int32, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpmovqd, INS_vpmovqd, INS_invalid, INS_cvtpd2dq}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) -HARDWARE_INTRINSIC(AVX512F, ConvertToVector128Int32WithTruncation, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttpd2dq}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg) +HARDWARE_INTRINSIC(AVX512F, ConvertToVector256Int32WithTruncation, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvttpd2dq}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(AVX512F, ConvertToVector256Single, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cvtpd2ps}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg) HARDWARE_INTRINSIC(AVX512F, ConvertToVector256UInt16, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpmovdw, INS_vpmovdw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AVX512F, ConvertToVector256UInt32, 64, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_vpmovqd, INS_vpmovqd, INS_invalid, INS_invalid}, HW_Category_SimpleSIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialCodeGen) diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp index a5302889d7e3ad..7042f81002765e 100644 --- a/src/coreclr/jit/lowerxarch.cpp +++ b/src/coreclr/jit/lowerxarch.cpp @@ -5759,12 +5759,20 @@ void Lowering::ContainCheckStoreIndir(GenTreeStoreInd* node) break; } + case NI_AVX512F_ConvertToVector256Int32: + { + if (varTypeIsFloating(simdBaseType)) + { + break; + } + FALLTHROUGH; + } + case NI_AVX512F_ConvertToVector128Int16: case NI_AVX512F_ConvertToVector128Int32: case NI_AVX512F_ConvertToVector128UInt16: case NI_AVX512F_ConvertToVector128UInt32: case NI_AVX512F_ConvertToVector256Int16: - case NI_AVX512F_ConvertToVector256Int32: case NI_AVX512F_ConvertToVector256UInt16: case NI_AVX512F_ConvertToVector256UInt32: case NI_AVX512BW_ConvertToVector128Byte: @@ -7402,12 +7410,22 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) break; } + case NI_AVX512F_ConvertToVector256Int32: + { + if (varTypeIsFloating(simdBaseType)) + { + // This version is "ins xmm, xmm/mem" and + // gets the default containment handling + break; + } + FALLTHROUGH; + } + case NI_AVX512F_ConvertToVector128Int16: case NI_AVX512F_ConvertToVector128Int32: case NI_AVX512F_ConvertToVector128UInt16: case NI_AVX512F_ConvertToVector128UInt32: case NI_AVX512F_ConvertToVector256Int16: - case NI_AVX512F_ConvertToVector256Int32: case NI_AVX512F_ConvertToVector256UInt16: case NI_AVX512F_ConvertToVector256UInt32: case NI_AVX512BW_ConvertToVector128Byte: diff --git a/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs b/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs index affc29d19310c0..6d124bda4673c6 100644 --- a/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs +++ b/src/coreclr/tools/Common/Compiler/InstructionSetSupport.cs @@ -58,6 +58,8 @@ public static string GetHardwareIntrinsicId(TargetArchitecture architecture, Typ { if (potentialType.Name == "X64") potentialType = (MetadataType)potentialType.ContainingType; + if (potentialType.Name == "VL") + potentialType = (MetadataType)potentialType.ContainingType; if (potentialType.Namespace != "System.Runtime.Intrinsics.X86") return ""; } @@ -65,6 +67,8 @@ public static string GetHardwareIntrinsicId(TargetArchitecture architecture, Typ { if (potentialType.Name == "X64") potentialType = (MetadataType)potentialType.ContainingType; + if (potentialType.Name == "VL") + potentialType = (MetadataType)potentialType.ContainingType; if (potentialType.Namespace != "System.Runtime.Intrinsics.X86") return ""; } diff --git a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_X86.cs b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_X86.cs index 1b8c3cec126d30..299c4bdd4602c5 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_X86.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_X86.cs @@ -1179,10 +1179,10 @@ ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "ShiftRightLogical", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Imm"] = "32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "0 != result[0]", ["ValidateRemainingResults"] = "0!= result[i]"}), ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "ShiftRightLogical", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "(ulong)(firstOp[0] >> 1) != result[0]", ["ValidateRemainingResults"] = "(ulong)(firstOp[i] >> 1) != result[i]"}), ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "ShiftRightLogical", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt64", ["Imm"] = "64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateFirstResult"] = "0 != result[0]", ["ValidateRemainingResults"] = "0 != result[i]"}), - ("ImmBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[1])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[7]) != BitConverter.SingleToInt32Bits(right[4])"}), - ("ImmBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[1])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[3]) != BitConverter.DoubleToInt64Bits(right[2])"}), - ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != firstOp[1]", ["ValidateRemainingResults"] = "result[i] != (i < 4 ? firstOp[0] : (i == 4 ? firstOp[5] : firstOp[4]))"}), - ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != firstOp[1]", ["ValidateRemainingResults"] = "result[i] != (i < 4 ? firstOp[0] : (i == 4 ? firstOp[5] : firstOp[4]))"}), + ("ImmBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Single", ["Imm"] = "17", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(result[0]) != BitConverter.SingleToInt32Bits(left[1])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[7]) != BitConverter.SingleToInt32Bits(right[4])"}), + ("ImmBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["Imm"] = "85", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(result[0]) != BitConverter.DoubleToInt64Bits(left[1])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[3]) != BitConverter.DoubleToInt64Bits(right[2])"}), + ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "result[0] != firstOp[1]", ["ValidateRemainingResults"] = "result[i] != firstOp[((i / 4) * 4) + ((i % 4) != 0 ? 0 : 1)]"}), + ("ImmUnOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Shuffle", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "UInt32", ["Imm"] = "1", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "result[0] != firstOp[1]", ["ValidateRemainingResults"] = "result[i] != firstOp[((i / 4) * 4) + ((i % 4) != 0 ? 0 : 1)]"}), ("SimpleBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(left[0] - right[0]) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(left[i] - right[i]) != BitConverter.DoubleToInt64Bits(result[i])"}), ("SimpleBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "(int)(left[0] - right[0]) != result[0]", ["ValidateRemainingResults"] = "(int)(left[i] - right[i]) != result[i]"}), ("SimpleBinOpTest.template", new Dictionary { ["Isa"] = "Avx512F", ["LoadIsa"] = "Avx512F", ["Method"] = "Subtract", ["RetVectorType"] = "Vector512", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector512", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector512", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateFirstResult"] = "(long)(left[0] - right[0]) != result[0]", ["ValidateRemainingResults"] = "(long)(left[i] - right[i]) != result[i]"}), diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesBinOpTest.template index 818fd566769a6a..3a3a64b1b88c34 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesBinOpTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -189,48 +141,22 @@ namespace JIT.HardwareIntrinsics.Arm Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(AesBinaryOpTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); - + private static {Op1BaseType}[] _data1 = new {Op1BaseType}[{InputSize}] {Input}; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[{KeySize}] {Key}; private static {RetBaseType}[] _expectedRet = new {RetBaseType}[{ExpectedRetSize}] {ExpectedRet}; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static AesBinaryOpTest__{TestName}() - { - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public AesBinaryOpTest__{TestName}() { Succeeded = true; @@ -286,50 +212,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op2VectorType}<{Op2BaseType}>* pClsVar2 = &_clsVar2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pClsVar2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -342,48 +224,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new AesBinaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new AesBinaryOpTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &test._fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -394,23 +234,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -422,20 +245,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(&test._fld2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -444,14 +253,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); @@ -483,7 +284,7 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(outArray, method); } - + private void ValidateResult({RetBaseType}[] result, [CallerMemberName] string method = "") { bool succeeded = true; @@ -493,7 +294,7 @@ namespace JIT.HardwareIntrinsics.Arm if (result[i] != _expectedRet[i] ) { succeeded = false; - } + } } if (!succeeded) diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesUnOpTest.template index e6c9d6e88b5507..c466d0c18645e4 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/AesUnOpTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -178,19 +130,6 @@ namespace JIT.HardwareIntrinsics.Arm Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(AesUnaryOpTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &_fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)) - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -199,19 +138,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data = new {Op1BaseType}[{InputSize}] {Input}; private static {RetBaseType}[] _expectedRet = new {RetBaseType}[{ExpectedRetSize}] {ExpectedRet}; - - private static {Op1VectorType}<{Op1BaseType}> _clsVar; private {Op1VectorType}<{Op1BaseType}> _fld; private DataTable _dataTable; - static AesUnaryOpTest__{TestName}() - { - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public AesUnaryOpTest__{TestName}() { Succeeded = true; @@ -263,46 +194,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar = &_clsVar) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -314,45 +205,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var result = {Isa}.{Method}(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new AesUnaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new AesUnaryOpTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &test._fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -363,21 +215,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &_fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -389,19 +226,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -410,14 +234,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractTest.template index 650fe3ed52a239..e141a6f4528d46 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -169,16 +121,6 @@ namespace JIT.HardwareIntrinsics.Arm testClass.ValidateResult(_fld1, result); } - - public void RunStructFldScenario_Load(ExtractTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - var result = {Isa}.{Method}({LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), ElementIndex); - - testClass.ValidateResult(_fld1, result); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -189,18 +131,10 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private DataTable _dataTable; - static ExtractTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public ExtractTest__{TestName}() { Succeeded = true; @@ -253,40 +187,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, ({Op1BaseType})result); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - ElementIndex - }); - - ValidateResult(_dataTable.inArray1Ptr, ({Op1BaseType})result); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}(_clsVar1, ElementIndex); - - ValidateResult(_clsVar1, result); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - { - var result = {Isa}.{Method}({LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pClsVar1), ElementIndex); - - ValidateResult(_clsVar1, result); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -297,40 +197,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, result); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var result = {Isa}.{Method}(op1, ElementIndex); - - ValidateResult(op1, result); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ExtractTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, ElementIndex); - - ValidateResult(test._fld1, result); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ExtractTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - { - var result = {Isa}.{Method}({LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), ElementIndex); - - ValidateResult(test._fld1, result); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -340,18 +206,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, result); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - var result = {Isa}.{Method}({LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), ElementIndex); - - ValidateResult(_fld1, result); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -362,19 +216,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, result); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)&test._fld1), - ElementIndex - ); - - ValidateResult(test._fld1, result); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -383,14 +224,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractVectorTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractVectorTest.template index 7bfdc0f68ffea5..fcac6c0fd3bab5 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractVectorTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ExtractVectorTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -190,22 +142,6 @@ namespace JIT.HardwareIntrinsics.Arm Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(ExtractVectorTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)pFld2), - ElementIndex - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -218,22 +154,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static ExtractVectorTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public ExtractVectorTest__{TestName}() { Succeeded = true; @@ -295,53 +220,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - ElementIndex - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - ElementIndex - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op2VectorType}<{Op2BaseType}>* pClsVar2 = &_clsVar2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pClsVar2)), - ElementIndex - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -354,49 +232,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var op2 = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(op1, op2, ElementIndex); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, op2, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ExtractVectorTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, ElementIndex); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ExtractVectorTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &test._fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)pFld2), - ElementIndex - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -407,24 +242,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)pFld2), - ElementIndex - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -436,21 +253,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(&test._fld2)), - ElementIndex - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -459,14 +261,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template index 24cbaa509f1f3e..8697ae3fe1a24c 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertScalarTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -190,22 +142,6 @@ namespace JIT.HardwareIntrinsics.Arm Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(InsertScalarTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2) - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -218,22 +154,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op3VectorType}<{Op3BaseType}> _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op3VectorType}<{Op3BaseType}> _fld3; private DataTable _dataTable; - static InsertScalarTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - 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}>>()); - } - public InsertScalarTest__{TestName}() { Succeeded = true; @@ -295,53 +220,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte), typeof({Op3VectorType}<{Op3BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - ElementIndex, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - {ElementIndex}, - _clsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op3VectorType}<{Op3BaseType}>* pClsVar3 = &_clsVar3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {ElementIndex}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(pClsVar3)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -354,49 +232,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op3, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var op3 = {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)); - var result = {Isa}.{Method}(op1, {ElementIndex}, op3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, op3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new InsertScalarTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, {ElementIndex}, test._fld3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new InsertScalarTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &test._fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -407,24 +242,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -436,21 +253,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {ElementIndex}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(&test._fld3)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -459,14 +261,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertSelectedScalarTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertSelectedScalarTest.template index 7fd251179af20c..2a5b44393d7dde 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertSelectedScalarTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertSelectedScalarTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -190,23 +142,6 @@ namespace JIT.HardwareIntrinsics.Arm Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(InsertSelectedScalarTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex1}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2), - {ElementIndex2} - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -220,22 +155,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op3VectorType}<{Op3BaseType}> _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op3VectorType}<{Op3BaseType}> _fld3; private DataTable _dataTable; - static InsertSelectedScalarTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - 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}>>()); - } - public InsertSelectedScalarTest__{TestName}() { Succeeded = true; @@ -300,56 +224,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte), typeof({Op3VectorType}<{Op3BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - ElementIndex1, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)), - ElementIndex2 - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - {ElementIndex1}, - _clsVar3, - {ElementIndex2} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op3VectorType}<{Op3BaseType}>* pClsVar3 = &_clsVar3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {ElementIndex1}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(pClsVar3)), - {ElementIndex2} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -362,50 +236,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op3, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var op3 = {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(_dataTable.inArray3Ptr)); - var result = {Isa}.{Method}(op1, {ElementIndex1}, op3, {ElementIndex2}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, op3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new InsertSelectedScalarTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, {ElementIndex1}, test._fld3, {ElementIndex2}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new InsertSelectedScalarTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &test._fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex1}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2), - {ElementIndex2} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -416,25 +246,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op3VectorType}<{Op3BaseType}>* pFld2 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex1}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)pFld2), - {ElementIndex2} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -446,22 +257,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {ElementIndex1}, - {LoadIsa}.Load{Op3VectorType}(({Op3BaseType}*)(&test._fld3)), - {ElementIndex2} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -470,14 +265,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertTest.template index 2164bcc00d9a67..ed766212e437df 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/InsertTest.template @@ -38,65 +38,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -182,22 +134,6 @@ namespace JIT.HardwareIntrinsics.Arm Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(InsertTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op1BaseType}* pFld3 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - ElementIndex, - *pFld3 - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -208,22 +144,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1BaseType} _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1BaseType} _fld3; private DataTable _dataTable; - static InsertTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - - _clsVar3 = {NextValueOp3}; - } - public InsertTest__{TestName}() { Succeeded = true; @@ -286,55 +211,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, op3, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - {Op1BaseType} op3 = {NextValueOp3}; - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte), typeof({Op1BaseType}) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - ElementIndex, - op3 - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, op3, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - ElementIndex, - _clsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op1BaseType}* pClsVar3 = &_clsVar3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pClsVar1), - ElementIndex, - *pClsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -348,50 +224,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op3, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var op3 = {NextValueOp3}; - - var result = {Isa}.{Method}(op1, ElementIndex, op3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, op3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new InsertTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, ElementIndex, test._fld3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new InsertTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op1BaseType}* pFld3 = &test._fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - ElementIndex, - *pFld3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -402,24 +234,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op1BaseType}* pFld3 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - ElementIndex, - *pFld3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -431,21 +245,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - ElementIndex, - test._fld3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -454,14 +253,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadAndInsertScalarTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadAndInsertScalarTest.template index cbdaa300879889..f74ef42e057e92 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadAndInsertScalarTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadAndInsertScalarTest.template @@ -39,65 +39,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -187,22 +139,6 @@ namespace JIT.HardwareIntrinsics.Arm testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(LoadAndInsertTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op1BaseType}* pFld3 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex}, - pFld3 - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, _fld3, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -213,22 +149,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1BaseType} _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1BaseType} _fld3; private DataTable _dataTable; - static LoadAndInsertTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - - _clsVar3 = {NextValueOp3}; - } - public LoadAndInsertTest__{TestName}() { Succeeded = true; @@ -295,56 +220,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, op3, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - {Op1BaseType} op3 = {NextValueOp3}; - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte), typeof({Op1BaseType}*) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - ElementIndex, - Pointer.Box(&op3, typeof({Op1BaseType}*)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, op3, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - fixed ({Op1BaseType}* pClsVar3 = &_clsVar3) - { - var result = {Isa}.{Method}( - _clsVar1, - {ElementIndex}, - pClsVar3 - ); - Unsafe.Write(_dataTable.outArrayPtr, result); - } - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op1BaseType}* pClsVar3 = &_clsVar3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pClsVar1), - {ElementIndex}, - pClsVar3 - ); - Unsafe.Write(_dataTable.outArrayPtr, result); - } - ValidateResult(_clsVar1, _clsVar3, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -358,53 +233,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op3, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var op3 = {NextValueOp3}; - - var result = {Isa}.{Method}(op1, {ElementIndex}, &op3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, op3, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new LoadAndInsertTest__{TestName}(); - fixed ({Op1BaseType}* pFld3 = &test._fld3) - { - var result = {Isa}.{Method}(test._fld1, {ElementIndex}, pFld3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new LoadAndInsertTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op1BaseType}* pFld3 = &test._fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex}, - pFld3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -419,24 +247,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op1BaseType}* pFld3 = &_fld3) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)pFld1), - {ElementIndex}, - pFld3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _fld3, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -448,21 +258,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {ElementIndex}, - &test._fld3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld3, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -471,14 +266,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadPairVectorTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadPairVectorTest.template index a9cd9dd47966b7..01229a242cd964 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadPairVectorTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/LoadPairVectorTest.template @@ -33,12 +33,6 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works test.RunReflectionScenario(); - // Validates loading to a static member works - test.RunClsVarScenario(); - - // Validates loading to the field of a local class works - test.RunClassLclFldScenario(); - // Validates loading to the field of a local struct works test.RunStructLclFldScenario(); @@ -131,8 +125,6 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static ({RetVectorType}<{RetBaseType}>,{RetVectorType}<{RetBaseType}>) _clsVar; - private ({RetVectorType}<{RetBaseType}>,{RetVectorType}<{RetBaseType}>) _fld; private DataTable _dataTable; @@ -171,27 +163,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - _clsVar = {Isa}.{Method}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - - Unsafe.Write(_dataTable.outArrayPtr, _clsVar); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TestName}(); - test._fld = {Isa}.{Method}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - - Unsafe.Write(_dataTable.outArrayPtr, test._fld); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarBinOpTest.template index 52e8ff92e588b1..95e16fbd710423 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarBinOpTest.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -90,18 +84,9 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType} _data1; private static {Op2BaseType} _data2; - private static {Op1BaseType} _clsVar1; - private static {Op2BaseType} _clsVar2; - private {Op1BaseType} _fld1; private {Op2BaseType} _fld2; - static ScalarBinaryOpTest__{TestName}() - { - _clsVar1 = {NextValueOp1}; - _clsVar2 = {NextValueOp2}; - } - public ScalarBinaryOpTest__{TestName}() { Succeeded = true; @@ -142,18 +127,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_data1, _data2, ({RetBaseType})result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - ValidateResult(_clsVar1, _clsVar2, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -165,16 +138,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(data1, data2, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarBinaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - ValidateResult(test._fld1, test._fld2, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarUnOpTest.template index 96796751f9b284..c6fe68908e5627 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ScalarUnOpTest.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -86,20 +80,13 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType} _data; - private static {Op1BaseType} _clsVar; - private {Op1BaseType} _fld; - static ScalarUnaryOpTest__{TestName}() - { - _clsVar = {NextValueOp1}; - } - public ScalarUnaryOpTest__{TestName}() { Succeeded = true; - + _fld = {NextValueOp1}; _data = {NextValueOp1}; } @@ -131,17 +118,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_data, ({RetBaseType})result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - ValidateResult(_clsVar, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -152,16 +128,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(data, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarUnaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld); - - ValidateResult(test._fld, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreBinOpTest.template index e5825f5fd3a28f..8c539c7865b4fa 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreBinOpTest.template @@ -39,65 +39,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -190,21 +142,6 @@ namespace JIT.HardwareIntrinsics.Arm testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(StoreBinaryOpTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - {Isa}.{Method}( - ({RetBaseType}*)testClass._dataTable.outArrayPtr, - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -216,22 +153,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static StoreBinaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public StoreBinaryOpTest__{TestName}() { Succeeded = true; @@ -288,46 +214,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, _clsVar1, _clsVar2); - - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op2VectorType}<{Op2BaseType}>* pClsVar2 = &_clsVar2) - { - {Isa}.{Method}( - ({Op1BaseType}*)_dataTable.outArrayPtr, - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pClsVar2)) - ); - - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -339,46 +225,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var op2 = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, op1, op2); - - ValidateResult(op1, op2, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new StoreBinaryOpTest__{TestName}(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, test._fld1, test._fld2); - - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new StoreBinaryOpTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &test._fld2) - { - {Isa}.{Method}( - ({RetBaseType}*)_dataTable.outArrayPtr, - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -388,23 +234,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - {Isa}.{Method}( - ({RetBaseType}*)_dataTable.outArrayPtr, - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -415,20 +244,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - {Isa}.{Method}( - ({RetBaseType}*)_dataTable.outArrayPtr, - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(&test._fld2)) - ); - - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -437,14 +252,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template index 54db39df09c770..918616f32b51d8 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreSelectedScalarTest.template @@ -39,65 +39,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -179,16 +131,6 @@ namespace JIT.HardwareIntrinsics.Arm testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(StoreSelectedScalarTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - {Isa}.{Method}(({RetBaseType}*)testClass._dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), {ElementIndex}); - - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -199,18 +141,10 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private DataTable _dataTable; - static StoreSelectedScalarTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public StoreSelectedScalarTest__{TestName}() { Succeeded = true; @@ -257,40 +191,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - ElementIndex }); - - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, _clsVar1, {ElementIndex}); - - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - { - {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), {ElementIndex}); - - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -301,40 +201,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, op1, {ElementIndex}); - - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new StoreSelectedScalarTest__{TestName}(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, test._fld1, {ElementIndex}); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new StoreSelectedScalarTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - { - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), {ElementIndex}); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -344,18 +210,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), {ElementIndex}); - - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -366,16 +220,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), {ElementIndex}); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -384,14 +228,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreUnOpTest.template index 7653b84a10af10..da8f91f1f53bb1 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/StoreUnOpTest.template @@ -39,65 +39,17 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -179,16 +131,6 @@ namespace JIT.HardwareIntrinsics.Arm testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(StoreUnaryOpTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - {Isa}.{Method}(({RetBaseType}*)testClass._dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1))); - - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -198,18 +140,10 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private DataTable _dataTable; - static StoreUnaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public StoreUnaryOpTest__{TestName}() { Succeeded = true; @@ -255,40 +189,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)) - }); - - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, _clsVar1); - - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - { - {Isa}.{Method}(({Op1BaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1))); - - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -299,40 +199,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, op1); - - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new StoreUnaryOpTest__{TestName}(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, test._fld1); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new StoreUnaryOpTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - { - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1))); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -342,18 +208,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_fld1, _dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1))); - - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -364,16 +218,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(test._fld1, _dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1))); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -382,14 +226,6 @@ namespace JIT.HardwareIntrinsics.Arm test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_2Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_2Test.template index ff26478143df4a..95574352689e2b 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_2Test.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_2Test.template @@ -17,7 +17,7 @@ using Xunit; namespace JIT.HardwareIntrinsics.Arm { public static partial class Program - { + { [Fact] public static void VectorLookupExtension_2_{RetBaseType}() { @@ -31,15 +31,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -53,7 +47,7 @@ namespace JIT.HardwareIntrinsics.Arm { // Validates we throw on unsupported hardware test.RunUnsupportedScenario(); - } + } if (!test.Succeeded) { @@ -176,11 +170,6 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data2 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data3 = new {Op2BaseType}[Op1ElementCount]; - private static {Op2VectorType}<{Op2BaseType}> _clsVar0; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1VectorType}<{Op1BaseType}> _clsVar2; - private static {Op2VectorType}<{Op2BaseType}> _clsVar3; - private {Op2VectorType}<{Op2BaseType}> _fld0; private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1VectorType}<{Op1BaseType}> _fld2; @@ -188,18 +177,6 @@ namespace JIT.HardwareIntrinsics.Arm private DataTable _dataTable; - static VectorLookupExtension_2Test__{Method}{RetBaseType}() - { - for (var i = 0; i < Op2ElementCount; i++) { _data0[i] = {NextValueOp0}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar0), ref Unsafe.As<{Op2BaseType}, byte>(ref _data0[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data2[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op1BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op2ElementCount; i++) { _data3[i] = {NextValueOp2}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op2BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public VectorLookupExtension_2Test__{Method}{RetBaseType}() { Succeeded = true; @@ -221,7 +198,7 @@ namespace JIT.HardwareIntrinsics.Arm } public bool IsSupported => {Isa}.IsSupported; - + public bool Succeeded { get; set; } public void RunBasicScenario_UnsafeRead() @@ -264,21 +241,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray0Ptr, _dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar0, - (_clsVar1, - _clsVar2), - _clsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar0, _clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -293,17 +255,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op0, op1, op2, op3, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new VectorLookupExtension_2Test__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld0, (test._fld1, test._fld2), test._fld3); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld0, test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -352,7 +303,7 @@ namespace JIT.HardwareIntrinsics.Arm { Succeeded = false; } - } + } private void ValidateResult({Op2VectorType}<{Op2BaseType}> op0, {Op1VectorType}<{Op1BaseType}> op1, {Op1VectorType}<{Op1BaseType}> op2, {Op2VectorType}<{Op2BaseType}> op3, void* result, [CallerMemberName] string method = "") { diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_3Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_3Test.template index 490c6650893ca5..9fc5bed8818acc 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_3Test.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_3Test.template @@ -31,15 +31,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -53,7 +47,7 @@ namespace JIT.HardwareIntrinsics.Arm { // Validates we throw on unsupported hardware test.RunUnsupportedScenario(); - } + } if (!test.Succeeded) { @@ -188,12 +182,6 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data3 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data4 = new {Op2BaseType}[Op2ElementCount]; - private static {Op2VectorType}<{Op2BaseType}> _clsVar0; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1VectorType}<{Op1BaseType}> _clsVar2; - private static {Op1VectorType}<{Op1BaseType}> _clsVar3; - private static {Op2VectorType}<{Op2BaseType}> _clsVar4; - private {Op2VectorType}<{Op2BaseType}> _fld0; private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1VectorType}<{Op1BaseType}> _fld2; @@ -202,20 +190,6 @@ namespace JIT.HardwareIntrinsics.Arm private DataTable _dataTable; - static VectorLookupExtension_3Test__{Method}{RetBaseType}() - { - for (var i = 0; i < Op2ElementCount; i++) { _data0[i] = {NextValueOp0}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar0), ref Unsafe.As<{Op2BaseType}, byte>(ref _data0[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data2[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op1BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data3[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op1BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op2ElementCount; i++) { _data4[i] = {NextValueOp2}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar4), ref Unsafe.As<{Op2BaseType}, byte>(ref _data4[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public VectorLookupExtension_3Test__{Method}{RetBaseType}() { Succeeded = true; @@ -240,7 +214,7 @@ namespace JIT.HardwareIntrinsics.Arm } public bool IsSupported => {Isa}.IsSupported; - + public bool Succeeded { get; set; } public void RunBasicScenario_UnsafeRead() @@ -284,22 +258,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray0Ptr, _dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar0, - (_clsVar1, - _clsVar2, - _clsVar3), - _clsVar4 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar0, _clsVar1, _clsVar2, _clsVar3, _clsVar4, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -315,17 +273,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op0, op1, op2, op3, op4, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new VectorLookupExtension_3Test__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld0, (test._fld1, test._fld2, test._fld3), test._fld4); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld0, test._fld1, test._fld2, test._fld3, test._fld4, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_4Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_4Test.template index 46e860ecc71fdb..cf88f29ed5d9ad 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_4Test.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookupExtension_4Test.template @@ -31,15 +31,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -200,13 +194,6 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data4 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data5 = new {Op2BaseType}[Op2ElementCount]; - private static {Op2VectorType}<{Op2BaseType}> _clsVar0; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1VectorType}<{Op1BaseType}> _clsVar2; - private static {Op1VectorType}<{Op1BaseType}> _clsVar3; - private static {Op1VectorType}<{Op1BaseType}> _clsVar4; - private static {Op2VectorType}<{Op2BaseType}> _clsVar5; - private {Op2VectorType}<{Op2BaseType}> _fld0; private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1VectorType}<{Op1BaseType}> _fld2; @@ -216,22 +203,6 @@ namespace JIT.HardwareIntrinsics.Arm private DataTable _dataTable; - static VectorLookupExtension_4Test__{Method}{RetBaseType}() - { - for (var i = 0; i < Op2ElementCount; i++) { _data0[i] = {NextValueOp0}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar0), ref Unsafe.As<{Op2BaseType}, byte>(ref _data0[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data2[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op1BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data3[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op1BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data4[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar4), ref Unsafe.As<{Op1BaseType}, byte>(ref _data4[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op2ElementCount; i++) { _data5[i] = {NextValueOp2}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar5), ref Unsafe.As<{Op2BaseType}, byte>(ref _data5[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public VectorLookupExtension_4Test__{Method}{RetBaseType}() { Succeeded = true; @@ -259,7 +230,7 @@ namespace JIT.HardwareIntrinsics.Arm } public bool IsSupported => {Isa}.IsSupported; - + public bool Succeeded { get; set; } public void RunBasicScenario_UnsafeRead() @@ -304,23 +275,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray0Ptr, _dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.inArray5Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar0, - (_clsVar1, - _clsVar2, - _clsVar3, - _clsVar4), - _clsVar5 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar0, _clsVar1, _clsVar2, _clsVar3, _clsVar4, _clsVar5, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -337,17 +291,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op0, op1, op2, op3, op4, op5, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new VectorLookupExtension_4Test__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld0, (test._fld1, test._fld2, test._fld3, test._fld4), test._fld5); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld0, test._fld1, test._fld2, test._fld3, test._fld4, test._fld5, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_2Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_2Test.template index e68c67b1891713..976885162379c9 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_2Test.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_2Test.template @@ -31,15 +31,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -48,7 +42,7 @@ namespace JIT.HardwareIntrinsics.Arm // Validates passing an instance member of a struct works test.RunStructFldScenario(); - } + } else { // Validates we throw on unsupported hardware @@ -164,26 +158,12 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data2 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data3 = new {Op2BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1VectorType}<{Op1BaseType}> _clsVar2; - private static {Op2VectorType}<{Op2BaseType}> _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1VectorType}<{Op1BaseType}> _fld2; private {Op2VectorType}<{Op2BaseType}> _fld3; private DataTable _dataTable; - static VectorLookup_2Test__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data2[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op1BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op2ElementCount; i++) { _data3[i] = {NextValueOp2}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op2BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public VectorLookup_2Test__{Method}{RetBaseType}() { Succeeded = true; @@ -202,7 +182,7 @@ namespace JIT.HardwareIntrinsics.Arm } public bool IsSupported => {Isa}.IsSupported; - + public bool Succeeded { get; set; } public void RunBasicScenario_UnsafeRead() @@ -242,20 +222,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - (_clsVar1, - _clsVar2), - _clsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -269,17 +235,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, op3, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new VectorLookup_2Test__{Method}{RetBaseType}(); - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_3Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_3Test.template index b53282594a9931..1cf097dd61e24e 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_3Test.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_3Test.template @@ -31,15 +31,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -53,7 +47,7 @@ namespace JIT.HardwareIntrinsics.Arm { // Validates we throw on unsupported hardware test.RunUnsupportedScenario(); - } + } if (!test.Succeeded) { @@ -176,11 +170,6 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data3 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data4 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1VectorType}<{Op1BaseType}> _clsVar2; - private static {Op1VectorType}<{Op1BaseType}> _clsVar3; - private static {Op2VectorType}<{Op2BaseType}> _clsVar4; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1VectorType}<{Op1BaseType}> _fld2; private {Op1VectorType}<{Op1BaseType}> _fld3; @@ -188,18 +177,6 @@ namespace JIT.HardwareIntrinsics.Arm private DataTable _dataTable; - static VectorLookup_3Test__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data2[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op1BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data3[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op1BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op2ElementCount; i++) { _data4[i] = {NextValueOp2}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar4), ref Unsafe.As<{Op2BaseType}, byte>(ref _data4[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public VectorLookup_3Test__{Method}{RetBaseType}() { Succeeded = true; @@ -221,7 +198,7 @@ namespace JIT.HardwareIntrinsics.Arm } public bool IsSupported => {Isa}.IsSupported; - + public bool Succeeded { get; set; } public void RunBasicScenario_UnsafeRead() @@ -262,21 +239,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - (_clsVar1, - _clsVar2, - _clsVar3), - _clsVar4 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _clsVar3, _clsVar4, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -291,17 +253,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, op3, op4, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new VectorLookup_3Test__{Method}{RetBaseType}(); - var result = {Isa}.{Method}((test._fld1, test._fld2, test._fld3), test._fld4); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, test._fld3, test._fld4, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -350,7 +301,7 @@ namespace JIT.HardwareIntrinsics.Arm { Succeeded = false; } - } + } private void ValidateResult({Op1VectorType}<{Op1BaseType}> op1, {Op1VectorType}<{Op1BaseType}> op2, {Op1VectorType}<{Op1BaseType}> op3, {Op2VectorType}<{Op2BaseType}> op4, void* result, [CallerMemberName] string method = "") { diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_4Test.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_4Test.template index 1f2632a947a35f..d089eaf82365fe 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_4Test.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/VectorLookup_4Test.template @@ -24,22 +24,16 @@ namespace JIT.HardwareIntrinsics.Arm var test = new VectorLookup_4Test__{Method}{RetBaseType}(); if (test.IsSupported) - { + { // Validates basic functionality works, using Unsafe.Read test.RunBasicScenario_UnsafeRead(); // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -53,7 +47,7 @@ namespace JIT.HardwareIntrinsics.Arm { // Validates we throw on unsupported hardware test.RunUnsupportedScenario(); - } + } if (!test.Succeeded) { @@ -188,12 +182,6 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data4 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data5 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op1VectorType}<{Op1BaseType}> _clsVar2; - private static {Op1VectorType}<{Op1BaseType}> _clsVar3; - private static {Op1VectorType}<{Op1BaseType}> _clsVar4; - private static {Op2VectorType}<{Op2BaseType}> _clsVar5; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op1VectorType}<{Op1BaseType}> _fld2; private {Op1VectorType}<{Op1BaseType}> _fld3; @@ -202,20 +190,6 @@ namespace JIT.HardwareIntrinsics.Arm private DataTable _dataTable; - static VectorLookup_4Test__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data2[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op1BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data3[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar3), ref Unsafe.As<{Op1BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op1ElementCount; i++) { _data4[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar4), ref Unsafe.As<{Op1BaseType}, byte>(ref _data4[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - for (var i = 0; i < Op2ElementCount; i++) { _data5[i] = {NextValueOp2}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar5), ref Unsafe.As<{Op2BaseType}, byte>(ref _data5[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public VectorLookup_4Test__{Method}{RetBaseType}() { Succeeded = true; @@ -240,7 +214,7 @@ namespace JIT.HardwareIntrinsics.Arm } public bool IsSupported => {Isa}.IsSupported; - + public bool Succeeded { get; set; } public void RunBasicScenario_UnsafeRead() @@ -282,22 +256,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.inArray4Ptr, _dataTable.inArray5Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - (_clsVar1, - _clsVar2, - _clsVar3, - _clsVar4), - _clsVar5 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _clsVar3, _clsVar4, _clsVar5, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -313,17 +271,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, op3, op4, op5, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new VectorLookup_4Test__{Method}{RetBaseType}(); - var result = {Isa}.{Method}((test._fld1, test._fld2, test._fld3, test._fld4), test._fld5); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, test._fld3, test._fld4, test._fld5, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -372,7 +319,7 @@ namespace JIT.HardwareIntrinsics.Arm { Succeeded = false; } - } + } private void ValidateResult({Op1VectorType}<{Op1BaseType}> op1, {Op1VectorType}<{Op1BaseType}> op2, {Op1VectorType}<{Op1BaseType}> op3, {Op1VectorType}<{Op1BaseType}> op4, {Op2VectorType}<{Op2BaseType}> op5, void* result, [CallerMemberName] string method = "") { diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_BinaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_BinaryOpTestTemplate.template index a48ad3d30cba25..a75fbb9480f3f3 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_BinaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_BinaryOpTestTemplate.template @@ -38,15 +38,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -159,22 +153,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static {TemplateName}BinaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public {TemplateName}BinaryOpTest__{TestName}() { Succeeded = true; @@ -233,19 +216,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -258,17 +228,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}BinaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmBinaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmBinaryOpTestTemplate.template index 661973b069f462..2563b1fd5c5e9f 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmBinaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmBinaryOpTestTemplate.template @@ -38,15 +38,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -160,22 +154,11 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static ImmBinaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public ImmBinaryOpTest__{TestName}() { Succeeded = true; @@ -237,20 +220,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -263,17 +232,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ImmBinaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmTernaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmTernaryOpTestTemplate.template index 0e707789699108..bef93f71f678a8 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmTernaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmTernaryOpTestTemplate.template @@ -38,15 +38,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -173,26 +167,12 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private static {Op3VectorType}<{Op3BaseType}> _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private {Op3VectorType}<{Op3BaseType}> _fld3; private DataTable _dataTable; - static {TemplateName}TernaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), 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}>>()); - } - public {TemplateName}TernaryOpTest__{TestName}() { Succeeded = true; @@ -260,21 +240,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - _clsVar3, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -288,17 +253,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, op3, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}TernaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmUnaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmUnaryOpTestTemplate.template index 852899beec5704..71d1562a947b76 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmUnaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_ImmUnaryOpTestTemplate.template @@ -38,15 +38,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -147,18 +141,10 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private DataTable _dataTable; - static {TemplateName}UnaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public {TemplateName}UnaryOpTest__{TestName}() { Succeeded = true; @@ -214,19 +200,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -238,17 +211,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}UnaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_TernaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_TernaryOpTestTemplate.template index 4c794ff6eb56dd..24fa91288ac924 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_TernaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_TernaryOpTestTemplate.template @@ -38,15 +38,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -172,26 +166,12 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private static {Op3VectorType}<{Op3BaseType}> _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private {Op3VectorType}<{Op3BaseType}> _fld3; private DataTable _dataTable; - static {TemplateName}TernaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), 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}>>()); - } - public {TemplateName}TernaryOpTest__{TestName}() { Succeeded = true; @@ -256,20 +236,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - _clsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -283,17 +249,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, op2, op3, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}TernaryOpTest__{TestName}(); - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpScalarTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpScalarTestTemplate.template index 6fb9262397ec59..9e46279abc32a4 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpScalarTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpScalarTestTemplate.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -126,17 +120,10 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType} _data; - private static {Op1BaseType} _clsVar; - private {Op1BaseType} _fld; private DataTable _dataTable; - static {TemplateName}UnaryOpTest__{TestName}() - { - _clsVar = {NextValueOp1}; - } - public {TemplateName}UnaryOpTest__{TestName}() { Succeeded = true; @@ -176,18 +163,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_data, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -199,17 +174,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(data, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}UnaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpTestTemplate.template index 8282bfb12b1533..7f991df4a4a6b6 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_UnaryOpTestTemplate.template @@ -38,15 +38,9 @@ namespace JIT.HardwareIntrinsics.Arm // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -146,18 +140,10 @@ namespace JIT.HardwareIntrinsics.Arm private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private DataTable _dataTable; - static {TemplateName}UnaryOpTest__{TestName}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public {TemplateName}UnaryOpTest__{TestName}() { Succeeded = true; @@ -210,18 +196,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -233,17 +207,6 @@ namespace JIT.HardwareIntrinsics.Arm ValidateResult(op1, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}UnaryOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_r.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_r.csproj index a9308667c02535..05eba017a9df15 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_r.csproj @@ -1,6 +1,6 @@ - 16 + 8 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_ro.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_ro.csproj index 6154ed27bc5428..356f5e1fa6ad23 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_Arm_ro.csproj @@ -1,6 +1,6 @@ - 16 + 8 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_r.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_r.csproj index a0b263b6da9398..fa59559ab5689c 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_r.csproj @@ -1,6 +1,6 @@ - 16 + 8 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_ro.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_ro.csproj index e043d3a01b7f72..4adf6dbb03e485 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_General_ro.csproj @@ -1,6 +1,6 @@ - 16 + 8 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_r.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_r.csproj index bde7f164f6ba7e..4fae2968d100a1 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_r.csproj @@ -1,6 +1,6 @@ - 16 + 2 true true @@ -10,9 +10,6 @@ true true true - - - 1 diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_ro.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_ro.csproj index d8284ca9f59313..441189e79510dd 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx512_ro.csproj @@ -1,6 +1,6 @@ - 16 + 2 true true @@ -10,9 +10,6 @@ true true true - - - 1 diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_r.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_r.csproj index 3e35137c7ecd6e..97841e89da035d 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_r.csproj @@ -1,6 +1,6 @@ - 16 + 2 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_ro.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_ro.csproj index 07d0054bd46baf..768062f68afb39 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_Avx_ro.csproj @@ -1,6 +1,6 @@ - 16 + 2 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_r.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_r.csproj index 18aea40efa1aea..76ad46ac48f309 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_r.csproj @@ -1,6 +1,6 @@ - 16 + 2 true true diff --git a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_ro.csproj b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_ro.csproj index a0860f4aecceb1..b34844d05ae56a 100644 --- a/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/HardwareIntrinsics_X86_ro.csproj @@ -1,6 +1,6 @@ - 16 + 2 true true diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template index 34428e11526c0b..bf0d615a214f3e 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesBinOpTest.template @@ -41,71 +41,17 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -145,48 +91,22 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(AesBinaryOpTest__{Method}{RetBaseType} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); - + private static {Op1BaseType}[] _data1 = new {Op1BaseType}[{InputSize}] {Input}; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[{KeySize}] {Key}; private static {RetBaseType}[] _expectedRet = new {RetBaseType}[{ExpectedRetSize}] {ExpectedRet}; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static AesBinaryOpTest__{Method}{RetBaseType}() - { - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public AesBinaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -255,64 +175,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - fixed ({Op2VectorType}<{Op2BaseType}>* pClsVar2 = &_clsVar2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pClsVar2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -325,60 +187,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new AesBinaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new AesBinaryOpTest__{Method}{RetBaseType}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &test._fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -389,23 +197,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - fixed ({Op2VectorType}<{Op2BaseType}>* pFld2 = &_fld2) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(pFld2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -417,20 +208,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld1)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(&test._fld2)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -439,14 +216,6 @@ namespace JIT.HardwareIntrinsics.X86 test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); @@ -478,7 +247,7 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(outArray, method); } - + private void ValidateResult({RetBaseType}[] result, [CallerMemberName] string method = "") { bool succeeded = true; @@ -488,7 +257,7 @@ namespace JIT.HardwareIntrinsics.X86 if (result[i] != _expectedRet[i] ) { succeeded = false; - } + } } if (!succeeded) diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template index 622c656aad42ad..074df686354f64 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesImmOpTest.template @@ -41,71 +41,17 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -142,20 +88,6 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(AesImmOpTest__{Method}{RetBaseType}{Imm} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &_fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)), - {Imm} - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -165,18 +97,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[{InputSize}] {Input}; private static {RetBaseType}[] _expectedRet = new {RetBaseType}[{ExpectedRetSize}] {ExpectedRet}; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static AesImmOpTest__{Method}{RetBaseType}{Imm}() - { - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public AesImmOpTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -244,63 +168,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar = &_clsVar) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar)), - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -312,57 +179,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new AesImmOpTest__{Method}{RetBaseType}{Imm}(); - var result = {Isa}.{Method}(test._fld, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new AesImmOpTest__{Method}{RetBaseType}{Imm}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &test._fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)), - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -373,22 +189,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &_fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)), - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -400,20 +200,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld)), - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -422,14 +208,6 @@ namespace JIT.HardwareIntrinsics.X86 test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template index 99efc81973b095..d82ae0a0b91da7 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/AesUnOpTest.template @@ -41,71 +41,17 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing a static member works, using pinning and Load - test.RunClsVarScenario_Load(); - } - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local class works, using pinning and Load - test.RunClassLclFldScenario_Load(); - } - // Validates passing an instance member of a class works test.RunClassFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a class works, using pinning and Load - test.RunClassFldScenario_Load(); - } - // Validates passing the field of a local struct works test.RunStructLclFldScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing the field of a local struct works, using pinning and Load - test.RunStructLclFldScenario_Load(); - } - // Validates passing an instance member of a struct works test.RunStructFldScenario(); - - if ({LoadIsa}.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } } else { @@ -142,19 +88,6 @@ namespace JIT.HardwareIntrinsics.X86 Unsafe.Write(testClass._dataTable.outArrayPtr, result); testClass.ValidateResult(testClass._dataTable.outArrayPtr); } - - public void RunStructFldScenario_Load(AesUnaryOpTest__{Method}{RetBaseType} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &_fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)) - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(testClass._dataTable.outArrayPtr); - } - } } private static readonly int LargestVectorSize = {LargestVectorSize}; @@ -163,19 +96,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[{InputSize}] {Input}; private static {RetBaseType}[] _expectedRet = new {RetBaseType}[{ExpectedRetSize}] {ExpectedRet}; - - private static {Op1VectorType}<{Op1BaseType}> _clsVar; private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static AesUnaryOpTest__{Method}{RetBaseType}() - { - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public AesUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -239,59 +164,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar = &_clsVar) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -303,56 +175,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new AesUnaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new AesUnaryOpTest__{Method}{RetBaseType}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &test._fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -363,21 +185,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld = &_fld) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - } - public void RunStructLclFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); @@ -389,19 +196,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(&test._fld)) - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunStructFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); @@ -410,14 +204,6 @@ namespace JIT.HardwareIntrinsics.X86 test.RunStructFldScenario(this); } - public void RunStructFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario_Load)); - - var test = TestStruct.Create(); - test.RunStructFldScenario_Load(this); - } - public void RunUnsupportedScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template index 7411de8c93f3db..867b903a02e1ac 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractScalarTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -122,18 +98,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static ExtractScalarTest__{Method}{RetBaseType}{Imm}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public ExtractScalarTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -202,47 +170,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetBaseType})(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetBaseType})(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -254,39 +181,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template index b21b572f592870..15b020899f7966 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ExtractVector128Test.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -122,18 +98,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static ExtractVector128Test__{Method}{RetBaseType}{Imm}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public ExtractVector128Test__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -202,47 +170,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -254,39 +181,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template index 1684db98b9a6d1..2331a4da0c2695 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/GenericUnOpTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -122,18 +98,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static GenericUnaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public GenericUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -199,46 +167,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method})) - .MakeGenericMethod( new Type[] { typeof({Op1BaseType}) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method})) - .MakeGenericMethod( new Type[] { typeof({Op1BaseType}) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}<{RetBaseType}>( - _clsVar - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -250,39 +178,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}<{RetBaseType}>(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}<{RetBaseType}>(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template index 94bcb7aef90c12..2848cd4da81de3 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmBinOpTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -127,22 +103,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static ImmBinaryOpTest__{Method}{RetBaseType}{Imm}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public ImmBinaryOpTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -218,50 +183,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -274,41 +195,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template index 500c34fa3f901e..1b403ffcc02566 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ImmUnOpTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -122,18 +98,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static ImmUnaryOpTest__{Method}{RetBaseType}{Imm}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public ImmUnaryOpTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -202,47 +170,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -254,39 +181,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template index 35191c6d7650cf..514382fa56e484 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertScalarTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -126,19 +102,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; private static {Op1BaseType} _scalarClsData = {Data}; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private {Op1BaseType} _scalarFldData = {Data}; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static InsertScalarTest__{Method}{RetBaseType}{Imm}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public InsertScalarTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -217,50 +185,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, {Data}, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({RetBaseType}), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - {Data}, - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, {Data}, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({RetBaseType}), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)), - {Data}, - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, {Data}, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar, - _scalarClsData, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _scalarClsData,_dataTable.outArrayPtr); - } - public void RunLclVarScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario)); @@ -274,43 +198,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, localData, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - {Op1BaseType} localData = {Data}; - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, localData, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, localData, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - {Op1BaseType} localData = {Data}; - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp, localData, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, localData, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new InsertScalarTest__{Method}{RetBaseType}{Imm}(); - var result = {Isa}.{Method}(test._fld, test._scalarFldData, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld, test._scalarFldData, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template index d8076b1f6934a8..fba0d7993367fa 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/InsertVector128Test.template @@ -43,33 +43,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -129,22 +105,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static InsertVector128Test__{Method}{RetBaseType}{Imm}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public InsertVector128Test__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -220,50 +185,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -276,41 +197,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template index 19ce2ce5eb4e01..7b97794b72aaba 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/LoadBinOpTest.template @@ -42,33 +42,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -127,20 +103,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op2VectorType}<{Op2BaseType}> _fld2; private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static SimpleBinaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - - for (var i = 0; i < Op2ElementCount; i++) { _data2[i] = {NextValueOp2}; } - 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}() { Succeeded = true; @@ -211,47 +177,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.inArray1Ptr, typeof({RetBaseType}*)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.inArray1Ptr, typeof({RetBaseType}*)), - {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - ({RetBaseType}*)_dataTable.inArray1Ptr, - _clsVar2 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -264,41 +189,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = ({RetBaseType}*)_dataTable.inArray1Ptr; - var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = ({RetBaseType}*)_dataTable.inArray1Ptr; - var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new SimpleBinaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(({RetBaseType}*)_dataTable.inArray1Ptr, test._fld2); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, test._fld2, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template index 92d142d28c1835..487941a088089b 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/PclmulqdqOpTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -124,21 +100,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op2BaseType}[] _data2 = new {Op2BaseType}[{Input2Size}] {Input2}; private static {RetBaseType}[] _expectedRet = new {RetBaseType}[{ExpectedRetSize}] {ExpectedRet}; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static PclmulqdqOpTest__{Method}{RetBaseType}{Imm}() - { - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op2VectorType}<{Op2BaseType}>, byte>(ref _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public PclmulqdqOpTest__{Method}{RetBaseType}{Imm}() { Succeeded = true; @@ -211,50 +177,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>), typeof(byte) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)), - (byte){Imm} - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - {Imm} - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -267,41 +189,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - var result = {Isa}.{Method}(left, right, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new PclmulqdqOpTest__{Method}{RetBaseType}{Imm}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, {Imm}); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); @@ -371,7 +258,7 @@ namespace JIT.HardwareIntrinsics.X86 if (result[i] != _expectedRet[i] ) { succeeded = false; - } + } } if (!succeeded) diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template index 5bc1ae2629e075..48d402cda79ffd 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarBinOpTest.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -90,18 +84,9 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType} _data1; private static {Op2BaseType} _data2; - private static {Op1BaseType} _clsVar1; - private static {Op2BaseType} _clsVar2; - private {Op1BaseType} _fld1; private {Op2BaseType} _fld2; - static ScalarBinaryOpTest__{Method}{RetBaseType}() - { - _clsVar1 = {NextValueOp1}; - _clsVar2 = {NextValueOp2}; - } - public ScalarBinaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -142,18 +127,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_data1, _data2, ({RetBaseType})result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - ValidateResult(_clsVar1, _clsVar2, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -165,16 +138,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data1, data2, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarBinaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - ValidateResult(test._fld1, test._fld2, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template index 87487817ca1806..91639731341863 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarSimdUnOpTest.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -92,17 +86,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType} _data; - private static {Op1BaseType} _clsVar; - private {Op1BaseType} _fld; private ScalarSimdUnaryOpTest__DataTable<{RetBaseType}> _dataTable; - static ScalarSimdUnaryOpTest__{Method}{RetBaseType}() - { - _clsVar = {NextValueOp1}; - } - public ScalarSimdUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -141,18 +128,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_data, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -164,17 +139,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarSimdUnaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpBinResTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpBinResTest.template index adaf228d3da61e..5ccd3a90e43cff 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpBinResTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpBinResTest.template @@ -33,15 +33,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -95,21 +89,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op2BaseType} _data2; private static {Op3BaseType} _data3; - private static {Op1BaseType} _clsVar1; - private static {Op2BaseType} _clsVar2; - private static {Op3BaseType} _clsVar3; - private {Op1BaseType} _fld1; private {Op2BaseType} _fld2; private {Op3BaseType} _fld3; - static ScalarTernOpBinResTest__{Method}{RetBaseType}() - { - _clsVar1 = {NextValueOp1}; - _clsVar2 = {NextValueOp2}; - _clsVar3 = {NextValueOp3}; - } - public ScalarTernOpBinResTest__{Method}{RetBaseType}() { Succeeded = true; @@ -158,19 +141,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_data1, _data2, buffer, ({RetBaseType})result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - {Op3BaseType} buffer = 0; - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - &buffer - ); - - ValidateResult(_clsVar1, _clsVar2, buffer, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -183,18 +153,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data1, data2, data3, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - {Op3BaseType} buffer = 0; - - var test = new ScalarTernOpBinResTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, &buffer); - - ValidateResult(test._fld1, test._fld2, buffer, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTest.template index 7b5311fb6e45c8..52be10611fcb5e 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTest.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -93,21 +87,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op2BaseType} _data2; private static {Op3BaseType} _data3; - private static {Op1BaseType} _clsVar1; - private static {Op2BaseType} _clsVar2; - private static {Op3BaseType} _clsVar3; - private {Op1BaseType} _fld1; private {Op2BaseType} _fld2; private {Op3BaseType} _fld3; - static ScalarTernOpTest__{Method}{RetBaseType}() - { - _clsVar1 = {NextValueOp1}; - _clsVar2 = {NextValueOp2}; - _clsVar3 = {NextValueOp3}; - } - public ScalarTernOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -152,19 +135,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_data1, _data2, _data3, ({RetBaseType})result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - _clsVar3 - ); - - ValidateResult(_clsVar1, _clsVar2, _clsVar3, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -177,16 +147,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data1, data2, data3, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarTernOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); - - ValidateResult(test._fld1, test._fld2, test._fld3, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTupleBinRetTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTupleBinRetTest.template index 601913aa060180..d719247b491658 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTupleBinRetTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarTernOpTupleBinRetTest.template @@ -29,15 +29,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -90,21 +84,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op2BaseType} _data2; private static {Op3BaseType} _data3; - private static {Op1BaseType} _clsVar1; - private static {Op2BaseType} _clsVar2; - private static {Op3BaseType} _clsVar3; - private {Op1BaseType} _fld1; private {Op2BaseType} _fld2; private {Op3BaseType} _fld3; - static ScalarTernOpTupleTest__{Method}{RetBaseType}() - { - _clsVar1 = {NextValueOp1}; - _clsVar2 = {NextValueOp2}; - _clsVar3 = {NextValueOp3}; - } - public ScalarTernOpTupleTest__{Method}{RetBaseType}() { Succeeded = true; @@ -149,19 +132,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_data1, _data2, _data3, (({RetBaseType}, {RetBaseType}))result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - _clsVar3 - ); - - ValidateResult(_clsVar1, _clsVar2, _clsVar3, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -174,16 +144,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data1, data2, data3, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarTernOpTupleTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); - - ValidateResult(test._fld1, test._fld2, test._fld3, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template index 06ee75d61af9e6..e0de8a8c29f9fe 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/ScalarUnOpTest.template @@ -32,15 +32,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.ReadUnaligned test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.ReadUnaligned test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -86,20 +80,13 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType} _data; - private static {Op1BaseType} _clsVar; - private {Op1BaseType} _fld; - static ScalarUnaryOpTest__{Method}{RetBaseType}() - { - _clsVar = {NextValueOp1}; - } - public ScalarUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; - + _fld = {NextValueOp1}; _data = {NextValueOp1}; } @@ -131,17 +118,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_data, ({RetBaseType})result); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - ValidateResult(_clsVar, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -152,16 +128,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(data, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ScalarUnaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld); - - ValidateResult(test._fld, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template index f79e2d8d005157..a9b011959440a9 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpConvTest.template @@ -42,33 +42,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -120,18 +96,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimdScalarUnaryOpTest__DataTable<{Op1BaseType}> _dataTable; - static SimdScalarUnaryOpConvertTest__{Method}{Op1VectorType}{Op1BaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public SimdScalarUnaryOpConvertTest__{Method}{Op1VectorType}{Op1BaseType}() { Succeeded = true; @@ -192,41 +160,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, ({RetBaseType})(result)); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - ValidateResult(_dataTable.inArrayPtr, ({RetBaseType})(result)); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - ValidateResult(_dataTable.inArrayPtr, ({RetBaseType})(result)); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - ValidateResult(_clsVar, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -237,36 +170,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, result); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - ValidateResult(firstOp, result); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - ValidateResult(firstOp, result); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new SimdScalarUnaryOpConvertTest__{Method}{Op1VectorType}{Op1BaseType}(); - var result = {Isa}.{Method}(test._fld); - - ValidateResult(test._fld, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template index 77cb2422e73d5f..b4dfc50f372355 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimdScalarUnOpTest.template @@ -42,33 +42,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -120,18 +96,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimdScalarUnaryOpTest__DataTable<{Op1BaseType}> _dataTable; - static SimdScalarUnaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public SimdScalarUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -192,41 +160,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, ({RetBaseType})(result)); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - ValidateResult(_dataTable.inArrayPtr, ({RetBaseType})(result)); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - ValidateResult(_dataTable.inArrayPtr, ({RetBaseType})(result)); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - ValidateResult(_clsVar, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -237,36 +170,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, result); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - ValidateResult(firstOp, result); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - ValidateResult(firstOp, result); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new SimdScalarUnaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld); - - ValidateResult(test._fld, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpConvTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpConvTest.template index 7c83efd8b70e74..07c10338ba811c 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpConvTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleBinOpConvTest.template @@ -42,33 +42,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -126,22 +102,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType} _data2; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2BaseType} _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2BaseType} _fld2; private SimpleBinaryOpConvTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static SimpleBinaryOpConvTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - _data2 = {NextValueOp2}; - _clsVar2 = _data2; - } - public SimpleBinaryOpConvTest__{Method}{RetBaseType}() { Succeeded = true; @@ -211,47 +176,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inData2, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2BaseType}) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - _dataTable.inData2 - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inData2, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2BaseType}) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - _dataTable.inData2 - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inData2, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -264,41 +188,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = _dataTable.inData2; - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = _dataTable.inData2; - var result = {Isa}.{Method}(left, right); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new SimpleBinaryOpConvTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template index 1faa0db95f5039..f4be90b4c0b269 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/SimpleUnOpConvTest.template @@ -41,33 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -122,18 +98,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar; - private {Op1VectorType}<{Op1BaseType}> _fld; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static SimpleUnaryOpConvTest__{Method}{Op1VectorType}{Op1BaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar), ref Unsafe.As<{Op1BaseType}, byte>(ref _data[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public SimpleUnaryOpConvTest__{Method}{Op1VectorType}{Op1BaseType}() { Succeeded = true; @@ -198,44 +166,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -247,39 +177,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(firstOp, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var firstOp = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var firstOp = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - var result = {Isa}.{Method}(firstOp); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(firstOp, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new SimpleUnaryOpConvTest__{Method}{Op1VectorType}{Op1BaseType}(); - var result = {Isa}.{Method}(test._fld); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template index 6a058ce9b9b30e..81a8f57c67f7b9 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreBinOpTest.template @@ -42,33 +42,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -126,22 +102,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private SimpleBinaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}, {Op2BaseType}> _dataTable; - static StoreBinaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public StoreBinaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -213,47 +178,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2VectorType}<{Op2BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)) - }); - - ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - {Isa}.{Method}( - ({RetBaseType}*)_dataTable.outArrayPtr, - _clsVar1, - _clsVar2 - ); - - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -265,38 +189,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(left, right, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var left = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.Load{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, left, right); - - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var left = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var right = {LoadIsa}.LoadAligned{Op2VectorType}(({Op2BaseType}*)(_dataTable.inArray2Ptr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, left, right); - - ValidateResult(left, right, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new StoreBinaryOpTest__{Method}{RetBaseType}(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, test._fld1, test._fld2); - - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreUnOpTest.template index 00824139c88293..264cb8e54dfb99 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreUnOpTest.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/StoreUnOpTest.template @@ -42,33 +42,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - - // Validates calling via reflection works, using LoadAligned - test.RunReflectionScenario_LoadAligned(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - if ({LoadIsa}.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - - // Validates passing a local works, using LoadAligned - test.RunLclVarScenario_LoadAligned(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -121,18 +97,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private SimpleUnaryOpTest__DataTable<{RetBaseType}, {Op1BaseType}> _dataTable; - static StoreUnaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public StoreUnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -197,44 +165,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); } - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); - - typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({RetBaseType}*), typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - Pointer.Box(_dataTable.outArrayPtr, typeof({RetBaseType}*)), - {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)) - }); - - ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - {Isa}.{Method}( - ({RetBaseType}*)_dataTable.outArrayPtr, - _clsVar1 - ); - - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -245,36 +175,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(value, _dataTable.outArrayPtr); } - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var value = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, value); - - ValidateResult(value, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_LoadAligned() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); - - var value = {LoadIsa}.LoadAligned{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArrayPtr)); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, value); - - ValidateResult(value, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new StoreUnaryOpTest__{Method}{RetBaseType}(); - {Isa}.{Method}(({RetBaseType}*)_dataTable.outArrayPtr, test._fld1); - - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BinaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BinaryOpTestTemplate.template index daa18b1d95e2df..6c50e7bc1e5b54 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BinaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BinaryOpTestTemplate.template @@ -41,15 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -162,22 +156,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static {TemplateName}BinaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public {TemplateName}BinaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -249,19 +232,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -274,17 +244,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(op1, op2, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}BinaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanBinaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanBinaryOpTestTemplate.template index 442a9e3cdd64ca..ef9e29773dfa55 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanBinaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanBinaryOpTestTemplate.template @@ -41,15 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -152,22 +146,11 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private DataTable _dataTable; - static {TemplateName}BinaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), ref Unsafe.As<{Op2BaseType}, byte>(ref _data2[0]), (uint)Unsafe.SizeOf<{Op2VectorType}<{Op2BaseType}>>()); - } - public {TemplateName}BinaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -235,18 +218,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result)); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2 - ); - - ValidateResult(_clsVar1, _clsVar2, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -258,16 +229,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(op1, op2, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}BinaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1, test._fld2); - - ValidateResult(test._fld1, test._fld2, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanUnaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanUnaryOpTestTemplate.template index 848e13ac749265..bdc5ee2944f2bd 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanUnaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_BooleanUnaryOpTestTemplate.template @@ -41,15 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -139,18 +133,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private DataTable _dataTable; - static {TemplateName}UnaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public {TemplateName}UnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -211,17 +197,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, (bool)(result)); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1 - ); - - ValidateResult(_clsVar1, result); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -232,16 +207,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(op1, result); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}UnaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1); - - ValidateResult(test._fld1, result); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_TernaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_TernaryOpTestTemplate.template index 468fb019b49f50..eb6fc49d009b33 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_TernaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_TernaryOpTestTemplate.template @@ -41,15 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -175,26 +169,12 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op2BaseType}[] _data2 = new {Op2BaseType}[Op2ElementCount]; private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private static {Op2VectorType}<{Op2BaseType}> _clsVar2; - private static {Op3VectorType}<{Op3BaseType}> _clsVar3; - private {Op1VectorType}<{Op1BaseType}> _fld1; private {Op2VectorType}<{Op2BaseType}> _fld2; private {Op3VectorType}<{Op3BaseType}> _fld3; private DataTable _dataTable; - static {TemplateName}TernaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), 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 _clsVar2), 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}>>()); - } - public {TemplateName}TernaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -273,20 +253,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - _clsVar2, - _clsVar3 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _clsVar2, _clsVar3, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -300,17 +266,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(op1, op2, op3, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}TernaryOpTest__{Method}{RetBaseType}(); - 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 RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_UnaryOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_UnaryOpTestTemplate.template index d3fba4058951bd..e5f9148acd9368 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86/Shared/_UnaryOpTestTemplate.template +++ b/src/tests/JIT/HardwareIntrinsics/X86/Shared/_UnaryOpTestTemplate.template @@ -41,15 +41,9 @@ namespace JIT.HardwareIntrinsics.X86 // Validates calling via reflection works, using Unsafe.Read test.RunReflectionScenario_UnsafeRead(); - // Validates passing a static member works - test.RunClsVarScenario(); - // Validates passing a local works, using Unsafe.Read test.RunLclVarScenario_UnsafeRead(); - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - // Validates passing an instance member of a class works test.RunClassFldScenario(); @@ -149,18 +143,10 @@ namespace JIT.HardwareIntrinsics.X86 private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - private {Op1VectorType}<{Op1BaseType}> _fld1; private DataTable _dataTable; - static {TemplateName}UnaryOpTest__{Method}{RetBaseType}() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _clsVar1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - } - public {TemplateName}UnaryOpTest__{Method}{RetBaseType}() { Succeeded = true; @@ -225,18 +211,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); } - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1 - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - public void RunLclVarScenario_UnsafeRead() { TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); @@ -248,17 +222,6 @@ namespace JIT.HardwareIntrinsics.X86 ValidateResult(op1, _dataTable.outArrayPtr); } - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new {TemplateName}UnaryOpTest__{Method}{RetBaseType}(); - var result = {Isa}.{Method}(test._fld1); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - public void RunClassFldScenario() { TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.Int16.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.Int16.cs index 28f4ffa1f59475..ec887e9526622d 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.Int16.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.Int16.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512Int32Int16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (short)(random.Next(short.MinValue, short.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512Int32Int16() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512Int32Int16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (short)(random.Next(short.MinValue, short.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (short)(random.Next(short.MinValue, short.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new Int32[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri Int16[] inArray = new Int16[Op1ElementCount]; Int32[] outArray = new Int32[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.UInt16.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.UInt16.cs index e935b8a837a512..b3ab95f6f1dee3 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.UInt16.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int32.UInt16.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512Int32UInt16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (ushort)(random.Next(0, ushort.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512Int32UInt16() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512Int32UInt16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (ushort)(random.Next(0, ushort.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (ushort)(random.Next(0, ushort.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new UInt32[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri UInt16[] inArray = new UInt16[Op1ElementCount]; UInt32[] outArray = new UInt32[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.Int32.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.Int32.cs index 34269547caa138..ae2bd5014fc7fe 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.Int32.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.Int32.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512Int64Int32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(int.MinValue, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512Int64Int32() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512Int64Int32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(int.MinValue, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(int.MinValue, int.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new Int64[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri Int32[] inArray = new Int32[Op1ElementCount]; Int64[] outArray = new Int64[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.UInt32.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.UInt32.cs index ec444eae342eb2..5f13328315cabb 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.UInt32.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512Int64.UInt32.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512Int64UInt32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (uint)(random.Next(0, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512Int64UInt32() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512Int64UInt32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (uint)(random.Next(0, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (uint)(random.Next(0, int.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new UInt64[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri UInt32[] inArray = new UInt32[Op1ElementCount]; UInt64[] outArray = new UInt64[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.Int16.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.Int16.cs index 74741dbac2490e..8da6a6b7a5a279 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.Int16.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.Int16.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512UInt32Int16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (short)(random.Next(short.MinValue, short.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512UInt32Int16() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512UInt32Int16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (short)(random.Next(short.MinValue, short.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (short)(random.Next(short.MinValue, short.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new Int32[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri Int16[] inArray = new Int16[Op1ElementCount]; Int32[] outArray = new Int32[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.UInt16.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.UInt16.cs index 4d40e06766c6af..71815b0cb7441c 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.UInt16.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt32.UInt16.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512UInt32UInt16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (ushort)(random.Next(0, ushort.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512UInt32UInt16() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512UInt32UInt16() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (ushort)(random.Next(0, ushort.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (ushort)(random.Next(0, ushort.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new UInt32[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri UInt16[] inArray = new UInt16[Op1ElementCount]; UInt32[] outArray = new UInt32[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.Int32.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.Int32.cs index 746bcc7d915721..abc3d7bb06ac89 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.Int32.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.Int32.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512UInt64Int32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(int.MinValue, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512UInt64Int32() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512UInt64Int32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(int.MinValue, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (int)(random.Next(int.MinValue, int.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new Int64[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri Int32[] inArray = new Int32[Op1ElementCount]; Int64[] outArray = new Int64[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.UInt32.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.UInt32.cs index 9f8ea7c5bc41fa..d9e876b084ab1e 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.UInt32.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/ConvertToVector512UInt64.UInt32.cs @@ -105,7 +105,7 @@ static SimpleUnaryOpTest__ConvertToVector512UInt64UInt32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (uint)(random.Next(0, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar), ref Unsafe.As(ref _data[0]), 32); } public SimpleUnaryOpTest__ConvertToVector512UInt64UInt32() @@ -115,7 +115,7 @@ public SimpleUnaryOpTest__ConvertToVector512UInt64UInt32() var random = new Random(); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (uint)(random.Next(0, int.MaxValue)); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld), ref Unsafe.As(ref _data[0]), 32); for (var i = 0; i < Op1ElementCount; i++) { _data[i] = (uint)(random.Next(0, int.MaxValue)); } _dataTable = new SimpleUnaryOpTest__DataTable(_data, new UInt64[RetElementCount], VectorSize); @@ -272,7 +272,7 @@ private void ValidateResult(void* firstOp, void* result, [CallerMemberName] stri UInt32[] inArray = new UInt32[Op1ElementCount]; UInt64[] outArray = new UInt64[RetElementCount]; - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 16); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray[0]), ref Unsafe.AsRef(firstOp), 32); Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), VectorSize); ValidateResult(inArray, outArray, method); diff --git a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/UnpackLow.cs b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/UnpackLow.cs index a1081b27455176..405003ece34ed9 100644 --- a/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/UnpackLow.cs +++ b/src/tests/JIT/HardwareIntrinsics/X86_Avx512/Avx512F/UnpackLow.cs @@ -24,8 +24,8 @@ public static unsafe void UnpackLow() using (TestTable_2Input doubleTable = new TestTable_2Input(new double[8] { 1, -5, 100, 0, 1, -5, 100, 0 }, new double[8] { 22, -1, -50, 0, 22, -1, -50, 0 }, new double[8])) { - var vf1 = Unsafe.Read>(floatTable.inArray1Ptr); - var vf2 = Unsafe.Read>(floatTable.inArray2Ptr); + var vf1 = Unsafe.Read>(floatTable.inArray1Ptr); + var vf2 = Unsafe.Read>(floatTable.inArray2Ptr); var vf3 = Avx512F.UnpackLow(vf1, vf2); Unsafe.Write(floatTable.outArrayPtr, vf3); @@ -48,8 +48,8 @@ public static unsafe void UnpackLow() testResult = Fail; } - var vd1 = Unsafe.Read>(doubleTable.inArray1Ptr); - var vd2 = Unsafe.Read>(doubleTable.inArray2Ptr); + var vd1 = Unsafe.Read>(doubleTable.inArray1Ptr); + var vd2 = Unsafe.Read>(doubleTable.inArray2Ptr); var vd3 = Avx512F.UnpackLow(vd1, vd2); Unsafe.Write(doubleTable.outArrayPtr, vd3);