From 7aca5dc45856b82f565c8596cb0ec65fd66bc1fb Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 15 Dec 2021 17:58:50 -0800 Subject: [PATCH 01/83] 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 51e9afc0743987..a4b6180b680b15 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 5aade83cbda17c..93b812e4f97745 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 af0a2a1e47fe58..5d39dbc423b86a 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 706b988f049e51..27c584f3d2de8c 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 65879aff4024c3..e9ed85847083f8 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 279a20e7a36213..4d391da739f001 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 1b201603f95a1b..9ab417a20e87f3 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/83] 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 93b812e4f97745..4fc2544430c2ec 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/83] 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 a4b6180b680b15..51e9afc0743987 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 5d39dbc423b86a..3abdd00bb2d616 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 3fd3792eb8b1f9..e087476a1d8dd9 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 27c584f3d2de8c..182ba459ff1ad7 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 c89b006a418970..48d69a83fc12b8 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 4d391da739f001..a598da197accdb 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 9ab417a20e87f3..e1f395ddb28dae 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/83] 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 e087476a1d8dd9..948ebff524cc89 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/83] 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 51e9afc0743987..ff4e0b2d3c2859 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 948ebff524cc89..7b162f15ed6358 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 182ba459ff1ad7..39a4ceecc8137c 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 a598da197accdb..0bfda25fec22b9 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 e1f395ddb28dae..be92ffe5fa3a45 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/83] 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 7b162f15ed6358..f20ceeec116a80 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/83] 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 f20ceeec116a80..c684dfd8c8c9f7 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/83] 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 39a4ceecc8137c..5ab6b7a751eeb5 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 e9ed85847083f8..a2375f43c58ba8 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 0bfda25fec22b9..95d6a05a373531 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 1ee091aa07c04e..26d9a5982a0ecb 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 7d7ee6e054ec32..88622fda569665 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 b13b25f71f1dd5..79d46a4b6faec6 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 83e4a310ec7a39..c0e13fbea82dce 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 f71c7d338a62f9..4b2f6dfd8cbfed 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 aded274dfb79d6..e7c0177dd97889 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 74c0e0c152278b..78a4733d32cfb3 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 f68b360cc0e6aa..8304bb3bc38d24 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 2b56e4ab6d9b22..13a247a629166c 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 33fead32fa5186..e8fa25cd27c508 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 62fd34edfd0f0e..ffcacde6ceb9a1 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 543fe0ce0a95a1..56ef479f3846c5 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 d006f1a715fae8..cd68a85770f683 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 6d7a4d7192003e..654ba489ea93ee 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 88f56816d3b9d5..3738dc54eb14df 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 22fbf089b59a30..3f61d51536c382 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 794d092b600f9c..6f563e504fa1c2 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 a7a1d2262d2428..0de0c5a31f4774 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 7745fa0bfc76df..54a8fadcd16a59 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 b1b57ae63e1a4c..fc362a681a5fcf 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 8ed0e6473f16ab..251d66819a2aea 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 0520b792032b96..c37e9cca76dc95 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 1bb5d048973238..ddf8cfbf6c663b 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 9d9364a99220e0..031c0a669f8a0f 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 b7465422babcbc..c3787a81a0dc68 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 ffbdf964e36c22..2bc25d1f1a755e 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 83b39f57f19249..d28c6805d018df 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 150cebc294ae0c..de3bd3641e6f28 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 00000000000000..e3af2e5b402cf7 --- /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 00000000000000..5cd7fffcf5bd15 --- /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 00000000000000..971ea322d3a980 --- /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 00000000000000..7c2c09d4ba9dfd --- /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 00000000000000..9d25d54c7b71f9 --- /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 00000000000000..bf1c618dbb9077 --- /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 00000000000000..8c10a98ba34d0f --- /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 00000000000000..189fa642ce0ea0 --- /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 00000000000000..f05a70b16cb989 --- /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 00000000000000..e944fd88150b58 --- /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 00000000000000..012c06d7431b58 --- /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 00000000000000..df109aaadd6228 --- /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 00000000000000..fb19e1773bcdc4 --- /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 00000000000000..3eb92f0bc6b681 --- /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 9ab2011c865436..d0fba586242e32 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 491dda7065267c..a9c06ea07783c0 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 b471eff3acf6f4..9ece03c3257b2a 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 a076639659e677..45d9d67ee406c8 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 731a5a567feaeb..8317ad38d62ffb 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 7cf4294fb00345..4813b6d21910ef 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 c77860df01f679..ea3ac736788288 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 cecabeabc53373..cc1c88cbcbcdad 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 9b316164edef1f..b71f006eeee353 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 9b906de9804ce9..148fb9bb5b969d 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 87943f475dadd9..75ed085e957cea 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 3debb286fb9351..0e8787d6d13192 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 84670aead920cf..6949c309808873 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 ac57e2481a5685..0b905b137f1cfa 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 ec6da1aa16e206..3c982923b85561 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 00000000000000..e9570fedb65ea8 --- /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/83] 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 91aad49405a8a6..66c89c4de57d5a 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/83] 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 5ab6b7a751eeb5..f312f3fd5bd4a5 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/83] 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 26d9a5982a0ecb..1ee091aa07c04e 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 88622fda569665..7d7ee6e054ec32 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 79d46a4b6faec6..b13b25f71f1dd5 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 c0e13fbea82dce..83e4a310ec7a39 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 4b2f6dfd8cbfed..f71c7d338a62f9 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 e7c0177dd97889..aded274dfb79d6 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 78a4733d32cfb3..74c0e0c152278b 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 8304bb3bc38d24..f68b360cc0e6aa 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 13a247a629166c..2b56e4ab6d9b22 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 e8fa25cd27c508..33fead32fa5186 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 ffcacde6ceb9a1..62fd34edfd0f0e 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 56ef479f3846c5..543fe0ce0a95a1 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 cd68a85770f683..d006f1a715fae8 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 654ba489ea93ee..6d7a4d7192003e 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 3738dc54eb14df..88f56816d3b9d5 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 3f61d51536c382..22fbf089b59a30 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 6f563e504fa1c2..794d092b600f9c 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 0de0c5a31f4774..a7a1d2262d2428 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 54a8fadcd16a59..7745fa0bfc76df 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 fc362a681a5fcf..b1b57ae63e1a4c 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 251d66819a2aea..8ed0e6473f16ab 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 c37e9cca76dc95..0520b792032b96 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 ddf8cfbf6c663b..1bb5d048973238 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 031c0a669f8a0f..9d9364a99220e0 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 c3787a81a0dc68..b7465422babcbc 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 2bc25d1f1a755e..ffbdf964e36c22 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 d28c6805d018df..83b39f57f19249 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 de3bd3641e6f28..150cebc294ae0c 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 d0fba586242e32..9ab2011c865436 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 a9c06ea07783c0..491dda7065267c 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 9ece03c3257b2a..b471eff3acf6f4 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 45d9d67ee406c8..a076639659e677 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 8317ad38d62ffb..731a5a567feaeb 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 4813b6d21910ef..7cf4294fb00345 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 ea3ac736788288..c77860df01f679 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 cc1c88cbcbcdad..cecabeabc53373 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 b71f006eeee353..9b316164edef1f 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 148fb9bb5b969d..9b906de9804ce9 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 75ed085e957cea..87943f475dadd9 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 0e8787d6d13192..3debb286fb9351 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 6949c309808873..84670aead920cf 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 0b905b137f1cfa..ac57e2481a5685 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 3c982923b85561..ec6da1aa16e206 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 e9570fedb65ea8..00000000000000 --- 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/83] 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 e3af2e5b402cf7..00000000000000 --- 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 5cd7fffcf5bd15..00000000000000 --- 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 971ea322d3a980..00000000000000 --- 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 7c2c09d4ba9dfd..00000000000000 --- 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 9d25d54c7b71f9..00000000000000 --- 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 bf1c618dbb9077..00000000000000 --- 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 8c10a98ba34d0f..00000000000000 --- 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 189fa642ce0ea0..00000000000000 --- 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 f05a70b16cb989..00000000000000 --- 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 e944fd88150b58..00000000000000 --- 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 012c06d7431b58..00000000000000 --- 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 df109aaadd6228..00000000000000 --- 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 fb19e1773bcdc4..00000000000000 --- 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 3eb92f0bc6b681..00000000000000 --- 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/83] 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 00000000000000..dac9a8172a5153 --- /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 00000000000000..8f2c8355c3f11f --- /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/83] 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 66c89c4de57d5a..91aad49405a8a6 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 6773d68622c3bc..d4d5f140833f24 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/83] 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 8f2c8355c3f11f..69a8f62fa0e12d 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 00000000000000..bf6f589eb325bb --- /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/83] 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 94b322ebf25d89..1410f2cf69fd5c 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/83] 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 b021a0e71baaf1..275d256844d96b 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 f1b3a380231639..e4b9a1326680c0 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 67decddf2f8edf..7b0ed86e3c529f 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 48d69a83fc12b8..d4e7ef5b10c8d6 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 91aad49405a8a6..0ea35082692946 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/83] 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 bf6f589eb325bb..00000000000000 --- 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/83] 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 1410f2cf69fd5c..752d3f245f4ae7 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/83] 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 275d256844d96b..758fecb7086a15 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 752d3f245f4ae7..785159211be227 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/83] 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 758fecb7086a15..971b18668ec83b 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/83] 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 971b18668ec83b..287993ceccb1b6 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/83] 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 785159211be227..7535cd334d9624 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/83] 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 7f530ac2ce96d2..d7daa1c94c96d0 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 a13e3df246e493..050de316aa70ff 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 1ee03c84a398f0..33b980d24da771 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/83] 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 4da5ba3dd174f3..7ab7fed97b14b8 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/83] 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 7ab7fed97b14b8..077d363b33eead 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 287993ceccb1b6..745bd21ade3ce1 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 09223e6971d64e..796a9e8126e6f1 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 adf2a3be3f16b2..936746afc5e3ed 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/83] 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 745bd21ade3ce1..3163b29dc6ae19 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/83] 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 077d363b33eead..9246b052a52015 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 936746afc5e3ed..908acf8b20bbd8 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/83] 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 1d4959fabb6d1d..5462455bef84f1 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 613d1e7c0d748f..eb0f067d6ac89e 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/83] 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 5462455bef84f1..1fedbf5eae072a 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/83] 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 1fedbf5eae072a..cf544bd0ac0f44 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/83] 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 cf544bd0ac0f44..502e769a8835ce 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/83] 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 502e769a8835ce..8d52ad1ac7695c 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/83] 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 8d52ad1ac7695c..29257f575c769f 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 7eeb3b0f57bd2a..0f2ce9dbc48237 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/83] 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 29257f575c769f..8d52ad1ac7695c 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/83] 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 7535cd334d9624..ddc1da23dd0b29 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/83] 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 992a2cb1c0f38a..b848508c96aaa1 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/83] 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 c2efe70bfe405b..14fa27e58a4bb6 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/83] 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 de2d334040ccca..79992782658233 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 14fa27e58a4bb6..b8897e81dc8e34 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 d960fff1cfcc3c..6df972c716a7f3 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/83] 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 3c9368eaa8f10b..7025050d2b2109 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/83] 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 7025050d2b2109..a08e6d710fe872 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/83] 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 a08e6d710fe872..4330d7ac903917 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/83] 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 4330d7ac903917..bbf5f522b15d48 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/83] 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 bbf5f522b15d48..ea3d10a0d34f8d 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/83] 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 35477a29d8734d..87360df540e957 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/83] 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 87360df540e957..620cfd5cf58037 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/83] 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 67e1269dfd429a..56c392cdae2a29 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 1331644a0a992b..171fdfe1126d80 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/83] 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 ddc1da23dd0b29..5364e6fb101182 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/83] 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 620cfd5cf58037..9a3e12f0a017a2 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/83] 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 56c392cdae2a29..67e1269dfd429a 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 171fdfe1126d80..1331644a0a992b 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 feed7383a1c0df7bc6e1e94a736c3a1f5ef80fa2 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 7 Feb 2022 20:25:03 -0800 Subject: [PATCH 58/83] Initial work for optimizations on VectorZero value numbering --- src/coreclr/jit/assertionprop.cpp | 18 ++++++++++++-- src/coreclr/jit/liveness.cpp | 4 +++ src/coreclr/jit/valuenum.cpp | 41 +++++++++++++++++++++++++++++++ src/coreclr/jit/valuenum.h | 5 ++++ 4 files changed, 66 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index 4e0e708be326c6..85619eb66887f6 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -2874,7 +2874,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) ValueNum vnCns = vnStore->VNConservativeNormalValue(vnPair); // Check if node evaluates to a constant. - if (!vnStore->IsVNConstant(vnCns)) + if (!vnStore->IsVNConstant(vnCns) && !vnStore->IsVNVectorZero(vnCns)) { return nullptr; } @@ -3033,6 +3033,19 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) } break; +#if FEATURE_HW_INTRINSICS + case TYP_SIMD8: + case TYP_SIMD12: + case TYP_SIMD16: + case TYP_SIMD32: + { + conValTree = gtNewSimdZeroNode(tree->TypeGet(), CorInfoType::CORINFO_TYPE_FLOAT, 16, + true); // gtGetSIMDZero(tree->TypeGet(), CorInfoType::CORINFO_TYPE_FLOAT, + // varDsc->GetStructHnd()); + } + break; +#endif + case TYP_BYREF: // Do not support const byref optimization. break; @@ -5412,7 +5425,8 @@ struct VNAssertionPropVisitorInfo // GenTree* Compiler::optExtractSideEffListFromConst(GenTree* tree) { - assert(vnStore->IsVNConstant(vnStore->VNConservativeNormalValue(tree->gtVNPair))); + assert(vnStore->IsVNConstant(vnStore->VNConservativeNormalValue(tree->gtVNPair)) || + vnStore->IsVNVectorZero(vnStore->VNConservativeNormalValue(tree->gtVNPair))); GenTree* sideEffList = nullptr; diff --git a/src/coreclr/jit/liveness.cpp b/src/coreclr/jit/liveness.cpp index d9592683db7981..61a5af2f6cd546 100644 --- a/src/coreclr/jit/liveness.cpp +++ b/src/coreclr/jit/liveness.cpp @@ -2068,6 +2068,10 @@ void Compiler::fgComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VARSET_VALAR case GT_KEEPALIVE: #ifdef FEATURE_HW_INTRINSICS case GT_HWINTRINSIC: + if (node->IsVectorZero()) + { + fgTryRemoveNonLocal(node, &blockRange); + } #endif // FEATURE_HW_INTRINSICS // Never remove these nodes, as they are always side-effecting. // diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 3ec66459831975..2317e880cd7c44 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4594,6 +4594,47 @@ bool ValueNumStore::IsVNConstant(ValueNum vn) } } +bool ValueNumStore::IsVNVectorZero(ValueNum vn) +{ + if (vn == NoVN) + { + return false; + } +#if FEATURE_HW_INTRINSICS + Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); + if (c->m_attribs == CEA_Func1) + { + VNDefFunc1Arg* const chunkSlots = reinterpret_cast(c->m_defs); + if (chunkSlots[vn - c->m_baseVN].m_func == VNF_HWI_Vector128_get_Zero) + { + return true; + } + } +#endif + return false; +} + +var_types ValueNumStore::GetVectorType(ValueNum vn) +{ + if (vn == NoVN) + { + return TYP_UNKNOWN; + } +//#if FEATURE_HW_INTRINSICS +// Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); +// if (c->m_attribs == CEA_Func1) +// { +// VNDefFunc1Arg* const chunkSlots = reinterpret_cast(c->m_defs); +// +// ValueNum baseTypeVN = chunkSlots[vn - c->m_baseVN].m_arg0; +// var_types simdBaseType = (CorInfoType)GetConstantInt32(baseTypeVN); +// +// return simdBaseType; +// } +//#endif + return TYP_UNKNOWN; +} + bool ValueNumStore::IsVNInt32Constant(ValueNum vn) { if (!IsVNConstant(vn)) diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h index 6c19327c800375..cfe66b77172ed5 100644 --- a/src/coreclr/jit/valuenum.h +++ b/src/coreclr/jit/valuenum.h @@ -714,6 +714,11 @@ class ValueNumStore // Returns true iff the VN represents a (non-handle) constant. bool IsVNConstant(ValueNum vn); + // Returns true iff the VN represents a (non-handle) constant. + bool IsVNVectorZero(ValueNum vn); + + var_types GetVectorType(ValueNum vn); + // Returns true iff the VN represents an integer constant. bool IsVNInt32Constant(ValueNum vn); From 9840c5b83a3eab5e23ed0d3c2c38e2e950827869 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 13:35:44 -0800 Subject: [PATCH 59/83] Allowing all Vector.Zero to be constant prop'ed. Added VNFuncSimdTypeInfo. --- src/coreclr/jit/assertionprop.cpp | 15 +++++-- src/coreclr/jit/liveness.cpp | 15 ++++--- src/coreclr/jit/valuenum.cpp | 72 +++++++++++++++++++++---------- src/coreclr/jit/valuenum.h | 17 ++++++-- 4 files changed, 84 insertions(+), 35 deletions(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index 85619eb66887f6..d88a15fcb38d97 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -2873,7 +2873,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) ValueNumPair vnPair = tree->gtVNPair; ValueNum vnCns = vnStore->VNConservativeNormalValue(vnPair); - // Check if node evaluates to a constant. + // Check if node evaluates to a constant or Vector.Zero. if (!vnStore->IsVNConstant(vnCns) && !vnStore->IsVNVectorZero(vnCns)) { return nullptr; @@ -3039,9 +3039,16 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) case TYP_SIMD16: case TYP_SIMD32: { - conValTree = gtNewSimdZeroNode(tree->TypeGet(), CorInfoType::CORINFO_TYPE_FLOAT, 16, - true); // gtGetSIMDZero(tree->TypeGet(), CorInfoType::CORINFO_TYPE_FLOAT, - // varDsc->GetStructHnd()); + assert(vnStore->IsVNVectorZero(vnCns)); + + VNFuncSimdTypeInfo vnInfo = vnStore->GetFuncSimdTypeOfVN(vnCns); + + assert(vnInfo.m_simdBaseJitType != CORINFO_TYPE_UNDEF); + assert(vnInfo.m_simdSize != 0); + assert(getSIMDTypeForSize(vnInfo.m_simdSize) == vnStore->TypeOfVN(vnCns)); + + conValTree = gtNewSimdZeroNode(tree->TypeGet(), vnInfo.m_simdBaseJitType, vnInfo.m_simdSize, + true); } break; #endif diff --git a/src/coreclr/jit/liveness.cpp b/src/coreclr/jit/liveness.cpp index 61a5af2f6cd546..b6dc9acbe76425 100644 --- a/src/coreclr/jit/liveness.cpp +++ b/src/coreclr/jit/liveness.cpp @@ -2066,19 +2066,22 @@ void Compiler::fgComputeLifeLIR(VARSET_TP& life, BasicBlock* block, VARSET_VALAR case GT_PUTARG_STK: case GT_IL_OFFSET: case GT_KEEPALIVE: + // Never remove these nodes, as they are always side-effecting. + // + // NOTE: the only side-effect of some of these nodes (GT_CMP, GT_SUB_HI) is a write to the flags + // register. + // Properly modeling this would allow these nodes to be removed. + break; + #ifdef FEATURE_HW_INTRINSICS case GT_HWINTRINSIC: + // Conservative: This only removes Vector.Zero nodes, but could be expanded. if (node->IsVectorZero()) { fgTryRemoveNonLocal(node, &blockRange); } -#endif // FEATURE_HW_INTRINSICS - // Never remove these nodes, as they are always side-effecting. - // - // NOTE: the only side-effect of some of these nodes (GT_CMP, GT_SUB_HI) is a write to the flags - // register. - // Properly modeling this would allow these nodes to be removed. break; +#endif // FEATURE_HW_INTRINSICS case GT_NOP: { diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 2317e880cd7c44..6f8821f71c470f 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -1888,7 +1888,7 @@ ValueNum ValueNumStore::VNZeroForType(var_types typ) // "fully zeroed" vectors, and here we may be loading one from memory, leaving upper // bits undefined. So using "SIMD_Init" is "the next best thing", so to speak, and // TYP_FLOAT is one of the more popular base types, so that's why we use it here. - return VNForFunc(typ, VNF_SIMD_Init, VNForFloatCon(0), VNForSimdType(genTypeSize(typ), TYP_FLOAT)); + return VNForFunc(typ, VNF_SIMD_Init, VNForFloatCon(0), VNForSimdType(genTypeSize(typ), CORINFO_TYPE_FLOAT)); #endif // FEATURE_SIMD // These should be unreached. @@ -1935,9 +1935,9 @@ ValueNum ValueNumStore::VNOneForType(var_types typ) } #ifdef FEATURE_SIMD -ValueNum ValueNumStore::VNForSimdType(unsigned simdSize, var_types simdBaseType) +ValueNum ValueNumStore::VNForSimdType(unsigned simdSize, CorInfoType simdBaseJitType) { - ValueNum baseTypeVN = VNForIntCon(INT32(simdBaseType)); + ValueNum baseTypeVN = VNForIntCon(INT32(simdBaseJitType)); ValueNum sizeVN = VNForIntCon(simdSize); ValueNum simdTypeVN = VNForFunc(TYP_REF, VNF_SimdType, sizeVN, baseTypeVN); @@ -4605,35 +4605,63 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) if (c->m_attribs == CEA_Func1) { VNDefFunc1Arg* const chunkSlots = reinterpret_cast(c->m_defs); - if (chunkSlots[vn - c->m_baseVN].m_func == VNF_HWI_Vector128_get_Zero) + VNFunc vnFunc = chunkSlots[vn - c->m_baseVN].m_func; + switch (chunkSlots[vn - c->m_baseVN].m_func) { - return true; + case VNF_HWI_Vector128_get_Zero: +#if defined(TARGET_XARCH) + case VNF_HWI_Vector256_get_Zero: +#elif defined(TARGET_ARM64) + case VNF_HWI_Vector64_get_Zero: +#endif + { + return true; + } } } #endif return false; } -var_types ValueNumStore::GetVectorType(ValueNum vn) +#if FEATURE_SIMD +VNFuncSimdTypeInfo ValueNumStore::GetFuncSimdTypeOfVN(ValueNum vn) { + VNFuncSimdTypeInfo vnFuncSimdType; + if (vn == NoVN) { - return TYP_UNKNOWN; + vnFuncSimdType.m_simdTypeVN = NoVN; + vnFuncSimdType.m_simdSize = 0; + vnFuncSimdType.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnFuncSimdType; } -//#if FEATURE_HW_INTRINSICS -// Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); -// if (c->m_attribs == CEA_Func1) -// { -// VNDefFunc1Arg* const chunkSlots = reinterpret_cast(c->m_defs); -// -// ValueNum baseTypeVN = chunkSlots[vn - c->m_baseVN].m_arg0; -// var_types simdBaseType = (CorInfoType)GetConstantInt32(baseTypeVN); -// -// return simdBaseType; -// } -//#endif - return TYP_UNKNOWN; + Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); + if (c->m_attribs == CEA_Func1) + { + VNDefFunc1Arg* chunkSlots = reinterpret_cast(c->m_defs); + ValueNum simdTypeVN = chunkSlots[vn - c->m_baseVN].m_arg0; + Chunk* simdTypeChunk = m_chunks.GetNoExpand(GetChunkNum(simdTypeVN)); + + if (simdTypeChunk->m_attribs == CEA_Func2 && simdTypeChunk->m_typ == TYP_REF) + { + VNDefFunc2Arg* simdTypeChunkSlots = reinterpret_cast(simdTypeChunk->m_defs); + VNDefFunc2Arg simdTypeSlot = simdTypeChunkSlots[simdTypeVN - simdTypeChunk->m_baseVN]; + + if (simdTypeSlot.m_func == VNF_SimdType) + { + vnFuncSimdType.m_simdTypeVN = simdTypeVN; + vnFuncSimdType.m_simdSize = GetConstantInt32(simdTypeSlot.m_arg0); + vnFuncSimdType.m_simdBaseJitType = (CorInfoType)GetConstantInt32(simdTypeSlot.m_arg1); + return vnFuncSimdType; + } + } + } + vnFuncSimdType.m_simdTypeVN = NoVN; + vnFuncSimdType.m_simdSize = 0; + vnFuncSimdType.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnFuncSimdType; } +#endif // FEATURE_SIMD bool ValueNumStore::IsVNInt32Constant(ValueNum vn) { @@ -9595,7 +9623,7 @@ void Compiler::fgValueNumberSimd(GenTreeSIMD* tree) if (encodeResultType) { - ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseType()); + ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitType()); resvnp.SetBoth(simdTypeVN); #ifdef DEBUG @@ -9710,7 +9738,7 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree) if (encodeResultType) { - ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseType()); + ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitType()); resvnp.SetBoth(simdTypeVN); #ifdef DEBUG diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h index cfe66b77172ed5..40452da12d5d9a 100644 --- a/src/coreclr/jit/valuenum.h +++ b/src/coreclr/jit/valuenum.h @@ -184,6 +184,14 @@ struct VNFuncApp } }; +// An instance of this struct represents the decoded information of a SIMD type from a value number of a function. +struct VNFuncSimdTypeInfo +{ + ValueNum m_simdTypeVN; + unsigned int m_simdSize; + CorInfoType m_simdBaseJitType; +}; + // We use a unique prefix character when printing value numbers in dumps: i.e. $1c0 // This define is used with string concatenation to put this in printf format strings #define FMT_VN "$%x" @@ -463,7 +471,7 @@ class ValueNumStore #ifdef FEATURE_SIMD // A helper function for constructing VNF_SimdType VNs. - ValueNum VNForSimdType(unsigned simdSize, var_types simdBaseType); + ValueNum VNForSimdType(unsigned simdSize, CorInfoType simdBaseJitType); #endif // FEATURE_SIMD // Create or return the existimg value number representing a singleton exception set @@ -714,10 +722,13 @@ class ValueNumStore // Returns true iff the VN represents a (non-handle) constant. bool IsVNConstant(ValueNum vn); - // Returns true iff the VN represents a (non-handle) constant. + // Returns true if the VN represents a Vector64/128/256.Zero. bool IsVNVectorZero(ValueNum vn); - var_types GetVectorType(ValueNum vn); +#if FEATURE_SIMD + /// Returns VNFuncSimdTypeInfo(NoVN, 0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type on a function. + VNFuncSimdTypeInfo GetFuncSimdTypeOfVN(ValueNum vn); +#endif // Returns true iff the VN represents an integer constant. bool IsVNInt32Constant(ValueNum vn); From 36c4001a1a28b7e1ebc5ff3b47d3f0425b464d89 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 13:37:20 -0800 Subject: [PATCH 60/83] 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 6056af895080eb..e5abbaff8b6597 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 b074f09889789a26a2241600838d77d769cb5ac6 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 14:26:40 -0800 Subject: [PATCH 61/83] Quick rename --- src/coreclr/jit/valuenum.cpp | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 6f8821f71c470f..dd200d9e3516d3 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4626,14 +4626,14 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) #if FEATURE_SIMD VNFuncSimdTypeInfo ValueNumStore::GetFuncSimdTypeOfVN(ValueNum vn) { - VNFuncSimdTypeInfo vnFuncSimdType; + VNFuncSimdTypeInfo vnInfo; if (vn == NoVN) { - vnFuncSimdType.m_simdTypeVN = NoVN; - vnFuncSimdType.m_simdSize = 0; - vnFuncSimdType.m_simdBaseJitType = CORINFO_TYPE_UNDEF; - return vnFuncSimdType; + vnInfo.m_simdTypeVN = NoVN; + vnInfo.m_simdSize = 0; + vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnInfo; } Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); if (c->m_attribs == CEA_Func1) @@ -4649,17 +4649,17 @@ VNFuncSimdTypeInfo ValueNumStore::GetFuncSimdTypeOfVN(ValueNum vn) if (simdTypeSlot.m_func == VNF_SimdType) { - vnFuncSimdType.m_simdTypeVN = simdTypeVN; - vnFuncSimdType.m_simdSize = GetConstantInt32(simdTypeSlot.m_arg0); - vnFuncSimdType.m_simdBaseJitType = (CorInfoType)GetConstantInt32(simdTypeSlot.m_arg1); - return vnFuncSimdType; + vnInfo.m_simdTypeVN = simdTypeVN; + vnInfo.m_simdSize = GetConstantInt32(simdTypeSlot.m_arg0); + vnInfo.m_simdBaseJitType = (CorInfoType)GetConstantInt32(simdTypeSlot.m_arg1); + return vnInfo; } } } - vnFuncSimdType.m_simdTypeVN = NoVN; - vnFuncSimdType.m_simdSize = 0; - vnFuncSimdType.m_simdBaseJitType = CORINFO_TYPE_UNDEF; - return vnFuncSimdType; + vnInfo.m_simdTypeVN = NoVN; + vnInfo.m_simdSize = 0; + vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnInfo; } #endif // FEATURE_SIMD From 2331a6e00e8156154af62261de9c0a0fabf03cf5 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 14:42:55 -0800 Subject: [PATCH 62/83] Removed extra variable --- src/coreclr/jit/valuenum.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index dd200d9e3516d3..dc2341cde62c26 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4605,7 +4605,6 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) if (c->m_attribs == CEA_Func1) { VNDefFunc1Arg* const chunkSlots = reinterpret_cast(c->m_defs); - VNFunc vnFunc = chunkSlots[vn - c->m_baseVN].m_func; switch (chunkSlots[vn - c->m_baseVN].m_func) { case VNF_HWI_Vector128_get_Zero: From f0d1eccca3a1990887aa639967c569fa3e3aeba0 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 14:45:49 -0800 Subject: [PATCH 63/83] Added default case --- src/coreclr/jit/valuenum.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index dc2341cde62c26..d9acd0227d92d4 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4616,6 +4616,9 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) { return true; } + + default: + return false; } } #endif From b15036f6abfce1e4773b961a391adf9cb75a9ae3 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 8 Feb 2022 14:51:14 -0800 Subject: [PATCH 64/83] Format --- src/coreclr/jit/assertionprop.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index d88a15fcb38d97..76f9d441605693 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -3050,7 +3050,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) conValTree = gtNewSimdZeroNode(tree->TypeGet(), vnInfo.m_simdBaseJitType, vnInfo.m_simdSize, true); } - break; + break; #endif case TYP_BYREF: From d27d87781f332433753f8e6951af3776224fee63 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 9 Feb 2022 12:23:11 -0800 Subject: [PATCH 65/83] Fixed vnDumpSimdType to take into account CorInfoType --- src/coreclr/jit/valuenum.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index d9acd0227d92d4..60285d60ec42d5 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -6230,10 +6230,10 @@ void ValueNumStore::vnDumpSimdType(Compiler* comp, VNFuncApp* simdType) assert(IsVNConstant(simdType->m_args[0])); assert(IsVNConstant(simdType->m_args[1])); - int simdSize = ConstantValue(simdType->m_args[0]); - var_types baseType = (var_types)ConstantValue(simdType->m_args[1]); + int simdSize = ConstantValue(simdType->m_args[0]); + CorInfoType baseJitType = (CorInfoType)ConstantValue(simdType->m_args[1]); - printf("%s(simd%d, %s)", VNFuncName(simdType->m_func), simdSize, varTypeName(baseType)); + printf("%s(simd%d, %s)", VNFuncName(simdType->m_func), simdSize, varTypeName(JitType2PreciseVarType(baseJitType))); } #endif // FEATURE_SIMD From e48ad6536d410ba56e05eb79793a8a1536f5bed2 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 9 Feb 2022 13:27:13 -0800 Subject: [PATCH 66/83] Fixed gtNewSimdZeroNode to produce the right Vector*_get_Zero based on simdSize --- 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 61dda8f4ca86bf..3bf8a2ab4a9b79 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -21336,9 +21336,9 @@ GenTree* Compiler::gtNewSimdZeroNode(var_types type, NamedIntrinsic intrinsic = NI_Illegal; #if defined(TARGET_XARCH) - intrinsic = (simdSize == 32) ? NI_Vector256_get_Zero : NI_Vector128_get_Zero; + intrinsic = (simdSize > 16) ? NI_Vector256_get_Zero : NI_Vector128_get_Zero; #elif defined(TARGET_ARM64) - intrinsic = (simdSize == 16) ? NI_Vector128_get_Zero : NI_Vector64_get_Zero; + intrinsic = (simdSize > 8) ? NI_Vector128_get_Zero : NI_Vector64_get_Zero; #else #error Unsupported platform #endif // !TARGET_XARCH && !TARGET_ARM64 From da48e4e32a14a2a346a4acfd953494aac7495a4f Mon Sep 17 00:00:00 2001 From: Will Smith Date: Wed, 9 Feb 2022 16:37:56 -0800 Subject: [PATCH 67/83] Formatting --- src/coreclr/jit/assertionprop.cpp | 3 +-- src/coreclr/jit/gentree.cpp | 2 +- src/coreclr/jit/valuenum.h | 3 ++- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index 76f9d441605693..f1bac0708b66e4 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -3047,8 +3047,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) assert(vnInfo.m_simdSize != 0); assert(getSIMDTypeForSize(vnInfo.m_simdSize) == vnStore->TypeOfVN(vnCns)); - conValTree = gtNewSimdZeroNode(tree->TypeGet(), vnInfo.m_simdBaseJitType, vnInfo.m_simdSize, - true); + conValTree = gtNewSimdZeroNode(tree->TypeGet(), vnInfo.m_simdBaseJitType, vnInfo.m_simdSize, true); } break; #endif diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 3bf8a2ab4a9b79..a3c2d6e6dbc885 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -21336,7 +21336,7 @@ GenTree* Compiler::gtNewSimdZeroNode(var_types type, NamedIntrinsic intrinsic = NI_Illegal; #if defined(TARGET_XARCH) - intrinsic = (simdSize > 16) ? NI_Vector256_get_Zero : NI_Vector128_get_Zero; + intrinsic = (simdSize == 32) ? NI_Vector256_get_Zero : NI_Vector128_get_Zero; #elif defined(TARGET_ARM64) intrinsic = (simdSize > 8) ? NI_Vector128_get_Zero : NI_Vector64_get_Zero; #else diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h index 40452da12d5d9a..30e8acab6439cf 100644 --- a/src/coreclr/jit/valuenum.h +++ b/src/coreclr/jit/valuenum.h @@ -726,7 +726,8 @@ class ValueNumStore bool IsVNVectorZero(ValueNum vn); #if FEATURE_SIMD - /// Returns VNFuncSimdTypeInfo(NoVN, 0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type on a function. + /// Returns VNFuncSimdTypeInfo(NoVN, 0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type + /// on a function. VNFuncSimdTypeInfo GetFuncSimdTypeOfVN(ValueNum vn); #endif From 3785e342ef5707d1ed9da076054cf1a0a4c2b7b6 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 10 Feb 2022 16:19:41 -0800 Subject: [PATCH 68/83] Feedback and a loop test --- src/coreclr/jit/assertionprop.cpp | 2 +- src/coreclr/jit/valuenum.cpp | 61 +++++++++++-------- src/coreclr/jit/valuenum.h | 14 +++-- .../JitBlue/Runtime_33972/Runtime_33972.cs | 25 ++++++++ 4 files changed, 70 insertions(+), 32 deletions(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index f1bac0708b66e4..7acfcb81b3b7d5 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -3041,7 +3041,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) { assert(vnStore->IsVNVectorZero(vnCns)); - VNFuncSimdTypeInfo vnInfo = vnStore->GetFuncSimdTypeOfVN(vnCns); + VNSimdTypeInfo vnInfo = vnStore->GetVectorZeroSimdTypeOfVN(vnCns); assert(vnInfo.m_simdBaseJitType != CORINFO_TYPE_UNDEF); assert(vnInfo.m_simdSize != 0); diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 60285d60ec42d5..faa6255b3d944b 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4601,11 +4601,10 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) return false; } #if FEATURE_HW_INTRINSICS - Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); - if (c->m_attribs == CEA_Func1) + VNFuncApp funcApp; + if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { - VNDefFunc1Arg* const chunkSlots = reinterpret_cast(c->m_defs); - switch (chunkSlots[vn - c->m_baseVN].m_func) + switch (funcApp.m_func) { case VNF_HWI_Vector128_get_Zero: #if defined(TARGET_XARCH) @@ -4626,39 +4625,51 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) } #if FEATURE_SIMD -VNFuncSimdTypeInfo ValueNumStore::GetFuncSimdTypeOfVN(ValueNum vn) +VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) { - VNFuncSimdTypeInfo vnInfo; + VNSimdTypeInfo vnInfo; if (vn == NoVN) { - vnInfo.m_simdTypeVN = NoVN; vnInfo.m_simdSize = 0; vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; return vnInfo; } - Chunk* c = m_chunks.GetNoExpand(GetChunkNum(vn)); - if (c->m_attribs == CEA_Func1) + + // The SIMD type is encoded as a function, + // even though it is not actually a function. + VNFuncApp simdType; + if (GetVNFunc(vn, &simdType) && simdType.m_func == VNF_SimdType && simdType.m_arity == 2) { - VNDefFunc1Arg* chunkSlots = reinterpret_cast(c->m_defs); - ValueNum simdTypeVN = chunkSlots[vn - c->m_baseVN].m_arg0; - Chunk* simdTypeChunk = m_chunks.GetNoExpand(GetChunkNum(simdTypeVN)); + vnInfo.m_simdSize = GetConstantInt32(simdType.m_args[0]); + vnInfo.m_simdBaseJitType = (CorInfoType)GetConstantInt32(simdType.m_args[1]); + return vnInfo; + } - if (simdTypeChunk->m_attribs == CEA_Func2 && simdTypeChunk->m_typ == TYP_REF) - { - VNDefFunc2Arg* simdTypeChunkSlots = reinterpret_cast(simdTypeChunk->m_defs); - VNDefFunc2Arg simdTypeSlot = simdTypeChunkSlots[simdTypeVN - simdTypeChunk->m_baseVN]; + vnInfo.m_simdSize = 0; + vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnInfo; +} - if (simdTypeSlot.m_func == VNF_SimdType) - { - vnInfo.m_simdTypeVN = simdTypeVN; - vnInfo.m_simdSize = GetConstantInt32(simdTypeSlot.m_arg0); - vnInfo.m_simdBaseJitType = (CorInfoType)GetConstantInt32(simdTypeSlot.m_arg1); - return vnInfo; - } - } +VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) +{ + VNSimdTypeInfo vnInfo; + + if (!IsVNVectorZero(vn)) + { + vnInfo.m_simdSize = 0; + vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnInfo; + } + + // Vector.Zero does not have any arguments, + // but its SIMD type is encoded as an argument. + VNFuncApp funcApp; + if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) + { + return GetSimdTypeOfVN(funcApp.m_args[0]); } - vnInfo.m_simdTypeVN = NoVN; + vnInfo.m_simdSize = 0; vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; return vnInfo; diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h index 30e8acab6439cf..9a742d0ba94139 100644 --- a/src/coreclr/jit/valuenum.h +++ b/src/coreclr/jit/valuenum.h @@ -184,10 +184,9 @@ struct VNFuncApp } }; -// An instance of this struct represents the decoded information of a SIMD type from a value number of a function. -struct VNFuncSimdTypeInfo +// An instance of this struct represents the decoded information of a SIMD type from a value number. +struct VNSimdTypeInfo { - ValueNum m_simdTypeVN; unsigned int m_simdSize; CorInfoType m_simdBaseJitType; }; @@ -726,9 +725,12 @@ class ValueNumStore bool IsVNVectorZero(ValueNum vn); #if FEATURE_SIMD - /// Returns VNFuncSimdTypeInfo(NoVN, 0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type - /// on a function. - VNFuncSimdTypeInfo GetFuncSimdTypeOfVN(ValueNum vn); + /// Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type. + VNSimdTypeInfo GetSimdTypeOfVN(ValueNum vn); + + /// Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type + /// for a Vector.Zero value number. + VNSimdTypeInfo GetVectorZeroSimdTypeOfVN(ValueNum vn); #endif // Returns true iff the VN represents an integer constant. 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 5364e6fb101182..46b0f7790dd79b 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -149,6 +149,28 @@ static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZero return AdvSimd.CompareEqual(left, asVar); } + [MethodImpl(MethodImplOptions.NoInlining)] + static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariableLoop(Vector128 left) + { + Vector128 result = default; + var asVar = Vector128.Create(0f, 0f, 0f, 0f); + for (var i = 0; i < 4; i++) + { + result = AdvSimd.CompareEqual(left, asVar); + result = AdvSimd.CompareEqual(left, asVar); + result = AdvSimd.CompareEqual(left, asVar); + result = AdvSimd.CompareEqual(left, asVar); + for (var j = 0; j < 4; j++) + { + result = AdvSimd.CompareEqual(left, asVar); + result = AdvSimd.CompareEqual(left, asVar); + result = AdvSimd.CompareEqual(left, asVar); + result = AdvSimd.CompareEqual(left, asVar); + } + } + return result; + } + [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128 left) { @@ -464,6 +486,9 @@ static int Tests_AdvSimd() if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariable(Vector128.Zero), Single.NaN)) result = -1; + if (!ValidateResult_Vector128(AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZeroZero_AsVariableLoop(Vector128.Zero), Single.NaN)) + result = -1; + // End CompareEqual Tests return result; From 2b108d2c29a1387126a14d1b64f2c93a6fa0228d Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 10 Feb 2022 18:08:40 -0800 Subject: [PATCH 69/83] Added another test. Formatting fixes --- src/coreclr/jit/valuenum.cpp | 2 +- .../JitBlue/Runtime_33972/Runtime_33972.cs | 21 +++++++++++++++++++ 2 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index faa6255b3d944b..b79dc048a1cc4d 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4667,7 +4667,7 @@ VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) VNFuncApp funcApp; if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { - return GetSimdTypeOfVN(funcApp.m_args[0]); + return GetSimdTypeOfVN(funcApp.m_args[0]); } vnInfo.m_simdSize = 0; 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 46b0f7790dd79b..04520f0d19a174 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_33972/Runtime_33972.cs @@ -171,6 +171,24 @@ static Vector128 AdvSimd_CompareEqual_Vector128_Single_CreateZeroZeroZero return result; } + [MethodImpl(MethodImplOptions.NoInlining)] + static unsafe Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Long_AsVariableLoop(Vector128 left) + { + Vector128 result = default; + Vector128 asVar = Vector128.Create((long)0); + Vector128 asVar2 = Vector128.Create((nint)0); + Vector128 asVar3 = asVar2.AsInt64(); + for (var i = 0; i < 4; i++) + { + result = AdvSimd.Arm64.CompareEqual(left, asVar); + for (var j = 0; j < 4; j++) + { + result = AdvSimd.Arm64.CompareEqual(left, asVar3); + } + } + return result; + } + [MethodImpl(MethodImplOptions.NoInlining)] static Vector128 AdvSimd_Arm64_CompareEqual_Vector128_Double_Zero(Vector128 left) { @@ -568,6 +586,9 @@ static int Tests_AdvSimd_Arm64() if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Int64_Zero(Vector128.Zero), -1)) result = -1; + if (!ValidateResult_Vector128(AdvSimd_Arm64_CompareEqual_Vector128_Long_AsVariableLoop(Vector128.Zero), -1)) + result = -1; + // Vector64 if (!ValidateResult_Vector64(AdvSimd_Arm64_CompareEqualScalar_Vector64_Single_Zero(Vector64.Zero), Vector64.CreateScalar(Single.NaN))) From b1c44cff65532780bc8199f8e2a9789f06e137e0 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 10 Feb 2022 19:06:05 -0800 Subject: [PATCH 70/83] Added GetSimdBaseJitPreciseType --- src/coreclr/jit/gentree.h | 28 ++++++++++++++++++++++++++++ src/coreclr/jit/valuenum.cpp | 4 ++-- 2 files changed, 30 insertions(+), 2 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index e5abbaff8b6597..a26319b073255d 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -5259,6 +5259,34 @@ struct GenTreeJitIntrinsic : public GenTreeMultiOp return (CorInfoType)gtSimdBaseJitType; } + CorInfoType GetSimdBaseJitPreciseType() const + { + CorInfoType simdBaseJitType = GetSimdBaseJitType(); + switch (simdBaseJitType) + { + case CORINFO_TYPE_NATIVEINT: + { +#if TARGET_64BIT + return CORINFO_TYPE_LONG; +#else + return CORINFO_TYPE_INT; +#endif + } + + case CORINFO_TYPE_NATIVEUINT: + { +#if TARGET_64BIT + return CORINFO_TYPE_ULONG; +#else + return CORINFO_TYPE_UINT; +#endif + } + + default: + return simdBaseJitType; + } + } + void SetSimdBaseJitType(CorInfoType simdBaseJitType) { gtSimdBaseJitType = (unsigned char)simdBaseJitType; diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index b79dc048a1cc4d..e25fa4cd9db6e3 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -9636,7 +9636,7 @@ void Compiler::fgValueNumberSimd(GenTreeSIMD* tree) if (encodeResultType) { - ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitType()); + ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitPreciseType()); resvnp.SetBoth(simdTypeVN); #ifdef DEBUG @@ -9751,7 +9751,7 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree) if (encodeResultType) { - ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitType()); + ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitPreciseType()); resvnp.SetBoth(simdTypeVN); #ifdef DEBUG From 014b09f0def331a94224ae95977a5bc05c8b855c Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:25:23 -0800 Subject: [PATCH 71/83] Feedback --- src/coreclr/jit/gentree.h | 2 +- src/coreclr/jit/valuenum.cpp | 16 +++++++++++----- src/coreclr/jit/valuenum.h | 6 +++--- 3 files changed, 15 insertions(+), 9 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index a26319b073255d..5181f1f3c3532a 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -5259,7 +5259,7 @@ struct GenTreeJitIntrinsic : public GenTreeMultiOp return (CorInfoType)gtSimdBaseJitType; } - CorInfoType GetSimdBaseJitPreciseType() const + CorInfoType GetNormalizedSimdBaseJitType() const { CorInfoType simdBaseJitType = GetSimdBaseJitType(); switch (simdBaseJitType) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index e25fa4cd9db6e3..a0f9bd008d5635 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4602,8 +4602,9 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) } #if FEATURE_HW_INTRINSICS VNFuncApp funcApp; - if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) + if (GetVNFunc(vn, &funcApp)) { + assert(funcApp.m_arity == 1); switch (funcApp.m_func) { case VNF_HWI_Vector128_get_Zero: @@ -4639,8 +4640,9 @@ VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) // The SIMD type is encoded as a function, // even though it is not actually a function. VNFuncApp simdType; - if (GetVNFunc(vn, &simdType) && simdType.m_func == VNF_SimdType && simdType.m_arity == 2) + if (GetVNFunc(vn, &simdType) && simdType.m_func == VNF_SimdType) { + assert(simdType.m_arity == 2); vnInfo.m_simdSize = GetConstantInt32(simdType.m_args[0]); vnInfo.m_simdBaseJitType = (CorInfoType)GetConstantInt32(simdType.m_args[1]); return vnInfo; @@ -4651,6 +4653,9 @@ VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) return vnInfo; } +// TODO: Vector.Zero nodes in VN currently encode their SIMD type for +// conservative reasons. In the future, it might be possible not do this +// on most platforms since Vector.Zero's base type does not matter. VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) { VNSimdTypeInfo vnInfo; @@ -4665,8 +4670,9 @@ VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) // Vector.Zero does not have any arguments, // but its SIMD type is encoded as an argument. VNFuncApp funcApp; - if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) + if (GetVNFunc(vn, &funcApp)) { + assert(funcApp.m_arity == 1); return GetSimdTypeOfVN(funcApp.m_args[0]); } @@ -9636,7 +9642,7 @@ void Compiler::fgValueNumberSimd(GenTreeSIMD* tree) if (encodeResultType) { - ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitPreciseType()); + ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetNormalizedSimdBaseJitType()); resvnp.SetBoth(simdTypeVN); #ifdef DEBUG @@ -9751,7 +9757,7 @@ void Compiler::fgValueNumberHWIntrinsic(GenTreeHWIntrinsic* tree) if (encodeResultType) { - ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetSimdBaseJitPreciseType()); + ValueNum simdTypeVN = vnStore->VNForSimdType(tree->GetSimdSize(), tree->GetNormalizedSimdBaseJitType()); resvnp.SetBoth(simdTypeVN); #ifdef DEBUG diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h index 9a742d0ba94139..c94d9828994782 100644 --- a/src/coreclr/jit/valuenum.h +++ b/src/coreclr/jit/valuenum.h @@ -725,11 +725,11 @@ class ValueNumStore bool IsVNVectorZero(ValueNum vn); #if FEATURE_SIMD - /// Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type. + // Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type. VNSimdTypeInfo GetSimdTypeOfVN(ValueNum vn); - /// Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type - /// for a Vector.Zero value number. + // Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type + // for a Vector.Zero value number. VNSimdTypeInfo GetVectorZeroSimdTypeOfVN(ValueNum vn); #endif From bb58117c96046718d5179d208b3faf4224b5ca50 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:33:00 -0800 Subject: [PATCH 72/83] Minor fix --- src/coreclr/jit/valuenum.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index a0f9bd008d5635..85cea7f763425a 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4602,9 +4602,8 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) } #if FEATURE_HW_INTRINSICS VNFuncApp funcApp; - if (GetVNFunc(vn, &funcApp)) + if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { - assert(funcApp.m_arity == 1); switch (funcApp.m_func) { case VNF_HWI_Vector128_get_Zero: From 7aae73b6e7295a6cd0656f366ae5e43c8b7c4595 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:35:24 -0800 Subject: [PATCH 73/83] Minor comment update --- src/coreclr/jit/valuenum.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 85cea7f763425a..ce74e4bf5b7aea 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4652,9 +4652,9 @@ VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) return vnInfo; } -// TODO: Vector.Zero nodes in VN currently encode their SIMD type for -// conservative reasons. In the future, it might be possible not do this -// on most platforms since Vector.Zero's base type does not matter. +// REVIEW: Vector.Zero nodes in VN currently encode their SIMD type for +// conservative reasons. In the future, it might be possible not do this +// on most platforms since Vector.Zero's base type does not matter. VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) { VNSimdTypeInfo vnInfo; From 423d25a09aec1bf7a1021b2c302cf6d837c35768 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:39:41 -0800 Subject: [PATCH 74/83] Added another comment --- src/coreclr/jit/valuenum.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index ce74e4bf5b7aea..aa758c39417a07 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4601,6 +4601,8 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) return false; } #if FEATURE_HW_INTRINSICS + // This will only return true if Vector.Zero encodes + // its base type. VNFuncApp funcApp; if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { From 616bb9bb57977109ba1488a02d154c1339e70d1c Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:44:33 -0800 Subject: [PATCH 75/83] Added another comment --- src/coreclr/jit/valuenum.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index aa758c39417a07..5c9171c3843955 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4602,7 +4602,9 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) } #if FEATURE_HW_INTRINSICS // This will only return true if Vector.Zero encodes - // its base type. + // its base type. On XARCH there may be + // scenarios where Vector.Zero will not encode its base type; + // therefore, returning false here. VNFuncApp funcApp; if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { From 84d3a94ae13a2fc3050767b0e9e80678573f7e1e Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:45:47 -0800 Subject: [PATCH 76/83] Added another comment --- src/coreclr/jit/valuenum.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 5c9171c3843955..86a1ce288305d3 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4602,7 +4602,7 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) } #if FEATURE_HW_INTRINSICS // This will only return true if Vector.Zero encodes - // its base type. On XARCH there may be + // its base type as an argument. On XARCH there may be // scenarios where Vector.Zero will not encode its base type; // therefore, returning false here. VNFuncApp funcApp; From ac3b474c117d76bdf74c0649514b1408f8341c7b Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 11:47:18 -0800 Subject: [PATCH 77/83] Update comment --- src/coreclr/jit/valuenum.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 86a1ce288305d3..51602da9d8c502 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4601,10 +4601,10 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) return false; } #if FEATURE_HW_INTRINSICS - // This will only return true if Vector.Zero encodes - // its base type as an argument. On XARCH there may be - // scenarios where Vector.Zero will not encode its base type; - // therefore, returning false here. + // REVIEW: This will only return true if Vector.Zero encodes + // its base type as an argument. On XARCH there may be + // scenarios where Vector.Zero will not encode its base type; + // therefore, returning false here. VNFuncApp funcApp; if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { From 2769740154d1a12ab958b1df2341ae0341883f5a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 11 Feb 2022 12:25:32 -0800 Subject: [PATCH 78/83] Formatting --- src/coreclr/jit/valuenum.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 51602da9d8c502..58afd2ec4e4f50 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4658,7 +4658,7 @@ VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) // REVIEW: Vector.Zero nodes in VN currently encode their SIMD type for // conservative reasons. In the future, it might be possible not do this -// on most platforms since Vector.Zero's base type does not matter. +// on most platforms since Vector.Zero's base type does not matter. VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) { VNSimdTypeInfo vnInfo; From 4a6d9a23435af91f92b820b22d83b6f043df6b7a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 14 Feb 2022 10:43:25 -0800 Subject: [PATCH 79/83] Feedback --- src/coreclr/jit/gentree.h | 4 +- src/coreclr/jit/valuenum.cpp | 115 ++++++++++++++++++++--------------- src/coreclr/jit/valuenum.h | 6 +- 3 files changed, 69 insertions(+), 56 deletions(-) diff --git a/src/coreclr/jit/gentree.h b/src/coreclr/jit/gentree.h index 4f0bee5effb061..b48547e780427c 100644 --- a/src/coreclr/jit/gentree.h +++ b/src/coreclr/jit/gentree.h @@ -5330,7 +5330,7 @@ struct GenTreeJitIntrinsic : public GenTreeMultiOp { case CORINFO_TYPE_NATIVEINT: { -#if TARGET_64BIT +#ifdef TARGET_64BIT return CORINFO_TYPE_LONG; #else return CORINFO_TYPE_INT; @@ -5339,7 +5339,7 @@ struct GenTreeJitIntrinsic : public GenTreeMultiOp case CORINFO_TYPE_NATIVEUINT: { -#if TARGET_64BIT +#ifdef TARGET_64BIT return CORINFO_TYPE_ULONG; #else return CORINFO_TYPE_UINT; diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index f20dc8d726361b..09093917d548aa 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4594,52 +4594,42 @@ bool ValueNumStore::IsVNConstant(ValueNum vn) } } +//------------------------------------------------------------------------ +// IsVNVectorZero: Checks if the value number is a Vector*_get_Zero. +// +// Arguments: +// vn – The value number. +// +// Return Value: +// true – The value number is a Vector*_get_Zero. +// false – The value number is not a Vector*_get_Zero. bool ValueNumStore::IsVNVectorZero(ValueNum vn) { - if (vn == NoVN) - { - return false; - } -#if FEATURE_HW_INTRINSICS - // REVIEW: This will only return true if Vector.Zero encodes - // its base type as an argument. On XARCH there may be - // scenarios where Vector.Zero will not encode its base type; - // therefore, returning false here. - VNFuncApp funcApp; - if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) +#ifdef FEATURE_SIMD + VNSimdTypeInfo vnInfo = GetVectorZeroSimdTypeOfVN(vn); + // Check the size to see if we got a valid SIMD type. + // '0' means it is not valid. + if (vnInfo.m_simdSize != 0) { - switch (funcApp.m_func) - { - case VNF_HWI_Vector128_get_Zero: -#if defined(TARGET_XARCH) - case VNF_HWI_Vector256_get_Zero: -#elif defined(TARGET_ARM64) - case VNF_HWI_Vector64_get_Zero: -#endif - { - return true; - } - - default: - return false; - } + return true; } #endif return false; } -#if FEATURE_SIMD +#ifdef FEATURE_SIMD +//------------------------------------------------------------------------ +// GetSimdTypeOfVN: Returns the SIMD type information based on the given value number. +// +// Arguments: +// vn – The value number. +// +// Return Value: +// Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type. VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) { VNSimdTypeInfo vnInfo; - if (vn == NoVN) - { - vnInfo.m_simdSize = 0; - vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; - return vnInfo; - } - // The SIMD type is encoded as a function, // even though it is not actually a function. VNFuncApp simdType; @@ -4656,29 +4646,56 @@ VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) return vnInfo; } -// REVIEW: Vector.Zero nodes in VN currently encode their SIMD type for +//------------------------------------------------------------------------ +// GetVectorZeroSimdTypeOfVN: Returns the SIMD type information based on the given value number +// if it's Vector*_get_Zero. +// +// Arguments: +// vn – The value number. +// +// Return Value: +// Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type +// for a Vector*_get_Zero value number. +// +// REVIEW: Vector*_get_Zero nodes in VN currently encode their SIMD type for // conservative reasons. In the future, it might be possible not do this -// on most platforms since Vector.Zero's base type does not matter. +// on most platforms since Vector*_get_Zero's base type does not matter. VNSimdTypeInfo ValueNumStore::GetVectorZeroSimdTypeOfVN(ValueNum vn) { - VNSimdTypeInfo vnInfo; - - if (!IsVNVectorZero(vn)) - { - vnInfo.m_simdSize = 0; - vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; - return vnInfo; - } - - // Vector.Zero does not have any arguments, +#ifdef FEATURE_HW_INTRINSICS + // REVIEW: This will only return true if Vector*_get_Zero encodes + // its base type as an argument. On XARCH there may be + // scenarios where Vector*_get_Zero will not encode its base type; + // therefore, returning false here. + // Vector*_get_Zero does not have any arguments, // but its SIMD type is encoded as an argument. VNFuncApp funcApp; - if (GetVNFunc(vn, &funcApp)) + if (GetVNFunc(vn, &funcApp) && funcApp.m_arity == 1) { - assert(funcApp.m_arity == 1); - return GetSimdTypeOfVN(funcApp.m_args[0]); + switch (funcApp.m_func) + { + case VNF_HWI_Vector128_get_Zero: +#if defined(TARGET_XARCH) + case VNF_HWI_Vector256_get_Zero: +#elif defined(TARGET_ARM64) + case VNF_HWI_Vector64_get_Zero: +#endif + { + return GetSimdTypeOfVN(funcApp.m_args[0]); + } + + default: + { + VNSimdTypeInfo vnInfo; + vnInfo.m_simdSize = 0; + vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; + return vnInfo; + } + } } +#endif + VNSimdTypeInfo vnInfo; vnInfo.m_simdSize = 0; vnInfo.m_simdBaseJitType = CORINFO_TYPE_UNDEF; return vnInfo; diff --git a/src/coreclr/jit/valuenum.h b/src/coreclr/jit/valuenum.h index c94d9828994782..235017a78cbec7 100644 --- a/src/coreclr/jit/valuenum.h +++ b/src/coreclr/jit/valuenum.h @@ -721,15 +721,11 @@ class ValueNumStore // Returns true iff the VN represents a (non-handle) constant. bool IsVNConstant(ValueNum vn); - // Returns true if the VN represents a Vector64/128/256.Zero. bool IsVNVectorZero(ValueNum vn); -#if FEATURE_SIMD - // Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type. +#ifdef FEATURE_SIMD VNSimdTypeInfo GetSimdTypeOfVN(ValueNum vn); - // Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type - // for a Vector.Zero value number. VNSimdTypeInfo GetVectorZeroSimdTypeOfVN(ValueNum vn); #endif From 2d6f367966dc58e693cc2be63a32fc15bbcb6d31 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 14 Feb 2022 11:27:44 -0800 Subject: [PATCH 80/83] Fixing build --- src/coreclr/jit/valuenum.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/coreclr/jit/valuenum.cpp b/src/coreclr/jit/valuenum.cpp index 09093917d548aa..03053f3ebdb53b 100644 --- a/src/coreclr/jit/valuenum.cpp +++ b/src/coreclr/jit/valuenum.cpp @@ -4598,11 +4598,11 @@ bool ValueNumStore::IsVNConstant(ValueNum vn) // IsVNVectorZero: Checks if the value number is a Vector*_get_Zero. // // Arguments: -// vn – The value number. +// vn - The value number. // // Return Value: -// true – The value number is a Vector*_get_Zero. -// false – The value number is not a Vector*_get_Zero. +// true - The value number is a Vector*_get_Zero. +// false - The value number is not a Vector*_get_Zero. bool ValueNumStore::IsVNVectorZero(ValueNum vn) { #ifdef FEATURE_SIMD @@ -4622,7 +4622,7 @@ bool ValueNumStore::IsVNVectorZero(ValueNum vn) // GetSimdTypeOfVN: Returns the SIMD type information based on the given value number. // // Arguments: -// vn – The value number. +// vn - The value number. // // Return Value: // Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type. @@ -4651,7 +4651,7 @@ VNSimdTypeInfo ValueNumStore::GetSimdTypeOfVN(ValueNum vn) // if it's Vector*_get_Zero. // // Arguments: -// vn – The value number. +// vn - The value number. // // Return Value: // Returns VNSimdTypeInfo(0, CORINFO_TYPE_UNDEF) if the given value number has not been given a SIMD type From 759e8c07803c86a52474ab4bb013f86b2ca8fa67 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Tue, 15 Feb 2022 17:32:55 -0800 Subject: [PATCH 81/83] 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 e5abbaff8b6597..0440c74c050aac 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 From 4bd81c7c7a5015e54eb9712ba20965479a7ac3f7 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Thu, 17 Feb 2022 23:54:14 -0800 Subject: [PATCH 82/83] Update assertionprop.cpp --- src/coreclr/jit/assertionprop.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index ef6ae379863f6a..50b0be8d13182d 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -3049,13 +3049,12 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) case TYP_SIMD32: { assert(vnStore->IsVNVectorZero(vnCns)); - VNSimdTypeInfo vnInfo = vnStore->GetVectorZeroSimdTypeOfVN(vnCns); assert(vnInfo.m_simdBaseJitType != CORINFO_TYPE_UNDEF); assert(vnInfo.m_simdSize != 0); assert(getSIMDTypeForSize(vnInfo.m_simdSize) == vnStore->TypeOfVN(vnCns)); - + conValTree = gtNewSimdZeroNode(tree->TypeGet(), vnInfo.m_simdBaseJitType, vnInfo.m_simdSize, true); } break; From 396e8a15ba6aa14704d15d08891d8b6222eae56a Mon Sep 17 00:00:00 2001 From: Will Smith Date: Fri, 18 Feb 2022 08:31:09 -0800 Subject: [PATCH 83/83] Formatting --- src/coreclr/jit/assertionprop.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/coreclr/jit/assertionprop.cpp b/src/coreclr/jit/assertionprop.cpp index 50b0be8d13182d..f7d791d80155e9 100644 --- a/src/coreclr/jit/assertionprop.cpp +++ b/src/coreclr/jit/assertionprop.cpp @@ -3054,7 +3054,7 @@ GenTree* Compiler::optVNConstantPropOnTree(BasicBlock* block, GenTree* tree) assert(vnInfo.m_simdBaseJitType != CORINFO_TYPE_UNDEF); assert(vnInfo.m_simdSize != 0); assert(getSIMDTypeForSize(vnInfo.m_simdSize) == vnStore->TypeOfVN(vnCns)); - + conValTree = gtNewSimdZeroNode(tree->TypeGet(), vnInfo.m_simdBaseJitType, vnInfo.m_simdSize, true); } break;