diff --git a/src/coreclr/jit/hwintrinsic.h b/src/coreclr/jit/hwintrinsic.h index 610499f05eb76..915657e014631 100644 --- a/src/coreclr/jit/hwintrinsic.h +++ b/src/coreclr/jit/hwintrinsic.h @@ -957,6 +957,12 @@ struct HWIntrinsicInfo switch (id) { + case NI_Sve_ConditionalExtractAfterLastActiveElement: + return NI_Sve_ConditionalExtractAfterLastActiveElementScalar; + + case NI_Sve_ConditionalExtractLastActiveElement: + return NI_Sve_ConditionalExtractLastActiveElementScalar; + case NI_Sve_SaturatingDecrementBy16BitElementCount: return NI_Sve_SaturatingDecrementBy16BitElementCountScalar; diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp index d69b0a9016575..3a13fcfab7358 100644 --- a/src/coreclr/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/jit/hwintrinsicarm64.cpp @@ -2801,6 +2801,35 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_Sve_ConditionalExtractAfterLastActiveElementScalar: + case NI_Sve_ConditionalExtractLastActiveElementScalar: + { + assert(sig->numArgs == 3); + +#ifdef DEBUG + isValidScalarIntrinsic = true; +#endif + + CORINFO_ARG_LIST_HANDLE arg1 = sig->args; + CORINFO_ARG_LIST_HANDLE arg2 = info.compCompHnd->getArgNext(arg1); + CORINFO_ARG_LIST_HANDLE arg3 = info.compCompHnd->getArgNext(arg2); + var_types argType = TYP_UNKNOWN; + CORINFO_CLASS_HANDLE argClass = NO_CLASS_HANDLE; + + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg3, &argClass))); + op3 = getArgForHWIntrinsic(argType, argClass); + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg2, &argClass))); + op2 = getArgForHWIntrinsic(argType, argClass); + CorInfoType op2BaseJitType = getBaseJitTypeOfSIMDType(argClass); + argType = JITtype2varType(strip(info.compCompHnd->getArgType(sig, arg1, &argClass))); + op1 = getArgForHWIntrinsic(argType, argClass); + + retNode = gtNewScalarHWIntrinsicNode(retType, op1, op2, op3, intrinsic); + + retNode->AsHWIntrinsic()->SetSimdBaseJitType(simdBaseJitType); + retNode->AsHWIntrinsic()->SetAuxiliaryJitType(op2BaseJitType); + break; + } default: { diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 4b47ad7412967..5c7b97e3ebc07 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -2252,6 +2252,51 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; } + case NI_Sve_ConditionalExtractAfterLastActiveElementScalar: + case NI_Sve_ConditionalExtractLastActiveElementScalar: + { + opt = emitter::optGetSveInsOpt(emitTypeSize(node->GetSimdBaseType())); + + if (emitter::isGeneralRegisterOrZR(targetReg)) + { + assert(varTypeIsIntegralOrI(intrin.baseType)); + + emitSize = emitTypeSize(node); + + if (targetReg != op2Reg) + { + assert(targetReg != op1Reg); + assert(targetReg != op3Reg); + GetEmitter()->emitIns_Mov(INS_mov, emitSize, targetReg, op2Reg, + /* canSkip */ true); + } + + GetEmitter()->emitInsSve_R_R_R(ins, emitSize, targetReg, op1Reg, op3Reg, opt, + INS_SCALABLE_OPTS_NONE); + break; + } + + // FP scalars are processed by the INS_SCALABLE_OPTS_WITH_SIMD_SCALAR variant of the instructions + FALLTHROUGH; + } + case NI_Sve_ConditionalExtractAfterLastActiveElement: + case NI_Sve_ConditionalExtractLastActiveElement: + { + assert(emitter::isFloatReg(targetReg)); + assert(varTypeIsFloating(node->gtType) || varTypeIsSIMD(node->gtType)); + + if (targetReg != op2Reg) + { + assert(targetReg != op1Reg); + assert(targetReg != op3Reg); + GetEmitter()->emitIns_Mov(INS_mov, emitTypeSize(node), targetReg, op2Reg, + /* canSkip */ true); + } + GetEmitter()->emitInsSve_R_R_R(ins, EA_SCALABLE, targetReg, op1Reg, op3Reg, opt, + INS_SCALABLE_OPTS_WITH_SIMD_SCALAR); + break; + } + default: unreached(); } diff --git a/src/coreclr/jit/hwintrinsiclistarm64sve.h b/src/coreclr/jit/hwintrinsiclistarm64sve.h index 9288662fd003a..b976202ef822d 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64sve.h +++ b/src/coreclr/jit/hwintrinsiclistarm64sve.h @@ -41,6 +41,10 @@ HARDWARE_INTRINSIC(Sve, Compute16BitAddresses, HARDWARE_INTRINSIC(Sve, Compute32BitAddresses, -1, 2, true, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_adr, INS_invalid, INS_sve_adr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, Compute64BitAddresses, -1, 2, true, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_adr, INS_invalid, INS_sve_adr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) HARDWARE_INTRINSIC(Sve, Compute8BitAddresses, -1, 2, true, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_adr, INS_invalid, INS_sve_adr, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen) +HARDWARE_INTRINSIC(Sve, ConditionalExtractAfterLastActiveElement, -1, 3, true, {INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialCodeGen) +HARDWARE_INTRINSIC(Sve, ConditionalExtractAfterLastActiveElementAndReplicate, -1, 3, true, {INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, ConditionalExtractLastActiveElement, -1, 3, true, {INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_HasScalarInputVariant|HW_Flag_SpecialCodeGen) +HARDWARE_INTRINSIC(Sve, ConditionalExtractLastActiveElementAndReplicate, -1, 3, true, {INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, ConditionalSelect, -1, 3, true, {INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel, INS_sve_sel}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation|HW_Flag_SupportsContainment) HARDWARE_INTRINSIC(Sve, ConvertToInt32, -1, -1, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcvtzs, INS_sve_fcvtzs}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ConvertToInt64, -1, -1, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcvtzs, INS_sve_fcvtzs}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation) @@ -259,14 +263,12 @@ HARDWARE_INTRINSIC(Sve, ZipLow, // *************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************** // Special intrinsics that are generated during importing or lowering -#define SPECIAL_NI_Sve NI_Sve_ConvertMaskToVector +#define SPECIAL_NI_Sve NI_Sve_ConditionalExtractAfterLastActiveElementScalar +HARDWARE_INTRINSIC(Sve, ConditionalExtractAfterLastActiveElementScalar, 0, 3, false, {INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta, INS_sve_clasta}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) +HARDWARE_INTRINSIC(Sve, ConditionalExtractLastActiveElementScalar, 0, 3, false, {INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb, INS_sve_clastb}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, ConvertMaskToVector, -1, 1, true, {INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov, INS_sve_mov}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ExplicitMaskedOperation) HARDWARE_INTRINSIC(Sve, ConvertVectorToMask, -1, 2, true, {INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne, INS_sve_cmpne}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, CreateTrueMaskAll, -1, -1, false, {INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue, INS_sve_ptrue}, HW_Category_Helper, HW_Flag_Scalable|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, StoreAndZipx2, -1, 3, true, {INS_sve_st2b, INS_sve_st2b, INS_sve_st2h, INS_sve_st2h, INS_sve_st2w, INS_sve_st2w, INS_sve_st2d, INS_sve_st2d, INS_sve_st2w, INS_sve_st2d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) -HARDWARE_INTRINSIC(Sve, StoreAndZipx3, -1, 3, true, {INS_sve_st3b, INS_sve_st3b, INS_sve_st3h, INS_sve_st3h, INS_sve_st3w, INS_sve_st3w, INS_sve_st3d, INS_sve_st3d, INS_sve_st3w, INS_sve_st3d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) -HARDWARE_INTRINSIC(Sve, StoreAndZipx4, -1, 3, true, {INS_sve_st4b, INS_sve_st4b, INS_sve_st4h, INS_sve_st4h, INS_sve_st4w, INS_sve_st4w, INS_sve_st4d, INS_sve_st4d, INS_sve_st4w, INS_sve_st4d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) - // Scalar variants of Saturating*By*BitElementCount. There is 8bit versions as the generic version is scalar only. HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy16BitElementCountScalar, 0, 3, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdech, INS_sve_uqdech, INS_sve_sqdech, INS_sve_uqdech, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy32BitElementCountScalar, 0, 3, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqdecw, INS_sve_uqdecw, INS_sve_sqdecw, INS_sve_uqdecw, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) @@ -274,6 +276,9 @@ HARDWARE_INTRINSIC(Sve, SaturatingDecrementBy64BitElementCountScalar, HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy16BitElementCountScalar, 0, 3, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqinch, INS_sve_uqinch, INS_sve_sqinch, INS_sve_uqinch, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy32BitElementCountScalar, 0, 3, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincw, INS_sve_uqincw, INS_sve_sqincw, INS_sve_uqincw, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, SaturatingIncrementBy64BitElementCountScalar, 0, 3, false, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sqincd, INS_sve_uqincd, INS_sve_sqincd, INS_sve_uqincd, INS_invalid, INS_invalid}, HW_Category_Scalar, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_HasEnumOperand|HW_Flag_SpecialCodeGen|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics) +HARDWARE_INTRINSIC(Sve, StoreAndZipx2, -1, 3, true, {INS_sve_st2b, INS_sve_st2b, INS_sve_st2h, INS_sve_st2h, INS_sve_st2w, INS_sve_st2w, INS_sve_st2d, INS_sve_st2d, INS_sve_st2w, INS_sve_st2d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(Sve, StoreAndZipx3, -1, 3, true, {INS_sve_st3b, INS_sve_st3b, INS_sve_st3h, INS_sve_st3h, INS_sve_st3w, INS_sve_st3w, INS_sve_st3d, INS_sve_st3d, INS_sve_st3w, INS_sve_st3d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(Sve, StoreAndZipx4, -1, 3, true, {INS_sve_st4b, INS_sve_st4b, INS_sve_st4h, INS_sve_st4h, INS_sve_st4w, INS_sve_st4w, INS_sve_st4d, INS_sve_st4d, INS_sve_st4w, INS_sve_st4d}, HW_Category_MemoryStore, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_NeedsConsecutiveRegisters) #endif // FEATURE_HW_INTRINSIC diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs index 10318cb724040..079541962cc9f 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs @@ -1411,6 +1411,378 @@ internal Arm64() { } /// public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) { throw new PlatformNotSupportedException(); } + /// Conditionally extract element after last + + /// + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector mask, byte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe double ConditionalExtractAfterLastActiveElement(Vector mask, double defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe short ConditionalExtractAfterLastActiveElement(Vector mask, short defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe int ConditionalExtractAfterLastActiveElement(Vector mask, int defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe long ConditionalExtractAfterLastActiveElement(Vector mask, long defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector mask, sbyte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe float ConditionalExtractAfterLastActiveElement(Vector mask, float defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector mask, ushort defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector mask, uint defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector mask, ulong defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + + /// Conditionally extract element after last + + /// + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) { throw new PlatformNotSupportedException(); } + + + /// Conditionally extract last element + + /// + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe byte ConditionalExtractLastActiveElement(Vector mask, byte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe double ConditionalExtractLastActiveElement(Vector mask, double defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe short ConditionalExtractLastActiveElement(Vector mask, short defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe int ConditionalExtractLastActiveElement(Vector mask, int defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe long ConditionalExtractLastActiveElement(Vector mask, long defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe sbyte ConditionalExtractLastActiveElement(Vector mask, sbyte defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe float ConditionalExtractLastActiveElement(Vector mask, float defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe ushort ConditionalExtractLastActiveElement(Vector mask, ushort defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe uint ConditionalExtractLastActiveElement(Vector mask, uint defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe ulong ConditionalExtractLastActiveElement(Vector mask, ulong defaultValues, Vector data) { throw new PlatformNotSupportedException(); } + + + /// Conditionally extract last element + + /// + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) { throw new PlatformNotSupportedException(); } + + /// Compare equal to /// ConditionalSelect : Conditionally select elements diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs index f12e1f4d48ba2..ae978c4362f24 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs @@ -1441,6 +1441,378 @@ internal Arm64() { } /// public static unsafe Vector Compute8BitAddresses(Vector bases, Vector indices) => Compute8BitAddresses(bases, indices); + /// Conditionally extract element after last + + /// + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector mask, byte defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe double ConditionalExtractAfterLastActiveElement(Vector mask, double defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe short ConditionalExtractAfterLastActiveElement(Vector mask, short defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe int ConditionalExtractAfterLastActiveElement(Vector mask, int defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe long ConditionalExtractAfterLastActiveElement(Vector mask, long defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector mask, sbyte defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe float ConditionalExtractAfterLastActiveElement(Vector mask, float defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector mask, ushort defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTA Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector mask, uint defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + /// + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data); + + /// + /// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTA Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector mask, ulong defaultValues, Vector data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data); + + + /// Conditionally extract element after last + + /// + /// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + /// + /// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractAfterLastActiveElementAndReplicate(Vector mask, Vector defaultScalar, Vector data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data); + + + /// Conditionally extract last element + + /// + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe byte ConditionalExtractLastActiveElement(Vector mask, byte defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe double ConditionalExtractLastActiveElement(Vector mask, double defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe short ConditionalExtractLastActiveElement(Vector mask, short defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe int ConditionalExtractLastActiveElement(Vector mask, int defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe long ConditionalExtractLastActiveElement(Vector mask, long defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Btied, Pg, Btied, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.B + /// + public static unsafe sbyte ConditionalExtractLastActiveElement(Vector mask, sbyte defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe float ConditionalExtractLastActiveElement(Vector mask, float defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Htied, Pg, Htied, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.H + /// + public static unsafe ushort ConditionalExtractLastActiveElement(Vector mask, ushort defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Stied, Pg, Stied, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data) + /// CLASTB Wtied, Pg, Wtied, Zdata.S + /// + public static unsafe uint ConditionalExtractLastActiveElement(Vector mask, uint defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + /// + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Dtied, Pg, Dtied, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElement(Vector mask, Vector defaultValue, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValue, data); + + /// + /// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data) + /// CLASTB Xtied, Pg, Xtied, Zdata.D + /// + public static unsafe ulong ConditionalExtractLastActiveElement(Vector mask, ulong defaultValues, Vector data) => ConditionalExtractLastActiveElement(mask, defaultValues, data); + + + /// Conditionally extract last element + + /// + /// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data) + /// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data) + /// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data) + /// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// + /// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data) + /// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D + /// + public static unsafe Vector ConditionalExtractLastActiveElementAndReplicate(Vector mask, Vector fallback, Vector data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data); + + /// Compare equal to /// ConditionalSelect : Conditionally select elements diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index f4885977916ae..3df9a05b405ba 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -4412,6 +4412,67 @@ internal Arm64() { } public static System.Numerics.Vector Compute8BitAddresses(System.Numerics.Vector bases, System.Numerics.Vector indices) { throw null; } public static System.Numerics.Vector Compute8BitAddresses(System.Numerics.Vector bases, System.Numerics.Vector indices) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static byte ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, byte defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static double ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, double defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static short ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, short defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static int ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, int defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static long ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, long defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static sbyte ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, sbyte defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static float ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, float defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static ushort ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, ushort defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static uint ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, uint defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static ulong ConditionalExtractAfterLastActiveElement(System.Numerics.Vector mask, ulong defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector defaultScalar, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static byte ConditionalExtractLastActiveElement(System.Numerics.Vector mask, byte defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static double ConditionalExtractLastActiveElement(System.Numerics.Vector mask, double defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static short ConditionalExtractLastActiveElement(System.Numerics.Vector mask, short defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static int ConditionalExtractLastActiveElement(System.Numerics.Vector mask, int defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static long ConditionalExtractLastActiveElement(System.Numerics.Vector mask, long defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static sbyte ConditionalExtractLastActiveElement(System.Numerics.Vector mask, sbyte defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static float ConditionalExtractLastActiveElement(System.Numerics.Vector mask, float defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static ushort ConditionalExtractLastActiveElement(System.Numerics.Vector mask, ushort defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static uint ConditionalExtractLastActiveElement(System.Numerics.Vector mask, uint defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElement(System.Numerics.Vector mask, System.Numerics.Vector defaultValue, System.Numerics.Vector data) { throw null; } + public static ulong ConditionalExtractLastActiveElement(System.Numerics.Vector mask, ulong defaultValues, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector mask, System.Numerics.Vector fallback, System.Numerics.Vector data) { throw null; } + public static System.Numerics.Vector ConditionalSelect(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector ConditionalSelect(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector ConditionalSelect(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } diff --git a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs index 1caaf29a9d226..7455aebc0ad32 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs @@ -58,6 +58,8 @@ const string SimpleVecOpTest_VectorValidationLogic = @"succeeded = !({ValidateVectorResult});"; +const string SimpleScalarOpTest_ValidationLogic = @"succeeded = !({ValidateScalarResult});"; + const string SimpleTernVecOpTest_ValidationLogic = @"for (var i = 0; i < RetElementCount; i++) { if ({ValidateIterResult}) @@ -284,6 +286,7 @@ ("_SveImmTernOpTestTemplate.template", "SveVecImmTernOpTest.template", new Dictionary { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic, ["TemplateValidationLogicForCndSel"] = SimpleTernVecOpTest_ValidationLogicForCndSel, ["TemplateValidationLogicForCndSel_FalseValue"] = SimpleTernVecOpTest_ValidationLogicForCndSel_FalseValue }), ("_SveTernOpMaskedOpTestTemplate.template", "SveVecTernOpMaskedTest.template", new Dictionary { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic, ["TemplateValidationLogicForCndSel"] = SimpleTernVecOpTest_ValidationLogicForCndSel, ["TemplateValidationLogicForCndSel_FalseValue"] = SimpleTernVecOpTest_ValidationLogicForCndSel_FalseValue }), ("_SveImmTernOpFirstArgTestTemplate.template", "SveVecImmTernOpFirstArgTest.template", new Dictionary { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic, ["TemplateValidationLogicForCndSel"] = SimpleTernVecOpTest_ValidationLogicForCndSel, ["TemplateValidationLogicForCndSel_FalseValue"] = SimpleTernVecOpTest_ValidationLogicForCndSel_FalseValue }), + ("_SveScalarTernOpTestTemplate.template", "SveScalarTernOpTest.template", new Dictionary { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleScalarOpTest_ValidationLogic }), ("_SveImm2UnaryOpTestTemplate.template", "SveVecImm2UnOpTest.template", new Dictionary { ["TemplateName"] = "Imm", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic }), ("_SveMinimalUnaryOpTestTemplate.template", "SveVecReduceUnOpTest.template", new Dictionary { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = VecReduceOpTest_ValidationLogic }), ("_SveMasklessUnaryOpTestTemplate.template", "SveMasklessSimpleVecOpTest.template", new Dictionary { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic }), @@ -4176,6 +4179,67 @@ ("SveVecReduceUnOpTest.template",new Dictionary {["TestName"] = "Sve_ZeroExtendWideningUpper_uint_ushort", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ZeroExtendWideningUpper", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateReduceOpResult"] = "Helpers.ZeroExtendWideningUpper(firstOp, 0) != result[0]", ["ValidateRemainingResults"] = "Helpers.ZeroExtendWideningUpper(firstOp, i) != result[i]"}), ("SveVecReduceUnOpTest.template",new Dictionary {["TestName"] = "Sve_ZeroExtendWideningUpper_ulong_uint", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ZeroExtendWideningUpper", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateReduceOpResult"] = "Helpers.ZeroExtendWideningUpper(firstOp, 0) != result[0]", ["ValidateRemainingResults"] = "Helpers.ZeroExtendWideningUpper(firstOp, i) != result[i]"}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_float", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_float_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_double", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_double_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_sbyte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_sbyte_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_short", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_short_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int16", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_int", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_int_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_long", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_long_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_byte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_byte_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_ushort", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_ushort_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_uint", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_uint_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_ulong", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElement_ulong_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElement", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractAfterLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_float", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_double", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_sbyte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_short", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_int", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_long", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_byte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_ushort", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_uint", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractAfterLastActiveElementAndReplicate_ulong", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractAfterLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractAfterLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_float", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_float_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_double", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_double_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_sbyte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_sbyte_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_short", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_short_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int16", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_int", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_int_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_long", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_long_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_byte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_byte_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_ushort", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_ushort_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_uint", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_uint_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_ulong", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElement(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveScalarTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElement_ulong_scalar", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElement", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateScalarResult"] = "Helpers.ConditionalExtractLastActiveElement(firstOp, secondOp, thirdOp) != result",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_float", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp3"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_double", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Double", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp3"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_sbyte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_short", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_int", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_long", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_byte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Byte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_ushort", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt16", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt16", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt16", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_uint", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt32", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecTernOpTest.template", new Dictionary { ["TestName"] = "Sve_ConditionalExtractLastActiveElementAndReplicate_ulong", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ConditionalExtractLastActiveElementAndReplicate", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "UInt64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "UInt64", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp3"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(firstOp, secondOp, thirdOp)[i] != result[i]", ["GetIterResult"] = "Helpers.ConditionalExtractLastActiveElementAndReplicate(first, second, third)[i]", ["ConvertFunc"] = " ",}), + ("SveVecPairBinOpTest.template", new Dictionary { ["TestName"] = "SveZipHigh_float", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ZipHigh", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateEntry"] = "result[i] != left[index + half] || result[i + 1] != right[index + half]"}), ("SveVecPairBinOpTest.template", new Dictionary { ["TestName"] = "SveZipHigh_double", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ZipHigh", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateEntry"] = "result[i] != left[index + half] || result[i + 1] != right[index + half]"}), ("SveVecPairBinOpTest.template", new Dictionary { ["TestName"] = "SveZipHigh_sbyte", ["Isa"] = "Sve", ["LoadIsa"] = "Sve", ["Method"] = "ZipHigh", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateEntry"] = "result[i] != left[index + half] || result[i + 1] != right[index + half]"}), diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs index ebffa0504f744..1c9268fa84e3e 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs @@ -168,6 +168,30 @@ public static int LastActiveElement(byte[] v) return -1; } + public static int LastActiveElement(sbyte[] v) + { + for (var i = v.Length - 1; i >= 0; i--) + { + if (v[i] != 0) + { + return i; + } + } + return -1; + } + + public static int LastActiveElement(short[] v) + { + for (var i = v.Length - 1; i >= 0; i--) + { + if (v[i] != 0) + { + return i; + } + } + return -1; + } + public static int LastActiveElement(ushort[] v) { for (var i = v.Length - 1; i >= 0; i--) @@ -180,6 +204,18 @@ public static int LastActiveElement(ushort[] v) return -1; } + public static int LastActiveElement(int[] v) + { + for (var i = v.Length - 1; i >= 0; i--) + { + if (v[i] != 0) + { + return i; + } + } + return -1; + } + public static int LastActiveElement(uint[] v) { for (var i = v.Length - 1; i >= 0; i--) @@ -192,6 +228,18 @@ public static int LastActiveElement(uint[] v) return -1; } + public static int LastActiveElement(long[] v) + { + for (var i = v.Length - 1; i >= 0; i--) + { + if (v[i] != 0) + { + return i; + } + } + return -1; + } + public static int LastActiveElement(ulong[] v) { for (var i = v.Length - 1; i >= 0; i--) @@ -204,6 +252,30 @@ public static int LastActiveElement(ulong[] v) return -1; } + private static int LastActiveElement(float[] v) + { + for (int i = v.Length - 1; i >= 0; i--) + { + if (Unsafe.BitCast(v[i]) != 0) + { + return i; + } + } + return -1; + } + + private static int LastActiveElement(double[] v) + { + for (int i = v.Length - 1; i >= 0; i--) + { + if (Unsafe.BitCast(v[i]) != 0) + { + return i; + } + } + return -1; + } + public static byte[] CreateMaskForNextActiveElement(byte[] mask, byte[] srcMask) { var count = srcMask.Length; @@ -7889,5 +7961,815 @@ public static T[] CreateBreakBeforePropagateMask(T[] mask, T[] op1, T[] op2) } return result; } + + private static byte ConditionalExtract(byte[] op1, byte op2, byte[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static byte[] ConditionalExtract(byte[] op1, byte[] op2, byte[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + byte[] result = new byte[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static byte ConditionalExtractAfterLastActiveElement(byte[] op1, byte op2, byte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static byte ConditionalExtractLastActiveElement(byte[] op1, byte op2, byte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static byte[] ConditionalExtractAfterLastActiveElement(byte[] op1, byte[] op2, byte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static byte[] ConditionalExtractAfterLastActiveElementAndReplicate(byte[] op1, byte[] op2, byte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static byte[] ConditionalExtractLastActiveElement(byte[] op1, byte[] op2, byte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static byte[] ConditionalExtractLastActiveElementAndReplicate(byte[] op1, byte[] op2, byte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static sbyte ConditionalExtract(sbyte[] op1, sbyte op2, sbyte[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static sbyte[] ConditionalExtract(sbyte[] op1, sbyte[] op2, sbyte[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + sbyte[] result = new sbyte[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static sbyte ConditionalExtractAfterLastActiveElement(sbyte[] op1, sbyte op2, sbyte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static sbyte ConditionalExtractLastActiveElement(sbyte[] op1, sbyte op2, sbyte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static sbyte[] ConditionalExtractAfterLastActiveElement(sbyte[] op1, sbyte[] op2, sbyte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static sbyte[] ConditionalExtractAfterLastActiveElementAndReplicate(sbyte[] op1, sbyte[] op2, sbyte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static sbyte[] ConditionalExtractLastActiveElement(sbyte[] op1, sbyte[] op2, sbyte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static sbyte[] ConditionalExtractLastActiveElementAndReplicate(sbyte[] op1, sbyte[] op2, sbyte[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static short ConditionalExtract(short[] op1, short op2, short[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static short[] ConditionalExtract(short[] op1, short[] op2, short[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + short[] result = new short[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static short ConditionalExtractAfterLastActiveElement(short[] op1, short op2, short[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static short ConditionalExtractLastActiveElement(short[] op1, short op2, short[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static short[] ConditionalExtractAfterLastActiveElement(short[] op1, short[] op2, short[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static short[] ConditionalExtractAfterLastActiveElementAndReplicate(short[] op1, short[] op2, short[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static short[] ConditionalExtractLastActiveElement(short[] op1, short[] op2, short[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static short[] ConditionalExtractLastActiveElementAndReplicate(short[] op1, short[] op2, short[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static ushort ConditionalExtract(ushort[] op1, ushort op2, ushort[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static ushort[] ConditionalExtract(ushort[] op1, ushort[] op2, ushort[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + ushort[] result = new ushort[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static ushort ConditionalExtractAfterLastActiveElement(ushort[] op1, ushort op2, ushort[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static ushort ConditionalExtractLastActiveElement(ushort[] op1, ushort op2, ushort[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static ushort[] ConditionalExtractAfterLastActiveElement(ushort[] op1, ushort[] op2, ushort[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static ushort[] ConditionalExtractAfterLastActiveElementAndReplicate(ushort[] op1, ushort[] op2, ushort[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static ushort[] ConditionalExtractLastActiveElement(ushort[] op1, ushort[] op2, ushort[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static ushort[] ConditionalExtractLastActiveElementAndReplicate(ushort[] op1, ushort[] op2, ushort[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static int ConditionalExtract(int[] op1, int op2, int[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static int[] ConditionalExtract(int[] op1, int[] op2, int[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int[] result = new int[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static int ConditionalExtractAfterLastActiveElement(int[] op1, int op2, int[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static int ConditionalExtractLastActiveElement(int[] op1, int op2, int[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static int[] ConditionalExtractAfterLastActiveElement(int[] op1, int[] op2, int[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static int[] ConditionalExtractAfterLastActiveElementAndReplicate(int[] op1, int[] op2, int[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static int[] ConditionalExtractLastActiveElement(int[] op1, int[] op2, int[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static int[] ConditionalExtractLastActiveElementAndReplicate(int[] op1, int[] op2, int[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static uint ConditionalExtract(uint[] op1, uint op2, uint[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static uint[] ConditionalExtract(uint[] op1, uint[] op2, uint[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + uint[] result = new uint[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static uint ConditionalExtractAfterLastActiveElement(uint[] op1, uint op2, uint[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static uint ConditionalExtractLastActiveElement(uint[] op1, uint op2, uint[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static uint[] ConditionalExtractAfterLastActiveElement(uint[] op1, uint[] op2, uint[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static uint[] ConditionalExtractAfterLastActiveElementAndReplicate(uint[] op1, uint[] op2, uint[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static uint[] ConditionalExtractLastActiveElement(uint[] op1, uint[] op2, uint[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static uint[] ConditionalExtractLastActiveElementAndReplicate(uint[] op1, uint[] op2, uint[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static long ConditionalExtract(long[] op1, long op2, long[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static long[] ConditionalExtract(long[] op1, long[] op2, long[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + long[] result = new long[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static long ConditionalExtractAfterLastActiveElement(long[] op1, long op2, long[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static long ConditionalExtractLastActiveElement(long[] op1, long op2, long[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static long[] ConditionalExtractAfterLastActiveElement(long[] op1, long[] op2, long[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static long[] ConditionalExtractAfterLastActiveElementAndReplicate(long[] op1, long[] op2, long[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static long[] ConditionalExtractLastActiveElement(long[] op1, long[] op2, long[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static long[] ConditionalExtractLastActiveElementAndReplicate(long[] op1, long[] op2, long[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + public static ulong ConditionalExtractAfterLastActiveElement(ulong[] op1, ulong op2, ulong[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + private static ulong ConditionalExtract(ulong[] op1, ulong op2, ulong[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static ulong[] ConditionalExtract(ulong[] op1, ulong[] op2, ulong[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + ulong[] result = new ulong[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static ulong ConditionalExtractLastActiveElement(ulong[] op1, ulong op2, ulong[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static ulong[] ConditionalExtractAfterLastActiveElement(ulong[] op1, ulong[] op2, ulong[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static ulong[] ConditionalExtractAfterLastActiveElementAndReplicate(ulong[] op1, ulong[] op2, ulong[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static ulong[] ConditionalExtractLastActiveElement(ulong[] op1, ulong[] op2, ulong[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static ulong[] ConditionalExtractLastActiveElementAndReplicate(ulong[] op1, ulong[] op2, ulong[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static float ConditionalExtract(float[] op1, float op2, float[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static float[] ConditionalExtract(float[] op1, float[] op2, float[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + float[] result = new float[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static float ConditionalExtractAfterLastActiveElement(float[] op1, float op2, float[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static float ConditionalExtractLastActiveElement(float[] op1, float op2, float[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static float[] ConditionalExtractAfterLastActiveElement(float[] op1, float[] op2, float[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static float[] ConditionalExtractAfterLastActiveElementAndReplicate(float[] op1, float[] op2, float[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static float[] ConditionalExtractLastActiveElement(float[] op1, float[] op2, float[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static float[] ConditionalExtractLastActiveElementAndReplicate(float[] op1, float[] op2, float[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } + + private static double ConditionalExtract(double[] op1, double op2, double[] op3, bool after) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + return op3[pos]; + } + + private static double[] ConditionalExtract(double[] op1, double[] op2, double[] op3, bool after, bool replicate) + { + int last = LastActiveElement(op1); + if (last < 0) + { + return op2; + } + + double[] result = new double[op1.Length]; + int pos = last; + if (after) + { + pos++; + if (pos == op1.Length) { + pos = 0; + } + } + + if (replicate) + { + Array.Fill(result, op3[pos]); + } + else + { + Array.Fill(result, 0, 0, op1.Length); + result[0] = op3[pos]; + } + + return result; + } + + public static double ConditionalExtractAfterLastActiveElement(double[] op1, double op2, double[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true); + } + + public static double ConditionalExtractLastActiveElement(double[] op1, double op2, double[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false); + } + + public static double[] ConditionalExtractAfterLastActiveElement(double[] op1, double[] op2, double[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ false); + } + + public static double[] ConditionalExtractAfterLastActiveElementAndReplicate(double[] op1, double[] op2, double[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ true, /* replicate = */ true); + } + + public static double[] ConditionalExtractLastActiveElement(double[] op1, double[] op2, double[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ false); + } + + public static double[] ConditionalExtractLastActiveElementAndReplicate(double[] op1, double[] op2, double[] op3) + { + return ConditionalExtract(op1, op2, op3, /* after = */ false, /* replicate = */ true); + } } } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_SveScalarTernOpTestTemplate.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_SveScalarTernOpTestTemplate.template new file mode 100644 index 0000000000000..5b21288c8dc74 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/_SveScalarTernOpTestTemplate.template @@ -0,0 +1,338 @@ +// 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.Numerics; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; +using Xunit; + +namespace JIT.HardwareIntrinsics.Arm +{ + public static partial class Program + { + [Fact] + public static void {TestName}() + { + var test = new {TemplateName}TernaryOpTest__{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(); + + // Validates passing a local works, using Unsafe.Read + test.RunLclVarScenario_UnsafeRead(); + + // Validates passing an instance member of a class works + test.RunClassFldScenario(); + + // Validates passing the field of a local struct works + test.RunStructLclFldScenario(); + + // Validates passing an instance member of a struct works + test.RunStructFldScenario(); + } + else + { + // 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 {TemplateName}TernaryOpTest__{TestName} + { + private struct DataTable + { + private byte[] inArray1; + public {Op2BaseType} inScalar2; + private byte[] inArray3; + + private GCHandle inHandle1; + private GCHandle inHandle2; + private GCHandle inHandle3; + private GCHandle outHandle; + + private ulong alignment; + + public DataTable({Op1BaseType}[] inArray1, {Op2BaseType} inScalar2, {Op3BaseType}[] inArray3, int alignment) + { + int sizeOfinArray1 = inArray1.Length * Unsafe.SizeOf<{Op1BaseType}>(); + int sizeOfinArray3 = inArray3.Length * Unsafe.SizeOf<{Op3BaseType}>(); + if ((alignment != 64 && alignment != 16 && alignment != 8) || (alignment * 2) < sizeOfinArray1 || (alignment * 2) < sizeOfinArray3) + { + throw new ArgumentException("Invalid value of alignment"); + } + + this.inArray1 = new byte[alignment * 2]; + this.inArray3 = new byte[alignment * 2]; + + this.inHandle1 = GCHandle.Alloc(this.inArray1, GCHandleType.Pinned); + this.inHandle3 = GCHandle.Alloc(this.inArray3, GCHandleType.Pinned); + + this.alignment = (ulong)alignment; + + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1); + Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef(inArray3Ptr), ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), (uint)sizeOfinArray3); + } + + public void* inArray1Ptr => Align((byte*)(inHandle1.AddrOfPinnedObject().ToPointer()), alignment); + public void* inArray3Ptr => Align((byte*)(inHandle3.AddrOfPinnedObject().ToPointer()), alignment); + + public void Dispose() + { + inHandle1.Free(); + inHandle3.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 {Op2BaseType} _fld2; + public {Op1VectorType}<{Op3BaseType}> _fld3; + + 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}>>()); + _data2 = {NextValueOp2}; + testStruct._fld2 = _data2; + for (var i = 0; i < Op1ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op3BaseType}>, byte>(ref testStruct._fld3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op3BaseType}>>()); + + return testStruct; + } + + public void RunStructFldScenario({TemplateName}TernaryOpTest__{TestName} testClass) + { + {RetBaseType} result = {Isa}.{Method}(_fld1, _fld2, _fld3); + + testClass.ValidateResult(_fld1, _fld2, _fld3, result); + } + } + + private static readonly int LargestVectorSize = {LargestVectorSize}; + + private static readonly int Op1ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>() / sizeof({Op1BaseType}); + private static readonly int Op3ElementCount = Unsafe.SizeOf<{Op1VectorType}<{Op3BaseType}>>() / sizeof({Op3BaseType}); + + private static {Op1BaseType}[] _maskData = new {Op1BaseType}[Op1ElementCount]; + private static {Op1BaseType}[] _data1 = new {Op1BaseType}[Op1ElementCount]; + private static {Op2BaseType} _data2; + private static {Op3BaseType}[] _data3 = new {Op3BaseType}[Op3ElementCount]; + + private {Op1VectorType}<{Op1BaseType}> _mask; + private {Op1VectorType}<{Op1BaseType}> _fld1; + private {Op2BaseType} _fld2; + private {Op1VectorType}<{Op3BaseType}> _fld3; + private {Op1VectorType}<{Op1BaseType}> _falseFld; + + private DataTable _dataTable; + + public {TemplateName}TernaryOpTest__{TestName}() + { + Succeeded = true; + + for (var i = 0; i < Op1ElementCount; i++) { _maskData[i] = ({Op1BaseType})({NextValueOp1} % 2); } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _mask), ref Unsafe.As<{Op1BaseType}, byte>(ref _maskData[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + 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}>>()); + _data2 = {NextValueOp2}; + _fld2 = _data2; + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op3BaseType}>, byte>(ref _fld3), ref Unsafe.As<{Op3BaseType}, byte>(ref _data3[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op3BaseType}>>()); + + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1VectorType}<{Op1BaseType}>, byte>(ref _falseFld), ref Unsafe.As<{Op1BaseType}, byte>(ref _data1[0]), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + + for (var i = 0; i < Op1ElementCount; i++) { _data1[i] = {NextValueOp1}; } + _data2 = {NextValueOp2}; + for (var i = 0; i < Op3ElementCount; i++) { _data3[i] = {NextValueOp3}; } + _dataTable = new DataTable(_data1, _data2, _data3, LargestVectorSize); + } + + public bool IsSupported => {Isa}.IsSupported; + + public bool Succeeded { get; set; } + + public void RunBasicScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + + {RetBaseType} result = {Isa}.{Method}( + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), + _dataTable.inScalar2, + Unsafe.Read<{Op1VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr) + ); + + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inScalar2, _dataTable.inArray3Ptr, result); + } + + public void RunBasicScenario_Load() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + + {Op1VectorType}<{Op1BaseType}> loadMask1 = Sve.CreateTrueMask{Op1BaseType}(SveMaskPattern.All); + {Op1VectorType}<{Op3BaseType}> loadMask3 = Sve.CreateTrueMask{Op3BaseType}(SveMaskPattern.All); + + {RetBaseType} result = {Isa}.{Method}( + {LoadIsa}.Load{Op1VectorType}(loadMask1, ({Op1BaseType}*)(_dataTable.inArray1Ptr)), + _dataTable.inScalar2, + {LoadIsa}.Load{Op1VectorType}(loadMask3, ({Op3BaseType}*)(_dataTable.inArray3Ptr)) + ); + + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inScalar2, _dataTable.inArray3Ptr, result); + } + + public void RunReflectionScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + + {RetBaseType} result = ({RetBaseType}) typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1VectorType}<{Op1BaseType}>), typeof({Op2BaseType}), typeof({Op1VectorType}<{Op3BaseType}>) }) + .Invoke(null, new object[] { + Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr), + _dataTable.inScalar2, + Unsafe.Read<{Op1VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr) + }); + + ValidateResult(_dataTable.inArray1Ptr, _dataTable.inScalar2, _dataTable.inArray3Ptr, result); + } + + public void RunLclVarScenario_UnsafeRead() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + + var op1 = Unsafe.Read<{Op1VectorType}<{Op1BaseType}>>(_dataTable.inArray1Ptr); + var op2 = _dataTable.inScalar2; + var op3 = Unsafe.Read<{Op1VectorType}<{Op3BaseType}>>(_dataTable.inArray3Ptr); + {RetBaseType} result = {Isa}.{Method}(op1, op2, op3); + + ValidateResult(op1, op2, op3, result); + } + + public void RunClassFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + + {RetBaseType} result = {Isa}.{Method}(_fld1, _fld2, _fld3); + + ValidateResult(_fld1, _fld2, _fld3, result); + } + + public void RunStructLclFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + + var test = TestStruct.Create(); + {RetBaseType} result = {Isa}.{Method}(test._fld1, test._fld2, test._fld3); + + ValidateResult(test._fld1, test._fld2, test._fld3, result); + } + + public void RunStructFldScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + + var test = TestStruct.Create(); + test.RunStructFldScenario(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, {Op2BaseType} op2, {Op1VectorType}<{Op3BaseType}> op3, {RetBaseType} result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {Op2BaseType} inScalar2; + {Op3BaseType}[] inArray3 = new {Op3BaseType}[Op1ElementCount]; + + Unsafe.WriteUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), op1); + inScalar2 = op2; + Unsafe.WriteUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), op3); + + ValidateResult(inArray1, inScalar2, inArray3, result, method); + } + + private void ValidateResult(void* op1, {Op2BaseType} op2, void* op3, {RetBaseType} result, [CallerMemberName] string method = "") + { + {Op1BaseType}[] inArray1 = new {Op1BaseType}[Op1ElementCount]; + {Op2BaseType} inScalar2; + {Op3BaseType}[] inArray3 = new {Op3BaseType}[Op1ElementCount]; + + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), ref Unsafe.AsRef(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>()); + inScalar2 = op2; + Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef(op3), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op3BaseType}>>()); + + ValidateResult(inArray1, inScalar2, inArray3, result, method); + } + + private void ValidateResult({Op1BaseType}[] firstOp, {Op2BaseType} secondOp, {Op3BaseType}[] thirdOp, {RetBaseType} result, [CallerMemberName] string method = "") + { + bool succeeded = true; + + {TemplateValidationLogic} + + if (!succeeded) + { + TestLibrary.TestFramework.LogInformation($"{nameof({Isa})}.{nameof({Isa}.{Method})}({RetBaseType})({Op1VectorType}<{Op1BaseType}>, {Op2BaseType}, {Op1VectorType}<{Op3BaseType}>): {method} failed:"); + TestLibrary.TestFramework.LogInformation($" firstOp: ({string.Join(", ", firstOp)})"); + TestLibrary.TestFramework.LogInformation($"secondOp: ({string.Join(", ", secondOp)})"); + TestLibrary.TestFramework.LogInformation($" thirdOp: ({string.Join(", ", thirdOp)})"); + TestLibrary.TestFramework.LogInformation($" result: ({string.Join(", ", result)})"); + TestLibrary.TestFramework.LogInformation(string.Empty); + + Succeeded = false; + } + } + } +}