From 7aca5dc45856b82f565c8596cb0ec65fd66bc1fb Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 15 Dec 2021 17:58:50 -0800 Subject: [PATCH 01/59] Initial work --- src/coreclr/jit/codegenlinear.cpp | 2 +- src/coreclr/jit/emitarm64.cpp | 5 +++++ src/coreclr/jit/gentree.cpp | 13 +++++++++++++ src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 10 +++++++++- src/coreclr/jit/hwintrinsiclistarm64.h | 2 +- src/coreclr/jit/lowerarmarch.cpp | 9 +++++++++ src/coreclr/jit/lsraarm64.cpp | 3 ++- 7 files changed, 40 insertions(+), 4 deletions(-) diff --git a/src/coreclr/jit/codegenlinear.cpp b/src/coreclr/jit/codegenlinear.cpp index 51e9afc074398..a4b6180b680b1 100644 --- a/src/coreclr/jit/codegenlinear.cpp +++ b/src/coreclr/jit/codegenlinear.cpp @@ -1657,7 +1657,7 @@ void CodeGen::genConsumeRegs(GenTree* tree) #ifdef FEATURE_SIMD // (In)Equality operation that produces bool result, when compared // against Vector zero, marks its Vector Zero operand as contained. - assert(tree->OperIsLeaf() || tree->IsSIMDZero()); + assert(tree->OperIsLeaf() || tree->IsSIMDZero() || tree->IsIntegralConstVector(0)); #else assert(tree->OperIsLeaf()); #endif diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 5aade83cbda17..93b812e4f9774 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -12979,6 +12979,11 @@ void emitter::emitDispIns( emitDispVectorReg(id->idReg1(), id->idInsOpt(), true); emitDispVectorReg(id->idReg2(), id->idInsOpt(), false); } + if (ins == INS_cmeq) + { + printf(" "); + emitDispFloatZero(); + } break; case IF_DV_2N: // DV_2N .........iiiiiii ......nnnnnddddd Vd Vn imm (shift - scalar) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index af0a2a1e47fe5..5d39dbc423b86 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -17851,6 +17851,19 @@ bool GenTree::isContainableHWIntrinsic() const return true; } + default: + { + return false; + } + } +#elif TARGET_ARM64 + switch (AsHWIntrinsic()->GetHWIntrinsicId()) + { + case NI_Vector128_get_Zero: + { + return true; + } + default: { return false; diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 706b988f049e5..27c584f3d2de8 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -377,7 +377,15 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } else { - GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); + if (intrin.id == NI_AdvSimd_CompareEqual && intrin.op2->isContained() && + intrin.op2->IsIntegralConstVector(0)) + { + GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); + } + else + { + GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); + } } break; diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h index 65879aff4024c..e9ed85847083f 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/jit/hwintrinsiclistarm64.h @@ -216,7 +216,7 @@ HARDWARE_INTRINSIC(AdvSimd, BitwiseClear, HARDWARE_INTRINSIC(AdvSimd, BitwiseSelect, -1, 3, {INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl}, HW_Category_SIMD, HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd, Ceiling, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_frintp, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, CeilingScalar, 8, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_frintp, INS_frintp}, HW_Category_SIMD, HW_Flag_SIMDScalar) -HARDWARE_INTRINSIC(AdvSimd, CompareEqual, -1, 2, {INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_invalid, INS_invalid, INS_fcmeq, INS_invalid}, HW_Category_SIMD, HW_Flag_Commutative) +HARDWARE_INTRINSIC(AdvSimd, CompareEqual, -1, 2, {INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_invalid, INS_invalid, INS_fcmeq, INS_invalid}, HW_Category_SIMD, HW_Flag_Commutative|HW_Flag_SupportsContainment) HARDWARE_INTRINSIC(AdvSimd, CompareGreaterThan, -1, 2, {INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_invalid, INS_invalid, INS_fcmgt, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, CompareGreaterThanOrEqual, -1, 2, {INS_cmge, INS_cmhs, INS_cmge, INS_cmhs, INS_cmge, INS_cmhs, INS_invalid, INS_invalid, INS_fcmge, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, CompareLessThan, -1, 2, {INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_invalid, INS_invalid, INS_fcmgt, INS_invalid}, HW_Category_SIMD, HW_Flag_SpecialCodeGen) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 279a20e7a3621..4d391da739f00 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1869,6 +1869,15 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) MakeSrcContained(node, intrin.op4); break; + case NI_AdvSimd_CompareEqual: + { + if (intrin.op2->IsIntegralConstVector(0)) + { + MakeSrcContained(node, intrin.op2); + } + break; + } + case NI_Vector64_CreateScalarUnsafe: case NI_Vector128_CreateScalarUnsafe: case NI_AdvSimd_DuplicateToVector64: diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index 1b201603f95a1..9ab417a20e87f 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1103,7 +1103,8 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) } else { - if (intrin.op2 != nullptr) + if (intrin.op2 != nullptr && + !(intrin.id == NI_AdvSimd_CompareEqual && intrin.op2->IsIntegralConstVector(0) && intrin.op2->isContained())) { // RMW intrinsic operands doesn't have to be delayFree when they can be assigned the same register as op1Reg // (i.e. a register that corresponds to read-modify-write operand) and one of them is the last use. From 275291309e5cf749aa0c29214024172b5ac4478c Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 15 Dec 2021 18:03:58 -0800 Subject: [PATCH 02/59] Added a comma to display --- src/coreclr/jit/emitarm64.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 93b812e4f9774..4fc2544430c2e 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -12981,7 +12981,7 @@ void emitter::emitDispIns( } if (ins == INS_cmeq) { - printf(" "); + printf(", "); emitDispFloatZero(); } break; From 526e6c800e477c0ff223eb8130e9471035893bfd Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 16 Dec 2021 15:31:12 -0800 Subject: [PATCH 03/59] Cleanup --- src/coreclr/jit/codegenlinear.cpp | 2 +- src/coreclr/jit/gentree.cpp | 1 + src/coreclr/jit/gentree.h | 17 +++++++++++++++++ src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 6 ++++-- src/coreclr/jit/instrsarm64.h | 4 ++-- src/coreclr/jit/lowerarmarch.cpp | 2 +- src/coreclr/jit/lsraarm64.cpp | 10 +++++++--- 7 files changed, 33 insertions(+), 9 deletions(-) diff --git a/src/coreclr/jit/codegenlinear.cpp b/src/coreclr/jit/codegenlinear.cpp index a4b6180b680b1..51e9afc074398 100644 --- a/src/coreclr/jit/codegenlinear.cpp +++ b/src/coreclr/jit/codegenlinear.cpp @@ -1657,7 +1657,7 @@ void CodeGen::genConsumeRegs(GenTree* tree) #ifdef FEATURE_SIMD // (In)Equality operation that produces bool result, when compared // against Vector zero, marks its Vector Zero operand as contained. - assert(tree->OperIsLeaf() || tree->IsSIMDZero() || tree->IsIntegralConstVector(0)); + assert(tree->OperIsLeaf() || tree->IsSIMDZero()); #else assert(tree->OperIsLeaf()); #endif diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 5d39dbc423b86..3abdd00bb2d61 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -17859,6 +17859,7 @@ bool GenTree::isContainableHWIntrinsic() const #elif TARGET_ARM64 switch (AsHWIntrinsic()->GetHWIntrinsicId()) { + case NI_Vector64_get_Zero: case NI_Vector128_get_Zero: { return true; diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 3fd3792eb8b1f..e087476a1d8dd 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7712,6 +7712,23 @@ inline bool GenTree::IsSIMDZero() const } #endif +#ifdef FEATURE_HW_INTRINSICS + if (gtOper == GT_HWINTRINSIC) + { + const GenTreeHWIntrinsic* node = AsHWIntrinsic(); + + if (node->GetOperandCount() == 0) + { + const var_types simdBaseType = node->GetSimdBaseType(); + if (varTypeIsIntegral(simdBaseType) || varTypeIsFloating(simdBaseType)) + { + const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); + return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); + } + } + } +#endif // FEATURE_HW_INTRINSICS + return false; } diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 27c584f3d2de8..182ba459ff1ad 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -377,9 +377,11 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } else { - if (intrin.id == NI_AdvSimd_CompareEqual && intrin.op2->isContained() && - intrin.op2->IsIntegralConstVector(0)) + if (intrin.op2->isContained()) { + assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); + assert(intrin.op2->IsSIMDZero()); + GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); } else diff --git a/src/coreclr/jit/instrsarm64.h b/src/coreclr/jit/instrsarm64.h index c89b006a41897..48d69a83fc12b 100644 --- a/src/coreclr/jit/instrsarm64.h +++ b/src/coreclr/jit/instrsarm64.h @@ -312,8 +312,8 @@ INST4(neg, "neg", 0, IF_EN4G, 0x4B0003E0, 0x4B0003E0, INST4(cmeq, "cmeq", 0, IF_EN4H, 0x7EE08C00, 0x2E208C00, 0x5E209800, 0x0E209800) // cmeq Vd,Vn,Vm DV_3E 01111110111mmmmm 100011nnnnnddddd 7EE0 8C00 Vd,Vn,Vm (scalar) // cmeq Vd,Vn,Vm DV_3A 0Q101110XX1mmmmm 100011nnnnnddddd 2E20 8C00 Vd,Vn,Vm (vector) - // cmeq Vd,Vn DV_2L 01011110XX100000 100110nnnnnddddd 5E20 9800 Vd,Vn (scalar) - // cmeq Vd,Vn DV_2M 0Q001110XX100000 100110nnnnnddddd 0E20 9800 Vd,Vn (vector) + // cmeq Vd,Vn DV_2L 01011110XX100000 100110nnnnnddddd 5E20 9800 Vd,Vn,#0 (scalar - with zero) + // cmeq Vd,Vn DV_2M 0Q001110XX100000 100110nnnnnddddd 0E20 9800 Vd,Vn,#0 (vector - with zero) INST4(cmge, "cmge", 0, IF_EN4H, 0x5EE03C00, 0x0E203C00, 0x7E208800, 0x2E208800) // cmge Vd,Vn,Vm DV_3E 01011110111mmmmm 001111nnnnnddddd 5EE0 3C00 Vd,Vn,Vm (scalar) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 4d391da739f00..a598da197accd 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1871,7 +1871,7 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_CompareEqual: { - if (intrin.op2->IsIntegralConstVector(0)) + if (intrin.op2->IsSIMDZero()) { MakeSrcContained(node, intrin.op2); } diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index 9ab417a20e87f..e1f395ddb28da 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1101,10 +1101,14 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) } } } - else + else if (intrin.op2 != nullptr) { - if (intrin.op2 != nullptr && - !(intrin.id == NI_AdvSimd_CompareEqual && intrin.op2->IsIntegralConstVector(0) && intrin.op2->isContained())) + if (intrin.op2->isContained()) + { + assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); + assert(intrin.op2->IsSIMDZero()); + } + else { // RMW intrinsic operands doesn't have to be delayFree when they can be assigned the same register as op1Reg // (i.e. a register that corresponds to read-modify-write operand) and one of them is the last use. From d8504269565e23337e32f625809ae38a8f9a9920 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 16 Dec 2021 17:12:11 -0800 Subject: [PATCH 04/59] Fixing build --- src/coreclr/jit/gentree.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index e087476a1d8dd..948ebff524cc8 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7723,7 +7723,11 @@ inline bool GenTree::IsSIMDZero() const if (varTypeIsIntegral(simdBaseType) || varTypeIsFloating(simdBaseType)) { const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); +#if defined(TARGET_XARCH) + return (intrinsicId == NI_Vector128_get_Zero) || (intrinsicId == NI_Vector256_get_Zero); +#elif defined(TARGET_ARM64) return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); +#endif // !TARGET_XARCH && !TARGET_ARM64 } } } From 0ee645017e7c9a049236634cd233a9e0993f1be5 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 17 Dec 2021 12:43:26 -0800 Subject: [PATCH 05/59] More cleanup --- src/coreclr/jit/codegenlinear.cpp | 2 +- src/coreclr/jit/gentree.h | 65 +++++++++++++++++++-- src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 2 +- src/coreclr/jit/lowerarmarch.cpp | 2 +- src/coreclr/jit/lsraarm64.cpp | 5 +- 5 files changed, 65 insertions(+), 11 deletions(-) diff --git a/src/coreclr/jit/codegenlinear.cpp b/src/coreclr/jit/codegenlinear.cpp index 51e9afc074398..ff4e0b2d3c285 100644 --- a/src/coreclr/jit/codegenlinear.cpp +++ b/src/coreclr/jit/codegenlinear.cpp @@ -1657,7 +1657,7 @@ void CodeGen::genConsumeRegs(GenTree* tree) #ifdef FEATURE_SIMD // (In)Equality operation that produces bool result, when compared // against Vector zero, marks its Vector Zero operand as contained. - assert(tree->OperIsLeaf() || tree->IsSIMDZero()); + assert(tree->OperIsLeaf() || tree->IsSIMDZero() || tree->IsVectorZero()); #else assert(tree->OperIsLeaf()); #endif diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 948ebff524cc8..7b162f15ed635 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -1758,6 +1758,8 @@ struct GenTree inline bool IsIntegralConst(ssize_t constVal) const; inline bool IsIntegralConstVector(ssize_t constVal) const; inline bool IsSIMDZero() const; + inline bool IsFloatPositiveZero() const; + inline bool IsVectorZero() const; inline bool IsBoxedValue(); @@ -2160,7 +2162,7 @@ struct GenTree inline bool IsCnsFltOrDbl() const; - inline bool IsCnsNonZeroFltOrDbl(); + inline bool IsCnsNonZeroFltOrDbl() const; bool IsIconHandle() const { @@ -7712,21 +7714,72 @@ inline bool GenTree::IsSIMDZero() const } #endif + return false; +} + +//------------------------------------------------------------------- +// IsFloatPositiveZero: returns true if this is exactly a const float value of postive zero (+0.0) +// +// Returns: +// True if this represents a const floating-point value of exactly positive zero (+0.0). +// Will return false if the value is negative zero (-0.0). +// +inline bool GenTree::IsFloatPositiveZero() const +{ + return !(IsCnsNonZeroFltOrDbl()); +} + +//------------------------------------------------------------------- +// IsVectorZero: returns true if this is a SIMD vector +// with all its elements equal to zero. +// +// TODO: We already have IsSIMDZero() and IsIntegralConstVector(0), +// however, IsSIMDZero() does not cover hardware intrinsics, and IsIntegralConstVector(0) does not cover floating point. +// In order to not risk adverse behaviour by modifying those, this function 'IsVectorZero' was introduced. +// At some point, it makes sense to normalize this logic to be a single function call rather than have several separate ones; +// preferably this one. +// +// Returns: +// True if this represents an integral or floating-point const SIMD vector with all its elements equal to zero. +// +inline bool GenTree::IsVectorZero() const +{ +#ifdef FEATURE_SIMD + if (gtOper == GT_SIMD) + { + const GenTreeSIMD* node = AsSIMD(); + + if (node->GetSIMDIntrinsicId() == SIMDIntrinsicInit) + { + return (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero()); + } + } +#endif + #ifdef FEATURE_HW_INTRINSICS if (gtOper == GT_HWINTRINSIC) { const GenTreeHWIntrinsic* node = AsHWIntrinsic(); + const var_types simdBaseType = node->GetSimdBaseType(); - if (node->GetOperandCount() == 0) + if (varTypeIsIntegral(simdBaseType) || varTypeIsFloating(simdBaseType)) { - const var_types simdBaseType = node->GetSimdBaseType(); - if (varTypeIsIntegral(simdBaseType) || varTypeIsFloating(simdBaseType)) + const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); + + if (node->GetOperandCount() == 0) { - const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); #if defined(TARGET_XARCH) return (intrinsicId == NI_Vector128_get_Zero) || (intrinsicId == NI_Vector256_get_Zero); #elif defined(TARGET_ARM64) return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); +#endif // !TARGET_XARCH && !TARGET_ARM64 + } + else if ((node->GetOperandCount() == 1) && (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) + { +#if defined(TARGET_XARCH) + return (intrinsicId == NI_Vector128_Create) || (intrinsicId == NI_Vector256_Create); +#elif defined(TARGET_ARM64) + return (intrinsicId == NI_Vector64_Create) || (intrinsicId == NI_Vector128_Create); #endif // !TARGET_XARCH && !TARGET_ARM64 } } @@ -8400,7 +8453,7 @@ inline bool GenTree::IsCnsFltOrDbl() const return OperGet() == GT_CNS_DBL; } -inline bool GenTree::IsCnsNonZeroFltOrDbl() +inline bool GenTree::IsCnsNonZeroFltOrDbl() const { if (OperGet() == GT_CNS_DBL) { diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 182ba459ff1ad..39a4ceecc8137 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -380,7 +380,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) if (intrin.op2->isContained()) { assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); - assert(intrin.op2->IsSIMDZero()); + assert(intrin.op2->IsVectorZero()); GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); } diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index a598da197accd..0bfda25fec22b 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1871,7 +1871,7 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_CompareEqual: { - if (intrin.op2->IsSIMDZero()) + if (intrin.op2->IsVectorZero()) { MakeSrcContained(node, intrin.op2); } diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index e1f395ddb28da..be92ffe5fa3a4 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1103,10 +1103,11 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) } else if (intrin.op2 != nullptr) { - if (intrin.op2->isContained()) + // Do not give a register to the second operand if it is contained. + if (!hasImmediateOperand && intrin.op2->isContained()) { assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); - assert(intrin.op2->IsSIMDZero()); + assert(intrin.op2->IsVectorZero()); } else { From cb5a82e8be19c66591bb0bd63f59cb141719cd25 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 17 Dec 2021 12:47:01 -0800 Subject: [PATCH 06/59] Update comment --- src/coreclr/jit/gentree.h | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 7b162f15ed635..f20ceeec116a8 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7730,18 +7730,17 @@ inline bool GenTree::IsFloatPositiveZero() const } //------------------------------------------------------------------- -// IsVectorZero: returns true if this is a SIMD vector +// IsVectorZero: returns true if this is an integral or floating-point SIMD vector // with all its elements equal to zero. // -// TODO: We already have IsSIMDZero() and IsIntegralConstVector(0), -// however, IsSIMDZero() does not cover hardware intrinsics, and IsIntegralConstVector(0) does not cover floating point. -// In order to not risk adverse behaviour by modifying those, this function 'IsVectorZero' was introduced. -// At some point, it makes sense to normalize this logic to be a single function call rather than have several separate ones; -// preferably this one. -// // Returns: // True if this represents an integral or floating-point const SIMD vector with all its elements equal to zero. // +// TODO: We already have IsSIMDZero() and IsIntegralConstVector(0), +// however, IsSIMDZero() does not cover hardware intrinsics, and IsIntegralConstVector(0) does not cover floating +// point. In order to not risk adverse behaviour by modifying those, this function 'IsVectorZero' was introduced. +// At some point, it makes sense to normalize this logic to be a single function call rather than have several +// separate ones; preferably this one. inline bool GenTree::IsVectorZero() const { #ifdef FEATURE_SIMD From 6ae9a947eaff4871a26902b06b45c4fdefc27df6 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 17 Dec 2021 12:51:35 -0800 Subject: [PATCH 07/59] Update comment --- src/coreclr/jit/gentree.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index f20ceeec116a8..c684dfd8c8c9f 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7730,11 +7730,11 @@ inline bool GenTree::IsFloatPositiveZero() const } //------------------------------------------------------------------- -// IsVectorZero: returns true if this is an integral or floating-point SIMD vector +// IsVectorZero: returns true if this is an integral or floating-point (SIMD or HW intrinsic) vector // with all its elements equal to zero. // // Returns: -// True if this represents an integral or floating-point const SIMD vector with all its elements equal to zero. +// True if this represents an integral or floating-point const (SIMD or HW intrinsic) vector with all its elements equal to zero. // // TODO: We already have IsSIMDZero() and IsIntegralConstVector(0), // however, IsSIMDZero() does not cover hardware intrinsics, and IsIntegralConstVector(0) does not cover floating From 5c1997f93063afb9efb88c0fbc155d517bfde678 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 4 Jan 2022 14:36:50 -0800 Subject: [PATCH 08/59] Added CompareEqual Vector64/128 with Zero tests --- src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 33 +- src/coreclr/jit/hwintrinsiclistarm64.h | 2 +- src/coreclr/jit/lowerarmarch.cpp | 6 +- .../Arm/AdvSimd/AdvSimd_Part10_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part10_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part11_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part11_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part12_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part12_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part13_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part13_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part14_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part14_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part15_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part15_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part16_r.csproj | 14 + .../Arm/AdvSimd/AdvSimd_Part16_ro.csproj | 14 + .../Arm/AdvSimd/AdvSimd_Part3_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part3_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part4_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part4_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part5_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part5_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part6_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part6_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part7_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part7_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part8_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part8_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part9_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part9_ro.csproj | 28 +- .../CompareEqual.Vector128.Byte.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector128.Int16.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector128.Int32.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector128.SByte.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector128.Single.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector128.UInt16.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector128.UInt32.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.Byte.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.Int16.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.Int32.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.SByte.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.Single.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.UInt16.Zero.cs | 491 ++++++++++++++++++ .../CompareEqual.Vector64.UInt32.Zero.cs | 491 ++++++++++++++++++ .../Arm/AdvSimd/Program.AdvSimd_Part10.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part11.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part12.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part13.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part14.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part15.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part16.cs | 14 + .../Arm/AdvSimd/Program.AdvSimd_Part3.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part4.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part5.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part6.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part7.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part8.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part9.cs | 28 +- .../Arm/Shared/GenerateTests.csx | 14 + .../Arm/Shared/ZeroUnOpTest.template | 491 ++++++++++++++++++ 61 files changed, 7995 insertions(+), 559 deletions(-) create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs create mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 39a4ceecc8137..5ab6b7a751eeb 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -377,17 +377,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) } else { - if (intrin.op2->isContained()) - { - assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); - assert(intrin.op2->IsVectorZero()); - - GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); - } - else - { - GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); - } + GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); } break; @@ -506,6 +496,27 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); break; + case NI_AdvSimd_Arm64_CompareEqual: + if (intrin.op1->isContained()) + { + assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); + assert(intrin.op1->IsVectorZero()); + + GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); + } + else if (intrin.op2->isContained()) + { + assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); + assert(intrin.op2->IsVectorZero()); + + GetEmitter()->emitIns_R_R(ins, emitSize, targetReg, op1Reg, opt); + } + else + { + GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); + } + break; + case NI_AdvSimd_AbsoluteCompareLessThan: case NI_AdvSimd_AbsoluteCompareLessThanOrEqual: case NI_AdvSimd_CompareLessThan: diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h index e9ed85847083f..a2375f43c58ba 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/jit/hwintrinsiclistarm64.h @@ -216,7 +216,7 @@ HARDWARE_INTRINSIC(AdvSimd, BitwiseClear, HARDWARE_INTRINSIC(AdvSimd, BitwiseSelect, -1, 3, {INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl, INS_bsl}, HW_Category_SIMD, HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd, Ceiling, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_frintp, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, CeilingScalar, 8, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_frintp, INS_frintp}, HW_Category_SIMD, HW_Flag_SIMDScalar) -HARDWARE_INTRINSIC(AdvSimd, CompareEqual, -1, 2, {INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_invalid, INS_invalid, INS_fcmeq, INS_invalid}, HW_Category_SIMD, HW_Flag_Commutative|HW_Flag_SupportsContainment) +HARDWARE_INTRINSIC(AdvSimd, CompareEqual, -1, 2, {INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_cmeq, INS_invalid, INS_invalid, INS_fcmeq, INS_invalid}, HW_Category_SIMD, HW_Flag_Commutative|HW_Flag_SpecialCodeGen|HW_Flag_SupportsContainment) HARDWARE_INTRINSIC(AdvSimd, CompareGreaterThan, -1, 2, {INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_invalid, INS_invalid, INS_fcmgt, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, CompareGreaterThanOrEqual, -1, 2, {INS_cmge, INS_cmhs, INS_cmge, INS_cmhs, INS_cmge, INS_cmhs, INS_invalid, INS_invalid, INS_fcmge, INS_invalid}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd, CompareLessThan, -1, 2, {INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_cmgt, INS_cmhi, INS_invalid, INS_invalid, INS_fcmgt, INS_invalid}, HW_Category_SIMD, HW_Flag_SpecialCodeGen) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 0bfda25fec22b..95d6a05a37353 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1871,7 +1871,11 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_CompareEqual: { - if (intrin.op2->IsVectorZero()) + if (intrin.op1->IsVectorZero()) + { + MakeSrcContained(node, intrin.op1); + } + else if (intrin.op2->IsVectorZero()) { MakeSrcContained(node, intrin.op2); } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj index 1ee091aa07c04..26d9a5982a0ec 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj index 7d7ee6e054ec3..88622fda56966 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj index b13b25f71f1dd..79d46a4b6faec 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj index 83e4a310ec7a3..c0e13fbea82dc 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj index f71c7d338a62f..4b2f6dfd8cbfe 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj index aded274dfb79d..e7c0177dd9788 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj index 74c0e0c152278..78a4733d32cfb 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj index f68b360cc0e6a..8304bb3bc38d2 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj index 2b56e4ab6d9b2..13a247a629166 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj index 33fead32fa518..e8fa25cd27c50 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj index 62fd34edfd0f0..ffcacde6ceb9a 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj index 543fe0ce0a95a..56ef479f3846c 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj index d006f1a715fae..cd68a85770f68 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj index 6d7a4d7192003..654ba489ea93e 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj index 88f56816d3b9d..3738dc54eb14d 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj @@ -81,6 +81,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj index 22fbf089b59a3..3f61d51536c38 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj @@ -81,6 +81,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj index 794d092b600f9..6f563e504fa1c 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj index a7a1d2262d242..0de0c5a31f477 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj index 7745fa0bfc76d..54a8fadcd16a5 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj index b1b57ae63e1a4..fc362a681a5fc 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj index 8ed0e6473f16a..251d66819a2ae 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj index 0520b792032b9..c37e9cca76dc9 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj index 1bb5d04897323..ddf8cfbf6c663 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj index 9d9364a99220e..031c0a669f8a0 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj index b7465422babcb..c3787a81a0dc6 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj index ffbdf964e36c2..2bc25d1f1a755 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj index 83b39f57f1924..d28c6805d018d 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj @@ -8,6 +8,20 @@ + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj index 150cebc294ae0..de3bd3641e6f2 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj @@ -8,6 +8,20 @@ True + + + + + + + + + + + + + + @@ -94,20 +108,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs new file mode 100644 index 0000000000000..e3af2e5b402cf --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_Byte_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Byte[] inArray1, Byte[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Byte*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Byte); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Byte); + + private static Byte[] _data1 = new Byte[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + _dataTable = new DataTable(_data1, new Byte[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Byte*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Byte*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Byte*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Byte*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + Byte[] inArray1 = new Byte[Op1ElementCount]; + Byte[] outArray = new Byte[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Byte[] inArray1 = new Byte[Op1ElementCount]; + Byte[] outArray = new Byte[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs new file mode 100644 index 0000000000000..5cd7fffcf5bd1 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_Int16_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int16[] inArray1, Int16[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int16*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int16); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int16); + + private static Int16[] _data1 = new Int16[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + _dataTable = new DataTable(_data1, new Int16[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int16*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int16*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int16*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int16*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + Int16[] inArray1 = new Int16[Op1ElementCount]; + Int16[] outArray = new Int16[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int16[] inArray1 = new Int16[Op1ElementCount]; + Int16[] outArray = new Int16[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs new file mode 100644 index 0000000000000..971ea322d3a98 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_Int32_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int32[] inArray1, Int32[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int32*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int32); + + private static Int32[] _data1 = new Int32[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + _dataTable = new DataTable(_data1, new Int32[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int32*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int32*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int32*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Int32*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Int32[] outArray = new Int32[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Int32[] outArray = new Int32[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs new file mode 100644 index 0000000000000..7c2c09d4ba9df --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_SByte_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(SByte[] inArray1, SByte[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((SByte*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(SByte); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(SByte); + + private static SByte[] _data1 = new SByte[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + _dataTable = new DataTable(_data1, new SByte[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((SByte*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((SByte*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((SByte*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((SByte*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + SByte[] inArray1 = new SByte[Op1ElementCount]; + SByte[] outArray = new SByte[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + SByte[] inArray1 = new SByte[Op1ElementCount]; + SByte[] outArray = new SByte[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs new file mode 100644 index 0000000000000..9d25d54c7b71f --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_Single_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_Single_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Single_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Single[] inArray1, Single[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Single_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Single_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Single*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Single); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); + + private static Single[] _data1 = new Single[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_Single_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_Single_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Single*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((Single*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Single*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((Single*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Single_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_Single_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Single*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Single*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((Single*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + Single[] inArray1 = new Single[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Single[] inArray1 = new Single[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs new file mode 100644 index 0000000000000..bf1c618dbb907 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_UInt16_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt16*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt16); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt16); + + private static UInt16[] _data1 = new UInt16[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + _dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt16*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt16*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt16*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt16*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + UInt16[] inArray1 = new UInt16[Op1ElementCount]; + UInt16[] outArray = new UInt16[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + UInt16[] inArray1 = new UInt16[Op1ElementCount]; + UInt16[] outArray = new UInt16[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs new file mode 100644 index 0000000000000..8c10a98ba34d0 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector128_UInt32_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(UInt32[] inArray1, UInt32[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector128 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero testClass) + { + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt32*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 16; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt32); + + private static UInt32[] _data1 = new UInt32[Op1ElementCount]; + + private static Vector128 _clsVar1; + + private Vector128 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + _dataTable = new DataTable(_data1, new UInt32[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), + Vector128.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector128* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt32*)(pClsVar1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero(); + + fixed (Vector128* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt32*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector128* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt32*)(pFld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector128((UInt32*)(&test._fld1)), + Vector128.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") + { + UInt32[] inArray1 = new UInt32[Op1ElementCount]; + UInt32[] outArray = new UInt32[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + UInt32[] inArray1 = new UInt32[Op1ElementCount]; + UInt32[] outArray = new UInt32[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs new file mode 100644 index 0000000000000..189fa642ce0ea --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_Byte_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Byte[] inArray1, Byte[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Byte*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Byte); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Byte); + + private static Byte[] _data1 = new Byte[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } + _dataTable = new DataTable(_data1, new Byte[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Byte*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Byte*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Byte*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Byte*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + Byte[] inArray1 = new Byte[Op1ElementCount]; + Byte[] outArray = new Byte[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Byte[] inArray1 = new Byte[Op1ElementCount]; + Byte[] outArray = new Byte[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs new file mode 100644 index 0000000000000..f05a70b16cb98 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_Int16_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int16[] inArray1, Int16[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int16*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int16); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int16); + + private static Int16[] _data1 = new Int16[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } + _dataTable = new DataTable(_data1, new Int16[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int16*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int16*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int16*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int16*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + Int16[] inArray1 = new Int16[Op1ElementCount]; + Int16[] outArray = new Int16[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int16[] inArray1 = new Int16[Op1ElementCount]; + Int16[] outArray = new Int16[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs new file mode 100644 index 0000000000000..e944fd88150b5 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_Int32_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Int32[] inArray1, Int32[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int32*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int32); + + private static Int32[] _data1 = new Int32[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } + _dataTable = new DataTable(_data1, new Int32[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int32*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int32*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int32*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Int32*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Int32[] outArray = new Int32[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Int32[] inArray1 = new Int32[Op1ElementCount]; + Int32[] outArray = new Int32[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs new file mode 100644 index 0000000000000..012c06d7431b5 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_SByte_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(SByte[] inArray1, SByte[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((SByte*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(SByte); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(SByte); + + private static SByte[] _data1 = new SByte[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } + _dataTable = new DataTable(_data1, new SByte[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((SByte*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((SByte*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((SByte*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((SByte*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + SByte[] inArray1 = new SByte[Op1ElementCount]; + SByte[] outArray = new SByte[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + SByte[] inArray1 = new SByte[Op1ElementCount]; + SByte[] outArray = new SByte[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs new file mode 100644 index 0000000000000..df109aaadd622 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_Single_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_Single_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Single_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(Single[] inArray1, Single[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Single_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Single_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Single*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Single); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); + + private static Single[] _data1 = new Single[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_Single_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_Single_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } + _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Single*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Single_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_Single_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Single*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Single*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((Single*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + Single[] inArray1 = new Single[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + Single[] inArray1 = new Single[Op1ElementCount]; + Single[] outArray = new Single[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs new file mode 100644 index 0000000000000..fb19e1773bcdc --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_UInt16_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt16*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt16); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt16); + + private static UInt16[] _data1 = new UInt16[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } + _dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt16*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt16*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt16*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt16*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + UInt16[] inArray1 = new UInt16[Op1ElementCount]; + UInt16[] outArray = new UInt16[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + UInt16[] inArray1 = new UInt16[Op1ElementCount]; + UInt16[] outArray = new UInt16[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs new file mode 100644 index 0000000000000..3eb92f0bc6b68 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void CompareEqual_Vector64_UInt32_Zero() + { + var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // Validates calling via reflection works, using Unsafe.Read + test.RunReflectionScenario_UnsafeRead(); + + if (AdvSimd.IsSupported) + { + // Validates calling via reflection works, using Load + test.RunReflectionScenario_Load(); + } + + // Validates passing a static member works + test.RunClsVarScenario(); + + if (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing a local works, using Load + test.RunLclVarScenario_Load(); + } + + // Validates passing the field of a local class works + test.RunClassLclFldScenario(); + + if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) + { + // Validates passing an instance member of a struct works, using pinning and Load + test.RunStructFldScenario_Load(); + } + } + else + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable(UInt32[] inArray1, UInt32[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public Vector64 _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero testClass) + { + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero testClass) + { + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt32*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = 8; + + private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt32); + private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt32); + + private static UInt32[] _data1 = new UInt32[Op1ElementCount]; + + private static Vector64 _clsVar1; + + private Vector64 _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero() + { + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + } + + public ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } + _dataTable = new DataTable(_data1, new UInt32[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => AdvSimd.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = AdvSimd.CompareEqual( + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + Unsafe.Read>(_dataTable.inArray1Ptr), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + + var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) + .Invoke(null, new object[] { + AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)), + Vector64.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = AdvSimd.CompareEqual( + _clsVar1, + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed (Vector64* pClsVar1 = &_clsVar1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt32*)(pClsVar1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)); + var result = AdvSimd.CompareEqual(op1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero(); + + fixed (Vector64* pFld1 = &test._fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt32*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed (Vector64* pFld1 = &_fld1) + { + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt32*)(pFld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); + + var test = TestStruct.Create(); + var result = AdvSimd.CompareEqual( + AdvSimd.LoadVector64((UInt32*)(&test._fld1)), + Vector64.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") + { + UInt32[] inArray1 = new UInt32[Op1ElementCount]; + UInt32[] outArray = new UInt32[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + UInt32[] inArray1 = new UInt32[Op1ElementCount]; + UInt32[] outArray = new UInt32[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs index 9ab2011c86543..d0fba586242e3 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["Not.Vector64.Byte"] = Not_Vector64_Byte, + ["Not.Vector64.Double"] = Not_Vector64_Double, + ["Not.Vector64.Int16"] = Not_Vector64_Int16, + ["Not.Vector64.Int32"] = Not_Vector64_Int32, + ["Not.Vector64.Int64"] = Not_Vector64_Int64, + ["Not.Vector64.SByte"] = Not_Vector64_SByte, + ["Not.Vector64.Single"] = Not_Vector64_Single, + ["Not.Vector64.UInt16"] = Not_Vector64_UInt16, + ["Not.Vector64.UInt32"] = Not_Vector64_UInt32, + ["Not.Vector64.UInt64"] = Not_Vector64_UInt64, + ["Not.Vector128.Byte"] = Not_Vector128_Byte, + ["Not.Vector128.Double"] = Not_Vector128_Double, + ["Not.Vector128.Int16"] = Not_Vector128_Int16, + ["Not.Vector128.Int32"] = Not_Vector128_Int32, ["Not.Vector128.Int64"] = Not_Vector128_Int64, ["Not.Vector128.SByte"] = Not_Vector128_SByte, ["Not.Vector128.Single"] = Not_Vector128_Single, @@ -97,20 +111,6 @@ static Program() ["ReverseElement8.Vector64.Int32"] = ReverseElement8_Vector64_Int32, ["ReverseElement8.Vector64.Int64"] = ReverseElement8_Vector64_Int64, ["ReverseElement8.Vector64.UInt16"] = ReverseElement8_Vector64_UInt16, - ["ReverseElement8.Vector64.UInt32"] = ReverseElement8_Vector64_UInt32, - ["ReverseElement8.Vector64.UInt64"] = ReverseElement8_Vector64_UInt64, - ["ReverseElement8.Vector128.Int16"] = ReverseElement8_Vector128_Int16, - ["ReverseElement8.Vector128.Int32"] = ReverseElement8_Vector128_Int32, - ["ReverseElement8.Vector128.Int64"] = ReverseElement8_Vector128_Int64, - ["ReverseElement8.Vector128.UInt16"] = ReverseElement8_Vector128_UInt16, - ["ReverseElement8.Vector128.UInt32"] = ReverseElement8_Vector128_UInt32, - ["ReverseElement8.Vector128.UInt64"] = ReverseElement8_Vector128_UInt64, - ["RoundAwayFromZero.Vector64.Single"] = RoundAwayFromZero_Vector64_Single, - ["RoundAwayFromZero.Vector128.Single"] = RoundAwayFromZero_Vector128_Single, - ["RoundAwayFromZeroScalar.Vector64.Double"] = RoundAwayFromZeroScalar_Vector64_Double, - ["RoundAwayFromZeroScalar.Vector64.Single"] = RoundAwayFromZeroScalar_Vector64_Single, - ["RoundToNearest.Vector64.Single"] = RoundToNearest_Vector64_Single, - ["RoundToNearest.Vector128.Single"] = RoundToNearest_Vector128_Single, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs index 491dda7065267..a9c06ea07783c 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ReverseElement8.Vector64.UInt32"] = ReverseElement8_Vector64_UInt32, + ["ReverseElement8.Vector64.UInt64"] = ReverseElement8_Vector64_UInt64, + ["ReverseElement8.Vector128.Int16"] = ReverseElement8_Vector128_Int16, + ["ReverseElement8.Vector128.Int32"] = ReverseElement8_Vector128_Int32, + ["ReverseElement8.Vector128.Int64"] = ReverseElement8_Vector128_Int64, + ["ReverseElement8.Vector128.UInt16"] = ReverseElement8_Vector128_UInt16, + ["ReverseElement8.Vector128.UInt32"] = ReverseElement8_Vector128_UInt32, + ["ReverseElement8.Vector128.UInt64"] = ReverseElement8_Vector128_UInt64, + ["RoundAwayFromZero.Vector64.Single"] = RoundAwayFromZero_Vector64_Single, + ["RoundAwayFromZero.Vector128.Single"] = RoundAwayFromZero_Vector128_Single, + ["RoundAwayFromZeroScalar.Vector64.Double"] = RoundAwayFromZeroScalar_Vector64_Double, + ["RoundAwayFromZeroScalar.Vector64.Single"] = RoundAwayFromZeroScalar_Vector64_Single, + ["RoundToNearest.Vector64.Single"] = RoundToNearest_Vector64_Single, + ["RoundToNearest.Vector128.Single"] = RoundToNearest_Vector128_Single, ["RoundToNearestScalar.Vector64.Double"] = RoundToNearestScalar_Vector64_Double, ["RoundToNearestScalar.Vector64.Single"] = RoundToNearestScalar_Vector64_Single, ["RoundToNegativeInfinity.Vector64.Single"] = RoundToNegativeInfinity_Vector64_Single, @@ -97,20 +111,6 @@ static Program() ["ShiftLeftLogicalSaturate.Vector128.Int32.1"] = ShiftLeftLogicalSaturate_Vector128_Int32_1, ["ShiftLeftLogicalSaturate.Vector128.Int64.1"] = ShiftLeftLogicalSaturate_Vector128_Int64_1, ["ShiftLeftLogicalSaturate.Vector128.SByte.1"] = ShiftLeftLogicalSaturate_Vector128_SByte_1, - ["ShiftLeftLogicalSaturate.Vector128.UInt16.1"] = ShiftLeftLogicalSaturate_Vector128_UInt16_1, - ["ShiftLeftLogicalSaturate.Vector128.UInt32.1"] = ShiftLeftLogicalSaturate_Vector128_UInt32_1, - ["ShiftLeftLogicalSaturate.Vector128.UInt64.1"] = ShiftLeftLogicalSaturate_Vector128_UInt64_1, - ["ShiftLeftLogicalSaturateScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_Int64_1, - ["ShiftLeftLogicalSaturateScalar.Vector64.UInt64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_UInt64_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int16_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int32_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector64.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_SByte_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int16_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int32_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int64.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int64_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_SByte_1, - ["ShiftLeftLogicalSaturateUnsignedScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateUnsignedScalar_Vector64_Int64_1, - ["ShiftLeftLogicalScalar.Vector64.Int64.1"] = ShiftLeftLogicalScalar_Vector64_Int64_1, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs index b471eff3acf6f..9ece03c3257b2 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ShiftLeftLogicalSaturate.Vector128.UInt16.1"] = ShiftLeftLogicalSaturate_Vector128_UInt16_1, + ["ShiftLeftLogicalSaturate.Vector128.UInt32.1"] = ShiftLeftLogicalSaturate_Vector128_UInt32_1, + ["ShiftLeftLogicalSaturate.Vector128.UInt64.1"] = ShiftLeftLogicalSaturate_Vector128_UInt64_1, + ["ShiftLeftLogicalSaturateScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_Int64_1, + ["ShiftLeftLogicalSaturateScalar.Vector64.UInt64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_UInt64_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int16_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int32_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector64.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_SByte_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int16_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int32_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int64.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int64_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_SByte_1, + ["ShiftLeftLogicalSaturateUnsignedScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateUnsignedScalar_Vector64_Int64_1, + ["ShiftLeftLogicalScalar.Vector64.Int64.1"] = ShiftLeftLogicalScalar_Vector64_Int64_1, ["ShiftLeftLogicalScalar.Vector64.UInt64.1"] = ShiftLeftLogicalScalar_Vector64_UInt64_1, ["ShiftLeftLogicalWideningLower.Vector64.Byte.1"] = ShiftLeftLogicalWideningLower_Vector64_Byte_1, ["ShiftLeftLogicalWideningLower.Vector64.Int16.1"] = ShiftLeftLogicalWideningLower_Vector64_Int16_1, @@ -97,20 +111,6 @@ static Program() ["ShiftRightAndInsert.Vector128.Byte"] = ShiftRightAndInsert_Vector128_Byte, ["ShiftRightAndInsert.Vector128.Int16"] = ShiftRightAndInsert_Vector128_Int16, ["ShiftRightAndInsert.Vector128.Int32"] = ShiftRightAndInsert_Vector128_Int32, - ["ShiftRightAndInsert.Vector128.Int64"] = ShiftRightAndInsert_Vector128_Int64, - ["ShiftRightAndInsert.Vector128.SByte"] = ShiftRightAndInsert_Vector128_SByte, - ["ShiftRightAndInsert.Vector128.UInt16"] = ShiftRightAndInsert_Vector128_UInt16, - ["ShiftRightAndInsert.Vector128.UInt32"] = ShiftRightAndInsert_Vector128_UInt32, - ["ShiftRightAndInsert.Vector128.UInt64"] = ShiftRightAndInsert_Vector128_UInt64, - ["ShiftRightAndInsertScalar.Vector64.Int64"] = ShiftRightAndInsertScalar_Vector64_Int64, - ["ShiftRightAndInsertScalar.Vector64.UInt64"] = ShiftRightAndInsertScalar_Vector64_UInt64, - ["ShiftRightArithmetic.Vector64.Int16.1"] = ShiftRightArithmetic_Vector64_Int16_1, - ["ShiftRightArithmetic.Vector64.Int32.1"] = ShiftRightArithmetic_Vector64_Int32_1, - ["ShiftRightArithmetic.Vector64.SByte.1"] = ShiftRightArithmetic_Vector64_SByte_1, - ["ShiftRightArithmetic.Vector128.Int16.1"] = ShiftRightArithmetic_Vector128_Int16_1, - ["ShiftRightArithmetic.Vector128.Int32.1"] = ShiftRightArithmetic_Vector128_Int32_1, - ["ShiftRightArithmetic.Vector128.Int64.1"] = ShiftRightArithmetic_Vector128_Int64_1, - ["ShiftRightArithmetic.Vector128.SByte.1"] = ShiftRightArithmetic_Vector128_SByte_1, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs index a076639659e67..45d9d67ee406c 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ShiftRightAndInsert.Vector128.Int64"] = ShiftRightAndInsert_Vector128_Int64, + ["ShiftRightAndInsert.Vector128.SByte"] = ShiftRightAndInsert_Vector128_SByte, + ["ShiftRightAndInsert.Vector128.UInt16"] = ShiftRightAndInsert_Vector128_UInt16, + ["ShiftRightAndInsert.Vector128.UInt32"] = ShiftRightAndInsert_Vector128_UInt32, + ["ShiftRightAndInsert.Vector128.UInt64"] = ShiftRightAndInsert_Vector128_UInt64, + ["ShiftRightAndInsertScalar.Vector64.Int64"] = ShiftRightAndInsertScalar_Vector64_Int64, + ["ShiftRightAndInsertScalar.Vector64.UInt64"] = ShiftRightAndInsertScalar_Vector64_UInt64, + ["ShiftRightArithmetic.Vector64.Int16.1"] = ShiftRightArithmetic_Vector64_Int16_1, + ["ShiftRightArithmetic.Vector64.Int32.1"] = ShiftRightArithmetic_Vector64_Int32_1, + ["ShiftRightArithmetic.Vector64.SByte.1"] = ShiftRightArithmetic_Vector64_SByte_1, + ["ShiftRightArithmetic.Vector128.Int16.1"] = ShiftRightArithmetic_Vector128_Int16_1, + ["ShiftRightArithmetic.Vector128.Int32.1"] = ShiftRightArithmetic_Vector128_Int32_1, + ["ShiftRightArithmetic.Vector128.Int64.1"] = ShiftRightArithmetic_Vector128_Int64_1, + ["ShiftRightArithmetic.Vector128.SByte.1"] = ShiftRightArithmetic_Vector128_SByte_1, ["ShiftRightArithmeticAdd.Vector64.Int16.1"] = ShiftRightArithmeticAdd_Vector64_Int16_1, ["ShiftRightArithmeticAdd.Vector64.Int32.1"] = ShiftRightArithmeticAdd_Vector64_Int32_1, ["ShiftRightArithmeticAdd.Vector64.SByte.1"] = ShiftRightArithmeticAdd_Vector64_SByte_1, @@ -97,20 +111,6 @@ static Program() ["ShiftRightLogicalNarrowingLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt16_1, ["ShiftRightLogicalNarrowingLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt32_1, ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Byte_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int16_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int32_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_SByte_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt16_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt32_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Byte_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int16_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int32_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.SByte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_SByte_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt16_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt32_1, - ["ShiftRightLogicalNarrowingUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Byte_1, - ["ShiftRightLogicalNarrowingUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int16_1, - ["ShiftRightLogicalNarrowingUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int32_1, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs index 731a5a567feae..8317ad38d62ff 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int16_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int32_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_SByte_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt16_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt32_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Byte_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int16_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int32_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.SByte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_SByte_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt16_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt32_1, + ["ShiftRightLogicalNarrowingUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Byte_1, + ["ShiftRightLogicalNarrowingUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int16_1, + ["ShiftRightLogicalNarrowingUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int32_1, ["ShiftRightLogicalNarrowingUpper.Vector128.SByte.1"] = ShiftRightLogicalNarrowingUpper_Vector128_SByte_1, ["ShiftRightLogicalNarrowingUpper.Vector128.UInt16.1"] = ShiftRightLogicalNarrowingUpper_Vector128_UInt16_1, ["ShiftRightLogicalNarrowingUpper.Vector128.UInt32.1"] = ShiftRightLogicalNarrowingUpper_Vector128_UInt32_1, @@ -97,20 +111,6 @@ static Program() ["Store.Vector128.Int64"] = Store_Vector128_Int64, ["Store.Vector128.SByte"] = Store_Vector128_SByte, ["Store.Vector128.Single"] = Store_Vector128_Single, - ["Store.Vector128.UInt16"] = Store_Vector128_UInt16, - ["Store.Vector128.UInt32"] = Store_Vector128_UInt32, - ["Store.Vector128.UInt64"] = Store_Vector128_UInt64, - ["StoreSelectedScalar.Vector64.Byte.7"] = StoreSelectedScalar_Vector64_Byte_7, - ["StoreSelectedScalar.Vector64.Int16.3"] = StoreSelectedScalar_Vector64_Int16_3, - ["StoreSelectedScalar.Vector64.Int32.1"] = StoreSelectedScalar_Vector64_Int32_1, - ["StoreSelectedScalar.Vector64.SByte.7"] = StoreSelectedScalar_Vector64_SByte_7, - ["StoreSelectedScalar.Vector64.Single.1"] = StoreSelectedScalar_Vector64_Single_1, - ["StoreSelectedScalar.Vector64.UInt16.3"] = StoreSelectedScalar_Vector64_UInt16_3, - ["StoreSelectedScalar.Vector64.UInt32.1"] = StoreSelectedScalar_Vector64_UInt32_1, - ["StoreSelectedScalar.Vector128.Byte.15"] = StoreSelectedScalar_Vector128_Byte_15, - ["StoreSelectedScalar.Vector128.Double.1"] = StoreSelectedScalar_Vector128_Double_1, - ["StoreSelectedScalar.Vector128.Int16.7"] = StoreSelectedScalar_Vector128_Int16_7, - ["StoreSelectedScalar.Vector128.Int32.3"] = StoreSelectedScalar_Vector128_Int32_3, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs index 7cf4294fb0034..4813b6d21910e 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["Store.Vector128.UInt16"] = Store_Vector128_UInt16, + ["Store.Vector128.UInt32"] = Store_Vector128_UInt32, + ["Store.Vector128.UInt64"] = Store_Vector128_UInt64, + ["StoreSelectedScalar.Vector64.Byte.7"] = StoreSelectedScalar_Vector64_Byte_7, + ["StoreSelectedScalar.Vector64.Int16.3"] = StoreSelectedScalar_Vector64_Int16_3, + ["StoreSelectedScalar.Vector64.Int32.1"] = StoreSelectedScalar_Vector64_Int32_1, + ["StoreSelectedScalar.Vector64.SByte.7"] = StoreSelectedScalar_Vector64_SByte_7, + ["StoreSelectedScalar.Vector64.Single.1"] = StoreSelectedScalar_Vector64_Single_1, + ["StoreSelectedScalar.Vector64.UInt16.3"] = StoreSelectedScalar_Vector64_UInt16_3, + ["StoreSelectedScalar.Vector64.UInt32.1"] = StoreSelectedScalar_Vector64_UInt32_1, + ["StoreSelectedScalar.Vector128.Byte.15"] = StoreSelectedScalar_Vector128_Byte_15, + ["StoreSelectedScalar.Vector128.Double.1"] = StoreSelectedScalar_Vector128_Double_1, + ["StoreSelectedScalar.Vector128.Int16.7"] = StoreSelectedScalar_Vector128_Int16_7, + ["StoreSelectedScalar.Vector128.Int32.3"] = StoreSelectedScalar_Vector128_Int32_3, ["StoreSelectedScalar.Vector128.Int64.1"] = StoreSelectedScalar_Vector128_Int64_1, ["StoreSelectedScalar.Vector128.SByte.15"] = StoreSelectedScalar_Vector128_SByte_15, ["StoreSelectedScalar.Vector128.Single.3"] = StoreSelectedScalar_Vector128_Single_3, @@ -97,20 +111,6 @@ static Program() ["SubtractWideningUpper.Vector128.Int64.Vector128.Int32"] = SubtractWideningUpper_Vector128_Int64_Vector128_Int32, ["SubtractWideningUpper.Vector128.SByte.Vector128.SByte"] = SubtractWideningUpper_Vector128_SByte_Vector128_SByte, ["SubtractWideningUpper.Vector128.UInt16.Vector128.Byte"] = SubtractWideningUpper_Vector128_UInt16_Vector128_Byte, - ["SubtractWideningUpper.Vector128.UInt16.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt16_Vector128_UInt16, - ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt16, - ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt32, - ["SubtractWideningUpper.Vector128.UInt64.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt64_Vector128_UInt32, - ["VectorTableLookup.Vector64.Byte"] = VectorTableLookup_Vector64_Byte, - ["VectorTableLookup.Vector64.SByte"] = VectorTableLookup_Vector64_SByte, - ["VectorTableLookupExtension.Vector64.Byte"] = VectorTableLookupExtension_Vector64_Byte, - ["VectorTableLookupExtension.Vector64.SByte"] = VectorTableLookupExtension_Vector64_SByte, - ["Xor.Vector64.Byte"] = Xor_Vector64_Byte, - ["Xor.Vector64.Double"] = Xor_Vector64_Double, - ["Xor.Vector64.Int16"] = Xor_Vector64_Int16, - ["Xor.Vector64.Int32"] = Xor_Vector64_Int32, - ["Xor.Vector64.Int64"] = Xor_Vector64_Int64, - ["Xor.Vector64.SByte"] = Xor_Vector64_SByte, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs index c77860df01f67..ea3ac73678828 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["SubtractWideningUpper.Vector128.UInt16.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt16_Vector128_UInt16, + ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt16, + ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt32, + ["SubtractWideningUpper.Vector128.UInt64.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt64_Vector128_UInt32, + ["VectorTableLookup.Vector64.Byte"] = VectorTableLookup_Vector64_Byte, + ["VectorTableLookup.Vector64.SByte"] = VectorTableLookup_Vector64_SByte, + ["VectorTableLookupExtension.Vector64.Byte"] = VectorTableLookupExtension_Vector64_Byte, + ["VectorTableLookupExtension.Vector64.SByte"] = VectorTableLookupExtension_Vector64_SByte, + ["Xor.Vector64.Byte"] = Xor_Vector64_Byte, + ["Xor.Vector64.Double"] = Xor_Vector64_Double, + ["Xor.Vector64.Int16"] = Xor_Vector64_Int16, + ["Xor.Vector64.Int32"] = Xor_Vector64_Int32, + ["Xor.Vector64.Int64"] = Xor_Vector64_Int64, + ["Xor.Vector64.SByte"] = Xor_Vector64_SByte, ["Xor.Vector64.Single"] = Xor_Vector64_Single, ["Xor.Vector64.UInt16"] = Xor_Vector64_UInt16, ["Xor.Vector64.UInt32"] = Xor_Vector64_UInt32, diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs index cecabeabc5337..cc1c88cbcbcda 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs @@ -84,6 +84,20 @@ static Program() ["ConvertToUInt32RoundToZero.Vector64.Single"] = ConvertToUInt32RoundToZero_Vector64_Single, ["ConvertToUInt32RoundToZero.Vector128.Single"] = ConvertToUInt32RoundToZero_Vector128_Single, ["ConvertToUInt32RoundToZeroScalar.Vector64.Single"] = ConvertToUInt32RoundToZeroScalar_Vector64_Single, + ["CompareEqual.Vector64.Byte.Zero"] = CompareEqual_Vector64_Byte_Zero, + ["CompareEqual.Vector64.SByte.Zero"] = CompareEqual_Vector64_SByte_Zero, + ["CompareEqual.Vector64.UInt16.Zero"] = CompareEqual_Vector64_UInt16_Zero, + ["CompareEqual.Vector64.Int16.Zero"] = CompareEqual_Vector64_Int16_Zero, + ["CompareEqual.Vector64.UInt32.Zero"] = CompareEqual_Vector64_UInt32_Zero, + ["CompareEqual.Vector64.Int32.Zero"] = CompareEqual_Vector64_Int32_Zero, + ["CompareEqual.Vector64.Single.Zero"] = CompareEqual_Vector64_Single_Zero, + ["CompareEqual.Vector128.Byte.Zero"] = CompareEqual_Vector128_Byte_Zero, + ["CompareEqual.Vector128.SByte.Zero"] = CompareEqual_Vector128_SByte_Zero, + ["CompareEqual.Vector128.UInt16.Zero"] = CompareEqual_Vector128_UInt16_Zero, + ["CompareEqual.Vector128.Int16.Zero"] = CompareEqual_Vector128_Int16_Zero, + ["CompareEqual.Vector128.UInt32.Zero"] = CompareEqual_Vector128_UInt32_Zero, + ["CompareEqual.Vector128.Int32.Zero"] = CompareEqual_Vector128_Int32_Zero, + ["CompareEqual.Vector128.Single.Zero"] = CompareEqual_Vector128_Single_Zero, ["DivideScalar.Vector64.Double"] = DivideScalar_Vector64_Double, ["DivideScalar.Vector64.Single"] = DivideScalar_Vector64_Single, ["DuplicateSelectedScalarToVector64.Vector64.Byte.1"] = DuplicateSelectedScalarToVector64_Vector64_Byte_1, @@ -97,20 +111,6 @@ static Program() ["DuplicateSelectedScalarToVector64.Vector128.Int16.4"] = DuplicateSelectedScalarToVector64_Vector128_Int16_4, ["DuplicateSelectedScalarToVector64.Vector128.Int32.2"] = DuplicateSelectedScalarToVector64_Vector128_Int32_2, ["DuplicateSelectedScalarToVector64.Vector128.SByte.8"] = DuplicateSelectedScalarToVector64_Vector128_SByte_8, - ["DuplicateSelectedScalarToVector64.Vector128.Single.2"] = DuplicateSelectedScalarToVector64_Vector128_Single_2, - ["DuplicateSelectedScalarToVector64.Vector128.UInt16.4"] = DuplicateSelectedScalarToVector64_Vector128_UInt16_4, - ["DuplicateSelectedScalarToVector64.Vector128.UInt32.2"] = DuplicateSelectedScalarToVector64_Vector128_UInt32_2, - ["DuplicateSelectedScalarToVector128.Vector64.Byte.1"] = DuplicateSelectedScalarToVector128_Vector64_Byte_1, - ["DuplicateSelectedScalarToVector128.Vector64.Int16.1"] = DuplicateSelectedScalarToVector128_Vector64_Int16_1, - ["DuplicateSelectedScalarToVector128.Vector64.Int32.1"] = DuplicateSelectedScalarToVector128_Vector64_Int32_1, - ["DuplicateSelectedScalarToVector128.Vector64.SByte.1"] = DuplicateSelectedScalarToVector128_Vector64_SByte_1, - ["DuplicateSelectedScalarToVector128.Vector64.Single.1"] = DuplicateSelectedScalarToVector128_Vector64_Single_1, - ["DuplicateSelectedScalarToVector128.Vector64.UInt16.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt16_1, - ["DuplicateSelectedScalarToVector128.Vector64.UInt32.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt32_1, - ["DuplicateSelectedScalarToVector128.Vector128.Byte.8"] = DuplicateSelectedScalarToVector128_Vector128_Byte_8, - ["DuplicateSelectedScalarToVector128.Vector128.Int16.4"] = DuplicateSelectedScalarToVector128_Vector128_Int16_4, - ["DuplicateSelectedScalarToVector128.Vector128.Int32.2"] = DuplicateSelectedScalarToVector128_Vector128_Int32_2, - ["DuplicateSelectedScalarToVector128.Vector128.SByte.8"] = DuplicateSelectedScalarToVector128_Vector128_SByte_8, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs index 9b316164edef1..b71f006eeee35 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["DuplicateSelectedScalarToVector64.Vector128.Single.2"] = DuplicateSelectedScalarToVector64_Vector128_Single_2, + ["DuplicateSelectedScalarToVector64.Vector128.UInt16.4"] = DuplicateSelectedScalarToVector64_Vector128_UInt16_4, + ["DuplicateSelectedScalarToVector64.Vector128.UInt32.2"] = DuplicateSelectedScalarToVector64_Vector128_UInt32_2, + ["DuplicateSelectedScalarToVector128.Vector64.Byte.1"] = DuplicateSelectedScalarToVector128_Vector64_Byte_1, + ["DuplicateSelectedScalarToVector128.Vector64.Int16.1"] = DuplicateSelectedScalarToVector128_Vector64_Int16_1, + ["DuplicateSelectedScalarToVector128.Vector64.Int32.1"] = DuplicateSelectedScalarToVector128_Vector64_Int32_1, + ["DuplicateSelectedScalarToVector128.Vector64.SByte.1"] = DuplicateSelectedScalarToVector128_Vector64_SByte_1, + ["DuplicateSelectedScalarToVector128.Vector64.Single.1"] = DuplicateSelectedScalarToVector128_Vector64_Single_1, + ["DuplicateSelectedScalarToVector128.Vector64.UInt16.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt16_1, + ["DuplicateSelectedScalarToVector128.Vector64.UInt32.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt32_1, + ["DuplicateSelectedScalarToVector128.Vector128.Byte.8"] = DuplicateSelectedScalarToVector128_Vector128_Byte_8, + ["DuplicateSelectedScalarToVector128.Vector128.Int16.4"] = DuplicateSelectedScalarToVector128_Vector128_Int16_4, + ["DuplicateSelectedScalarToVector128.Vector128.Int32.2"] = DuplicateSelectedScalarToVector128_Vector128_Int32_2, + ["DuplicateSelectedScalarToVector128.Vector128.SByte.8"] = DuplicateSelectedScalarToVector128_Vector128_SByte_8, ["DuplicateSelectedScalarToVector128.Vector128.Single.2"] = DuplicateSelectedScalarToVector128_Vector128_Single_2, ["DuplicateSelectedScalarToVector128.Vector128.UInt16.4"] = DuplicateSelectedScalarToVector128_Vector128_UInt16_4, ["DuplicateSelectedScalarToVector128.Vector128.UInt32.2"] = DuplicateSelectedScalarToVector128_Vector128_UInt32_2, @@ -97,20 +111,6 @@ static Program() ["ExtractVector64.UInt16.1"] = ExtractVector64_UInt16_1, ["ExtractVector64.UInt32.1"] = ExtractVector64_UInt32_1, ["ExtractVector128.Byte.1"] = ExtractVector128_Byte_1, - ["ExtractVector128.Double.1"] = ExtractVector128_Double_1, - ["ExtractVector128.Int16.1"] = ExtractVector128_Int16_1, - ["ExtractVector128.Int32.1"] = ExtractVector128_Int32_1, - ["ExtractVector128.Int64.1"] = ExtractVector128_Int64_1, - ["ExtractVector128.SByte.1"] = ExtractVector128_SByte_1, - ["ExtractVector128.Single.1"] = ExtractVector128_Single_1, - ["ExtractVector128.UInt16.1"] = ExtractVector128_UInt16_1, - ["ExtractVector128.UInt32.1"] = ExtractVector128_UInt32_1, - ["ExtractVector128.UInt64.1"] = ExtractVector128_UInt64_1, - ["Floor.Vector64.Single"] = Floor_Vector64_Single, - ["Floor.Vector128.Single"] = Floor_Vector128_Single, - ["FloorScalar.Vector64.Double"] = FloorScalar_Vector64_Double, - ["FloorScalar.Vector64.Single"] = FloorScalar_Vector64_Single, - ["FusedAddHalving.Vector64.Byte"] = FusedAddHalving_Vector64_Byte, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs index 9b906de9804ce..148fb9bb5b969 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["ExtractVector128.Double.1"] = ExtractVector128_Double_1, + ["ExtractVector128.Int16.1"] = ExtractVector128_Int16_1, + ["ExtractVector128.Int32.1"] = ExtractVector128_Int32_1, + ["ExtractVector128.Int64.1"] = ExtractVector128_Int64_1, + ["ExtractVector128.SByte.1"] = ExtractVector128_SByte_1, + ["ExtractVector128.Single.1"] = ExtractVector128_Single_1, + ["ExtractVector128.UInt16.1"] = ExtractVector128_UInt16_1, + ["ExtractVector128.UInt32.1"] = ExtractVector128_UInt32_1, + ["ExtractVector128.UInt64.1"] = ExtractVector128_UInt64_1, + ["Floor.Vector64.Single"] = Floor_Vector64_Single, + ["Floor.Vector128.Single"] = Floor_Vector128_Single, + ["FloorScalar.Vector64.Double"] = FloorScalar_Vector64_Double, + ["FloorScalar.Vector64.Single"] = FloorScalar_Vector64_Single, + ["FusedAddHalving.Vector64.Byte"] = FusedAddHalving_Vector64_Byte, ["FusedAddHalving.Vector64.Int16"] = FusedAddHalving_Vector64_Int16, ["FusedAddHalving.Vector64.Int32"] = FusedAddHalving_Vector64_Int32, ["FusedAddHalving.Vector64.SByte"] = FusedAddHalving_Vector64_SByte, @@ -97,20 +111,6 @@ static Program() ["LeadingZeroCount.Vector128.UInt16"] = LeadingZeroCount_Vector128_UInt16, ["LeadingZeroCount.Vector128.UInt32"] = LeadingZeroCount_Vector128_UInt32, ["LoadAndInsertScalar.Vector64.Byte.7"] = LoadAndInsertScalar_Vector64_Byte_7, - ["LoadAndInsertScalar.Vector64.Int16.3"] = LoadAndInsertScalar_Vector64_Int16_3, - ["LoadAndInsertScalar.Vector64.Int32.1"] = LoadAndInsertScalar_Vector64_Int32_1, - ["LoadAndInsertScalar.Vector64.SByte.7"] = LoadAndInsertScalar_Vector64_SByte_7, - ["LoadAndInsertScalar.Vector64.Single.1"] = LoadAndInsertScalar_Vector64_Single_1, - ["LoadAndInsertScalar.Vector64.UInt16.3"] = LoadAndInsertScalar_Vector64_UInt16_3, - ["LoadAndInsertScalar.Vector64.UInt32.1"] = LoadAndInsertScalar_Vector64_UInt32_1, - ["LoadAndInsertScalar.Vector128.Byte.15"] = LoadAndInsertScalar_Vector128_Byte_15, - ["LoadAndInsertScalar.Vector128.Double.1"] = LoadAndInsertScalar_Vector128_Double_1, - ["LoadAndInsertScalar.Vector128.Int16.7"] = LoadAndInsertScalar_Vector128_Int16_7, - ["LoadAndInsertScalar.Vector128.Int32.3"] = LoadAndInsertScalar_Vector128_Int32_3, - ["LoadAndInsertScalar.Vector128.Int64.1"] = LoadAndInsertScalar_Vector128_Int64_1, - ["LoadAndInsertScalar.Vector128.SByte.15"] = LoadAndInsertScalar_Vector128_SByte_15, - ["LoadAndInsertScalar.Vector128.Single.3"] = LoadAndInsertScalar_Vector128_Single_3, - ["LoadAndInsertScalar.Vector128.UInt16.7"] = LoadAndInsertScalar_Vector128_UInt16_7, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs index 87943f475dadd..75ed085e957ce 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["LoadAndInsertScalar.Vector64.Int16.3"] = LoadAndInsertScalar_Vector64_Int16_3, + ["LoadAndInsertScalar.Vector64.Int32.1"] = LoadAndInsertScalar_Vector64_Int32_1, + ["LoadAndInsertScalar.Vector64.SByte.7"] = LoadAndInsertScalar_Vector64_SByte_7, + ["LoadAndInsertScalar.Vector64.Single.1"] = LoadAndInsertScalar_Vector64_Single_1, + ["LoadAndInsertScalar.Vector64.UInt16.3"] = LoadAndInsertScalar_Vector64_UInt16_3, + ["LoadAndInsertScalar.Vector64.UInt32.1"] = LoadAndInsertScalar_Vector64_UInt32_1, + ["LoadAndInsertScalar.Vector128.Byte.15"] = LoadAndInsertScalar_Vector128_Byte_15, + ["LoadAndInsertScalar.Vector128.Double.1"] = LoadAndInsertScalar_Vector128_Double_1, + ["LoadAndInsertScalar.Vector128.Int16.7"] = LoadAndInsertScalar_Vector128_Int16_7, + ["LoadAndInsertScalar.Vector128.Int32.3"] = LoadAndInsertScalar_Vector128_Int32_3, + ["LoadAndInsertScalar.Vector128.Int64.1"] = LoadAndInsertScalar_Vector128_Int64_1, + ["LoadAndInsertScalar.Vector128.SByte.15"] = LoadAndInsertScalar_Vector128_SByte_15, + ["LoadAndInsertScalar.Vector128.Single.3"] = LoadAndInsertScalar_Vector128_Single_3, + ["LoadAndInsertScalar.Vector128.UInt16.7"] = LoadAndInsertScalar_Vector128_UInt16_7, ["LoadAndInsertScalar.Vector128.UInt32.3"] = LoadAndInsertScalar_Vector128_UInt32_3, ["LoadAndInsertScalar.Vector128.UInt64.1"] = LoadAndInsertScalar_Vector128_UInt64_1, ["LoadAndReplicateToVector64.Byte"] = LoadAndReplicateToVector64_Byte, @@ -97,20 +111,6 @@ static Program() ["MinPairwise.Vector64.Single"] = MinPairwise_Vector64_Single, ["MinPairwise.Vector64.UInt16"] = MinPairwise_Vector64_UInt16, ["MinPairwise.Vector64.UInt32"] = MinPairwise_Vector64_UInt32, - ["Multiply.Vector64.Byte"] = Multiply_Vector64_Byte, - ["Multiply.Vector64.Int16"] = Multiply_Vector64_Int16, - ["Multiply.Vector64.Int32"] = Multiply_Vector64_Int32, - ["Multiply.Vector64.SByte"] = Multiply_Vector64_SByte, - ["Multiply.Vector64.Single"] = Multiply_Vector64_Single, - ["Multiply.Vector64.UInt16"] = Multiply_Vector64_UInt16, - ["Multiply.Vector64.UInt32"] = Multiply_Vector64_UInt32, - ["Multiply.Vector128.Byte"] = Multiply_Vector128_Byte, - ["Multiply.Vector128.Int16"] = Multiply_Vector128_Int16, - ["Multiply.Vector128.Int32"] = Multiply_Vector128_Int32, - ["Multiply.Vector128.SByte"] = Multiply_Vector128_SByte, - ["Multiply.Vector128.Single"] = Multiply_Vector128_Single, - ["Multiply.Vector128.UInt16"] = Multiply_Vector128_UInt16, - ["Multiply.Vector128.UInt32"] = Multiply_Vector128_UInt32, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs index 3debb286fb935..0e8787d6d1319 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["Multiply.Vector64.Byte"] = Multiply_Vector64_Byte, + ["Multiply.Vector64.Int16"] = Multiply_Vector64_Int16, + ["Multiply.Vector64.Int32"] = Multiply_Vector64_Int32, + ["Multiply.Vector64.SByte"] = Multiply_Vector64_SByte, + ["Multiply.Vector64.Single"] = Multiply_Vector64_Single, + ["Multiply.Vector64.UInt16"] = Multiply_Vector64_UInt16, + ["Multiply.Vector64.UInt32"] = Multiply_Vector64_UInt32, + ["Multiply.Vector128.Byte"] = Multiply_Vector128_Byte, + ["Multiply.Vector128.Int16"] = Multiply_Vector128_Int16, + ["Multiply.Vector128.Int32"] = Multiply_Vector128_Int32, + ["Multiply.Vector128.SByte"] = Multiply_Vector128_SByte, + ["Multiply.Vector128.Single"] = Multiply_Vector128_Single, + ["Multiply.Vector128.UInt16"] = Multiply_Vector128_UInt16, + ["Multiply.Vector128.UInt32"] = Multiply_Vector128_UInt32, ["MultiplyScalar.Vector64.Double"] = MultiplyScalar_Vector64_Double, ["MultiplyScalar.Vector64.Single"] = MultiplyScalar_Vector64_Single, ["MultiplyAdd.Vector64.Byte"] = MultiplyAdd_Vector64_Byte, @@ -97,20 +111,6 @@ static Program() ["MultiplyBySelectedScalarWideningLowerAndAdd.Vector64.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_UInt32_Vector128_UInt32_3, ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int16_Vector64_Int16_3, ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int16_Vector128_Int16_7, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector64_Int32_1, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector128_Int32_3, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector64_UInt16_3, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector128_UInt16_7, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector64_UInt32_1, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector128_UInt32_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector64_Int16_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector128_Int16_7, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector64_Int32_1, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector128_Int32_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector64_UInt16_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector128_UInt16_7, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector64_UInt32_1, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector128_UInt32_3, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs index 84670aead920c..6949c30980887 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector64_Int32_1, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector128_Int32_3, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector64_UInt16_3, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector128_UInt16_7, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector64_UInt32_1, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector128_UInt32_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector64_Int16_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector128_Int16_7, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector64_Int32_1, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector128_Int32_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector64_UInt16_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector128_UInt16_7, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector64_UInt32_1, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector128_UInt32_3, ["MultiplyBySelectedScalarWideningUpperAndAdd.Vector128.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningUpperAndAdd_Vector128_Int16_Vector64_Int16_3, ["MultiplyBySelectedScalarWideningUpperAndAdd.Vector128.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningUpperAndAdd_Vector128_Int16_Vector128_Int16_7, ["MultiplyBySelectedScalarWideningUpperAndAdd.Vector128.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningUpperAndAdd_Vector128_Int32_Vector64_Int32_1, @@ -97,20 +111,6 @@ static Program() ["MultiplyRoundedDoublingByScalarSaturateHigh.Vector128.Int32"] = MultiplyRoundedDoublingByScalarSaturateHigh_Vector128_Int32, ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int16.Vector64.Int16.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int16_Vector64_Int16_3, ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int16.Vector128.Int16.7"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int16_Vector128_Int16_7, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector64_Int32_1, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector128_Int32_3, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector64.Int16.2"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector64_Int16_2, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector128.Int16.7"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector128_Int16_7, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector64_Int32_1, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector128_Int32_3, - ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int16, - ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int32, - ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int16, - ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int32, - ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector64.Single.1"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector64_Single_1, - ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector128.Single.3"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector128_Single_3, - ["MultiplySubtract.Vector64.Byte"] = MultiplySubtract_Vector64_Byte, - ["MultiplySubtract.Vector64.Int16"] = MultiplySubtract_Vector64_Int16, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs index ac57e2481a568..0b905b137f1cf 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs @@ -11,6 +11,20 @@ public static partial class Program static Program() { TestList = new Dictionary() { + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector64_Int32_1, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector128_Int32_3, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector64.Int16.2"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector64_Int16_2, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector128.Int16.7"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector128_Int16_7, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector64_Int32_1, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector128_Int32_3, + ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int16, + ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int32, + ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int16, + ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int32, + ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector64.Single.1"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector64_Single_1, + ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector128.Single.3"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector128_Single_3, + ["MultiplySubtract.Vector64.Byte"] = MultiplySubtract_Vector64_Byte, + ["MultiplySubtract.Vector64.Int16"] = MultiplySubtract_Vector64_Int16, ["MultiplySubtract.Vector64.Int32"] = MultiplySubtract_Vector64_Int32, ["MultiplySubtract.Vector64.SByte"] = MultiplySubtract_Vector64_SByte, ["MultiplySubtract.Vector64.UInt16"] = MultiplySubtract_Vector64_UInt16, @@ -97,20 +111,6 @@ static Program() ["NegateSaturate.Vector128.SByte"] = NegateSaturate_Vector128_SByte, ["NegateScalar.Vector64.Double"] = NegateScalar_Vector64_Double, ["NegateScalar.Vector64.Single"] = NegateScalar_Vector64_Single, - ["Not.Vector64.Byte"] = Not_Vector64_Byte, - ["Not.Vector64.Double"] = Not_Vector64_Double, - ["Not.Vector64.Int16"] = Not_Vector64_Int16, - ["Not.Vector64.Int32"] = Not_Vector64_Int32, - ["Not.Vector64.Int64"] = Not_Vector64_Int64, - ["Not.Vector64.SByte"] = Not_Vector64_SByte, - ["Not.Vector64.Single"] = Not_Vector64_Single, - ["Not.Vector64.UInt16"] = Not_Vector64_UInt16, - ["Not.Vector64.UInt32"] = Not_Vector64_UInt32, - ["Not.Vector64.UInt64"] = Not_Vector64_UInt64, - ["Not.Vector128.Byte"] = Not_Vector128_Byte, - ["Not.Vector128.Double"] = Not_Vector128_Double, - ["Not.Vector128.Int16"] = Not_Vector128_Int16, - ["Not.Vector128.Int32"] = Not_Vector128_Int32, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx index ec6da1aa16e20..3c982923b8556 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx @@ -482,6 +482,20 @@ private static readonly (string templateFileName, Dictionary tem ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "ConvertToUInt32RoundToZero_Vector64_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ConvertToUInt32RoundToZero", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConvertToUInt32RoundToZero(firstOp[i]) != result[i]"}), ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "ConvertToUInt32RoundToZero_Vector128_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ConvertToUInt32RoundToZero", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConvertToUInt32RoundToZero(firstOp[i]) != result[i]"}), ("SimpleUnOpTest.template", new Dictionary { ["TestName"] = "ConvertToUInt32RoundToZeroScalar_Vector64_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ConvertToUInt32RoundToZeroScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "Helpers.ConvertToUInt32RoundToZero(firstOp[0]) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Byte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_SByte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_UInt16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Int16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_UInt32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Int32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Single_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Byte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_SByte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_UInt16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Int16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_UInt32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Int32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), + ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Single_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("SimpleBinOpTest.template", new Dictionary { ["TestName"] = "DivideScalar_Vector64_Double", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "DivideScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Helpers.Divide(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != 0"}), ("SimpleBinOpTest.template", new Dictionary { ["TestName"] = "DivideScalar_Vector64_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "DivideScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(Helpers.Divide(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != 0"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "DuplicateSelectedScalarToVector64_Vector64_Byte_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "DuplicateSelectedScalarToVector64", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "1", ["ValidateIterResult"] = "firstOp[Imm] != result[i]"}), diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template new file mode 100644 index 0000000000000..e9570fedb65ea --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template @@ -0,0 +1,491 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +/****************************************************************************** + * This file is auto-generated from a template file by the GenerateTests.csx * + * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * + * changes, please update the corresponding template and run according to the * + * directions listed in the file. * + ******************************************************************************/ + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + private static void {TestName}() + { + var test = new ZeroUnOpTest__{TestName}(); + + if (test.IsSupported) + { + // Validates basic functionality works, using Unsafe.Read + test.RunBasicScenario_UnsafeRead(); + + if ({LoadIsa}.IsSupported) + { + // Validates basic functionality works, using Load + test.RunBasicScenario_Load(); + } + + // 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 + { + // Validates we throw on unsupported hardware + test.RunUnsupportedScenario(); + } + + if (!test.Succeeded) + { + throw new Exception("One or more scenarios did not complete as expected."); + } + } + } + + public sealed unsafe class ZeroUnOpTest__{TestName} + { + private struct DataTable + { + private byte[] inArray1; + private byte[] outArray; + + private GCHandle inHandle1; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable({Op1BaseType}[] inArray1, {RetBaseType}[] outArray, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); + int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); + if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.outArray = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + outHandle.Free(); + } + + private static unsafe void* Align(byte* buffer, ulong expectedAlignment) + { + return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); + } + } + + private struct TestStruct + { + public {Op1VectorType}<{Op1BaseType}> _fld1; + + public static TestStruct Create() + { + var testStruct = new TestStruct(); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario(ZeroUnOpTest__{TestName} testClass) + { + var result = {Isa}.{Method}(_fld1, {Op1VectorType}<{Op1BaseType}>.Zero); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + + public void RunStructFldScenario_Load(ZeroUnOpTest__{TestName} testClass) + { + fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(testClass._dataTable.outArrayPtr, result); + testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); + } + } + } + + private static readonly int LargestVectorSize = {LargestVectorSize}; + + private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); + private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); + + private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; + + private static {Op1VectorType}<{Op1BaseType}> _clsVar1; + + private {Op1VectorType}<{Op1BaseType}> _fld1; + + private DataTable _dataTable; + + static ZeroUnOpTest__{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 ZeroUnOpTest__{TestName}() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + _dataTable = new DataTable(_data1, new {RetBaseType}[RetElementCount], LargestVectorSize); + } + + public bool IsSupported => {Isa}.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + var result = {Isa}.{Method}( + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op1VectorType}<{Op1BaseType}>) }) + .Invoke(null, new object[] { + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), + {Op1VectorType}<{Op1BaseType}>.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); + ValidateResult(_dataTable.inArray1Ptr, _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({Op1VectorType}<{Op1BaseType}>) }) + .Invoke(null, new object[] { + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), + {Op1VectorType}<{Op1BaseType}>.Zero + }); + + Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); + ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + + var result = {Isa}.{Method}( + _clsVar1, + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + + public void RunClsVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); + + fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_clsVar1, _dataTable.outArrayPtr); + } + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr); + var result = {Isa}.{Method}(op1, {Op1VectorType}<{Op1BaseType}>.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunLclVarScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + + var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); + var result = {Isa}.{Method}(op1, {Op1VectorType}<{Op1BaseType}>.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(op1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + + var test = new ZeroUnOpTest__{TestName}(); + var result = {Isa}.{Method}(test._fld1, {Op1VectorType}<{Op1BaseType}>.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunClassLclFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); + + var test = new ZeroUnOpTest__{TestName}(); + + fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + var result = {Isa}.{Method}(_fld1, {Op1VectorType}<{Op1BaseType}>.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + + public void RunClassFldScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); + + fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) + { + var result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(_fld1, _dataTable.outArrayPtr); + } + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + var result = {Isa}.{Method}(test._fld1, {Op1VectorType}<{Op1BaseType}>.Zero); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _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)), + {Op1VectorType}<{Op1BaseType}>.Zero + ); + + Unsafe.Write(_dataTable.outArrayPtr, result); + ValidateResult(test._fld1, _dataTable.outArrayPtr); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + 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)); + + bool succeeded = false; + + try + { + RunBasicScenario_UnsafeRead(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + + private void ValidateResult({Op1VectorType}<{Op1BaseType}> op1, void* result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), op1); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); + + ValidateResult(inArray1, outArray, method); + } + + private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +} From fd19fdc5ed09c50c3fd83cfe964a3152b7bc998d Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 4 Jan 2022 14:52:20 -0800 Subject: [PATCH 09/59] Do not contain op1 for now --- src/coreclr/jit/lowerarmarch.cpp | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 91aad49405a8a..66c89c4de57d5 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1855,11 +1855,7 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_CompareEqual: { - if (intrin.op1->IsVectorZero()) - { - MakeSrcContained(node, intrin.op1); - } - else if (intrin.op2->IsVectorZero()) + if (intrin.op2->IsVectorZero()) { MakeSrcContained(node, intrin.op2); } From 178ff5216d84fc780c2af03f1753f18711de5f6f Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 4 Jan 2022 17:49:44 -0800 Subject: [PATCH 10/59] Wrong intrinsic id used --- src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 5ab6b7a751eeb..f312f3fd5bd4a 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -496,7 +496,7 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); break; - case NI_AdvSimd_Arm64_CompareEqual: + case NI_AdvSimd_CompareEqual: if (intrin.op1->isContained()) { assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); From c0a23c0d0c41e5e78187408d3af83923e5ff074c Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 6 Jan 2022 11:27:33 -0800 Subject: [PATCH 11/59] Removing generated tests --- .../Arm/AdvSimd/AdvSimd_Part10_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part10_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part11_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part11_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part12_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part12_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part13_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part13_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part14_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part14_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part15_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part15_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part16_r.csproj | 14 - .../Arm/AdvSimd/AdvSimd_Part16_ro.csproj | 14 - .../Arm/AdvSimd/AdvSimd_Part3_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part3_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part4_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part4_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part5_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part5_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part6_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part6_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part7_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part7_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part8_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part8_ro.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part9_r.csproj | 28 +- .../Arm/AdvSimd/AdvSimd_Part9_ro.csproj | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part10.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part11.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part12.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part13.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part14.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part15.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part16.cs | 14 - .../Arm/AdvSimd/Program.AdvSimd_Part3.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part4.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part5.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part6.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part7.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part8.cs | 28 +- .../Arm/AdvSimd/Program.AdvSimd_Part9.cs | 28 +- .../Arm/Shared/GenerateTests.csx | 14 - .../Arm/Shared/ZeroUnOpTest.template | 491 ------------------ 44 files changed, 546 insertions(+), 1093 deletions(-) delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj index 26d9a5982a0ec..1ee091aa07c04 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj index 88622fda56966..7d7ee6e054ec3 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part10_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj index 79d46a4b6faec..b13b25f71f1dd 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj index c0e13fbea82dc..83e4a310ec7a3 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part11_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj index 4b2f6dfd8cbfe..f71c7d338a62f 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj index e7c0177dd9788..aded274dfb79d 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part12_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj index 78a4733d32cfb..74c0e0c152278 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj index 8304bb3bc38d2..f68b360cc0e6a 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part13_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj index 13a247a629166..2b56e4ab6d9b2 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj index e8fa25cd27c50..33fead32fa518 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part14_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj index ffcacde6ceb9a..62fd34edfd0f0 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj index 56ef479f3846c..543fe0ce0a95a 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part15_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj index cd68a85770f68..d006f1a715fae 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj index 654ba489ea93e..6d7a4d7192003 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part16_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj index 3738dc54eb14d..88f56816d3b9d 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_r.csproj @@ -81,20 +81,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj index 3f61d51536c38..22fbf089b59a3 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part3_ro.csproj @@ -81,20 +81,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj index 6f563e504fa1c..794d092b600f9 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj index 0de0c5a31f477..a7a1d2262d242 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part4_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj index 54a8fadcd16a5..7745fa0bfc76d 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj index fc362a681a5fc..b1b57ae63e1a4 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part5_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj index 251d66819a2ae..8ed0e6473f16a 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj index c37e9cca76dc9..0520b792032b9 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part6_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj index ddf8cfbf6c663..1bb5d04897323 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj index 031c0a669f8a0..9d9364a99220e 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part7_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj index c3787a81a0dc6..b7465422babcb 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj index 2bc25d1f1a755..ffbdf964e36c2 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part8_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj index d28c6805d018d..83b39f57f1924 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_r.csproj @@ -8,20 +8,6 @@ - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj index de3bd3641e6f2..150cebc294ae0 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/AdvSimd_Part9_ro.csproj @@ -8,20 +8,6 @@ True - - - - - - - - - - - - - - @@ -108,6 +94,20 @@ + + + + + + + + + + + + + + diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs index d0fba586242e3..9ab2011c86543 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part10.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["Not.Vector64.Byte"] = Not_Vector64_Byte, - ["Not.Vector64.Double"] = Not_Vector64_Double, - ["Not.Vector64.Int16"] = Not_Vector64_Int16, - ["Not.Vector64.Int32"] = Not_Vector64_Int32, - ["Not.Vector64.Int64"] = Not_Vector64_Int64, - ["Not.Vector64.SByte"] = Not_Vector64_SByte, - ["Not.Vector64.Single"] = Not_Vector64_Single, - ["Not.Vector64.UInt16"] = Not_Vector64_UInt16, - ["Not.Vector64.UInt32"] = Not_Vector64_UInt32, - ["Not.Vector64.UInt64"] = Not_Vector64_UInt64, - ["Not.Vector128.Byte"] = Not_Vector128_Byte, - ["Not.Vector128.Double"] = Not_Vector128_Double, - ["Not.Vector128.Int16"] = Not_Vector128_Int16, - ["Not.Vector128.Int32"] = Not_Vector128_Int32, ["Not.Vector128.Int64"] = Not_Vector128_Int64, ["Not.Vector128.SByte"] = Not_Vector128_SByte, ["Not.Vector128.Single"] = Not_Vector128_Single, @@ -111,6 +97,20 @@ static Program() ["ReverseElement8.Vector64.Int32"] = ReverseElement8_Vector64_Int32, ["ReverseElement8.Vector64.Int64"] = ReverseElement8_Vector64_Int64, ["ReverseElement8.Vector64.UInt16"] = ReverseElement8_Vector64_UInt16, + ["ReverseElement8.Vector64.UInt32"] = ReverseElement8_Vector64_UInt32, + ["ReverseElement8.Vector64.UInt64"] = ReverseElement8_Vector64_UInt64, + ["ReverseElement8.Vector128.Int16"] = ReverseElement8_Vector128_Int16, + ["ReverseElement8.Vector128.Int32"] = ReverseElement8_Vector128_Int32, + ["ReverseElement8.Vector128.Int64"] = ReverseElement8_Vector128_Int64, + ["ReverseElement8.Vector128.UInt16"] = ReverseElement8_Vector128_UInt16, + ["ReverseElement8.Vector128.UInt32"] = ReverseElement8_Vector128_UInt32, + ["ReverseElement8.Vector128.UInt64"] = ReverseElement8_Vector128_UInt64, + ["RoundAwayFromZero.Vector64.Single"] = RoundAwayFromZero_Vector64_Single, + ["RoundAwayFromZero.Vector128.Single"] = RoundAwayFromZero_Vector128_Single, + ["RoundAwayFromZeroScalar.Vector64.Double"] = RoundAwayFromZeroScalar_Vector64_Double, + ["RoundAwayFromZeroScalar.Vector64.Single"] = RoundAwayFromZeroScalar_Vector64_Single, + ["RoundToNearest.Vector64.Single"] = RoundToNearest_Vector64_Single, + ["RoundToNearest.Vector128.Single"] = RoundToNearest_Vector128_Single, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs index a9c06ea07783c..491dda7065267 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part11.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["ReverseElement8.Vector64.UInt32"] = ReverseElement8_Vector64_UInt32, - ["ReverseElement8.Vector64.UInt64"] = ReverseElement8_Vector64_UInt64, - ["ReverseElement8.Vector128.Int16"] = ReverseElement8_Vector128_Int16, - ["ReverseElement8.Vector128.Int32"] = ReverseElement8_Vector128_Int32, - ["ReverseElement8.Vector128.Int64"] = ReverseElement8_Vector128_Int64, - ["ReverseElement8.Vector128.UInt16"] = ReverseElement8_Vector128_UInt16, - ["ReverseElement8.Vector128.UInt32"] = ReverseElement8_Vector128_UInt32, - ["ReverseElement8.Vector128.UInt64"] = ReverseElement8_Vector128_UInt64, - ["RoundAwayFromZero.Vector64.Single"] = RoundAwayFromZero_Vector64_Single, - ["RoundAwayFromZero.Vector128.Single"] = RoundAwayFromZero_Vector128_Single, - ["RoundAwayFromZeroScalar.Vector64.Double"] = RoundAwayFromZeroScalar_Vector64_Double, - ["RoundAwayFromZeroScalar.Vector64.Single"] = RoundAwayFromZeroScalar_Vector64_Single, - ["RoundToNearest.Vector64.Single"] = RoundToNearest_Vector64_Single, - ["RoundToNearest.Vector128.Single"] = RoundToNearest_Vector128_Single, ["RoundToNearestScalar.Vector64.Double"] = RoundToNearestScalar_Vector64_Double, ["RoundToNearestScalar.Vector64.Single"] = RoundToNearestScalar_Vector64_Single, ["RoundToNegativeInfinity.Vector64.Single"] = RoundToNegativeInfinity_Vector64_Single, @@ -111,6 +97,20 @@ static Program() ["ShiftLeftLogicalSaturate.Vector128.Int32.1"] = ShiftLeftLogicalSaturate_Vector128_Int32_1, ["ShiftLeftLogicalSaturate.Vector128.Int64.1"] = ShiftLeftLogicalSaturate_Vector128_Int64_1, ["ShiftLeftLogicalSaturate.Vector128.SByte.1"] = ShiftLeftLogicalSaturate_Vector128_SByte_1, + ["ShiftLeftLogicalSaturate.Vector128.UInt16.1"] = ShiftLeftLogicalSaturate_Vector128_UInt16_1, + ["ShiftLeftLogicalSaturate.Vector128.UInt32.1"] = ShiftLeftLogicalSaturate_Vector128_UInt32_1, + ["ShiftLeftLogicalSaturate.Vector128.UInt64.1"] = ShiftLeftLogicalSaturate_Vector128_UInt64_1, + ["ShiftLeftLogicalSaturateScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_Int64_1, + ["ShiftLeftLogicalSaturateScalar.Vector64.UInt64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_UInt64_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int16_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int32_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector64.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_SByte_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int16_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int32_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int64.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int64_1, + ["ShiftLeftLogicalSaturateUnsigned.Vector128.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_SByte_1, + ["ShiftLeftLogicalSaturateUnsignedScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateUnsignedScalar_Vector64_Int64_1, + ["ShiftLeftLogicalScalar.Vector64.Int64.1"] = ShiftLeftLogicalScalar_Vector64_Int64_1, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs index 9ece03c3257b2..b471eff3acf6f 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part12.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["ShiftLeftLogicalSaturate.Vector128.UInt16.1"] = ShiftLeftLogicalSaturate_Vector128_UInt16_1, - ["ShiftLeftLogicalSaturate.Vector128.UInt32.1"] = ShiftLeftLogicalSaturate_Vector128_UInt32_1, - ["ShiftLeftLogicalSaturate.Vector128.UInt64.1"] = ShiftLeftLogicalSaturate_Vector128_UInt64_1, - ["ShiftLeftLogicalSaturateScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_Int64_1, - ["ShiftLeftLogicalSaturateScalar.Vector64.UInt64.1"] = ShiftLeftLogicalSaturateScalar_Vector64_UInt64_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int16_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector64.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_Int32_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector64.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector64_SByte_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int16.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int16_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int32.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int32_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.Int64.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_Int64_1, - ["ShiftLeftLogicalSaturateUnsigned.Vector128.SByte.1"] = ShiftLeftLogicalSaturateUnsigned_Vector128_SByte_1, - ["ShiftLeftLogicalSaturateUnsignedScalar.Vector64.Int64.1"] = ShiftLeftLogicalSaturateUnsignedScalar_Vector64_Int64_1, - ["ShiftLeftLogicalScalar.Vector64.Int64.1"] = ShiftLeftLogicalScalar_Vector64_Int64_1, ["ShiftLeftLogicalScalar.Vector64.UInt64.1"] = ShiftLeftLogicalScalar_Vector64_UInt64_1, ["ShiftLeftLogicalWideningLower.Vector64.Byte.1"] = ShiftLeftLogicalWideningLower_Vector64_Byte_1, ["ShiftLeftLogicalWideningLower.Vector64.Int16.1"] = ShiftLeftLogicalWideningLower_Vector64_Int16_1, @@ -111,6 +97,20 @@ static Program() ["ShiftRightAndInsert.Vector128.Byte"] = ShiftRightAndInsert_Vector128_Byte, ["ShiftRightAndInsert.Vector128.Int16"] = ShiftRightAndInsert_Vector128_Int16, ["ShiftRightAndInsert.Vector128.Int32"] = ShiftRightAndInsert_Vector128_Int32, + ["ShiftRightAndInsert.Vector128.Int64"] = ShiftRightAndInsert_Vector128_Int64, + ["ShiftRightAndInsert.Vector128.SByte"] = ShiftRightAndInsert_Vector128_SByte, + ["ShiftRightAndInsert.Vector128.UInt16"] = ShiftRightAndInsert_Vector128_UInt16, + ["ShiftRightAndInsert.Vector128.UInt32"] = ShiftRightAndInsert_Vector128_UInt32, + ["ShiftRightAndInsert.Vector128.UInt64"] = ShiftRightAndInsert_Vector128_UInt64, + ["ShiftRightAndInsertScalar.Vector64.Int64"] = ShiftRightAndInsertScalar_Vector64_Int64, + ["ShiftRightAndInsertScalar.Vector64.UInt64"] = ShiftRightAndInsertScalar_Vector64_UInt64, + ["ShiftRightArithmetic.Vector64.Int16.1"] = ShiftRightArithmetic_Vector64_Int16_1, + ["ShiftRightArithmetic.Vector64.Int32.1"] = ShiftRightArithmetic_Vector64_Int32_1, + ["ShiftRightArithmetic.Vector64.SByte.1"] = ShiftRightArithmetic_Vector64_SByte_1, + ["ShiftRightArithmetic.Vector128.Int16.1"] = ShiftRightArithmetic_Vector128_Int16_1, + ["ShiftRightArithmetic.Vector128.Int32.1"] = ShiftRightArithmetic_Vector128_Int32_1, + ["ShiftRightArithmetic.Vector128.Int64.1"] = ShiftRightArithmetic_Vector128_Int64_1, + ["ShiftRightArithmetic.Vector128.SByte.1"] = ShiftRightArithmetic_Vector128_SByte_1, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs index 45d9d67ee406c..a076639659e67 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part13.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["ShiftRightAndInsert.Vector128.Int64"] = ShiftRightAndInsert_Vector128_Int64, - ["ShiftRightAndInsert.Vector128.SByte"] = ShiftRightAndInsert_Vector128_SByte, - ["ShiftRightAndInsert.Vector128.UInt16"] = ShiftRightAndInsert_Vector128_UInt16, - ["ShiftRightAndInsert.Vector128.UInt32"] = ShiftRightAndInsert_Vector128_UInt32, - ["ShiftRightAndInsert.Vector128.UInt64"] = ShiftRightAndInsert_Vector128_UInt64, - ["ShiftRightAndInsertScalar.Vector64.Int64"] = ShiftRightAndInsertScalar_Vector64_Int64, - ["ShiftRightAndInsertScalar.Vector64.UInt64"] = ShiftRightAndInsertScalar_Vector64_UInt64, - ["ShiftRightArithmetic.Vector64.Int16.1"] = ShiftRightArithmetic_Vector64_Int16_1, - ["ShiftRightArithmetic.Vector64.Int32.1"] = ShiftRightArithmetic_Vector64_Int32_1, - ["ShiftRightArithmetic.Vector64.SByte.1"] = ShiftRightArithmetic_Vector64_SByte_1, - ["ShiftRightArithmetic.Vector128.Int16.1"] = ShiftRightArithmetic_Vector128_Int16_1, - ["ShiftRightArithmetic.Vector128.Int32.1"] = ShiftRightArithmetic_Vector128_Int32_1, - ["ShiftRightArithmetic.Vector128.Int64.1"] = ShiftRightArithmetic_Vector128_Int64_1, - ["ShiftRightArithmetic.Vector128.SByte.1"] = ShiftRightArithmetic_Vector128_SByte_1, ["ShiftRightArithmeticAdd.Vector64.Int16.1"] = ShiftRightArithmeticAdd_Vector64_Int16_1, ["ShiftRightArithmeticAdd.Vector64.Int32.1"] = ShiftRightArithmeticAdd_Vector64_Int32_1, ["ShiftRightArithmeticAdd.Vector64.SByte.1"] = ShiftRightArithmeticAdd_Vector64_SByte_1, @@ -111,6 +97,20 @@ static Program() ["ShiftRightLogicalNarrowingLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt16_1, ["ShiftRightLogicalNarrowingLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingLower_Vector64_UInt32_1, ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Byte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Byte_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int16_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int32_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_SByte_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt16_1, + ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt32_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Byte_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int16_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int32_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.SByte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_SByte_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt16_1, + ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt32_1, + ["ShiftRightLogicalNarrowingUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Byte_1, + ["ShiftRightLogicalNarrowingUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int16_1, + ["ShiftRightLogicalNarrowingUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int32_1, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs index 8317ad38d62ff..731a5a567feae 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part14.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int16_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.Int32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_Int32_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.SByte.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_SByte_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt16.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt16_1, - ["ShiftRightLogicalNarrowingSaturateLower.Vector64.UInt32.1"] = ShiftRightLogicalNarrowingSaturateLower_Vector64_UInt32_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Byte_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int16_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_Int32_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.SByte.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_SByte_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt16.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt16_1, - ["ShiftRightLogicalNarrowingSaturateUpper.Vector128.UInt32.1"] = ShiftRightLogicalNarrowingSaturateUpper_Vector128_UInt32_1, - ["ShiftRightLogicalNarrowingUpper.Vector128.Byte.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Byte_1, - ["ShiftRightLogicalNarrowingUpper.Vector128.Int16.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int16_1, - ["ShiftRightLogicalNarrowingUpper.Vector128.Int32.1"] = ShiftRightLogicalNarrowingUpper_Vector128_Int32_1, ["ShiftRightLogicalNarrowingUpper.Vector128.SByte.1"] = ShiftRightLogicalNarrowingUpper_Vector128_SByte_1, ["ShiftRightLogicalNarrowingUpper.Vector128.UInt16.1"] = ShiftRightLogicalNarrowingUpper_Vector128_UInt16_1, ["ShiftRightLogicalNarrowingUpper.Vector128.UInt32.1"] = ShiftRightLogicalNarrowingUpper_Vector128_UInt32_1, @@ -111,6 +97,20 @@ static Program() ["Store.Vector128.Int64"] = Store_Vector128_Int64, ["Store.Vector128.SByte"] = Store_Vector128_SByte, ["Store.Vector128.Single"] = Store_Vector128_Single, + ["Store.Vector128.UInt16"] = Store_Vector128_UInt16, + ["Store.Vector128.UInt32"] = Store_Vector128_UInt32, + ["Store.Vector128.UInt64"] = Store_Vector128_UInt64, + ["StoreSelectedScalar.Vector64.Byte.7"] = StoreSelectedScalar_Vector64_Byte_7, + ["StoreSelectedScalar.Vector64.Int16.3"] = StoreSelectedScalar_Vector64_Int16_3, + ["StoreSelectedScalar.Vector64.Int32.1"] = StoreSelectedScalar_Vector64_Int32_1, + ["StoreSelectedScalar.Vector64.SByte.7"] = StoreSelectedScalar_Vector64_SByte_7, + ["StoreSelectedScalar.Vector64.Single.1"] = StoreSelectedScalar_Vector64_Single_1, + ["StoreSelectedScalar.Vector64.UInt16.3"] = StoreSelectedScalar_Vector64_UInt16_3, + ["StoreSelectedScalar.Vector64.UInt32.1"] = StoreSelectedScalar_Vector64_UInt32_1, + ["StoreSelectedScalar.Vector128.Byte.15"] = StoreSelectedScalar_Vector128_Byte_15, + ["StoreSelectedScalar.Vector128.Double.1"] = StoreSelectedScalar_Vector128_Double_1, + ["StoreSelectedScalar.Vector128.Int16.7"] = StoreSelectedScalar_Vector128_Int16_7, + ["StoreSelectedScalar.Vector128.Int32.3"] = StoreSelectedScalar_Vector128_Int32_3, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs index 4813b6d21910e..7cf4294fb0034 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part15.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["Store.Vector128.UInt16"] = Store_Vector128_UInt16, - ["Store.Vector128.UInt32"] = Store_Vector128_UInt32, - ["Store.Vector128.UInt64"] = Store_Vector128_UInt64, - ["StoreSelectedScalar.Vector64.Byte.7"] = StoreSelectedScalar_Vector64_Byte_7, - ["StoreSelectedScalar.Vector64.Int16.3"] = StoreSelectedScalar_Vector64_Int16_3, - ["StoreSelectedScalar.Vector64.Int32.1"] = StoreSelectedScalar_Vector64_Int32_1, - ["StoreSelectedScalar.Vector64.SByte.7"] = StoreSelectedScalar_Vector64_SByte_7, - ["StoreSelectedScalar.Vector64.Single.1"] = StoreSelectedScalar_Vector64_Single_1, - ["StoreSelectedScalar.Vector64.UInt16.3"] = StoreSelectedScalar_Vector64_UInt16_3, - ["StoreSelectedScalar.Vector64.UInt32.1"] = StoreSelectedScalar_Vector64_UInt32_1, - ["StoreSelectedScalar.Vector128.Byte.15"] = StoreSelectedScalar_Vector128_Byte_15, - ["StoreSelectedScalar.Vector128.Double.1"] = StoreSelectedScalar_Vector128_Double_1, - ["StoreSelectedScalar.Vector128.Int16.7"] = StoreSelectedScalar_Vector128_Int16_7, - ["StoreSelectedScalar.Vector128.Int32.3"] = StoreSelectedScalar_Vector128_Int32_3, ["StoreSelectedScalar.Vector128.Int64.1"] = StoreSelectedScalar_Vector128_Int64_1, ["StoreSelectedScalar.Vector128.SByte.15"] = StoreSelectedScalar_Vector128_SByte_15, ["StoreSelectedScalar.Vector128.Single.3"] = StoreSelectedScalar_Vector128_Single_3, @@ -111,6 +97,20 @@ static Program() ["SubtractWideningUpper.Vector128.Int64.Vector128.Int32"] = SubtractWideningUpper_Vector128_Int64_Vector128_Int32, ["SubtractWideningUpper.Vector128.SByte.Vector128.SByte"] = SubtractWideningUpper_Vector128_SByte_Vector128_SByte, ["SubtractWideningUpper.Vector128.UInt16.Vector128.Byte"] = SubtractWideningUpper_Vector128_UInt16_Vector128_Byte, + ["SubtractWideningUpper.Vector128.UInt16.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt16_Vector128_UInt16, + ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt16, + ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt32, + ["SubtractWideningUpper.Vector128.UInt64.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt64_Vector128_UInt32, + ["VectorTableLookup.Vector64.Byte"] = VectorTableLookup_Vector64_Byte, + ["VectorTableLookup.Vector64.SByte"] = VectorTableLookup_Vector64_SByte, + ["VectorTableLookupExtension.Vector64.Byte"] = VectorTableLookupExtension_Vector64_Byte, + ["VectorTableLookupExtension.Vector64.SByte"] = VectorTableLookupExtension_Vector64_SByte, + ["Xor.Vector64.Byte"] = Xor_Vector64_Byte, + ["Xor.Vector64.Double"] = Xor_Vector64_Double, + ["Xor.Vector64.Int16"] = Xor_Vector64_Int16, + ["Xor.Vector64.Int32"] = Xor_Vector64_Int32, + ["Xor.Vector64.Int64"] = Xor_Vector64_Int64, + ["Xor.Vector64.SByte"] = Xor_Vector64_SByte, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs index ea3ac73678828..c77860df01f67 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part16.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["SubtractWideningUpper.Vector128.UInt16.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt16_Vector128_UInt16, - ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt16"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt16, - ["SubtractWideningUpper.Vector128.UInt32.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt32_Vector128_UInt32, - ["SubtractWideningUpper.Vector128.UInt64.Vector128.UInt32"] = SubtractWideningUpper_Vector128_UInt64_Vector128_UInt32, - ["VectorTableLookup.Vector64.Byte"] = VectorTableLookup_Vector64_Byte, - ["VectorTableLookup.Vector64.SByte"] = VectorTableLookup_Vector64_SByte, - ["VectorTableLookupExtension.Vector64.Byte"] = VectorTableLookupExtension_Vector64_Byte, - ["VectorTableLookupExtension.Vector64.SByte"] = VectorTableLookupExtension_Vector64_SByte, - ["Xor.Vector64.Byte"] = Xor_Vector64_Byte, - ["Xor.Vector64.Double"] = Xor_Vector64_Double, - ["Xor.Vector64.Int16"] = Xor_Vector64_Int16, - ["Xor.Vector64.Int32"] = Xor_Vector64_Int32, - ["Xor.Vector64.Int64"] = Xor_Vector64_Int64, - ["Xor.Vector64.SByte"] = Xor_Vector64_SByte, ["Xor.Vector64.Single"] = Xor_Vector64_Single, ["Xor.Vector64.UInt16"] = Xor_Vector64_UInt16, ["Xor.Vector64.UInt32"] = Xor_Vector64_UInt32, diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs index cc1c88cbcbcda..cecabeabc5337 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part3.cs @@ -84,20 +84,6 @@ static Program() ["ConvertToUInt32RoundToZero.Vector64.Single"] = ConvertToUInt32RoundToZero_Vector64_Single, ["ConvertToUInt32RoundToZero.Vector128.Single"] = ConvertToUInt32RoundToZero_Vector128_Single, ["ConvertToUInt32RoundToZeroScalar.Vector64.Single"] = ConvertToUInt32RoundToZeroScalar_Vector64_Single, - ["CompareEqual.Vector64.Byte.Zero"] = CompareEqual_Vector64_Byte_Zero, - ["CompareEqual.Vector64.SByte.Zero"] = CompareEqual_Vector64_SByte_Zero, - ["CompareEqual.Vector64.UInt16.Zero"] = CompareEqual_Vector64_UInt16_Zero, - ["CompareEqual.Vector64.Int16.Zero"] = CompareEqual_Vector64_Int16_Zero, - ["CompareEqual.Vector64.UInt32.Zero"] = CompareEqual_Vector64_UInt32_Zero, - ["CompareEqual.Vector64.Int32.Zero"] = CompareEqual_Vector64_Int32_Zero, - ["CompareEqual.Vector64.Single.Zero"] = CompareEqual_Vector64_Single_Zero, - ["CompareEqual.Vector128.Byte.Zero"] = CompareEqual_Vector128_Byte_Zero, - ["CompareEqual.Vector128.SByte.Zero"] = CompareEqual_Vector128_SByte_Zero, - ["CompareEqual.Vector128.UInt16.Zero"] = CompareEqual_Vector128_UInt16_Zero, - ["CompareEqual.Vector128.Int16.Zero"] = CompareEqual_Vector128_Int16_Zero, - ["CompareEqual.Vector128.UInt32.Zero"] = CompareEqual_Vector128_UInt32_Zero, - ["CompareEqual.Vector128.Int32.Zero"] = CompareEqual_Vector128_Int32_Zero, - ["CompareEqual.Vector128.Single.Zero"] = CompareEqual_Vector128_Single_Zero, ["DivideScalar.Vector64.Double"] = DivideScalar_Vector64_Double, ["DivideScalar.Vector64.Single"] = DivideScalar_Vector64_Single, ["DuplicateSelectedScalarToVector64.Vector64.Byte.1"] = DuplicateSelectedScalarToVector64_Vector64_Byte_1, @@ -111,6 +97,20 @@ static Program() ["DuplicateSelectedScalarToVector64.Vector128.Int16.4"] = DuplicateSelectedScalarToVector64_Vector128_Int16_4, ["DuplicateSelectedScalarToVector64.Vector128.Int32.2"] = DuplicateSelectedScalarToVector64_Vector128_Int32_2, ["DuplicateSelectedScalarToVector64.Vector128.SByte.8"] = DuplicateSelectedScalarToVector64_Vector128_SByte_8, + ["DuplicateSelectedScalarToVector64.Vector128.Single.2"] = DuplicateSelectedScalarToVector64_Vector128_Single_2, + ["DuplicateSelectedScalarToVector64.Vector128.UInt16.4"] = DuplicateSelectedScalarToVector64_Vector128_UInt16_4, + ["DuplicateSelectedScalarToVector64.Vector128.UInt32.2"] = DuplicateSelectedScalarToVector64_Vector128_UInt32_2, + ["DuplicateSelectedScalarToVector128.Vector64.Byte.1"] = DuplicateSelectedScalarToVector128_Vector64_Byte_1, + ["DuplicateSelectedScalarToVector128.Vector64.Int16.1"] = DuplicateSelectedScalarToVector128_Vector64_Int16_1, + ["DuplicateSelectedScalarToVector128.Vector64.Int32.1"] = DuplicateSelectedScalarToVector128_Vector64_Int32_1, + ["DuplicateSelectedScalarToVector128.Vector64.SByte.1"] = DuplicateSelectedScalarToVector128_Vector64_SByte_1, + ["DuplicateSelectedScalarToVector128.Vector64.Single.1"] = DuplicateSelectedScalarToVector128_Vector64_Single_1, + ["DuplicateSelectedScalarToVector128.Vector64.UInt16.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt16_1, + ["DuplicateSelectedScalarToVector128.Vector64.UInt32.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt32_1, + ["DuplicateSelectedScalarToVector128.Vector128.Byte.8"] = DuplicateSelectedScalarToVector128_Vector128_Byte_8, + ["DuplicateSelectedScalarToVector128.Vector128.Int16.4"] = DuplicateSelectedScalarToVector128_Vector128_Int16_4, + ["DuplicateSelectedScalarToVector128.Vector128.Int32.2"] = DuplicateSelectedScalarToVector128_Vector128_Int32_2, + ["DuplicateSelectedScalarToVector128.Vector128.SByte.8"] = DuplicateSelectedScalarToVector128_Vector128_SByte_8, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs index b71f006eeee35..9b316164edef1 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part4.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["DuplicateSelectedScalarToVector64.Vector128.Single.2"] = DuplicateSelectedScalarToVector64_Vector128_Single_2, - ["DuplicateSelectedScalarToVector64.Vector128.UInt16.4"] = DuplicateSelectedScalarToVector64_Vector128_UInt16_4, - ["DuplicateSelectedScalarToVector64.Vector128.UInt32.2"] = DuplicateSelectedScalarToVector64_Vector128_UInt32_2, - ["DuplicateSelectedScalarToVector128.Vector64.Byte.1"] = DuplicateSelectedScalarToVector128_Vector64_Byte_1, - ["DuplicateSelectedScalarToVector128.Vector64.Int16.1"] = DuplicateSelectedScalarToVector128_Vector64_Int16_1, - ["DuplicateSelectedScalarToVector128.Vector64.Int32.1"] = DuplicateSelectedScalarToVector128_Vector64_Int32_1, - ["DuplicateSelectedScalarToVector128.Vector64.SByte.1"] = DuplicateSelectedScalarToVector128_Vector64_SByte_1, - ["DuplicateSelectedScalarToVector128.Vector64.Single.1"] = DuplicateSelectedScalarToVector128_Vector64_Single_1, - ["DuplicateSelectedScalarToVector128.Vector64.UInt16.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt16_1, - ["DuplicateSelectedScalarToVector128.Vector64.UInt32.1"] = DuplicateSelectedScalarToVector128_Vector64_UInt32_1, - ["DuplicateSelectedScalarToVector128.Vector128.Byte.8"] = DuplicateSelectedScalarToVector128_Vector128_Byte_8, - ["DuplicateSelectedScalarToVector128.Vector128.Int16.4"] = DuplicateSelectedScalarToVector128_Vector128_Int16_4, - ["DuplicateSelectedScalarToVector128.Vector128.Int32.2"] = DuplicateSelectedScalarToVector128_Vector128_Int32_2, - ["DuplicateSelectedScalarToVector128.Vector128.SByte.8"] = DuplicateSelectedScalarToVector128_Vector128_SByte_8, ["DuplicateSelectedScalarToVector128.Vector128.Single.2"] = DuplicateSelectedScalarToVector128_Vector128_Single_2, ["DuplicateSelectedScalarToVector128.Vector128.UInt16.4"] = DuplicateSelectedScalarToVector128_Vector128_UInt16_4, ["DuplicateSelectedScalarToVector128.Vector128.UInt32.2"] = DuplicateSelectedScalarToVector128_Vector128_UInt32_2, @@ -111,6 +97,20 @@ static Program() ["ExtractVector64.UInt16.1"] = ExtractVector64_UInt16_1, ["ExtractVector64.UInt32.1"] = ExtractVector64_UInt32_1, ["ExtractVector128.Byte.1"] = ExtractVector128_Byte_1, + ["ExtractVector128.Double.1"] = ExtractVector128_Double_1, + ["ExtractVector128.Int16.1"] = ExtractVector128_Int16_1, + ["ExtractVector128.Int32.1"] = ExtractVector128_Int32_1, + ["ExtractVector128.Int64.1"] = ExtractVector128_Int64_1, + ["ExtractVector128.SByte.1"] = ExtractVector128_SByte_1, + ["ExtractVector128.Single.1"] = ExtractVector128_Single_1, + ["ExtractVector128.UInt16.1"] = ExtractVector128_UInt16_1, + ["ExtractVector128.UInt32.1"] = ExtractVector128_UInt32_1, + ["ExtractVector128.UInt64.1"] = ExtractVector128_UInt64_1, + ["Floor.Vector64.Single"] = Floor_Vector64_Single, + ["Floor.Vector128.Single"] = Floor_Vector128_Single, + ["FloorScalar.Vector64.Double"] = FloorScalar_Vector64_Double, + ["FloorScalar.Vector64.Single"] = FloorScalar_Vector64_Single, + ["FusedAddHalving.Vector64.Byte"] = FusedAddHalving_Vector64_Byte, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs index 148fb9bb5b969..9b906de9804ce 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part5.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["ExtractVector128.Double.1"] = ExtractVector128_Double_1, - ["ExtractVector128.Int16.1"] = ExtractVector128_Int16_1, - ["ExtractVector128.Int32.1"] = ExtractVector128_Int32_1, - ["ExtractVector128.Int64.1"] = ExtractVector128_Int64_1, - ["ExtractVector128.SByte.1"] = ExtractVector128_SByte_1, - ["ExtractVector128.Single.1"] = ExtractVector128_Single_1, - ["ExtractVector128.UInt16.1"] = ExtractVector128_UInt16_1, - ["ExtractVector128.UInt32.1"] = ExtractVector128_UInt32_1, - ["ExtractVector128.UInt64.1"] = ExtractVector128_UInt64_1, - ["Floor.Vector64.Single"] = Floor_Vector64_Single, - ["Floor.Vector128.Single"] = Floor_Vector128_Single, - ["FloorScalar.Vector64.Double"] = FloorScalar_Vector64_Double, - ["FloorScalar.Vector64.Single"] = FloorScalar_Vector64_Single, - ["FusedAddHalving.Vector64.Byte"] = FusedAddHalving_Vector64_Byte, ["FusedAddHalving.Vector64.Int16"] = FusedAddHalving_Vector64_Int16, ["FusedAddHalving.Vector64.Int32"] = FusedAddHalving_Vector64_Int32, ["FusedAddHalving.Vector64.SByte"] = FusedAddHalving_Vector64_SByte, @@ -111,6 +97,20 @@ static Program() ["LeadingZeroCount.Vector128.UInt16"] = LeadingZeroCount_Vector128_UInt16, ["LeadingZeroCount.Vector128.UInt32"] = LeadingZeroCount_Vector128_UInt32, ["LoadAndInsertScalar.Vector64.Byte.7"] = LoadAndInsertScalar_Vector64_Byte_7, + ["LoadAndInsertScalar.Vector64.Int16.3"] = LoadAndInsertScalar_Vector64_Int16_3, + ["LoadAndInsertScalar.Vector64.Int32.1"] = LoadAndInsertScalar_Vector64_Int32_1, + ["LoadAndInsertScalar.Vector64.SByte.7"] = LoadAndInsertScalar_Vector64_SByte_7, + ["LoadAndInsertScalar.Vector64.Single.1"] = LoadAndInsertScalar_Vector64_Single_1, + ["LoadAndInsertScalar.Vector64.UInt16.3"] = LoadAndInsertScalar_Vector64_UInt16_3, + ["LoadAndInsertScalar.Vector64.UInt32.1"] = LoadAndInsertScalar_Vector64_UInt32_1, + ["LoadAndInsertScalar.Vector128.Byte.15"] = LoadAndInsertScalar_Vector128_Byte_15, + ["LoadAndInsertScalar.Vector128.Double.1"] = LoadAndInsertScalar_Vector128_Double_1, + ["LoadAndInsertScalar.Vector128.Int16.7"] = LoadAndInsertScalar_Vector128_Int16_7, + ["LoadAndInsertScalar.Vector128.Int32.3"] = LoadAndInsertScalar_Vector128_Int32_3, + ["LoadAndInsertScalar.Vector128.Int64.1"] = LoadAndInsertScalar_Vector128_Int64_1, + ["LoadAndInsertScalar.Vector128.SByte.15"] = LoadAndInsertScalar_Vector128_SByte_15, + ["LoadAndInsertScalar.Vector128.Single.3"] = LoadAndInsertScalar_Vector128_Single_3, + ["LoadAndInsertScalar.Vector128.UInt16.7"] = LoadAndInsertScalar_Vector128_UInt16_7, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs index 75ed085e957ce..87943f475dadd 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part6.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["LoadAndInsertScalar.Vector64.Int16.3"] = LoadAndInsertScalar_Vector64_Int16_3, - ["LoadAndInsertScalar.Vector64.Int32.1"] = LoadAndInsertScalar_Vector64_Int32_1, - ["LoadAndInsertScalar.Vector64.SByte.7"] = LoadAndInsertScalar_Vector64_SByte_7, - ["LoadAndInsertScalar.Vector64.Single.1"] = LoadAndInsertScalar_Vector64_Single_1, - ["LoadAndInsertScalar.Vector64.UInt16.3"] = LoadAndInsertScalar_Vector64_UInt16_3, - ["LoadAndInsertScalar.Vector64.UInt32.1"] = LoadAndInsertScalar_Vector64_UInt32_1, - ["LoadAndInsertScalar.Vector128.Byte.15"] = LoadAndInsertScalar_Vector128_Byte_15, - ["LoadAndInsertScalar.Vector128.Double.1"] = LoadAndInsertScalar_Vector128_Double_1, - ["LoadAndInsertScalar.Vector128.Int16.7"] = LoadAndInsertScalar_Vector128_Int16_7, - ["LoadAndInsertScalar.Vector128.Int32.3"] = LoadAndInsertScalar_Vector128_Int32_3, - ["LoadAndInsertScalar.Vector128.Int64.1"] = LoadAndInsertScalar_Vector128_Int64_1, - ["LoadAndInsertScalar.Vector128.SByte.15"] = LoadAndInsertScalar_Vector128_SByte_15, - ["LoadAndInsertScalar.Vector128.Single.3"] = LoadAndInsertScalar_Vector128_Single_3, - ["LoadAndInsertScalar.Vector128.UInt16.7"] = LoadAndInsertScalar_Vector128_UInt16_7, ["LoadAndInsertScalar.Vector128.UInt32.3"] = LoadAndInsertScalar_Vector128_UInt32_3, ["LoadAndInsertScalar.Vector128.UInt64.1"] = LoadAndInsertScalar_Vector128_UInt64_1, ["LoadAndReplicateToVector64.Byte"] = LoadAndReplicateToVector64_Byte, @@ -111,6 +97,20 @@ static Program() ["MinPairwise.Vector64.Single"] = MinPairwise_Vector64_Single, ["MinPairwise.Vector64.UInt16"] = MinPairwise_Vector64_UInt16, ["MinPairwise.Vector64.UInt32"] = MinPairwise_Vector64_UInt32, + ["Multiply.Vector64.Byte"] = Multiply_Vector64_Byte, + ["Multiply.Vector64.Int16"] = Multiply_Vector64_Int16, + ["Multiply.Vector64.Int32"] = Multiply_Vector64_Int32, + ["Multiply.Vector64.SByte"] = Multiply_Vector64_SByte, + ["Multiply.Vector64.Single"] = Multiply_Vector64_Single, + ["Multiply.Vector64.UInt16"] = Multiply_Vector64_UInt16, + ["Multiply.Vector64.UInt32"] = Multiply_Vector64_UInt32, + ["Multiply.Vector128.Byte"] = Multiply_Vector128_Byte, + ["Multiply.Vector128.Int16"] = Multiply_Vector128_Int16, + ["Multiply.Vector128.Int32"] = Multiply_Vector128_Int32, + ["Multiply.Vector128.SByte"] = Multiply_Vector128_SByte, + ["Multiply.Vector128.Single"] = Multiply_Vector128_Single, + ["Multiply.Vector128.UInt16"] = Multiply_Vector128_UInt16, + ["Multiply.Vector128.UInt32"] = Multiply_Vector128_UInt32, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs index 0e8787d6d1319..3debb286fb935 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part7.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["Multiply.Vector64.Byte"] = Multiply_Vector64_Byte, - ["Multiply.Vector64.Int16"] = Multiply_Vector64_Int16, - ["Multiply.Vector64.Int32"] = Multiply_Vector64_Int32, - ["Multiply.Vector64.SByte"] = Multiply_Vector64_SByte, - ["Multiply.Vector64.Single"] = Multiply_Vector64_Single, - ["Multiply.Vector64.UInt16"] = Multiply_Vector64_UInt16, - ["Multiply.Vector64.UInt32"] = Multiply_Vector64_UInt32, - ["Multiply.Vector128.Byte"] = Multiply_Vector128_Byte, - ["Multiply.Vector128.Int16"] = Multiply_Vector128_Int16, - ["Multiply.Vector128.Int32"] = Multiply_Vector128_Int32, - ["Multiply.Vector128.SByte"] = Multiply_Vector128_SByte, - ["Multiply.Vector128.Single"] = Multiply_Vector128_Single, - ["Multiply.Vector128.UInt16"] = Multiply_Vector128_UInt16, - ["Multiply.Vector128.UInt32"] = Multiply_Vector128_UInt32, ["MultiplyScalar.Vector64.Double"] = MultiplyScalar_Vector64_Double, ["MultiplyScalar.Vector64.Single"] = MultiplyScalar_Vector64_Single, ["MultiplyAdd.Vector64.Byte"] = MultiplyAdd_Vector64_Byte, @@ -111,6 +97,20 @@ static Program() ["MultiplyBySelectedScalarWideningLowerAndAdd.Vector64.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningLowerAndAdd_Vector64_UInt32_Vector128_UInt32_3, ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int16_Vector64_Int16_3, ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int16_Vector128_Int16_7, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector64_Int32_1, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector128_Int32_3, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector64_UInt16_3, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector128_UInt16_7, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector64_UInt32_1, + ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector128_UInt32_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector64_Int16_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector128_Int16_7, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector64_Int32_1, + ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector128_Int32_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector64_UInt16_3, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector128_UInt16_7, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector64_UInt32_1, + ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector128_UInt32_3, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs index 6949c30980887..84670aead920c 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part8.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector64_Int32_1, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_Int32_Vector128_Int32_3, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector64_UInt16_3, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt16_Vector128_UInt16_7, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector64_UInt32_1, - ["MultiplyBySelectedScalarWideningLowerAndSubtract.Vector64.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningLowerAndSubtract_Vector64_UInt32_Vector128_UInt32_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector64_Int16_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int16_Vector128_Int16_7, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector64_Int32_1, - ["MultiplyBySelectedScalarWideningUpper.Vector128.Int32.Vector128.Int32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_Int32_Vector128_Int32_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector64.UInt16.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector64_UInt16_3, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt16.Vector128.UInt16.7"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt16_Vector128_UInt16_7, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector64.UInt32.1"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector64_UInt32_1, - ["MultiplyBySelectedScalarWideningUpper.Vector128.UInt32.Vector128.UInt32.3"] = MultiplyBySelectedScalarWideningUpper_Vector128_UInt32_Vector128_UInt32_3, ["MultiplyBySelectedScalarWideningUpperAndAdd.Vector128.Int16.Vector64.Int16.3"] = MultiplyBySelectedScalarWideningUpperAndAdd_Vector128_Int16_Vector64_Int16_3, ["MultiplyBySelectedScalarWideningUpperAndAdd.Vector128.Int16.Vector128.Int16.7"] = MultiplyBySelectedScalarWideningUpperAndAdd_Vector128_Int16_Vector128_Int16_7, ["MultiplyBySelectedScalarWideningUpperAndAdd.Vector128.Int32.Vector64.Int32.1"] = MultiplyBySelectedScalarWideningUpperAndAdd_Vector128_Int32_Vector64_Int32_1, @@ -111,6 +97,20 @@ static Program() ["MultiplyRoundedDoublingByScalarSaturateHigh.Vector128.Int32"] = MultiplyRoundedDoublingByScalarSaturateHigh_Vector128_Int32, ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int16.Vector64.Int16.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int16_Vector64_Int16_3, ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int16.Vector128.Int16.7"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int16_Vector128_Int16_7, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector64_Int32_1, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector128_Int32_3, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector64.Int16.2"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector64_Int16_2, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector128.Int16.7"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector128_Int16_7, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector64_Int32_1, + ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector128_Int32_3, + ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int16, + ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int32, + ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int16, + ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int32, + ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector64.Single.1"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector64_Single_1, + ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector128.Single.3"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector128_Single_3, + ["MultiplySubtract.Vector64.Byte"] = MultiplySubtract_Vector64_Byte, + ["MultiplySubtract.Vector64.Int16"] = MultiplySubtract_Vector64_Int16, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs index 0b905b137f1cf..ac57e2481a568 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/Program.AdvSimd_Part9.cs @@ -11,20 +11,6 @@ public static partial class Program static Program() { TestList = new Dictionary() { - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector64_Int32_1, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector64.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector64_Int32_Vector128_Int32_3, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector64.Int16.2"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector64_Int16_2, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int16.Vector128.Int16.7"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int16_Vector128_Int16_7, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector64.Int32.1"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector64_Int32_1, - ["MultiplyRoundedDoublingBySelectedScalarSaturateHigh.Vector128.Int32.Vector128.Int32.3"] = MultiplyRoundedDoublingBySelectedScalarSaturateHigh_Vector128_Int32_Vector128_Int32_3, - ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int16, - ["MultiplyRoundedDoublingSaturateHigh.Vector64.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector64_Int32, - ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int16"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int16, - ["MultiplyRoundedDoublingSaturateHigh.Vector128.Int32"] = MultiplyRoundedDoublingSaturateHigh_Vector128_Int32, - ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector64.Single.1"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector64_Single_1, - ["MultiplyScalarBySelectedScalar.Vector64.Single.Vector128.Single.3"] = MultiplyScalarBySelectedScalar_Vector64_Single_Vector128_Single_3, - ["MultiplySubtract.Vector64.Byte"] = MultiplySubtract_Vector64_Byte, - ["MultiplySubtract.Vector64.Int16"] = MultiplySubtract_Vector64_Int16, ["MultiplySubtract.Vector64.Int32"] = MultiplySubtract_Vector64_Int32, ["MultiplySubtract.Vector64.SByte"] = MultiplySubtract_Vector64_SByte, ["MultiplySubtract.Vector64.UInt16"] = MultiplySubtract_Vector64_UInt16, @@ -111,6 +97,20 @@ static Program() ["NegateSaturate.Vector128.SByte"] = NegateSaturate_Vector128_SByte, ["NegateScalar.Vector64.Double"] = NegateScalar_Vector64_Double, ["NegateScalar.Vector64.Single"] = NegateScalar_Vector64_Single, + ["Not.Vector64.Byte"] = Not_Vector64_Byte, + ["Not.Vector64.Double"] = Not_Vector64_Double, + ["Not.Vector64.Int16"] = Not_Vector64_Int16, + ["Not.Vector64.Int32"] = Not_Vector64_Int32, + ["Not.Vector64.Int64"] = Not_Vector64_Int64, + ["Not.Vector64.SByte"] = Not_Vector64_SByte, + ["Not.Vector64.Single"] = Not_Vector64_Single, + ["Not.Vector64.UInt16"] = Not_Vector64_UInt16, + ["Not.Vector64.UInt32"] = Not_Vector64_UInt32, + ["Not.Vector64.UInt64"] = Not_Vector64_UInt64, + ["Not.Vector128.Byte"] = Not_Vector128_Byte, + ["Not.Vector128.Double"] = Not_Vector128_Double, + ["Not.Vector128.Int16"] = Not_Vector128_Int16, + ["Not.Vector128.Int32"] = Not_Vector128_Int32, }; } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx index 3c982923b8556..ec6da1aa16e20 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/GenerateTests.csx @@ -482,20 +482,6 @@ private static readonly (string templateFileName, Dictionary tem ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "ConvertToUInt32RoundToZero_Vector64_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ConvertToUInt32RoundToZero", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConvertToUInt32RoundToZero(firstOp[i]) != result[i]"}), ("SimpleVecOpTest.template", new Dictionary { ["TestName"] = "ConvertToUInt32RoundToZero_Vector128_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ConvertToUInt32RoundToZero", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConvertToUInt32RoundToZero(firstOp[i]) != result[i]"}), ("SimpleUnOpTest.template", new Dictionary { ["TestName"] = "ConvertToUInt32RoundToZeroScalar_Vector64_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "ConvertToUInt32RoundToZeroScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "Helpers.ConvertToUInt32RoundToZero(firstOp[0]) != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Byte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_SByte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_UInt16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Int16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_UInt32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Int32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector64_Single_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Byte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_SByte_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_UInt16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Int16_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_UInt32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Int32_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), - ("ZeroUnOpTest.template", new Dictionary { ["TestName"] = "CompareEqual_Vector128_Single_Zero", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "CompareEqual", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "firstOp[0] != result[0]", ["ValidateRemainingResults"] = "result[i] != 0"}), ("SimpleBinOpTest.template", new Dictionary { ["TestName"] = "DivideScalar_Vector64_Double", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "DivideScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateFirstResult"] = "BitConverter.DoubleToInt64Bits(Helpers.Divide(left[0], right[0])) != BitConverter.DoubleToInt64Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.DoubleToInt64Bits(result[i]) != 0"}), ("SimpleBinOpTest.template", new Dictionary { ["TestName"] = "DivideScalar_Vector64_Single", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "DivideScalar", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector64", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateFirstResult"] = "BitConverter.SingleToInt32Bits(Helpers.Divide(left[0], right[0])) != BitConverter.SingleToInt32Bits(result[0])", ["ValidateRemainingResults"] = "BitConverter.SingleToInt32Bits(result[i]) != 0"}), ("VecImmUnOpTest.template", new Dictionary { ["TestName"] = "DuplicateSelectedScalarToVector64_Vector64_Byte_1", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "DuplicateSelectedScalarToVector64", ["RetVectorType"] = "Vector64", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["Imm"] = "1", ["ValidateIterResult"] = "firstOp[Imm] != result[i]"}), diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template deleted file mode 100644 index e9570fedb65ea..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/ZeroUnOpTest.template +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void {TestName}() - { - var test = new ZeroUnOpTest__{TestName}(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if ({LoadIsa}.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // 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 - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__{TestName} - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable({Op1BaseType}[] inArray1, {RetBaseType}[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf<{RetBaseType}>(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public {Op1VectorType}<{Op1BaseType}> _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref testStruct._fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__{TestName} testClass) - { - var result = {Isa}.{Method}(_fld1, {Op1VectorType}<{Op1BaseType}>.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__{TestName} testClass) - { - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = {LargestVectorSize}; - - private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); - private static readonly int RetElementCount = Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>() / sizeof({RetBaseType}); - - private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; - - private static {Op1VectorType}<{Op1BaseType}> _clsVar1; - - private {Op1VectorType}<{Op1BaseType}> _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__{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 ZeroUnOpTest__{TestName}() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _fld1), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } - _dataTable = new DataTable(_data1, new {RetBaseType}[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => {Isa}.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = {Isa}.{Method}( - Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), - {Op1VectorType}<{Op1BaseType}>.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _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({Op1VectorType}<{Op1BaseType}>) }) - .Invoke(null, new object[] { - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)), - {Op1VectorType}<{Op1BaseType}>.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, ({RetVectorType}<{RetBaseType}>)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = {Isa}.{Method}( - _clsVar1, - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pClsVar1 = &_clsVar1) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pClsVar1)), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr); - var result = {Isa}.{Method}(op1, {Op1VectorType}<{Op1BaseType}>.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(_dataTable.inArray1Ptr)); - var result = {Isa}.{Method}(op1, {Op1VectorType}<{Op1BaseType}>.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__{TestName}(); - var result = {Isa}.{Method}(test._fld1, {Op1VectorType}<{Op1BaseType}>.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__{TestName}(); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &test._fld1) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = {Isa}.{Method}(_fld1, {Op1VectorType}<{Op1BaseType}>.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed ({Op1VectorType}<{Op1BaseType}>* pFld1 = &_fld1) - { - var result = {Isa}.{Method}( - {LoadIsa}.Load{Op1VectorType}(({Op1BaseType}*)(pFld1)), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = {Isa}.{Method}(test._fld1, {Op1VectorType}<{Op1BaseType}>.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _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)), - {Op1VectorType}<{Op1BaseType}>.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult({Op1VectorType}<{Op1BaseType}> op1, void* result, [CallerMemberName] string method = "") - { - {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; - {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; - {RetBaseType}[] outArray = new {RetBaseType}[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As<{RetBaseType}, byte>(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf<{RetVectorType}<{RetBaseType}>>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult({Op1BaseType}[] firstOp, {RetBaseType}[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}<{RetBaseType}>({Op1VectorType}<{Op1BaseType}>): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} From ad780ea0ffec0a6aa7ac08fdc586094c339e856a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 6 Jan 2022 11:28:45 -0800 Subject: [PATCH 12/59] Removing generated tests --- .../CompareEqual.Vector128.Byte.Zero.cs | 491 ------------------ .../CompareEqual.Vector128.Int16.Zero.cs | 491 ------------------ .../CompareEqual.Vector128.Int32.Zero.cs | 491 ------------------ .../CompareEqual.Vector128.SByte.Zero.cs | 491 ------------------ .../CompareEqual.Vector128.Single.Zero.cs | 491 ------------------ .../CompareEqual.Vector128.UInt16.Zero.cs | 491 ------------------ .../CompareEqual.Vector128.UInt32.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.Byte.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.Int16.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.Int32.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.SByte.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.Single.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.UInt16.Zero.cs | 491 ------------------ .../CompareEqual.Vector64.UInt32.Zero.cs | 491 ------------------ 14 files changed, 6874 deletions(-) delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs delete mode 100644 src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs deleted file mode 100644 index e3af2e5b402cf..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Byte.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_Byte_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Byte[] inArray1, Byte[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Byte*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Byte); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Byte); - - private static Byte[] _data1 = new Byte[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - _dataTable = new DataTable(_data1, new Byte[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Byte*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Byte_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Byte*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Byte*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Byte*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - Byte[] inArray1 = new Byte[Op1ElementCount]; - Byte[] outArray = new Byte[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Byte[] inArray1 = new Byte[Op1ElementCount]; - Byte[] outArray = new Byte[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs deleted file mode 100644 index 5cd7fffcf5bd1..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int16.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_Int16_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Int16[] inArray1, Int16[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int16*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int16); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int16); - - private static Int16[] _data1 = new Int16[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - _dataTable = new DataTable(_data1, new Int16[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int16*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Int16_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int16*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int16*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int16*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - Int16[] inArray1 = new Int16[Op1ElementCount]; - Int16[] outArray = new Int16[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Int16[] inArray1 = new Int16[Op1ElementCount]; - Int16[] outArray = new Int16[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs deleted file mode 100644 index 971ea322d3a98..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Int32.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_Int32_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Int32[] inArray1, Int32[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int32*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int32); - - private static Int32[] _data1 = new Int32[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - _dataTable = new DataTable(_data1, new Int32[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int32*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Int32_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int32*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int32*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Int32*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - Int32[] inArray1 = new Int32[Op1ElementCount]; - Int32[] outArray = new Int32[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Int32[] inArray1 = new Int32[Op1ElementCount]; - Int32[] outArray = new Int32[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs deleted file mode 100644 index 7c2c09d4ba9df..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.SByte.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_SByte_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(SByte[] inArray1, SByte[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((SByte*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(SByte); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(SByte); - - private static SByte[] _data1 = new SByte[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - _dataTable = new DataTable(_data1, new SByte[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((SByte*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_SByte_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((SByte*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((SByte*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((SByte*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - SByte[] inArray1 = new SByte[Op1ElementCount]; - SByte[] outArray = new SByte[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - SByte[] inArray1 = new SByte[Op1ElementCount]; - SByte[] outArray = new SByte[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs deleted file mode 100644 index 9d25d54c7b71f..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.Single.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_Single_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_Single_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_Single_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Single[] inArray1, Single[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_Single_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_Single_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Single*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Single); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); - - private static Single[] _data1 = new Single[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_Single_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_Single_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Single*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((Single*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Single*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((Single*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Single_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_Single_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Single*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Single*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((Single*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - Single[] inArray1 = new Single[Op1ElementCount]; - Single[] outArray = new Single[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Single[] inArray1 = new Single[Op1ElementCount]; - Single[] outArray = new Single[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs deleted file mode 100644 index bf1c618dbb907..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt16.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_UInt16_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt16*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt16); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt16); - - private static UInt16[] _data1 = new UInt16[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - _dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt16*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt16_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt16*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt16*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt16*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - UInt16[] inArray1 = new UInt16[Op1ElementCount]; - UInt16[] outArray = new UInt16[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - UInt16[] inArray1 = new UInt16[Op1ElementCount]; - UInt16[] outArray = new UInt16[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs deleted file mode 100644 index 8c10a98ba34d0..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector128.UInt32.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector128_UInt32_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(UInt32[] inArray1, UInt32[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector128 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero testClass) - { - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt32*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 16; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt32); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt32); - - private static UInt32[] _data1 = new UInt32[Op1ElementCount]; - - private static Vector128 _clsVar1; - - private Vector128 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - _dataTable = new DataTable(_data1, new UInt32[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), - Vector128.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector128)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector128* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt32*)(pClsVar1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector128_UInt32_Zero(); - - fixed (Vector128* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt32*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector128* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt32*)(pFld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector128.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector128((UInt32*)(&test._fld1)), - Vector128.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector128 op1, void* result, [CallerMemberName] string method = "") - { - UInt32[] inArray1 = new UInt32[Op1ElementCount]; - UInt32[] outArray = new UInt32[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - UInt32[] inArray1 = new UInt32[Op1ElementCount]; - UInt32[] outArray = new UInt32[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector128): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs deleted file mode 100644 index 189fa642ce0ea..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Byte.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_Byte_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Byte[] inArray1, Byte[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Byte*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Byte); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Byte); - - private static Byte[] _data1 = new Byte[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetByte(); } - _dataTable = new DataTable(_data1, new Byte[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Byte*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((Byte*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Byte_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Byte*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Byte*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Byte*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - Byte[] inArray1 = new Byte[Op1ElementCount]; - Byte[] outArray = new Byte[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Byte[] inArray1 = new Byte[Op1ElementCount]; - Byte[] outArray = new Byte[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Byte[] firstOp, Byte[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs deleted file mode 100644 index f05a70b16cb98..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int16.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_Int16_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Int16[] inArray1, Int16[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int16*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int16); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int16); - - private static Int16[] _data1 = new Int16[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt16(); } - _dataTable = new DataTable(_data1, new Int16[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int16*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((Int16*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Int16_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int16*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int16*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int16*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - Int16[] inArray1 = new Int16[Op1ElementCount]; - Int16[] outArray = new Int16[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Int16[] inArray1 = new Int16[Op1ElementCount]; - Int16[] outArray = new Int16[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Int16[] firstOp, Int16[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs deleted file mode 100644 index e944fd88150b5..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Int32.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_Int32_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Int32[] inArray1, Int32[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int32*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Int32); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Int32); - - private static Int32[] _data1 = new Int32[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetInt32(); } - _dataTable = new DataTable(_data1, new Int32[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int32*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((Int32*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Int32_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int32*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int32*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Int32*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - Int32[] inArray1 = new Int32[Op1ElementCount]; - Int32[] outArray = new Int32[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Int32[] inArray1 = new Int32[Op1ElementCount]; - Int32[] outArray = new Int32[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Int32[] firstOp, Int32[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs deleted file mode 100644 index 012c06d7431b5..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.SByte.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_SByte_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(SByte[] inArray1, SByte[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((SByte*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(SByte); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(SByte); - - private static SByte[] _data1 = new SByte[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSByte(); } - _dataTable = new DataTable(_data1, new SByte[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((SByte*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((SByte*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_SByte_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((SByte*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((SByte*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((SByte*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - SByte[] inArray1 = new SByte[Op1ElementCount]; - SByte[] outArray = new SByte[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - SByte[] inArray1 = new SByte[Op1ElementCount]; - SByte[] outArray = new SByte[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(SByte[] firstOp, SByte[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs deleted file mode 100644 index df109aaadd622..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.Single.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_Single_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_Single_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_Single_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(Single[] inArray1, Single[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_Single_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_Single_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Single*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(Single); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(Single); - - private static Single[] _data1 = new Single[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_Single_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_Single_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetSingle(); } - _dataTable = new DataTable(_data1, new Single[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Single*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((Single*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Single_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_Single_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Single*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Single*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((Single*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - Single[] inArray1 = new Single[Op1ElementCount]; - Single[] outArray = new Single[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - Single[] inArray1 = new Single[Op1ElementCount]; - Single[] outArray = new Single[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(Single[] firstOp, Single[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs deleted file mode 100644 index fb19e1773bcdc..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt16.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_UInt16_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(UInt16[] inArray1, UInt16[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt16*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt16); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt16); - - private static UInt16[] _data1 = new UInt16[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt16(); } - _dataTable = new DataTable(_data1, new UInt16[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt16*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((UInt16*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt16_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt16*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt16*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt16*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - UInt16[] inArray1 = new UInt16[Op1ElementCount]; - UInt16[] outArray = new UInt16[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - UInt16[] inArray1 = new UInt16[Op1ElementCount]; - UInt16[] outArray = new UInt16[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(UInt16[] firstOp, UInt16[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs b/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs deleted file mode 100644 index 3eb92f0bc6b68..0000000000000 --- a/src/tests/JIT/HardwareIntrinsics/Arm/AdvSimd/CompareEqual.Vector64.UInt32.Zero.cs +++ /dev/null @@ -1,491 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -/****************************************************************************** - * This file is auto-generated from a template file by the GenerateTests.csx * - * script in tests\src\JIT\HardwareIntrinsics.Arm\Shared. In order to make * - * changes, please update the corresponding template and run according to the * - * directions listed in the file. * - ******************************************************************************/ - -using System; -using System.Runtime.CompilerServices; -using System.Runtime.InteropServices; -using System.Runtime.Intrinsics; -using System.Runtime.Intrinsics.Arm; - -namespace JIT.HardwareIntrinsics.Arm -{ - public static partial class Program - { - private static void CompareEqual_Vector64_UInt32_Zero() - { - var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero(); - - if (test.IsSupported) - { - // Validates basic functionality works, using Unsafe.Read - test.RunBasicScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates basic functionality works, using Load - test.RunBasicScenario_Load(); - } - - // Validates calling via reflection works, using Unsafe.Read - test.RunReflectionScenario_UnsafeRead(); - - if (AdvSimd.IsSupported) - { - // Validates calling via reflection works, using Load - test.RunReflectionScenario_Load(); - } - - // Validates passing a static member works - test.RunClsVarScenario(); - - if (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing a local works, using Load - test.RunLclVarScenario_Load(); - } - - // Validates passing the field of a local class works - test.RunClassLclFldScenario(); - - if (AdvSimd.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 (AdvSimd.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 (AdvSimd.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 (AdvSimd.IsSupported) - { - // Validates passing an instance member of a struct works, using pinning and Load - test.RunStructFldScenario_Load(); - } - } - else - { - // Validates we throw on unsupported hardware - test.RunUnsupportedScenario(); - } - - if (!test.Succeeded) - { - throw new Exception("One or more scenarios did not complete as expected."); - } - } - } - - public sealed unsafe class ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero - { - private struct DataTable - { - private byte[] inArray1; - private byte[] outArray; - - private GCHandle inHandle1; - private GCHandle outHandle; - - private ulong alignment; - - public DataTable(UInt32[] inArray1, UInt32[] outArray, int alignment) - { - int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf(); - int sizeOfoutArray = outArray.Length * Unsafe.SizeOf(); - if ((alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfoutArray) - { - throw new ArgumentException("Invalid value of alignment"); - } - - this.inArray1 = new byte[alignment * 2]; - this.outArray = new byte[alignment * 2]; - - this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); - this.outHandle = GCHandle.Alloc(this.outArray, GCHandleType.Pinned); - - this.alignment = (ulong)alignment; - - Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As(ref inArray1[0]), (uint)sizeOfinArray1); - } - - public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); - public void* outArrayPtr => Align((byte*)(outHandle.AddrOfPinnedObject().ToPointer()), alignment); - - public void Dispose() - { - inHandle1.Free(); - outHandle.Free(); - } - - private static unsafe void* Align(byte* buffer, ulong expectedAlignment) - { - return (void*)(((ulong)buffer + expectedAlignment - 1) & ~(expectedAlignment - 1)); - } - } - - private struct TestStruct - { - public Vector64 _fld1; - - public static TestStruct Create() - { - var testStruct = new TestStruct(); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref testStruct._fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - return testStruct; - } - - public void RunStructFldScenario(ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero testClass) - { - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - - public void RunStructFldScenario_Load(ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero testClass) - { - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt32*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(testClass._dataTable.outArrayPtr, result); - testClass.ValidateResult(_fld1, testClass._dataTable.outArrayPtr); - } - } - } - - private static readonly int LargestVectorSize = 8; - - private static readonly int Op1ElementCount = Unsafe.SizeOf>() / sizeof(UInt32); - private static readonly int RetElementCount = Unsafe.SizeOf>() / sizeof(UInt32); - - private static UInt32[] _data1 = new UInt32[Op1ElementCount]; - - private static Vector64 _clsVar1; - - private Vector64 _fld1; - - private DataTable _dataTable; - - static ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero() - { - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _clsVar1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - } - - public ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero() - { - Succeeded = true; - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - Unsafe.CopyBlockUnaligned(ref Unsafe.As, byte>(ref _fld1), ref Unsafe.As(ref _data1[0]), (uint)Unsafe.SizeOf>()); - - for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = TestLibrary.Generator.GetUInt32(); } - _dataTable = new DataTable(_data1, new UInt32[RetElementCount], LargestVectorSize); - } - - public bool IsSupported => AdvSimd.IsSupported; - - public bool Succeeded { get; set; } - - public void RunBasicScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); - - var result = AdvSimd.CompareEqual( - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunBasicScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); - - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - Unsafe.Read>(_dataTable.inArray1Ptr), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunReflectionScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); - - var result = typeof(AdvSimd).GetMethod(nameof(AdvSimd.CompareEqual), new Type[] { typeof(Vector64), typeof(Vector64) }) - .Invoke(null, new object[] { - AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)), - Vector64.Zero - }); - - Unsafe.Write(_dataTable.outArrayPtr, (Vector64)(result)); - ValidateResult(_dataTable.inArray1Ptr, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); - - var result = AdvSimd.CompareEqual( - _clsVar1, - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - - public void RunClsVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load)); - - fixed (Vector64* pClsVar1 = &_clsVar1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt32*)(pClsVar1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_clsVar1, _dataTable.outArrayPtr); - } - } - - public void RunLclVarScenario_UnsafeRead() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); - - var op1 = Unsafe.Read>(_dataTable.inArray1Ptr); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunLclVarScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); - - var op1 = AdvSimd.LoadVector64((UInt32*)(_dataTable.inArray1Ptr)); - var result = AdvSimd.CompareEqual(op1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(op1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunClassLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load)); - - var test = new ZeroUnOpTest__CompareEqual_Vector64_UInt32_Zero(); - - fixed (Vector64* pFld1 = &test._fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt32*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - } - - public void RunClassFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); - - var result = AdvSimd.CompareEqual(_fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - - public void RunClassFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load)); - - fixed (Vector64* pFld1 = &_fld1) - { - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt32*)(pFld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(_fld1, _dataTable.outArrayPtr); - } - } - - public void RunStructLclFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual(test._fld1, Vector64.Zero); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructLclFldScenario_Load() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load)); - - var test = TestStruct.Create(); - var result = AdvSimd.CompareEqual( - AdvSimd.LoadVector64((UInt32*)(&test._fld1)), - Vector64.Zero - ); - - Unsafe.Write(_dataTable.outArrayPtr, result); - ValidateResult(test._fld1, _dataTable.outArrayPtr); - } - - public void RunStructFldScenario() - { - TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); - - var test = TestStruct.Create(); - 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)); - - bool succeeded = false; - - try - { - RunBasicScenario_UnsafeRead(); - } - catch (PlatformNotSupportedException) - { - succeeded = true; - } - - if (!succeeded) - { - Succeeded = false; - } - } - - private void ValidateResult(Vector64 op1, void* result, [CallerMemberName] string method = "") - { - UInt32[] inArray1 = new UInt32[Op1ElementCount]; - UInt32[] outArray = new UInt32[RetElementCount]; - - Unsafe.WriteUnaligned(ref Unsafe.As(ref inArray1[0]), op1); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(void* op1, void* result, [CallerMemberName] string method = "") - { - UInt32[] inArray1 = new UInt32[Op1ElementCount]; - UInt32[] outArray = new UInt32[RetElementCount]; - - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf>()); - Unsafe.CopyBlockUnaligned(ref Unsafe.As(ref outArray[0]), ref Unsafe.AsRef(result), (uint)Unsafe.SizeOf>()); - - ValidateResult(inArray1, outArray, method); - } - - private void ValidateResult(UInt32[] firstOp, UInt32[] result, [CallerMemberName] string method = "") - { - bool succeeded = true; - - {TemplateValidationLogic} - - if (!succeeded) - { - TestLibrary.TestFramework.LogInformation($"{nameof(AdvSimd)}.{nameof(AdvSimd.CompareEqual)}(Vector64): {method} failed:"); - TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); - TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); - TestLibrary.TestFramework.LogInformation(string.Empty); - - Succeeded = false; - } - } - } -} From 83c26ab3aa33300463880d281282d722d05bce64 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 6 Jan 2022 12:58:50 -0800 Subject: [PATCH 13/59] Added CompareEqual tests --- .../JitBlue/GitHub_33972/GitHub_33972.cs | 351 ++++++++++++++++++ .../JitBlue/GitHub_33972/GitHub_33972.csproj | 25 ++ 2 files changed, 376 insertions(+) create mode 100644 src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.cs create mode 100644 src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.cs b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.cs new file mode 100644 index 0000000000000..dac9a8172a515 --- /dev/null +++ b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.cs @@ -0,0 +1,351 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; + +class Program +{ + // CompareEqual + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Byte_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_SByte_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_UInt16_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Int16_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_UInt32_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Int32_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Single_Zero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Byte_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_SByte_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_UInt16_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Int16_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_UInt32_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Int32_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Single_Zero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Zero); + } + + // CompareEqual Swapped + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Byte_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_SByte_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_UInt16_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Int16_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_UInt32_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Int32_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Single_Zero_Swapped(Vector64 right) + { + return AdvSimd.CompareEqual(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Byte_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_SByte_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_UInt16_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Int16_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_UInt32_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Int32_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Single_Zero_Swapped(Vector128 right) + { + return AdvSimd.CompareEqual(Vector128.Zero, right); + } + + // Validation + + unsafe static bool ValidateResult_Vector64(Vector64 result, T expectedElementValue) where T: unmanaged + { + var succeeded = true; + + for (var i = 0; i < (8 / sizeof(T)); i++) + { + if (!result.GetElement(i).Equals(expectedElementValue)) + { + succeeded = false; + } + } + + return succeeded; + } + + unsafe static bool ValidateResult_Vector128(Vector128 result, T expectedElementValue) where T : unmanaged + { + var succeeded = true; + + for (var i = 0; i < (16 / sizeof(T)); i++) + { + if (!result.GetElement(i).Equals(expectedElementValue)) + { + succeeded = false; + } + } + + return succeeded; + } + + static int Tests() + { + var result = 0; + + // Begin CompareEqual Tests + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Byte_Zero(Vector64.Zero), Byte.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_SByte_Zero(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_UInt16_Zero(Vector64.Zero), UInt16.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Int16_Zero(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_UInt32_Zero(Vector64.Zero), UInt32.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Int32_Zero(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Single_Zero(Vector64.Zero), Single.NaN)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Byte_Zero(Vector128.Zero), Byte.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_SByte_Zero(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_UInt16_Zero(Vector128.Zero), UInt16.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Int16_Zero(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_UInt32_Zero(Vector128.Zero), UInt32.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Int32_Zero(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_Zero(Vector128.Zero), Single.NaN)) + result = -1; + + // End CompareEqual Tests + + return result; + } + + static int Tests_Swapped() + { + var result = 0; + + // Begin CompareEqual Tests + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Byte_Zero_Swapped(Vector64.Zero), Byte.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_SByte_Zero_Swapped(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_UInt16_Zero_Swapped(Vector64.Zero), UInt16.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Int16_Zero_Swapped(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_UInt32_Zero_Swapped(Vector64.Zero), UInt32.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Int32_Zero_Swapped(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Single_Zero_Swapped(Vector64.Zero), Single.NaN)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Byte_Zero_Swapped(Vector128.Zero), Byte.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_SByte_Zero_Swapped(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_UInt16_Zero_Swapped(Vector128.Zero), UInt16.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Int16_Zero_Swapped(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_UInt32_Zero_Swapped(Vector128.Zero), UInt32.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Int32_Zero_Swapped(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_Zero_Swapped(Vector128.Zero), Single.NaN)) + result = -1; + + // End CompareEqual Tests + + return result; + } + + static int Main(string[] args) + { + var result = 0; + + if (AdvSimd.IsSupported) + { + Console.WriteLine("Testing AdvSimd"); + + result = Tests(); + if(result != -1) + { + result = Tests_Swapped(); + } + + if (result == -1) + { + Console.WriteLine("AdvSimd Tests Failed"); + } + else + { + Console.WriteLine("AdvSimd Tests Passed"); + } + } + else + { + Console.WriteLine("Skipped AdvSimd Tests"); + } + + return result; + } +} diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj new file mode 100644 index 0000000000000..8f2c8355c3f11 --- /dev/null +++ b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj @@ -0,0 +1,25 @@ + + + Exe + + + None + True + + + + + + + + + From 9f7e7da301789601a6b93b21b262004d9ad2ff00 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 6 Jan 2022 13:15:12 -0800 Subject: [PATCH 14/59] Supporting containment for first operand --- src/coreclr/jit/lowerarmarch.cpp | 6 ++- src/coreclr/jit/lsraarm64.cpp | 67 ++++++++++++++++++-------------- 2 files changed, 43 insertions(+), 30 deletions(-) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 66c89c4de57d5..91aad49405a8a 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1855,7 +1855,11 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) case NI_AdvSimd_CompareEqual: { - if (intrin.op2->IsVectorZero()) + if (intrin.op1->IsVectorZero()) + { + MakeSrcContained(node, intrin.op1); + } + else if (intrin.op2->IsVectorZero()) { MakeSrcContained(node, intrin.op2); } diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index 6773d68622c3b..d4d5f140833f2 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1011,40 +1011,49 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) if (intrin.op1 != nullptr) { - bool simdRegToSimdRegMove = false; - - if ((intrin.id == NI_Vector64_CreateScalarUnsafe) || (intrin.id == NI_Vector128_CreateScalarUnsafe)) - { - simdRegToSimdRegMove = varTypeIsFloating(intrin.op1); - } - else if (intrin.id == NI_AdvSimd_Arm64_DuplicateToVector64) + // Do not give a register to the second operand if it is contained. + if (!hasImmediateOperand && intrin.op1->isContained()) { - simdRegToSimdRegMove = (intrin.op1->TypeGet() == TYP_DOUBLE); + assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); + assert(intrin.op1->IsVectorZero()); } - else if ((intrin.id == NI_Vector64_ToScalar) || (intrin.id == NI_Vector128_ToScalar)) + else { - simdRegToSimdRegMove = varTypeIsFloating(intrinsicTree); - } + bool simdRegToSimdRegMove = false; - // If we have an RMW intrinsic or an intrinsic with simple move semantic between two SIMD registers, - // we want to preference op1Reg to the target if op1 is not contained. - if (isRMW || simdRegToSimdRegMove) - { - tgtPrefOp1 = !intrin.op1->isContained(); - } + if ((intrin.id == NI_Vector64_CreateScalarUnsafe) || (intrin.id == NI_Vector128_CreateScalarUnsafe)) + { + simdRegToSimdRegMove = varTypeIsFloating(intrin.op1); + } + else if (intrin.id == NI_AdvSimd_Arm64_DuplicateToVector64) + { + simdRegToSimdRegMove = (intrin.op1->TypeGet() == TYP_DOUBLE); + } + else if ((intrin.id == NI_Vector64_ToScalar) || (intrin.id == NI_Vector128_ToScalar)) + { + simdRegToSimdRegMove = varTypeIsFloating(intrinsicTree); + } - if (intrinsicTree->OperIsMemoryLoadOrStore()) - { - srcCount += BuildAddrUses(intrin.op1); - } - else if (tgtPrefOp1) - { - tgtPrefUse = BuildUse(intrin.op1); - srcCount++; - } - else - { - srcCount += BuildOperandUses(intrin.op1); + // If we have an RMW intrinsic or an intrinsic with simple move semantic between two SIMD registers, + // we want to preference op1Reg to the target if op1 is not contained. + if (isRMW || simdRegToSimdRegMove) + { + tgtPrefOp1 = !intrin.op1->isContained(); + } + + if (intrinsicTree->OperIsMemoryLoadOrStore()) + { + srcCount += BuildAddrUses(intrin.op1); + } + else if (tgtPrefOp1) + { + tgtPrefUse = BuildUse(intrin.op1); + srcCount++; + } + else + { + srcCount += BuildOperandUses(intrin.op1); + } } } From 1e674151386d1661c161e90623a02c0c111da88e Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 6 Jan 2022 13:16:44 -0800 Subject: [PATCH 15/59] Fix test build --- .../JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj | 1 + 1 file changed, 1 insertion(+) diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj index 8f2c8355c3f11..69a8f62fa0e12 100644 --- a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj +++ b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj @@ -5,6 +5,7 @@ None True + True - - diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs similarity index 100% rename from src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.cs rename to src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.csproj b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.csproj new file mode 100644 index 0000000000000..bf6f589eb325b --- /dev/null +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.csproj @@ -0,0 +1,13 @@ + + + Exe + + + None + True + True + + + + + From bc7a557faccf785db88d33bba6b05f50b396a2ed Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 11:16:42 -0800 Subject: [PATCH 23/59] Adding AdvSimd_Arm64 tests: --- .../JitBlue/Runtime_33972/Runtime_33972.cs | 188 +++++++++++++++++- 1 file changed, 180 insertions(+), 8 deletions(-) diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index 94b322ebf25d8..1410f2cf69fd5 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -94,6 +94,48 @@ static Vector128 AdvSimd_CompareEqual_Vector128_Single_Zero(Vector128.Zero); } + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128 left) + { + return AdvSimd.Arm64.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_UInt64_Zero(Vector128 left) + { + return AdvSimd.Arm64.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero(Vector128 left) + { + return AdvSimd.Arm64.CompareEqual(left, Vector128.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero(Vector64 left) + { + return AdvSimd.Arm64.CompareEqualScalar(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero(Vector64 left) + { + return AdvSimd.Arm64.CompareEqualScalar(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero(Vector64 left) + { + return AdvSimd.Arm64.CompareEqualScalar(left, Vector64.Zero); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero(Vector64 left) + { + return AdvSimd.Arm64.CompareEqualScalar(left, Vector64.Zero); + } + // CompareEqual Swapped [MethodImpl(MethodImplOptions.NoInlining)] @@ -180,6 +222,48 @@ static Vector128 AdvSimd_CompareEqual_Vector128_Single_Zero_Swapped(Vecto return AdvSimd.CompareEqual(Vector128.Zero, right); } + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero_Swapped(Vector128 right) + { + return AdvSimd.Arm64.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_UInt64_Zero_Swapped(Vector128 right) + { + return AdvSimd.Arm64.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero_Swapped(Vector128 right) + { + return AdvSimd.Arm64.CompareEqual(Vector128.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero_Swapped(Vector64 right) + { + return AdvSimd.Arm64.CompareEqualScalar(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero_Swapped(Vector64 right) + { + return AdvSimd.Arm64.CompareEqualScalar(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero_Swapped(Vector64 right) + { + return AdvSimd.Arm64.CompareEqualScalar(Vector64.Zero, right); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero_Swapped(Vector64 right) + { + return AdvSimd.Arm64.CompareEqualScalar(Vector64.Zero, right); + } + // Validation unsafe static bool ValidateResult_Vector64(Vector64 result, T expectedElementValue) where T: unmanaged @@ -212,9 +296,9 @@ unsafe static bool ValidateResult_Vector128(Vector128 result, T expectedEl return succeeded; } - static int Tests() + static int Tests_AdvSimd() { - var result = 100; + var result = 0; // Begin CompareEqual Tests @@ -265,9 +349,9 @@ static int Tests() return result; } - static int Tests_Swapped() + static int Tests_AdvSimd_Swapped() { - var result = 100; + var result = 0; // Begin CompareEqual Tests @@ -318,20 +402,84 @@ static int Tests_Swapped() return result; } + static int Tests_AdvSimd_Arm64() + { + var result = 0; + + // Begin CompareEqual Tests + + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128.Zero), Double.NaN)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_UInt64_Zero(Vector128.Zero), UInt64.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero(Vector64.Zero), Single.NaN)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero(Vector64.Zero), Double.NaN)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero(Vector64.Zero), UInt64.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero(Vector64.Zero), -1)) + result = -1; + + // End CompareEqual Tests + + return result; + } + + static int Tests_AdvSimd_Arm64_Swapped() + { + var result = 0; + + // Begin CompareEqual Tests + + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero_Swapped(Vector128.Zero), Double.NaN)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_UInt64_Zero_Swapped(Vector128.Zero), UInt64.MaxValue)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero_Swapped(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero_Swapped(Vector64.Zero), Single.NaN)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero_Swapped(Vector64.Zero), Double.NaN)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero_Swapped(Vector64.Zero), UInt64.MaxValue)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero_Swapped(Vector64.Zero), -1)) + result = -1; + + // End CompareEqual Tests + + return result; + } + static int Main(string[] args) { - var result = 100; + var result = 0; if (AdvSimd.IsSupported) { Console.WriteLine("Testing AdvSimd"); - result = Tests(); + result = Tests_AdvSimd(); if(result != -1) { - result = Tests_Swapped(); + result = Tests_AdvSimd_Swapped(); } - + if (result == -1) { Console.WriteLine("AdvSimd Tests Failed"); @@ -346,6 +494,30 @@ static int Main(string[] args) Console.WriteLine("Skipped AdvSimd Tests"); } + if (AdvSimd.Arm64.IsSupported) + { + Console.WriteLine("Testing AdvSimd_Arm64"); + + result = Tests_AdvSimd_Arm64(); + if (result != -1) + { + result = Tests_AdvSimd_Arm64_Swapped(); + } + + if (result == -1) + { + Console.WriteLine("AdvSimd_Arm64 Tests Failed"); + } + else + { + Console.WriteLine("AdvSimd_Arm64 Tests Passed"); + } + } + else + { + Console.WriteLine("Skipped AdvSimd_Arm64 Tests"); + } + return result; } } From 5939f36f14703f1ec448a205d0d4c1447dcb4309 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 11:41:58 -0800 Subject: [PATCH 24/59] Adding support for rest of 'cmeq' and 'fcmeq' instructions --- src/coreclr/jit/emitarm64.cpp | 12 +++++++++++- src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 2 ++ src/coreclr/jit/hwintrinsiclistarm64.h | 4 ++-- src/coreclr/jit/instrsarm64.h | 8 ++++---- src/coreclr/jit/lowerarmarch.cpp | 2 ++ 5 files changed, 21 insertions(+), 7 deletions(-) diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index b021a0e71baaf..275d256844d96 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -12971,6 +12971,11 @@ void emitter::emitDispIns( emitDispVectorReg(id->idReg1(), id->idInsOpt(), true); emitDispVectorReg(id->idReg2(), id->idInsOpt(), false); } + if (ins == INS_fcmeq) + { + printf(", "); + emitDispImm(0, false); + } break; case IF_DV_2P: // DV_2P ................ ......nnnnnddddd Vd Vn (aes*, sha1su1) @@ -12993,7 +12998,7 @@ void emitter::emitDispIns( if (ins == INS_cmeq) { printf(", "); - emitDispFloatZero(); + emitDispImm(0, false); } break; @@ -13131,6 +13136,11 @@ void emitter::emitDispIns( emitDispReg(id->idReg1(), size, true); emitDispReg(id->idReg2(), size, false); } + if ((fmt == IF_DV_2L && ins == INS_cmeq) || (fmt == IF_DV_2G && ins == INS_fcmeq)) + { + printf(", "); + emitDispImm(0, false); + } break; case IF_DV_2H: // DV_2H X........X...... ......nnnnnddddd Rd Vn (fmov, fcvtXX - to general) diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index f1b3a38023163..e4b9a1326680c 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -497,6 +497,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; case NI_AdvSimd_CompareEqual: + case NI_AdvSimd_Arm64_CompareEqual: + case NI_AdvSimd_Arm64_CompareEqualScalar: if (intrin.op1->isContained()) { assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h index 67decddf2f8ed..7b0ed86e3c529 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/jit/hwintrinsiclistarm64.h @@ -466,8 +466,8 @@ HARDWARE_INTRINSIC(AdvSimd_Arm64, AddPairwiseScalar, HARDWARE_INTRINSIC(AdvSimd_Arm64, AddSaturate, -1, 2, {INS_suqadd, INS_usqadd, INS_suqadd, INS_usqadd, INS_suqadd, INS_usqadd, INS_suqadd, INS_usqadd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(AdvSimd_Arm64, AddSaturateScalar, 8, 2, {INS_sqadd, INS_uqadd, INS_sqadd, INS_uqadd, INS_sqadd, INS_uqadd, INS_suqadd, INS_usqadd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(AdvSimd_Arm64, Ceiling, 16, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_frintp}, HW_Category_SIMD, HW_Flag_NoFlag) -HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareEqual, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmeq, INS_cmeq, INS_invalid, INS_fcmeq}, HW_Category_SIMD, HW_Flag_Commutative) -HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareEqualScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmeq, INS_cmeq, INS_fcmeq, INS_fcmeq}, HW_Category_SIMD, HW_Flag_Commutative|HW_Flag_SIMDScalar) +HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareEqual, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmeq, INS_cmeq, INS_invalid, INS_fcmeq}, HW_Category_SIMD, HW_Flag_Commutative|HW_Flag_SpecialCodeGen|HW_Flag_SupportsContainment) +HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareEqualScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmeq, INS_cmeq, INS_fcmeq, INS_fcmeq}, HW_Category_SIMD, HW_Flag_Commutative|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_SupportsContainment) HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareGreaterThan, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmgt, INS_cmhi, INS_invalid, INS_fcmgt}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareGreaterThanOrEqual, 16, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmge, INS_cmhs, INS_invalid, INS_fcmge}, HW_Category_SIMD, HW_Flag_NoFlag) HARDWARE_INTRINSIC(AdvSimd_Arm64, CompareGreaterThanOrEqualScalar, 8, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_cmge, INS_cmhs, INS_fcmge, INS_fcmge}, HW_Category_SIMD, HW_Flag_SIMDScalar) diff --git a/src/coreclr/jit/instrsarm64.h b/src/coreclr/jit/instrsarm64.h index 48d69a83fc12b..d4e7ef5b10c8d 100644 --- a/src/coreclr/jit/instrsarm64.h +++ b/src/coreclr/jit/instrsarm64.h @@ -312,8 +312,8 @@ INST4(neg, "neg", 0, IF_EN4G, 0x4B0003E0, 0x4B0003E0, INST4(cmeq, "cmeq", 0, IF_EN4H, 0x7EE08C00, 0x2E208C00, 0x5E209800, 0x0E209800) // cmeq Vd,Vn,Vm DV_3E 01111110111mmmmm 100011nnnnnddddd 7EE0 8C00 Vd,Vn,Vm (scalar) // cmeq Vd,Vn,Vm DV_3A 0Q101110XX1mmmmm 100011nnnnnddddd 2E20 8C00 Vd,Vn,Vm (vector) - // cmeq Vd,Vn DV_2L 01011110XX100000 100110nnnnnddddd 5E20 9800 Vd,Vn,#0 (scalar - with zero) - // cmeq Vd,Vn DV_2M 0Q001110XX100000 100110nnnnnddddd 0E20 9800 Vd,Vn,#0 (vector - with zero) + // cmeq Vd,Vn,#0 DV_2L 01011110XX100000 100110nnnnnddddd 5E20 9800 Vd,Vn,#0 (scalar - with zero) + // cmeq Vd,Vn,#0 DV_2M 0Q001110XX100000 100110nnnnnddddd 0E20 9800 Vd,Vn,#0 (vector - with zero) INST4(cmge, "cmge", 0, IF_EN4H, 0x5EE03C00, 0x0E203C00, 0x7E208800, 0x2E208800) // cmge Vd,Vn,Vm DV_3E 01011110111mmmmm 001111nnnnnddddd 5EE0 3C00 Vd,Vn,Vm (scalar) @@ -331,8 +331,8 @@ INST4(cmgt, "cmgt", 0, IF_EN4H, 0x5EE03400, 0x0E203400, INST4(fcmeq, "fcmeq", 0, IF_EN4I, 0x5E20E400, 0x0E20E400, 0x5EA0D800, 0x0EA0D800) // fcmeq Vd,Vn,Vm DV_3D 010111100X1mmmmm 111001nnnnnddddd 5E20 E400 Vd Vn Vm (scalar) // fcmeq Vd,Vn,Vm DV_3B 0Q0011100X1mmmmm 111001nnnnnddddd 0E20 E400 Vd,Vn,Vm (vector) - // fcmeq Vd,Vn DV_2G 010111101X100000 110110nnnnnddddd 5EA0 D800 Vd Vn (scalar) - // fcmeq Vd,Vn DV_2A 0Q0011101X100000 110110nnnnnddddd 0EA0 D800 Vd Vn (vector) + // fcmeq Vd,Vn,#0 DV_2G 010111101X100000 110110nnnnnddddd 5EA0 D800 Vd Vn,#0 (scalar - with zero) + // fcmeq Vd,Vn,#0 DV_2A 0Q0011101X100000 110110nnnnnddddd 0EA0 D800 Vd Vn,#0 (vector - with zero) INST4(fcmge, "fcmge", 0, IF_EN4I, 0x7E20E400, 0x2E20E400, 0x7EA0C800, 0x2EA0C800) // fcmge Vd,Vn,Vm DV_3D 011111100X1mmmmm 111001nnnnnddddd 7E20 E400 Vd Vn Vm (scalar) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 91aad49405a8a..0ea3508269294 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1854,6 +1854,8 @@ void Lowering::ContainCheckHWIntrinsic(GenTreeHWIntrinsic* node) break; case NI_AdvSimd_CompareEqual: + case NI_AdvSimd_Arm64_CompareEqual: + case NI_AdvSimd_Arm64_CompareEqualScalar: { if (intrin.op1->IsVectorZero()) { From 6cd0ea84747ab94a05f903f33fd1a5c8707e16a3 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 11:47:23 -0800 Subject: [PATCH 25/59] Removing github csproj --- .../JitBlue/GitHub_33972/GitHub_33972.csproj | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj diff --git a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj b/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj deleted file mode 100644 index bf6f589eb325b..0000000000000 --- a/src/tests/JIT/Regression/JitBlue/GitHub_33972/GitHub_33972.csproj +++ /dev/null @@ -1,13 +0,0 @@ - - - Exe - - - None - True - True - - - - - From 2b304210cc166763732dc47ae989eee41f8b4be6 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 11:52:57 -0800 Subject: [PATCH 26/59] Minor test fix --- .../Regression/JitBlue/Runtime_33972/Runtime_33972.cs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index 1410f2cf69fd5..752d3f245f4ae 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -474,7 +474,10 @@ static int Main(string[] args) { Console.WriteLine("Testing AdvSimd"); - result = Tests_AdvSimd(); + if(result != -1) + { + result = Tests_AdvSimd(); + } if(result != -1) { result = Tests_AdvSimd_Swapped(); @@ -498,7 +501,10 @@ static int Main(string[] args) { Console.WriteLine("Testing AdvSimd_Arm64"); - result = Tests_AdvSimd_Arm64(); + if (result != -1) + { + result = Tests_AdvSimd_Arm64(); + } if (result != -1) { result = Tests_AdvSimd_Arm64_Swapped(); From 0828de6d1fea04a4f1814baf2fc85360e9c88fc1 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 12:36:53 -0800 Subject: [PATCH 27/59] Fixed tests --- src/coreclr/jit/emitarm64.cpp | 8 +-- .../JitBlue/Runtime_33972/Runtime_33972.cs | 54 ++++++++++++++----- 2 files changed, 46 insertions(+), 16 deletions(-) diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 275d256844d96..758fecb7086a1 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -4732,19 +4732,19 @@ void emitter::emitIns_R_R( assert(isVectorRegister(reg1)); assert(isVectorRegister(reg2)); - if (isValidVectorDatasize(size)) + if (insOptsAnyArrangement(opt)) { // Vector operation - assert(insOptsAnyArrangement(opt)); + assert(isValidVectorDatasize(size)); assert(isValidArrangement(size, opt)); elemsize = optGetElemsize(opt); fmt = IF_DV_2M; } else { - NYI("Untested"); // Scalar operation - assert(size == EA_8BYTE); // Only Double supported + assert(isValidScalarDatasize(size)); + assert(insOptsNone(opt)); fmt = IF_DV_2L; } break; diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index 752d3f245f4ae..785159211be22 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -266,7 +266,7 @@ static Vector64 AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero_Swapp // Validation - unsafe static bool ValidateResult_Vector64(Vector64 result, T expectedElementValue) where T: unmanaged + unsafe static bool ValidateResult_Vector64(Vector64 result, T expectedElementValue) where T : unmanaged { var succeeded = true; @@ -281,7 +281,22 @@ unsafe static bool ValidateResult_Vector64(Vector64 result, T expectedElem return succeeded; } - unsafe static bool ValidateResult_Vector128(Vector128 result, T expectedElementValue) where T: unmanaged + unsafe static bool ValidateResult_Vector64(Vector64 result, Vector64 expectedElementValue) where T : unmanaged + { + var succeeded = true; + + for (var i = 0; i < (8 / sizeof(T)); i++) + { + if (!result.GetElement(i).Equals(expectedElementValue.GetElement(i))) + { + succeeded = false; + } + } + + return succeeded; + } + + unsafe static bool ValidateResult_Vector128(Vector128 result, T expectedElementValue) where T : unmanaged { var succeeded = true; @@ -296,6 +311,21 @@ unsafe static bool ValidateResult_Vector128(Vector128 result, T expectedEl return succeeded; } + unsafe static bool ValidateResult_Vector128(Vector128 result, Vector128 expectedElementValue) where T : unmanaged + { + var succeeded = true; + + for (var i = 0; i < (16 / sizeof(T)); i++) + { + if (!result.GetElement(i).Equals(expectedElementValue.GetElement(i))) + { + succeeded = false; + } + } + + return succeeded; + } + static int Tests_AdvSimd() { var result = 0; @@ -417,16 +447,16 @@ static int Tests_AdvSimd_Arm64() if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero(Vector128.Zero), -1)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero(Vector64.Zero), Single.NaN)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero(Vector64.Zero), Vector64.CreateScalar(Single.NaN))) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero(Vector64.Zero), Double.NaN)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero(Vector64.Zero), Vector64.CreateScalar(Double.NaN))) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero(Vector64.Zero), UInt64.MaxValue)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero(Vector64.Zero), Vector64.CreateScalar(UInt64.MaxValue))) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero(Vector64.Zero), -1)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero(Vector64.Zero), Vector64.CreateScalar(-1L))) result = -1; // End CompareEqual Tests @@ -449,16 +479,16 @@ static int Tests_AdvSimd_Arm64_Swapped() if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero_Swapped(Vector128.Zero), -1)) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero_Swapped(Vector64.Zero), Single.NaN)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero_Swapped(Vector64.Zero), Vector64.CreateScalar(Single.NaN))) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero_Swapped(Vector64.Zero), Double.NaN)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Double_Zero_Swapped(Vector64.Zero), Vector64.CreateScalar(Double.NaN))) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero_Swapped(Vector64.Zero), UInt64.MaxValue)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_UInt64_Zero_Swapped(Vector64.Zero), Vector64.CreateScalar(UInt64.MaxValue))) result = -1; - if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero_Swapped(Vector64.Zero), -1)) + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Int64_Zero_Swapped(Vector64.Zero), Vector64.CreateScalar(-1L))) result = -1; // End CompareEqual Tests @@ -474,11 +504,11 @@ static int Main(string[] args) { Console.WriteLine("Testing AdvSimd"); - if(result != -1) + if (result != -1) { result = Tests_AdvSimd(); } - if(result != -1) + if (result != -1) { result = Tests_AdvSimd_Swapped(); } From fa43d198f11435d27999edde976dfdc08f50a47a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 13:41:14 -0800 Subject: [PATCH 28/59] Fix print --- src/coreclr/jit/emitarm64.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 758fecb7086a1..971b18668ec83 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -13136,7 +13136,7 @@ void emitter::emitDispIns( emitDispReg(id->idReg1(), size, true); emitDispReg(id->idReg2(), size, false); } - if ((fmt == IF_DV_2L && ins == INS_cmeq) || (fmt == IF_DV_2G && ins == INS_fcmeq)) + if ((fmt == IF_DV_2L && ins == INS_cmeq)) { printf(", "); emitDispImm(0, false); From 911f9290c558454ea756cca20ce4faaf6a1c88fe Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 13:48:56 -0800 Subject: [PATCH 29/59] Minor format change --- src/coreclr/jit/emitarm64.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 971b18668ec83..287993ceccb1b 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -13136,7 +13136,7 @@ void emitter::emitDispIns( emitDispReg(id->idReg1(), size, true); emitDispReg(id->idReg2(), size, false); } - if ((fmt == IF_DV_2L && ins == INS_cmeq)) + if (fmt == IF_DV_2L && ins == INS_cmeq) { printf(", "); emitDispImm(0, false); From b91be1ec018ef979ac95cdc8e6c6d67004b6fd2a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 10 Jan 2022 16:17:43 -0800 Subject: [PATCH 30/59] Fixing test --- .../Regression/JitBlue/Runtime_33972/Runtime_33972.cs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index 785159211be22..7535cd334d962 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -328,7 +328,7 @@ unsafe static bool ValidateResult_Vector128(Vector128 result, Vector128 static int Tests_AdvSimd() { - var result = 0; + var result = 100; // Begin CompareEqual Tests @@ -381,7 +381,7 @@ static int Tests_AdvSimd() static int Tests_AdvSimd_Swapped() { - var result = 0; + var result = 100; // Begin CompareEqual Tests @@ -434,7 +434,7 @@ static int Tests_AdvSimd_Swapped() static int Tests_AdvSimd_Arm64() { - var result = 0; + var result = 100; // Begin CompareEqual Tests @@ -466,7 +466,7 @@ static int Tests_AdvSimd_Arm64() static int Tests_AdvSimd_Arm64_Swapped() { - var result = 0; + var result = 100; // Begin CompareEqual Tests @@ -498,7 +498,7 @@ static int Tests_AdvSimd_Arm64_Swapped() static int Main(string[] args) { - var result = 0; + var result = 100; if (AdvSimd.IsSupported) { From 760a08c50ece0c761bf6ad0d6060508014bbae57 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 14 Jan 2022 15:38:02 -0800 Subject: [PATCH 31/59] Initial commit for Vector.Create to Vector.Zero normalization --- src/coreclr/jit/compiler.h | 3 ++ src/coreclr/jit/gentree.cpp | 70 +++++++++++++++++++++++++++++++++++++ src/coreclr/jit/morph.cpp | 14 ++++++++ 3 files changed, 87 insertions(+) diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h index 7f530ac2ce96d..d7daa1c94c96d 100644 --- a/src/coreclr/jit/compiler.h +++ b/src/coreclr/jit/compiler.h @@ -3535,6 +3535,9 @@ class Compiler GenTree* op2, CorInfoInlineTypeCheck typeCheckInliningResult); GenTree* gtFoldExprCall(GenTreeCall* call); +#ifdef FEATURE_HW_INTRINSICS + GenTree* gtFoldHWIntrinsic(GenTreeHWIntrinsic* node); +#endif GenTree* gtFoldTypeCompare(GenTree* tree); GenTree* gtFoldTypeEqualityCall(bool isEq, GenTree* op1, GenTree* op2); diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index a13e3df246e49..050de316aa70f 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11699,6 +11699,76 @@ GenTree* Compiler::gtFoldExprCall(GenTreeCall* call) return call; } +#ifdef FEATURE_HW_INTRINSICS + +//------------------------------------------------------------------------ +// gtFoldHWIntrinsic: see if a HWIntrinsic is foldable +// +// Arguments: +// node - HWIntrinsic node to examine +// +// Returns: +// The original node if no folding happened. +// An alternative tree if folding happens. +// +// Notes: +// Checks for HWIntrinsic nodes to Vector64.Create/Vector128.Create/Vector256.Create, +// and if the call is to one of these, attempt to optimize. + +GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) +{ + // Defer folding if not optimizing. + if (opts.OptimizationDisabled()) + { + return node; + } + + switch (node->GetHWIntrinsicId()) + { +#if defined(TARGET_XARCH) || defined(TARGET_ARM64) + case NI_Vector128_Create: + { + if ((node->GetOperandCount() == 1) && + (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) + { + node->ResetHWIntrinsicId(NI_Vector128_get_Zero); + } + break; + } +#endif + +#if defined(TARGET_XARCH) + case NI_Vector256_Create: + { + if ((node->GetOperandCount() == 1) && + (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) + { + node->ResetHWIntrinsicId(NI_Vector256_get_Zero); + } + break; + } +#endif + +#if defined(TARGET_ARM64) + case NI_Vector64_Create: + { + if ((node->GetOperandCount() == 1) && + (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) + { + node->ResetHWIntrinsicId(NI_Vector64_get_Zero); + } + break; + } +#endif + default: + break; + } + + return node; +} + +#endif + //------------------------------------------------------------------------ // gtFoldTypeEqualityCall: see if a (potential) type equality call is foldable // diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 1ee03c84a398f..33b980d24da77 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -14192,6 +14192,20 @@ GenTree* Compiler::fgMorphMultiOp(GenTreeMultiOp* multiOp) } #endif // defined(FEATURE_HW_INTRINSICS) && defined(TARGET_XARCH) +#ifdef FEATURE_HW_INTRINSICS + if (multiOp->OperIsHWIntrinsic()) + { + // See if this is foldable + GenTree* optTree = gtFoldHWIntrinsic(multiOp->AsHWIntrinsic()); + + // If we optimized, morph the result + if (optTree != multiOp) + { + return fgMorphTree(optTree); + } + } +#endif + return multiOp; } #endif // defined(FEATURE_SIMD) || defined(FEATURE_HW_INTRINSICS) From c1a90b44e33888212c8dd997c320e926a2cfcb87 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 18 Jan 2022 15:51:55 -0800 Subject: [PATCH 32/59] Added some emitter tests --- src/coreclr/jit/codegenarm64.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/coreclr/jit/codegenarm64.cpp b/src/coreclr/jit/codegenarm64.cpp index 4da5ba3dd174f..7ab7fed97b14b 100644 --- a/src/coreclr/jit/codegenarm64.cpp +++ b/src/coreclr/jit/codegenarm64.cpp @@ -8395,6 +8395,8 @@ void CodeGen::genArm64EmitterUnitTests() theEmitter->emitIns_R_R_R(INS_cmeq, EA_8BYTE, REG_V12, REG_V13, REG_V14, INS_OPTS_2S); theEmitter->emitIns_R_R_R(INS_cmeq, EA_16BYTE, REG_V15, REG_V16, REG_V17, INS_OPTS_4S); theEmitter->emitIns_R_R_R(INS_cmeq, EA_16BYTE, REG_V18, REG_V19, REG_V20, INS_OPTS_2D); + theEmitter->emitIns_R_R(INS_cmeq, EA_8BYTE, REG_V0, REG_V1); + theEmitter->emitIns_R_R(INS_cmeq, EA_16BYTE, REG_V2, REG_V3); // cmge vector theEmitter->emitIns_R_R_R(INS_cmge, EA_8BYTE, REG_V0, REG_V1, REG_V2, INS_OPTS_8B); From 32f86c1c00141372c44d06eaf8bd9b7a35372adc Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 18 Jan 2022 17:25:43 -0800 Subject: [PATCH 33/59] Feedback --- src/coreclr/jit/codegenarm64.cpp | 3 +- src/coreclr/jit/emitarm64.cpp | 4 +- src/coreclr/jit/lsraarm64.cpp | 144 ++++++++++++++----------------- src/coreclr/jit/lsrabuild.cpp | 13 +++ 4 files changed, 81 insertions(+), 83 deletions(-) diff --git a/src/coreclr/jit/codegenarm64.cpp b/src/coreclr/jit/codegenarm64.cpp index 7ab7fed97b14b..077d363b33eea 100644 --- a/src/coreclr/jit/codegenarm64.cpp +++ b/src/coreclr/jit/codegenarm64.cpp @@ -8396,7 +8396,8 @@ void CodeGen::genArm64EmitterUnitTests() theEmitter->emitIns_R_R_R(INS_cmeq, EA_16BYTE, REG_V15, REG_V16, REG_V17, INS_OPTS_4S); theEmitter->emitIns_R_R_R(INS_cmeq, EA_16BYTE, REG_V18, REG_V19, REG_V20, INS_OPTS_2D); theEmitter->emitIns_R_R(INS_cmeq, EA_8BYTE, REG_V0, REG_V1); - theEmitter->emitIns_R_R(INS_cmeq, EA_16BYTE, REG_V2, REG_V3); + theEmitter->emitIns_R_R(INS_fcmeq, EA_8BYTE, REG_V2, REG_V3); + theEmitter->emitIns_R_R(INS_fcmeq, EA_16BYTE, REG_V4, REG_V5); // cmge vector theEmitter->emitIns_R_R_R(INS_cmge, EA_8BYTE, REG_V0, REG_V1, REG_V2, INS_OPTS_8B); diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 287993ceccb1b..745bd21ade3ce 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -4735,7 +4735,7 @@ void emitter::emitIns_R_R( if (insOptsAnyArrangement(opt)) { // Vector operation - assert(isValidVectorDatasize(size)); + assert(size == EA_8BYTE); assert(isValidArrangement(size, opt)); elemsize = optGetElemsize(opt); fmt = IF_DV_2M; @@ -4743,7 +4743,7 @@ void emitter::emitIns_R_R( else { // Scalar operation - assert(isValidScalarDatasize(size)); + assert(size == EA_8BYTE); assert(insOptsNone(opt)); fmt = IF_DV_2L; } diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index 09223e6971d64..796a9e8126e6f 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1011,48 +1011,40 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) if (intrin.op1 != nullptr) { - // Do not give a register to the first operand if it is contained. - if (intrin.op1->IsVectorZero() && !hasImmediateOperand && intrin.op1->isContained()) + bool simdRegToSimdRegMove = false; + + if ((intrin.id == NI_Vector64_CreateScalarUnsafe) || (intrin.id == NI_Vector128_CreateScalarUnsafe)) { - assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); + simdRegToSimdRegMove = varTypeIsFloating(intrin.op1); } - else + else if (intrin.id == NI_AdvSimd_Arm64_DuplicateToVector64) { - bool simdRegToSimdRegMove = false; - - if ((intrin.id == NI_Vector64_CreateScalarUnsafe) || (intrin.id == NI_Vector128_CreateScalarUnsafe)) - { - simdRegToSimdRegMove = varTypeIsFloating(intrin.op1); - } - else if (intrin.id == NI_AdvSimd_Arm64_DuplicateToVector64) - { - simdRegToSimdRegMove = (intrin.op1->TypeGet() == TYP_DOUBLE); - } - else if ((intrin.id == NI_Vector64_ToScalar) || (intrin.id == NI_Vector128_ToScalar)) - { - simdRegToSimdRegMove = varTypeIsFloating(intrinsicTree); - } + simdRegToSimdRegMove = (intrin.op1->TypeGet() == TYP_DOUBLE); + } + else if ((intrin.id == NI_Vector64_ToScalar) || (intrin.id == NI_Vector128_ToScalar)) + { + simdRegToSimdRegMove = varTypeIsFloating(intrinsicTree); + } - // If we have an RMW intrinsic or an intrinsic with simple move semantic between two SIMD registers, - // we want to preference op1Reg to the target if op1 is not contained. - if (isRMW || simdRegToSimdRegMove) - { - tgtPrefOp1 = !intrin.op1->isContained(); - } + // If we have an RMW intrinsic or an intrinsic with simple move semantic between two SIMD registers, + // we want to preference op1Reg to the target if op1 is not contained. + if (isRMW || simdRegToSimdRegMove) + { + tgtPrefOp1 = !intrin.op1->isContained(); + } - if (intrinsicTree->OperIsMemoryLoadOrStore()) - { - srcCount += BuildAddrUses(intrin.op1); - } - else if (tgtPrefOp1) - { - tgtPrefUse = BuildUse(intrin.op1); - srcCount++; - } - else - { - srcCount += BuildOperandUses(intrin.op1); - } + if (intrinsicTree->OperIsMemoryLoadOrStore()) + { + srcCount += BuildAddrUses(intrin.op1); + } + else if (tgtPrefOp1) + { + tgtPrefUse = BuildUse(intrin.op1); + srcCount++; + } + else + { + srcCount += BuildOperandUses(intrin.op1); } } @@ -1101,58 +1093,50 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree) } else if (intrin.op2 != nullptr) { - // Do not give a register to the second operand if it is contained. - if (intrin.op2->IsVectorZero() && !hasImmediateOperand && intrin.op2->isContained()) - { - assert(HWIntrinsicInfo::SupportsContainment(intrin.id)); - } - else - { - // RMW intrinsic operands doesn't have to be delayFree when they can be assigned the same register as op1Reg - // (i.e. a register that corresponds to read-modify-write operand) and one of them is the last use. + // RMW intrinsic operands doesn't have to be delayFree when they can be assigned the same register as op1Reg + // (i.e. a register that corresponds to read-modify-write operand) and one of them is the last use. - assert(intrin.op1 != nullptr); + assert(intrin.op1 != nullptr); - bool forceOp2DelayFree = false; - if ((intrin.id == NI_Vector64_GetElement) || (intrin.id == NI_Vector128_GetElement)) + bool forceOp2DelayFree = false; + if ((intrin.id == NI_Vector64_GetElement) || (intrin.id == NI_Vector128_GetElement)) + { + if (!intrin.op2->IsCnsIntOrI() && (!intrin.op1->isContained() || intrin.op1->OperIsLocal())) { - if (!intrin.op2->IsCnsIntOrI() && (!intrin.op1->isContained() || intrin.op1->OperIsLocal())) - { - // If the index is not a constant and the object is not contained or is a local - // we will need a general purpose register to calculate the address - // internal register must not clobber input index - // TODO-Cleanup: An internal register will never clobber a source; this code actually - // ensures that the index (op2) doesn't interfere with the target. - buildInternalIntRegisterDefForNode(intrinsicTree); - forceOp2DelayFree = true; - } - - if (!intrin.op2->IsCnsIntOrI() && !intrin.op1->isContained()) - { - // If the index is not a constant or op1 is in register, - // we will use the SIMD temp location to store the vector. - var_types requiredSimdTempType = (intrin.id == NI_Vector64_GetElement) ? TYP_SIMD8 : TYP_SIMD16; - compiler->getSIMDInitTempVarNum(requiredSimdTempType); - } + // If the index is not a constant and the object is not contained or is a local + // we will need a general purpose register to calculate the address + // internal register must not clobber input index + // TODO-Cleanup: An internal register will never clobber a source; this code actually + // ensures that the index (op2) doesn't interfere with the target. + buildInternalIntRegisterDefForNode(intrinsicTree); + forceOp2DelayFree = true; } - if (forceOp2DelayFree) - { - srcCount += BuildDelayFreeUses(intrin.op2); - } - else + if (!intrin.op2->IsCnsIntOrI() && !intrin.op1->isContained()) { - srcCount += isRMW ? BuildDelayFreeUses(intrin.op2, intrin.op1) : BuildOperandUses(intrin.op2); + // If the index is not a constant or op1 is in register, + // we will use the SIMD temp location to store the vector. + var_types requiredSimdTempType = (intrin.id == NI_Vector64_GetElement) ? TYP_SIMD8 : TYP_SIMD16; + compiler->getSIMDInitTempVarNum(requiredSimdTempType); } + } - if (intrin.op3 != nullptr) - { - srcCount += isRMW ? BuildDelayFreeUses(intrin.op3, intrin.op1) : BuildOperandUses(intrin.op3); + if (forceOp2DelayFree) + { + srcCount += BuildDelayFreeUses(intrin.op2); + } + else + { + srcCount += isRMW ? BuildDelayFreeUses(intrin.op2, intrin.op1) : BuildOperandUses(intrin.op2); + } - if (intrin.op4 != nullptr) - { - srcCount += isRMW ? BuildDelayFreeUses(intrin.op4, intrin.op1) : BuildOperandUses(intrin.op4); - } + if (intrin.op3 != nullptr) + { + srcCount += isRMW ? BuildDelayFreeUses(intrin.op3, intrin.op1) : BuildOperandUses(intrin.op3); + + if (intrin.op4 != nullptr) + { + srcCount += isRMW ? BuildDelayFreeUses(intrin.op4, intrin.op1) : BuildOperandUses(intrin.op4); } } } diff --git a/src/coreclr/jit/lsrabuild.cpp b/src/coreclr/jit/lsrabuild.cpp index adf2a3be3f16b..936746afc5e3e 100644 --- a/src/coreclr/jit/lsrabuild.cpp +++ b/src/coreclr/jit/lsrabuild.cpp @@ -3078,6 +3078,13 @@ int LinearScan::BuildOperandUses(GenTree* node, regMaskTP candidates) return 1; } +#ifdef TARGET_ARM64 + if (node->IsVectorZero()) + { + return 0; + } +#endif + #if !defined(TARGET_64BIT) if (node->OperIs(GT_LONG)) { @@ -3164,6 +3171,12 @@ int LinearScan::BuildDelayFreeUses(GenTree* node, GenTree* rmwNode, regMaskTP ca { use = BuildUse(node, candidates); } +#ifdef TARGET_ARM64 + else if (node->IsVectorZero()) + { + return 0; + } +#endif #ifdef FEATURE_HW_INTRINSICS else if (node->OperIsHWIntrinsic()) { From b08f552063b59cf8c41c5a1f502ca1bc19aaf1cd Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 18 Jan 2022 19:13:40 -0800 Subject: [PATCH 34/59] Update emitarm64.cpp --- src/coreclr/jit/emitarm64.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/emitarm64.cpp b/src/coreclr/jit/emitarm64.cpp index 745bd21ade3ce..3163b29dc6ae1 100644 --- a/src/coreclr/jit/emitarm64.cpp +++ b/src/coreclr/jit/emitarm64.cpp @@ -4735,7 +4735,7 @@ void emitter::emitIns_R_R( if (insOptsAnyArrangement(opt)) { // Vector operation - assert(size == EA_8BYTE); + assert(isValidVectorDatasize(size)); assert(isValidArrangement(size, opt)); elemsize = optGetElemsize(opt); fmt = IF_DV_2M; From c89e47be99ec5187571953950fe0bd74880850e4 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 19 Jan 2022 11:14:26 -0800 Subject: [PATCH 35/59] Feedback --- src/coreclr/jit/codegenarm64.cpp | 8 ++++---- src/coreclr/jit/lsrabuild.cpp | 4 ++++ 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/src/coreclr/jit/codegenarm64.cpp b/src/coreclr/jit/codegenarm64.cpp index 077d363b33eea..9246b052a5201 100644 --- a/src/coreclr/jit/codegenarm64.cpp +++ b/src/coreclr/jit/codegenarm64.cpp @@ -6919,9 +6919,12 @@ void CodeGen::genArm64EmitterUnitTests() #ifdef ALL_ARM64_EMITTER_UNIT_TESTS // - // R_R fmov/fcmp/fcvt + // R_R cmeq/fmov/fcmp/fcvt // + // cmeq scalar + theEmitter->emitIns_R_R(INS_cmeq, EA_8BYTE, REG_V0, REG_V1); + // fmov to vector to vector theEmitter->emitIns_Mov(INS_fmov, EA_8BYTE, REG_V0, REG_V2, /* canSkip */ false); theEmitter->emitIns_Mov(INS_fmov, EA_4BYTE, REG_V1, REG_V3, /* canSkip */ false); @@ -8395,9 +8398,6 @@ void CodeGen::genArm64EmitterUnitTests() theEmitter->emitIns_R_R_R(INS_cmeq, EA_8BYTE, REG_V12, REG_V13, REG_V14, INS_OPTS_2S); theEmitter->emitIns_R_R_R(INS_cmeq, EA_16BYTE, REG_V15, REG_V16, REG_V17, INS_OPTS_4S); theEmitter->emitIns_R_R_R(INS_cmeq, EA_16BYTE, REG_V18, REG_V19, REG_V20, INS_OPTS_2D); - theEmitter->emitIns_R_R(INS_cmeq, EA_8BYTE, REG_V0, REG_V1); - theEmitter->emitIns_R_R(INS_fcmeq, EA_8BYTE, REG_V2, REG_V3); - theEmitter->emitIns_R_R(INS_fcmeq, EA_16BYTE, REG_V4, REG_V5); // cmge vector theEmitter->emitIns_R_R_R(INS_cmge, EA_8BYTE, REG_V0, REG_V1, REG_V2, INS_OPTS_8B); diff --git a/src/coreclr/jit/lsrabuild.cpp b/src/coreclr/jit/lsrabuild.cpp index 936746afc5e3e..908acf8b20bbd 100644 --- a/src/coreclr/jit/lsrabuild.cpp +++ b/src/coreclr/jit/lsrabuild.cpp @@ -3079,6 +3079,8 @@ int LinearScan::BuildOperandUses(GenTree* node, regMaskTP candidates) } #ifdef TARGET_ARM64 + // Must happen before OperIsHWIntrinsic case, + // but this occurs when a vector zero node is marked as contained. if (node->IsVectorZero()) { return 0; @@ -3172,6 +3174,8 @@ int LinearScan::BuildDelayFreeUses(GenTree* node, GenTree* rmwNode, regMaskTP ca use = BuildUse(node, candidates); } #ifdef TARGET_ARM64 + // Must happen before OperIsHWIntrinsic case, + // but this occurs when a vector zero node is marked as contained. else if (node->IsVectorZero()) { return 0; From b1065e8916c39542f1b29b9d7416dc79e11112f8 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 12:34:11 -0800 Subject: [PATCH 36/59] Handling variations of Vector.Create --- src/coreclr/jit/gentree.cpp | 60 ++++++++++++++++++++++--------------- src/coreclr/jit/morph.cpp | 6 ++-- 2 files changed, 40 insertions(+), 26 deletions(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 1d4959fabb6d1..5462455bef84f 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11728,41 +11728,53 @@ GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) switch (node->GetHWIntrinsicId()) { -#if defined(TARGET_XARCH) || defined(TARGET_ARM64) case NI_Vector128_Create: - { - if ((node->GetOperandCount() == 1) && - (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) - { - node->ResetHWIntrinsicId(NI_Vector128_get_Zero); - } - break; - } -#endif - #if defined(TARGET_XARCH) case NI_Vector256_Create: +#elif defined(TARGET_ARMARCH) + case NI_Vector64_Create: +#endif { - if ((node->GetOperandCount() == 1) && - (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) + bool hwAllArgsAreConstZero = true; + for (GenTree** use : node->UseEdges()) { - node->ResetHWIntrinsicId(NI_Vector256_get_Zero); + if (!(*use)->IsIntegralConst(0) && !(*use)->IsFloatPositiveZero()) + { + hwAllArgsAreConstZero = false; + break; + } } - break; - } -#endif -#if defined(TARGET_ARM64) - case NI_Vector64_Create: - { - if ((node->GetOperandCount() == 1) && - (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) + if (hwAllArgsAreConstZero) { - node->ResetHWIntrinsicId(NI_Vector64_get_Zero); + switch (node->GetHWIntrinsicId()) + { + case NI_Vector128_Create: + { + node->ResetHWIntrinsicId(NI_Vector128_get_Zero); + break; + } +#if defined(TARGET_XARCH) + case NI_Vector256_Create: + { + node->ResetHWIntrinsicId(NI_Vector256_get_Zero); + break; + } +#elif defined(TARGET_ARMARCH) + case NI_Vector64_Create: + { + node->ResetHWIntrinsicId(NI_Vector64_get_Zero); + break; + } +#endif + default: + assert(!"Unexpected HWIntrinsicId"); + break; + } } break; } -#endif + default: break; } diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 613d1e7c0d748..eb0f067d6ac89 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -14292,11 +14292,13 @@ GenTree* Compiler::fgMorphMultiOp(GenTreeMultiOp* multiOp) #ifdef FEATURE_HW_INTRINSICS if (multiOp->OperIsHWIntrinsic()) { + GenTreeHWIntrinsic* hw = multiOp->AsHWIntrinsic(); + // See if this is foldable - GenTree* optTree = gtFoldHWIntrinsic(multiOp->AsHWIntrinsic()); + GenTree* optTree = gtFoldHWIntrinsic(hw); // If we optimized, morph the result - if (optTree != multiOp) + if (optTree != hw) { return fgMorphTree(optTree); } From 451f8e32c29c7b9eb790648fb0049c53d1c5930b Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 12:49:37 -0800 Subject: [PATCH 37/59] Use Operands iterator instead of edges --- src/coreclr/jit/gentree.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 5462455bef84f..1fedbf5eae072 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11736,9 +11736,9 @@ GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) #endif { bool hwAllArgsAreConstZero = true; - for (GenTree** use : node->UseEdges()) + for (GenTree* arg : node->Operands()) { - if (!(*use)->IsIntegralConst(0) && !(*use)->IsFloatPositiveZero()) + if (arg->IsIntegralConst(0) && arg->IsFloatPositiveZero()) { hwAllArgsAreConstZero = false; break; From e231131e6afc6ed68d6d2bd6ccb961d6c3b60ac0 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 12:50:14 -0800 Subject: [PATCH 38/59] Fix condition --- src/coreclr/jit/gentree.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 1fedbf5eae072..cf544bd0ac0f4 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11738,7 +11738,7 @@ GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) bool hwAllArgsAreConstZero = true; for (GenTree* arg : node->Operands()) { - if (arg->IsIntegralConst(0) && arg->IsFloatPositiveZero()) + if (!arg->IsIntegralConst(0) && !arg->IsFloatPositiveZero()) { hwAllArgsAreConstZero = false; break; From 64ad95faba889fc4693e22e60f02563d65005292 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 15:30:17 -0800 Subject: [PATCH 39/59] Simplify --- src/coreclr/jit/gentree.cpp | 27 ++------------------------- 1 file changed, 2 insertions(+), 25 deletions(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index cf544bd0ac0f4..502e769a8835c 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11731,7 +11731,7 @@ GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Vector128_Create: #if defined(TARGET_XARCH) case NI_Vector256_Create: -#elif defined(TARGET_ARMARCH) +#elif defined(TARGET_ARM64) case NI_Vector64_Create: #endif { @@ -11747,30 +11747,7 @@ GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) if (hwAllArgsAreConstZero) { - switch (node->GetHWIntrinsicId()) - { - case NI_Vector128_Create: - { - node->ResetHWIntrinsicId(NI_Vector128_get_Zero); - break; - } -#if defined(TARGET_XARCH) - case NI_Vector256_Create: - { - node->ResetHWIntrinsicId(NI_Vector256_get_Zero); - break; - } -#elif defined(TARGET_ARMARCH) - case NI_Vector64_Create: - { - node->ResetHWIntrinsicId(NI_Vector64_get_Zero); - break; - } -#endif - default: - assert(!"Unexpected HWIntrinsicId"); - break; - } + return gtNewSimdZeroNode(node->gtType, node->GetSimdBaseJitType(), node->GetSimdSize(), node->IsSimdAsHWIntrinsic()); } break; } From 333fc670c1ceddc21fea5c11ef9539899c057c7f Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 15:31:10 -0800 Subject: [PATCH 40/59] format --- src/coreclr/jit/gentree.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 502e769a8835c..8d52ad1ac7695 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11747,7 +11747,8 @@ GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) if (hwAllArgsAreConstZero) { - return gtNewSimdZeroNode(node->gtType, node->GetSimdBaseJitType(), node->GetSimdSize(), node->IsSimdAsHWIntrinsic()); + return gtNewSimdZeroNode(node->gtType, node->GetSimdBaseJitType(), node->GetSimdSize(), + node->IsSimdAsHWIntrinsic()); } break; } From bc0290458eb96171f67a8207f1b5dfbad9f58a08 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 19:08:09 -0800 Subject: [PATCH 41/59] Fixed IsFloatPositiveZero --- src/coreclr/jit/gentree.cpp | 8 ++++---- src/coreclr/jit/gentree.h | 7 ++++++- 2 files changed, 10 insertions(+), 5 deletions(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 8d52ad1ac7695..29257f575c769 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11721,10 +11721,10 @@ GenTree* Compiler::gtFoldExprCall(GenTreeCall* call) GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) { // Defer folding if not optimizing. - if (opts.OptimizationDisabled()) - { - return node; - } + //if (opts.OptimizationDisabled()) + //{ + // return node; + //} switch (node->GetHWIntrinsicId()) { diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 7eeb3b0f57bd2..0f2ce9dbc4823 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7661,7 +7661,12 @@ inline bool GenTree::IsSIMDZero() const // inline bool GenTree::IsFloatPositiveZero() const { - return !(IsCnsNonZeroFltOrDbl()); + if (OperGet() == GT_CNS_DBL) + { + return !(IsCnsNonZeroFltOrDbl()); + } + + return false; } //------------------------------------------------------------------- From d8c39e38fbffdbc7bfcaf1588e04158a7a53207e Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 20 Jan 2022 19:13:06 -0800 Subject: [PATCH 42/59] Uncomment --- src/coreclr/jit/gentree.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 29257f575c769..8d52ad1ac7695 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11721,10 +11721,10 @@ GenTree* Compiler::gtFoldExprCall(GenTreeCall* call) GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) { // Defer folding if not optimizing. - //if (opts.OptimizationDisabled()) - //{ - // return node; - //} + if (opts.OptimizationDisabled()) + { + return node; + } switch (node->GetHWIntrinsicId()) { From 38d9e7e976993f9f68161b97d3fd6ed9f1a01fa6 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 21 Jan 2022 12:23:43 -0800 Subject: [PATCH 43/59] Updated tests to include Vector64.Create/Vector128.Create for ARM64 --- .../JitBlue/Runtime_33972/Runtime_33972.cs | 92 +++++++++++++++++++ 1 file changed, 92 insertions(+) diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index 7535cd334d962..ddc1da23dd0b2 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -52,6 +52,30 @@ static Vector64 AdvSimd_CompareEqual_Vector64_Single_Zero(Vector64 return AdvSimd.CompareEqual(left, Vector64.Zero); } + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Int32_CreateZero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Create(0)); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Int32_CreateZeroZero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Create(0, 0)); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Single_CreateZero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Create(0f)); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector64 AdvSimd_CompareEqual_Vector64_Single_CreateZeroZero(Vector64 left) + { + return AdvSimd.CompareEqual(left, Vector64.Create(0f, 0f)); + } + [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 AdvSimd_CompareEqual_Vector128_Byte_Zero(Vector128 left) { @@ -94,6 +118,30 @@ static Vector128 AdvSimd_CompareEqual_Vector128_Single_Zero(Vector128.Zero); } + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Int32_CreateZero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Create(0)); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Int32_CreateZeroZeroZeroZero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Create(0, 0, 0, 0)); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Create(0f)); + } + + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero(Vector128 left) + { + return AdvSimd.CompareEqual(left, Vector128.Create(0f, 0f, 0f, 0f)); + } + [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128 left) { @@ -332,6 +380,8 @@ static int Tests_AdvSimd() // Begin CompareEqual Tests + // Vector64 + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Byte_Zero(Vector64.Zero), Byte.MaxValue)) result = -1; @@ -353,6 +403,22 @@ static int Tests_AdvSimd() if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Single_Zero(Vector64.Zero), Single.NaN)) result = -1; + // Vector64.Create + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Int32_CreateZero(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Single_CreateZero(Vector64.Zero), Single.NaN)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Int32_CreateZeroZero(Vector64.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Single_CreateZeroZero(Vector64.Zero), Single.NaN)) + result = -1; + + // Vector128 + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Byte_Zero(Vector128.Zero), Byte.MaxValue)) result = -1; @@ -374,6 +440,20 @@ static int Tests_AdvSimd() if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_Zero(Vector128.Zero), Single.NaN)) result = -1; + // Vector128.Create + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Int32_CreateZero(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_CreateZero(Vector128.Zero), Single.NaN)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Int32_CreateZeroZeroZeroZero(Vector128.Zero), -1)) + result = -1; + + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero(Vector128.Zero), Single.NaN)) + result = -1; + // End CompareEqual Tests return result; @@ -385,6 +465,8 @@ static int Tests_AdvSimd_Swapped() // Begin CompareEqual Tests + // Vector64 + if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Byte_Zero_Swapped(Vector64.Zero), Byte.MaxValue)) result = -1; @@ -406,6 +488,8 @@ static int Tests_AdvSimd_Swapped() if (!ValidateResult_Vector64(AdvSimd_CompareEqual_Vector64_Single_Zero_Swapped(Vector64.Zero), Single.NaN)) result = -1; + // Vector128 + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Byte_Zero_Swapped(Vector128.Zero), Byte.MaxValue)) result = -1; @@ -438,6 +522,8 @@ static int Tests_AdvSimd_Arm64() // Begin CompareEqual Tests + // Vector128 + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128.Zero), Double.NaN)) result = -1; @@ -447,6 +533,8 @@ static int Tests_AdvSimd_Arm64() if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero(Vector128.Zero), -1)) result = -1; + // Vector64 + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero(Vector64.Zero), Vector64.CreateScalar(Single.NaN))) result = -1; @@ -470,6 +558,8 @@ static int Tests_AdvSimd_Arm64_Swapped() // Begin CompareEqual Tests + // Vector128 + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero_Swapped(Vector128.Zero), Double.NaN)) result = -1; @@ -479,6 +569,8 @@ static int Tests_AdvSimd_Arm64_Swapped() if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero_Swapped(Vector128.Zero), -1)) result = -1; + // Vector64 + if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero_Swapped(Vector64.Zero), Vector64.CreateScalar(Single.NaN))) result = -1; From fb6047c5236a0f695e2db0e402a9b76dc97f2073 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 21 Jan 2022 12:58:08 -0800 Subject: [PATCH 44/59] Making implementation of IsFloatPositiveZero explicit --- src/coreclr/jit/gentree.h | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 992a2cb1c0f38..b848508c96aaa 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7661,7 +7661,13 @@ inline bool GenTree::IsSIMDZero() const // inline bool GenTree::IsFloatPositiveZero() const { - return IsCnsFltOrDbl() && !IsCnsNonZeroFltOrDbl(); + if (OperGet() == GT_CNS_DBL) + { + double constValue = AsDblCon()->gtDconVal; + return *(__int64*)&constValue == 0; + } + + return false; } //------------------------------------------------------------------- From bc1b9f40052054da00b9b7d108771ea2e5453f8c Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 10:44:06 -0800 Subject: [PATCH 45/59] Update src/coreclr/jit/gentree.cpp Co-authored-by: SingleAccretion <62474226+SingleAccretion@users.noreply.github.com> --- src/coreclr/jit/gentree.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index c2efe70bfe405..14fa27e58a4bb 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11717,7 +11717,7 @@ GenTree* Compiler::gtFoldExprCall(GenTreeCall* call) // Notes: // Checks for HWIntrinsic nodes to Vector64.Create/Vector128.Create/Vector256.Create, // and if the call is to one of these, attempt to optimize. - +// GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) { // Defer folding if not optimizing. From d7904b649a7c272ec9f29c8cd126d2f50bb328a4 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 13:18:07 -0800 Subject: [PATCH 46/59] Feedback --- src/coreclr/jit/compiler.h | 6 ++-- src/coreclr/jit/gentree.cpp | 60 ------------------------------- src/coreclr/jit/morph.cpp | 70 +++++++++++++++++++++++++++++++------ 3 files changed, 63 insertions(+), 73 deletions(-) diff --git a/src/coreclr/jit/compiler.h b/src/coreclr/jit/compiler.h index de2d334040ccc..7999278265823 100644 --- a/src/coreclr/jit/compiler.h +++ b/src/coreclr/jit/compiler.h @@ -3538,9 +3538,6 @@ class Compiler GenTree* op2, CorInfoInlineTypeCheck typeCheckInliningResult); GenTree* gtFoldExprCall(GenTreeCall* call); -#ifdef FEATURE_HW_INTRINSICS - GenTree* gtFoldHWIntrinsic(GenTreeHWIntrinsic* node); -#endif GenTree* gtFoldTypeCompare(GenTree* tree); GenTree* gtFoldTypeEqualityCall(bool isEq, GenTree* op1, GenTree* op2); @@ -6412,6 +6409,9 @@ class Compiler GenTree* fgOptimizeCast(GenTreeCast* cast); GenTree* fgOptimizeEqualityComparisonWithConst(GenTreeOp* cmp); GenTree* fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp); +#ifdef FEATURE_HW_INTRINSICS + GenTree* fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node); +#endif GenTree* fgPropagateCommaThrow(GenTree* parent, GenTreeOp* commaThrow, GenTreeFlags precedingSideEffects); GenTree* fgMorphRetInd(GenTreeUnOp* tree); GenTree* fgMorphModToSubMulDiv(GenTreeOp* tree); diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 14fa27e58a4bb..b8897e81dc8e3 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -11702,66 +11702,6 @@ GenTree* Compiler::gtFoldExprCall(GenTreeCall* call) return call; } -#ifdef FEATURE_HW_INTRINSICS - -//------------------------------------------------------------------------ -// gtFoldHWIntrinsic: see if a HWIntrinsic is foldable -// -// Arguments: -// node - HWIntrinsic node to examine -// -// Returns: -// The original node if no folding happened. -// An alternative tree if folding happens. -// -// Notes: -// Checks for HWIntrinsic nodes to Vector64.Create/Vector128.Create/Vector256.Create, -// and if the call is to one of these, attempt to optimize. -// -GenTree* Compiler::gtFoldHWIntrinsic(GenTreeHWIntrinsic* node) -{ - // Defer folding if not optimizing. - if (opts.OptimizationDisabled()) - { - return node; - } - - switch (node->GetHWIntrinsicId()) - { - case NI_Vector128_Create: -#if defined(TARGET_XARCH) - case NI_Vector256_Create: -#elif defined(TARGET_ARM64) - case NI_Vector64_Create: -#endif - { - bool hwAllArgsAreConstZero = true; - for (GenTree* arg : node->Operands()) - { - if (!arg->IsIntegralConst(0) && !arg->IsFloatPositiveZero()) - { - hwAllArgsAreConstZero = false; - break; - } - } - - if (hwAllArgsAreConstZero) - { - return gtNewSimdZeroNode(node->gtType, node->GetSimdBaseJitType(), node->GetSimdSize(), - node->IsSimdAsHWIntrinsic()); - } - break; - } - - default: - break; - } - - return node; -} - -#endif - //------------------------------------------------------------------------ // gtFoldTypeEqualityCall: see if a (potential) type equality call is foldable // diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index d960fff1cfcc3..6df972c716a7f 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -13736,6 +13736,65 @@ GenTree* Compiler::fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp) return cmp; } +#ifdef FEATURE_HW_INTRINSICS + +//------------------------------------------------------------------------ +// gtFoldHWIntrinsic: optimize a HW intrinsic node +// +// Arguments: +// node - HWIntrinsic node to examine +// +// Returns: +// The original node if no folding happened. +// An alternative tree if folding happens. +// +// Notes: +// Checks for HWIntrinsic nodes: Vector64.Create/Vector128.Create/Vector256.Create, +// and if the call is one of these, attempt to optimize. +// +GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node) +{ + if (opts.OptimizationDisabled()) + { + return node; + } + + switch (node->GetHWIntrinsicId()) + { + case NI_Vector128_Create: +#if defined(TARGET_XARCH) + case NI_Vector256_Create: +#elif defined(TARGET_ARM64) + case NI_Vector64_Create: +#endif + { + bool hwAllArgsAreConstZero = true; + for (GenTree* arg : node->Operands()) + { + if (!arg->IsIntegralConst(0) && !arg->IsFloatPositiveZero()) + { + hwAllArgsAreConstZero = false; + break; + } + } + + if (hwAllArgsAreConstZero) + { + return gtNewSimdZeroNode(node->gtType, node->GetSimdBaseJitType(), node->GetSimdSize(), + node->IsSimdAsHWIntrinsic()); + } + break; + } + + default: + break; + } + + return node; +} + +#endif + //------------------------------------------------------------------------ // fgPropagateCommaThrow: propagate a "comma throw" up the tree. // @@ -14285,16 +14344,7 @@ GenTree* Compiler::fgMorphMultiOp(GenTreeMultiOp* multiOp) #ifdef FEATURE_HW_INTRINSICS if (multiOp->OperIsHWIntrinsic()) { - GenTreeHWIntrinsic* hw = multiOp->AsHWIntrinsic(); - - // See if this is foldable - GenTree* optTree = gtFoldHWIntrinsic(hw); - - // If we optimized, morph the result - if (optTree != hw) - { - return fgMorphTree(optTree); - } + return fgOptimizeHWIntrinsic(multiOp->AsHWIntrinsic()); } #endif From 5b7d991f59f3aceb6d07c9fe31fc91fe26f3b0ba Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 13:22:32 -0800 Subject: [PATCH 47/59] Update comment --- src/coreclr/jit/morph.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 3c9368eaa8f10..7025050d2b210 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -13422,8 +13422,8 @@ GenTree* Compiler::fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp) // node - HWIntrinsic node to examine // // Returns: -// The original node if no folding happened. -// An alternative tree if folding happens. +// The original node if no optimization happened. +// An alternative tree if an optimization happened. // // Notes: // Checks for HWIntrinsic nodes: Vector64.Create/Vector128.Create/Vector256.Create, From 5a7f67461ec0e99efdefe318c81fca366e3a940a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 13:24:47 -0800 Subject: [PATCH 48/59] Update comment --- src/coreclr/jit/morph.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 7025050d2b210..a08e6d710fe87 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -13416,7 +13416,7 @@ GenTree* Compiler::fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp) #ifdef FEATURE_HW_INTRINSICS //------------------------------------------------------------------------ -// gtFoldHWIntrinsic: optimize a HW intrinsic node +// fgOptimizeHWIntrinsic: optimize a HW intrinsic node // // Arguments: // node - HWIntrinsic node to examine From 377b7942ecd80e7ef47f942a3a2d5560acff7cc8 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 14:28:01 -0800 Subject: [PATCH 49/59] Do not perform optimization when VN CSE phase --- src/coreclr/jit/morph.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index a08e6d710fe87..4330d7ac90391 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -13431,7 +13431,7 @@ GenTree* Compiler::fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp) // GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node) { - if (opts.OptimizationDisabled()) + if (opts.OptimizationDisabled() || optValnumCSE_phase) { return node; } From 1cf0b32a3fc779ada3b13ac4d521cce3c7eb0faa Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 16:26:38 -0800 Subject: [PATCH 50/59] use ResetHWIntrinsicId --- src/coreclr/jit/morph.cpp | 28 +++++++++++++++++++++++++--- 1 file changed, 25 insertions(+), 3 deletions(-) diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index 4330d7ac90391..bbf5f522b15d4 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -13422,12 +13422,13 @@ GenTree* Compiler::fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp) // node - HWIntrinsic node to examine // // Returns: -// The original node if no optimization happened. +// The original node if no optimization happened or if tree bashing occured. // An alternative tree if an optimization happened. // // Notes: // Checks for HWIntrinsic nodes: Vector64.Create/Vector128.Create/Vector256.Create, // and if the call is one of these, attempt to optimize. +// This is post-order, meaning that it will not morph the children. // GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node) { @@ -13457,8 +13458,29 @@ GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node) if (hwAllArgsAreConstZero) { - return gtNewSimdZeroNode(node->gtType, node->GetSimdBaseJitType(), node->GetSimdSize(), - node->IsSimdAsHWIntrinsic()); + switch (node->GetHWIntrinsicId()) + { + case NI_Vector128_Create: + { + node->ResetHWIntrinsicId(NI_Vector128_get_Zero); + break; + } +#if defined(TARGET_XARCH) + case NI_Vector256_Create: + { + node->ResetHWIntrinsicId(NI_Vector256_get_Zero); + break; + } +#elif defined(TARGET_ARM64) + case NI_Vector64_Create: + { + node->ResetHWIntrinsicId(NI_Vector64_get_Zero); + break; + } +#endif + default: + unreached(); + } } break; } From 84f51cd4e45a251e776a3c91095a0efc69860fbe Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 16:36:18 -0800 Subject: [PATCH 51/59] Assert !optValnumCSE_phase --- src/coreclr/jit/morph.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/morph.cpp b/src/coreclr/jit/morph.cpp index bbf5f522b15d4..ea3d10a0d34f8 100644 --- a/src/coreclr/jit/morph.cpp +++ b/src/coreclr/jit/morph.cpp @@ -13432,7 +13432,9 @@ GenTree* Compiler::fgOptimizeRelationalComparisonWithConst(GenTreeOp* cmp) // GenTree* Compiler::fgOptimizeHWIntrinsic(GenTreeHWIntrinsic* node) { - if (opts.OptimizationDisabled() || optValnumCSE_phase) + assert(!optValnumCSE_phase); + + if (opts.OptimizationDisabled()) { return node; } @@ -14399,7 +14401,7 @@ GenTree* Compiler::fgMorphMultiOp(GenTreeMultiOp* multiOp) #endif // defined(FEATURE_HW_INTRINSICS) && defined(TARGET_XARCH) #ifdef FEATURE_HW_INTRINSICS - if (multiOp->OperIsHWIntrinsic()) + if (multiOp->OperIsHWIntrinsic() && !optValnumCSE_phase) { return fgOptimizeHWIntrinsic(multiOp->AsHWIntrinsic()); } From 31cd50dc86f6d5307cebd5991b4d8e05483cd519 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 16:46:34 -0800 Subject: [PATCH 52/59] Simplify IsVectorZero --- src/coreclr/jit/gentree.h | 39 ++++++--------------------------------- 1 file changed, 6 insertions(+), 33 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 35477a29d8734..87360df540e95 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7653,12 +7653,10 @@ inline bool GenTree::IsFloatPositiveZero() const } //------------------------------------------------------------------- -// IsVectorZero: returns true if this is an integral or floating-point (SIMD or HW intrinsic) vector -// with all its elements equal to zero. +// IsVectorZero: returns true if this node is a HWIntrinsic that is Vector*_get_Zero. // // Returns: -// True if this represents an integral or floating-point const (SIMD or HW intrinsic) vector with all its elements -// equal to zero. +// True if this represents a HWIntrinsic node that is Vector*_get_Zero. // // TODO: We already have IsSIMDZero() and IsIntegralConstVector(0), // however, IsSIMDZero() does not cover hardware intrinsics, and IsIntegralConstVector(0) does not cover floating @@ -7667,45 +7665,20 @@ inline bool GenTree::IsFloatPositiveZero() const // separate ones; preferably this one. inline bool GenTree::IsVectorZero() const { -#ifdef FEATURE_SIMD - if (gtOper == GT_SIMD) - { - const GenTreeSIMD* node = AsSIMD(); - - if (node->GetSIMDIntrinsicId() == SIMDIntrinsicInit) - { - return (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero()); - } - } -#endif - #ifdef FEATURE_HW_INTRINSICS if (gtOper == GT_HWINTRINSIC) { const GenTreeHWIntrinsic* node = AsHWIntrinsic(); const var_types simdBaseType = node->GetSimdBaseType(); + const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); - if (varTypeIsIntegral(simdBaseType) || varTypeIsFloating(simdBaseType)) + if (node->GetOperandCount() == 0) { - const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); - - if (node->GetOperandCount() == 0) - { #if defined(TARGET_XARCH) - return (intrinsicId == NI_Vector128_get_Zero) || (intrinsicId == NI_Vector256_get_Zero); -#elif defined(TARGET_ARM64) - return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); -#endif // !TARGET_XARCH && !TARGET_ARM64 - } - else if ((node->GetOperandCount() == 1) && - (node->Op(1)->IsIntegralConst(0) || node->Op(1)->IsFloatPositiveZero())) - { -#if defined(TARGET_XARCH) - return (intrinsicId == NI_Vector128_Create) || (intrinsicId == NI_Vector256_Create); + return (intrinsicId == NI_Vector128_get_Zero) || (intrinsicId == NI_Vector256_get_Zero); #elif defined(TARGET_ARM64) - return (intrinsicId == NI_Vector64_Create) || (intrinsicId == NI_Vector128_Create); + return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); #endif // !TARGET_XARCH && !TARGET_ARM64 - } } } #endif // FEATURE_HW_INTRINSICS From 383f147d505af587aae2a4b03732288ce6cd2e43 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 16:47:28 -0800 Subject: [PATCH 53/59] Simplify IsVectorZero --- src/coreclr/jit/gentree.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 87360df540e95..620cfd5cf5803 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7669,7 +7669,6 @@ inline bool GenTree::IsVectorZero() const if (gtOper == GT_HWINTRINSIC) { const GenTreeHWIntrinsic* node = AsHWIntrinsic(); - const var_types simdBaseType = node->GetSimdBaseType(); const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); if (node->GetOperandCount() == 0) From 29fb977ae58e6276c18536337ec9c944f2e0b2fe Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 17:09:18 -0800 Subject: [PATCH 54/59] Simplify some uses of Vector*_get_Zero --- src/coreclr/jit/lowerarmarch.cpp | 9 ++------- src/coreclr/jit/lowerxarch.cpp | 9 ++------- 2 files changed, 4 insertions(+), 14 deletions(-) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 67e1269dfd429..56c392cdae2a2 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1014,14 +1014,9 @@ void Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) if (VectorConstantIsBroadcastedI64(vecCns, simdSize / 8)) { // If we are a single constant or if all parts are the same, we might be able to optimize - // this even further for certain values, such as Zero or AllBitsSet. + // this even further for certain values, such as AllBitsSet. - if (vecCns.i64[0] == 0) - { - node->ResetHWIntrinsicId((simdSize == 8) ? NI_Vector64_get_Zero : NI_Vector128_get_Zero); - return; - } - else if (vecCns.i64[0] == -1) + if (vecCns.i64[0] == -1) { node->ResetHWIntrinsicId((simdSize == 8) ? NI_Vector64_get_AllBitsSet : NI_Vector128_get_AllBitsSet); return; diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp index 1331644a0a992..171fdfe1126d8 100644 --- a/src/coreclr/jit/lowerxarch.cpp +++ b/src/coreclr/jit/lowerxarch.cpp @@ -1563,14 +1563,9 @@ void Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) if (((simdSize == 16) || (simdSize == 32)) && VectorConstantIsBroadcastedI64(vecCns, simdSize / 8)) { // If we are a single constant or if all parts are the same, we might be able to optimize - // this even further for certain values, such as Zero or AllBitsSet. + // this even further for certain values, such as AllBitsSet. - if (vecCns.i64[0] == 0) - { - node->ResetHWIntrinsicId((simdSize == 16) ? NI_Vector128_get_Zero : NI_Vector256_get_Zero); - return; - } - else if (vecCns.i64[0] == -1) + if (vecCns.i64[0] == -1) { node->ResetHWIntrinsicId((simdSize == 16) ? NI_Vector128_get_AllBitsSet : NI_Vector256_get_AllBitsSet); return; From 51eae5a609051b0e67f8af86fae0375f689a250c Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 17:19:50 -0800 Subject: [PATCH 55/59] Added another test --- .../Regression/JitBlue/Runtime_33972/Runtime_33972.cs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs index ddc1da23dd0b2..5364e6fb10118 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -142,6 +142,13 @@ static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZero return AdvSimd.CompareEqual(left, Vector128.Create(0f, 0f, 0f, 0f)); } + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariable(Vector128 left) + { + var asVar = Vector128.Create(0f, 0f, 0f, 0f); + return AdvSimd.CompareEqual(left, asVar); + } + [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128 left) { @@ -454,6 +461,9 @@ static int Tests_AdvSimd() if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero(Vector128.Zero), Single.NaN)) result = -1; + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariable(Vector128.Zero), Single.NaN)) + result = -1; + // End CompareEqual Tests return result; From 7d06ebfde6e18b8db7f4116b9a3119cc1fef62d4 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 24 Jan 2022 17:48:30 -0800 Subject: [PATCH 56/59] Fixed formatting --- src/coreclr/jit/gentree.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 620cfd5cf5803..9a3e12f0a017a 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7668,8 +7668,8 @@ inline bool GenTree::IsVectorZero() const #ifdef FEATURE_HW_INTRINSICS if (gtOper == GT_HWINTRINSIC) { - const GenTreeHWIntrinsic* node = AsHWIntrinsic(); - const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); + const GenTreeHWIntrinsic* node = AsHWIntrinsic(); + const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); if (node->GetOperandCount() == 0) { From 177cd539dcd60850fb075c5f6b68041de3c2ab45 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 25 Jan 2022 10:33:53 -0800 Subject: [PATCH 57/59] Revert lowering removal --- src/coreclr/jit/lowerarmarch.cpp | 9 +++++++-- src/coreclr/jit/lowerxarch.cpp | 9 +++++++-- 2 files changed, 14 insertions(+), 4 deletions(-) diff --git a/src/coreclr/jit/lowerarmarch.cpp b/src/coreclr/jit/lowerarmarch.cpp index 56c392cdae2a2..67e1269dfd429 100644 --- a/src/coreclr/jit/lowerarmarch.cpp +++ b/src/coreclr/jit/lowerarmarch.cpp @@ -1014,9 +1014,14 @@ void Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) if (VectorConstantIsBroadcastedI64(vecCns, simdSize / 8)) { // If we are a single constant or if all parts are the same, we might be able to optimize - // this even further for certain values, such as AllBitsSet. + // this even further for certain values, such as Zero or AllBitsSet. - if (vecCns.i64[0] == -1) + if (vecCns.i64[0] == 0) + { + node->ResetHWIntrinsicId((simdSize == 8) ? NI_Vector64_get_Zero : NI_Vector128_get_Zero); + return; + } + else if (vecCns.i64[0] == -1) { node->ResetHWIntrinsicId((simdSize == 8) ? NI_Vector64_get_AllBitsSet : NI_Vector128_get_AllBitsSet); return; diff --git a/src/coreclr/jit/lowerxarch.cpp b/src/coreclr/jit/lowerxarch.cpp index 171fdfe1126d8..1331644a0a992 100644 --- a/src/coreclr/jit/lowerxarch.cpp +++ b/src/coreclr/jit/lowerxarch.cpp @@ -1563,9 +1563,14 @@ void Lowering::LowerHWIntrinsicCreate(GenTreeHWIntrinsic* node) if (((simdSize == 16) || (simdSize == 32)) && VectorConstantIsBroadcastedI64(vecCns, simdSize / 8)) { // If we are a single constant or if all parts are the same, we might be able to optimize - // this even further for certain values, such as AllBitsSet. + // this even further for certain values, such as Zero or AllBitsSet. - if (vecCns.i64[0] == -1) + if (vecCns.i64[0] == 0) + { + node->ResetHWIntrinsicId((simdSize == 16) ? NI_Vector128_get_Zero : NI_Vector256_get_Zero); + return; + } + else if (vecCns.i64[0] == -1) { node->ResetHWIntrinsicId((simdSize == 16) ? NI_Vector128_get_AllBitsSet : NI_Vector256_get_AllBitsSet); return; From 36c4001a1a28b7e1ebc5ff3b47d3f0425b464d89 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 13:37:20 -0800 Subject: [PATCH 58/59] Update gentree.h --- src/coreclr/jit/gentree.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 6056af895080e..e5abbaff8b659 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7651,7 +7651,7 @@ inline bool GenTree::IsSIMDZero() const // inline bool GenTree::IsFloatPositiveZero() const { - if (OperGet() == GT_CNS_DBL) + if (IsCnsFltOrDbl()) { double constValue = AsDblCon()->gtDconVal; return *(__int64*)&constValue == 0; From 759e8c07803c86a52474ab4bb013f86b2ca8fa67 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 15 Feb 2022 17:32:55 -0800 Subject: [PATCH 59/59] Feedback --- src/coreclr/jit/gentree.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index e5abbaff8b659..0440c74c050aa 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -7653,6 +7653,9 @@ inline bool GenTree::IsFloatPositiveZero() const { if (IsCnsFltOrDbl()) { + // This implementation is almost identical to IsCnsNonZeroFltOrDbl + // but it is easier to parse out + // rather than using !IsCnsNonZeroFltOrDbl. double constValue = AsDblCon()->gtDconVal; return *(__int64*)&constValue == 0; } @@ -7679,14 +7682,11 @@ inline bool GenTree::IsVectorZero() const const GenTreeHWIntrinsic* node = AsHWIntrinsic(); const NamedIntrinsic intrinsicId = node->GetHWIntrinsicId(); - if (node->GetOperandCount() == 0) - { #if defined(TARGET_XARCH) - return (intrinsicId == NI_Vector128_get_Zero) || (intrinsicId == NI_Vector256_get_Zero); + return (intrinsicId == NI_Vector128_get_Zero) || (intrinsicId == NI_Vector256_get_Zero); #elif defined(TARGET_ARM64) - return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); + return (intrinsicId == NI_Vector64_get_Zero) || (intrinsicId == NI_Vector128_get_Zero); #endif // !TARGET_XARCH && !TARGET_ARM64 - } } #endif // FEATURE_HW_INTRINSICS