VSadov/Satori
1
0
Fork 0
mirror of https://github.com/VSadov/Satori.git synced 2025-06-11 02:13:38 +09:00
Code Activity

JIT ARM64-SVE: Add Sve.ConditionalExtract* APIs (#104150)

Browse source 
* JIT ARM64-SVE: Add Sve.ConditionalExtract* APIs

* cleanup: fix formatting

* Update Helpers.cs

* cleanup: group and place APIs in alphabedical order and align the field

* Remove redundant HasScalarInputVariant flags from *Replicate intrinsics

* cleanup: place special intrinsics in alphabetical order

* cleanup: correctly specify emitted instructions in the comments

* fixup! cleanup: place special intrinsics in alphabetical order

* fixup! cleanup: group and place APIs in alphabedical order and align the field

* fixup! ARM64-SVE: GatherPrefetch (#103826)

* Revert "fixup! ARM64-SVE: GatherPrefetch (#103826)"

This reverts commit b0212caf190db21c54a59a48f226ca7c4eceea25.

* cleanup: align the lines for the newly added tests.

---------

Co-authored-by: Kunal Pathak <Kunal.Pathak@microsoft.com>
This commit is contained in:
Mikhail Ablakatov 2024-07-06 02:49:23 +01:00 • committed by GitHub
parent e224ffb9b7
commit 67e198341d
Signed by: github
GPG key ID: B5690EEEBB952194
10 changed files with 2179 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/coreclr/jit/hwintrinsic.h
View file

@ -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;

29
src/coreclr/jit/hwintrinsicarm64.cpp
View file

@ -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:
{

45
src/coreclr/jit/hwintrinsiccodegenarm64.cpp
View file

@ -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();
}

15
src/coreclr/jit/hwintrinsiclistarm64sve.h
View file

@ -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

372
src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs
View file

@ -1411,6 +1411,378 @@ namespace System.Runtime.Intrinsics.Arm
/// </summary>
public static unsafe Vector<ulong> Compute8BitAddresses(Vector<ulong> bases, Vector<ulong> indices) { throw new PlatformNotSupportedException(); }
/// Conditionally extract element after last
/// <summary>
/// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTA Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractAfterLastActiveElement(Vector<byte> mask, Vector<byte> defaultValue, Vector<byte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector<byte> mask, byte defaultValues, Vector<byte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractAfterLastActiveElement(Vector<double> mask, Vector<double> defaultValue, Vector<double> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe double ConditionalExtractAfterLastActiveElement(Vector<double> mask, double defaultValues, Vector<double> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTA Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractAfterLastActiveElement(Vector<short> mask, Vector<short> defaultValue, Vector<short> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe short ConditionalExtractAfterLastActiveElement(Vector<short> mask, short defaultValues, Vector<short> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractAfterLastActiveElement(Vector<int> mask, Vector<int> defaultValue, Vector<int> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe int ConditionalExtractAfterLastActiveElement(Vector<int> mask, int defaultValues, Vector<int> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractAfterLastActiveElement(Vector<long> mask, Vector<long> defaultValue, Vector<long> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data)
/// CLASTA Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe long ConditionalExtractAfterLastActiveElement(Vector<long> mask, long defaultValues, Vector<long> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTA Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, Vector<sbyte> defaultValue, Vector<sbyte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, sbyte defaultValues, Vector<sbyte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractAfterLastActiveElement(Vector<float> mask, Vector<float> defaultValue, Vector<float> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe float ConditionalExtractAfterLastActiveElement(Vector<float> mask, float defaultValues, Vector<float> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTA Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, Vector<ushort> defaultValue, Vector<ushort> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, ushort defaultValues, Vector<ushort> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractAfterLastActiveElement(Vector<uint> mask, Vector<uint> defaultValue, Vector<uint> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector<uint> mask, uint defaultValues, Vector<uint> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, Vector<ulong> defaultValue, Vector<ulong> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data)
/// CLASTA Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, ulong defaultValues, Vector<ulong> data) { throw new PlatformNotSupportedException(); }
/// Conditionally extract element after last
/// <summary>
/// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<byte> mask, Vector<byte> defaultScalar, Vector<byte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<double> mask, Vector<double> defaultScalar, Vector<double> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<short> mask, Vector<short> defaultScalar, Vector<short> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<int> mask, Vector<int> defaultScalar, Vector<int> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<long> mask, Vector<long> defaultScalar, Vector<long> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<sbyte> mask, Vector<sbyte> defaultScalar, Vector<sbyte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<float> mask, Vector<float> defaultScalar, Vector<float> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<ushort> mask, Vector<ushort> defaultScalar, Vector<ushort> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<uint> mask, Vector<uint> defaultScalar, Vector<uint> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<ulong> mask, Vector<ulong> defaultScalar, Vector<ulong> data) { throw new PlatformNotSupportedException(); }
/// Conditionally extract last element
/// <summary>
/// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTB Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractLastActiveElement(Vector<byte> mask, Vector<byte> defaultValue, Vector<byte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe byte ConditionalExtractLastActiveElement(Vector<byte> mask, byte defaultValues, Vector<byte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractLastActiveElement(Vector<double> mask, Vector<double> defaultValue, Vector<double> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe double ConditionalExtractLastActiveElement(Vector<double> mask, double defaultValues, Vector<double> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTB Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractLastActiveElement(Vector<short> mask, Vector<short> defaultValue, Vector<short> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe short ConditionalExtractLastActiveElement(Vector<short> mask, short defaultValues, Vector<short> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractLastActiveElement(Vector<int> mask, Vector<int> defaultValue, Vector<int> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe int ConditionalExtractLastActiveElement(Vector<int> mask, int defaultValues, Vector<int> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractLastActiveElement(Vector<long> mask, Vector<long> defaultValue, Vector<long> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data)
/// CLASTB Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe long ConditionalExtractLastActiveElement(Vector<long> mask, long defaultValues, Vector<long> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTB Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractLastActiveElement(Vector<sbyte> mask, Vector<sbyte> defaultValue, Vector<sbyte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe sbyte ConditionalExtractLastActiveElement(Vector<sbyte> mask, sbyte defaultValues, Vector<sbyte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractLastActiveElement(Vector<float> mask, Vector<float> defaultValue, Vector<float> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe float ConditionalExtractLastActiveElement(Vector<float> mask, float defaultValues, Vector<float> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTB Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractLastActiveElement(Vector<ushort> mask, Vector<ushort> defaultValue, Vector<ushort> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe ushort ConditionalExtractLastActiveElement(Vector<ushort> mask, ushort defaultValues, Vector<ushort> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractLastActiveElement(Vector<uint> mask, Vector<uint> defaultValue, Vector<uint> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe uint ConditionalExtractLastActiveElement(Vector<uint> mask, uint defaultValues, Vector<uint> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractLastActiveElement(Vector<ulong> mask, Vector<ulong> defaultValue, Vector<ulong> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data)
/// CLASTB Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe ulong ConditionalExtractLastActiveElement(Vector<ulong> mask, ulong defaultValues, Vector<ulong> data) { throw new PlatformNotSupportedException(); }
/// Conditionally extract last element
/// <summary>
/// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractLastActiveElementAndReplicate(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractLastActiveElementAndReplicate(Vector<double> mask, Vector<double> fallback, Vector<double> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractLastActiveElementAndReplicate(Vector<short> mask, Vector<short> fallback, Vector<short> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractLastActiveElementAndReplicate(Vector<int> mask, Vector<int> fallback, Vector<int> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractLastActiveElementAndReplicate(Vector<long> mask, Vector<long> fallback, Vector<long> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractLastActiveElementAndReplicate(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractLastActiveElementAndReplicate(Vector<float> mask, Vector<float> fallback, Vector<float> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractLastActiveElementAndReplicate(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractLastActiveElementAndReplicate(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data) { throw new PlatformNotSupportedException(); }
/// <summary>
/// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractLastActiveElementAndReplicate(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data) { throw new PlatformNotSupportedException(); }
/// Compare equal to
/// ConditionalSelect : Conditionally select elements

372
src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs
View file

@ -1441,6 +1441,378 @@ namespace System.Runtime.Intrinsics.Arm
/// </summary>
public static unsafe Vector<ulong> Compute8BitAddresses(Vector<ulong> bases, Vector<ulong> indices) => Compute8BitAddresses(bases, indices);
/// Conditionally extract element after last
/// <summary>
/// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTA Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractAfterLastActiveElement(Vector<byte> mask, Vector<byte> defaultValue, Vector<byte> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint8_t svclasta[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe byte ConditionalExtractAfterLastActiveElement(Vector<byte> mask, byte defaultValues, Vector<byte> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractAfterLastActiveElement(Vector<double> mask, Vector<double> defaultValue, Vector<double> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// float64_t svclasta[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe double ConditionalExtractAfterLastActiveElement(Vector<double> mask, double defaultValues, Vector<double> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTA Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractAfterLastActiveElement(Vector<short> mask, Vector<short> defaultValue, Vector<short> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int16_t svclasta[_n_s16](svbool_t pg, int16_t fallback, svint16_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe short ConditionalExtractAfterLastActiveElement(Vector<short> mask, short defaultValues, Vector<short> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractAfterLastActiveElement(Vector<int> mask, Vector<int> defaultValue, Vector<int> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int32_t svclasta[_n_s32](svbool_t pg, int32_t fallback, svint32_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe int ConditionalExtractAfterLastActiveElement(Vector<int> mask, int defaultValues, Vector<int> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractAfterLastActiveElement(Vector<long> mask, Vector<long> defaultValue, Vector<long> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int64_t svclasta[_n_s64](svbool_t pg, int64_t fallback, svint64_t data)
/// CLASTA Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe long ConditionalExtractAfterLastActiveElement(Vector<long> mask, long defaultValues, Vector<long> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTA Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, Vector<sbyte> defaultValue, Vector<sbyte> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int8_t svclasta[_n_s8](svbool_t pg, int8_t fallback, svint8_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe sbyte ConditionalExtractAfterLastActiveElement(Vector<sbyte> mask, sbyte defaultValues, Vector<sbyte> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractAfterLastActiveElement(Vector<float> mask, Vector<float> defaultValue, Vector<float> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// float32_t svclasta[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe float ConditionalExtractAfterLastActiveElement(Vector<float> mask, float defaultValues, Vector<float> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTA Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, Vector<ushort> defaultValue, Vector<ushort> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint16_t svclasta[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe ushort ConditionalExtractAfterLastActiveElement(Vector<ushort> mask, ushort defaultValues, Vector<ushort> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTA Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractAfterLastActiveElement(Vector<uint> mask, Vector<uint> defaultValue, Vector<uint> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint32_t svclasta[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data)
/// CLASTA Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe uint ConditionalExtractAfterLastActiveElement(Vector<uint> mask, uint defaultValues, Vector<uint> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTA Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, Vector<ulong> defaultValue, Vector<ulong> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint64_t svclasta[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data)
/// CLASTA Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe ulong ConditionalExtractAfterLastActiveElement(Vector<ulong> mask, ulong defaultValues, Vector<ulong> data) => ConditionalExtractAfterLastActiveElement(mask, defaultValues, data);
/// Conditionally extract element after last
/// <summary>
/// svuint8_t svclasta[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<byte> mask, Vector<byte> defaultScalar, Vector<byte> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svfloat64_t svclasta[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<double> mask, Vector<double> defaultScalar, Vector<double> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svint16_t svclasta[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<short> mask, Vector<short> defaultScalar, Vector<short> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svint32_t svclasta[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<int> mask, Vector<int> defaultScalar, Vector<int> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svint64_t svclasta[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<long> mask, Vector<long> defaultScalar, Vector<long> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svint8_t svclasta[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTA Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<sbyte> mask, Vector<sbyte> defaultScalar, Vector<sbyte> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svfloat32_t svclasta[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<float> mask, Vector<float> defaultScalar, Vector<float> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svuint16_t svclasta[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTA Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<ushort> mask, Vector<ushort> defaultScalar, Vector<ushort> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svuint32_t svclasta[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTA Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<uint> mask, Vector<uint> defaultScalar, Vector<uint> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// <summary>
/// svuint64_t svclasta[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTA Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractAfterLastActiveElementAndReplicate(Vector<ulong> mask, Vector<ulong> defaultScalar, Vector<ulong> data) => ConditionalExtractAfterLastActiveElementAndReplicate(mask, defaultScalar, data);
/// Conditionally extract last element
/// <summary>
/// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTB Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractLastActiveElement(Vector<byte> mask, Vector<byte> defaultValue, Vector<byte> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint8_t svclastb[_n_u8](svbool_t pg, uint8_t fallback, svuint8_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe byte ConditionalExtractLastActiveElement(Vector<byte> mask, byte defaultValues, Vector<byte> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractLastActiveElement(Vector<double> mask, Vector<double> defaultValue, Vector<double> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// float64_t svclastb[_n_f64](svbool_t pg, float64_t fallback, svfloat64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe double ConditionalExtractLastActiveElement(Vector<double> mask, double defaultValues, Vector<double> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTB Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractLastActiveElement(Vector<short> mask, Vector<short> defaultValue, Vector<short> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int16_t svclastb[_n_s16](svbool_t pg, int16_t fallback, svint16_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe short ConditionalExtractLastActiveElement(Vector<short> mask, short defaultValues, Vector<short> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractLastActiveElement(Vector<int> mask, Vector<int> defaultValue, Vector<int> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int32_t svclastb[_n_s32](svbool_t pg, int32_t fallback, svint32_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe int ConditionalExtractLastActiveElement(Vector<int> mask, int defaultValues, Vector<int> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractLastActiveElement(Vector<long> mask, Vector<long> defaultValue, Vector<long> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int64_t svclastb[_n_s64](svbool_t pg, int64_t fallback, svint64_t data)
/// CLASTB Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe long ConditionalExtractLastActiveElement(Vector<long> mask, long defaultValues, Vector<long> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTB Btied, Pg, Btied, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractLastActiveElement(Vector<sbyte> mask, Vector<sbyte> defaultValue, Vector<sbyte> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// int8_t svclastb[_n_s8](svbool_t pg, int8_t fallback, svint8_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.B
/// </summary>
public static unsafe sbyte ConditionalExtractLastActiveElement(Vector<sbyte> mask, sbyte defaultValues, Vector<sbyte> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractLastActiveElement(Vector<float> mask, Vector<float> defaultValue, Vector<float> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// float32_t svclastb[_n_f32](svbool_t pg, float32_t fallback, svfloat32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe float ConditionalExtractLastActiveElement(Vector<float> mask, float defaultValues, Vector<float> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTB Htied, Pg, Htied, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractLastActiveElement(Vector<ushort> mask, Vector<ushort> defaultValue, Vector<ushort> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint16_t svclastb[_n_u16](svbool_t pg, uint16_t fallback, svuint16_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.H
/// </summary>
public static unsafe ushort ConditionalExtractLastActiveElement(Vector<ushort> mask, ushort defaultValues, Vector<ushort> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTB Stied, Pg, Stied, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractLastActiveElement(Vector<uint> mask, Vector<uint> defaultValue, Vector<uint> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint32_t svclastb[_n_u32](svbool_t pg, uint32_t fallback, svuint32_t data)
/// CLASTB Wtied, Pg, Wtied, Zdata.S
/// </summary>
public static unsafe uint ConditionalExtractLastActiveElement(Vector<uint> mask, uint defaultValues, Vector<uint> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// <summary>
/// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTB Dtied, Pg, Dtied, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractLastActiveElement(Vector<ulong> mask, Vector<ulong> defaultValue, Vector<ulong> data) => ConditionalExtractLastActiveElement(mask, defaultValue, data);
/// <summary>
/// uint64_t svclastb[_n_u64](svbool_t pg, uint64_t fallback, svuint64_t data)
/// CLASTB Xtied, Pg, Xtied, Zdata.D
/// </summary>
public static unsafe ulong ConditionalExtractLastActiveElement(Vector<ulong> mask, ulong defaultValues, Vector<ulong> data) => ConditionalExtractLastActiveElement(mask, defaultValues, data);
/// Conditionally extract last element
/// <summary>
/// svuint8_t svclastb[_u8](svbool_t pg, svuint8_t fallback, svuint8_t data)
/// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<byte> ConditionalExtractLastActiveElementAndReplicate(Vector<byte> mask, Vector<byte> fallback, Vector<byte> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svfloat64_t svclastb[_f64](svbool_t pg, svfloat64_t fallback, svfloat64_t data)
/// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<double> ConditionalExtractLastActiveElementAndReplicate(Vector<double> mask, Vector<double> fallback, Vector<double> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svint16_t svclastb[_s16](svbool_t pg, svint16_t fallback, svint16_t data)
/// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<short> ConditionalExtractLastActiveElementAndReplicate(Vector<short> mask, Vector<short> fallback, Vector<short> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svint32_t svclastb[_s32](svbool_t pg, svint32_t fallback, svint32_t data)
/// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<int> ConditionalExtractLastActiveElementAndReplicate(Vector<int> mask, Vector<int> fallback, Vector<int> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svint64_t svclastb[_s64](svbool_t pg, svint64_t fallback, svint64_t data)
/// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<long> ConditionalExtractLastActiveElementAndReplicate(Vector<long> mask, Vector<long> fallback, Vector<long> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svint8_t svclastb[_s8](svbool_t pg, svint8_t fallback, svint8_t data)
/// CLASTB Ztied.B, Pg, Ztied.B, Zdata.B
/// </summary>
public static unsafe Vector<sbyte> ConditionalExtractLastActiveElementAndReplicate(Vector<sbyte> mask, Vector<sbyte> fallback, Vector<sbyte> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svfloat32_t svclastb[_f32](svbool_t pg, svfloat32_t fallback, svfloat32_t data)
/// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<float> ConditionalExtractLastActiveElementAndReplicate(Vector<float> mask, Vector<float> fallback, Vector<float> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svuint16_t svclastb[_u16](svbool_t pg, svuint16_t fallback, svuint16_t data)
/// CLASTB Ztied.H, Pg, Ztied.H, Zdata.H
/// </summary>
public static unsafe Vector<ushort> ConditionalExtractLastActiveElementAndReplicate(Vector<ushort> mask, Vector<ushort> fallback, Vector<ushort> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svuint32_t svclastb[_u32](svbool_t pg, svuint32_t fallback, svuint32_t data)
/// CLASTB Ztied.S, Pg, Ztied.S, Zdata.S
/// </summary>
public static unsafe Vector<uint> ConditionalExtractLastActiveElementAndReplicate(Vector<uint> mask, Vector<uint> fallback, Vector<uint> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// <summary>
/// svuint64_t svclastb[_u64](svbool_t pg, svuint64_t fallback, svuint64_t data)
/// CLASTB Ztied.D, Pg, Ztied.D, Zdata.D
/// </summary>
public static unsafe Vector<ulong> ConditionalExtractLastActiveElementAndReplicate(Vector<ulong> mask, Vector<ulong> fallback, Vector<ulong> data) => ConditionalExtractLastActiveElementAndReplicate(mask, fallback, data);
/// Compare equal to
/// ConditionalSelect : Conditionally select elements

61
src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs
View file

@ -4412,6 +4412,67 @@ namespace System.Runtime.Intrinsics.Arm
public static System.Numerics.Vector<ulong> Compute8BitAddresses(System.Numerics.Vector<ulong> bases, System.Numerics.Vector<long> indices) { throw null; }
public static System.Numerics.Vector<ulong> Compute8BitAddresses(System.Numerics.Vector<ulong> bases, System.Numerics.Vector<ulong> indices) { throw null; }
public static System.Numerics.Vector<byte> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<byte> mask, System.Numerics.Vector<byte> defaultValue, System.Numerics.Vector<byte> data) { throw null; }
public static byte ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<byte> mask, byte defaultValues, System.Numerics.Vector<byte> data) { throw null; }
public static System.Numerics.Vector<double> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<double> mask, System.Numerics.Vector<double> defaultValue, System.Numerics.Vector<double> data) { throw null; }
public static double ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<double> mask, double defaultValues, System.Numerics.Vector<double> data) { throw null; }
public static System.Numerics.Vector<short> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<short> mask, System.Numerics.Vector<short> defaultValue, System.Numerics.Vector<short> data) { throw null; }
public static short ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<short> mask, short defaultValues, System.Numerics.Vector<short> data) { throw null; }
public static System.Numerics.Vector<int> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<int> mask, System.Numerics.Vector<int> defaultValue, System.Numerics.Vector<int> data) { throw null; }
public static int ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<int> mask, int defaultValues, System.Numerics.Vector<int> data) { throw null; }
public static System.Numerics.Vector<long> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<long> mask, System.Numerics.Vector<long> defaultValue, System.Numerics.Vector<long> data) { throw null; }
public static long ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<long> mask, long defaultValues, System.Numerics.Vector<long> data) { throw null; }
public static System.Numerics.Vector<sbyte> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<sbyte> mask, System.Numerics.Vector<sbyte> defaultValue, System.Numerics.Vector<sbyte> data) { throw null; }
public static sbyte ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<sbyte> mask, sbyte defaultValues, System.Numerics.Vector<sbyte> data) { throw null; }
public static System.Numerics.Vector<float> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<float> mask, System.Numerics.Vector<float> defaultValue, System.Numerics.Vector<float> data) { throw null; }
public static float ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<float> mask, float defaultValues, System.Numerics.Vector<float> data) { throw null; }
public static System.Numerics.Vector<ushort> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<ushort> mask, System.Numerics.Vector<ushort> defaultValue, System.Numerics.Vector<ushort> data) { throw null; }
public static ushort ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<ushort> mask, ushort defaultValues, System.Numerics.Vector<ushort> data) { throw null; }
public static System.Numerics.Vector<uint> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<uint> mask, System.Numerics.Vector<uint> defaultValue, System.Numerics.Vector<uint> data) { throw null; }
public static uint ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<uint> mask, uint defaultValues, System.Numerics.Vector<uint> data) { throw null; }
public static System.Numerics.Vector<ulong> ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<ulong> mask, System.Numerics.Vector<ulong> defaultValue, System.Numerics.Vector<ulong> data) { throw null; }
public static ulong ConditionalExtractAfterLastActiveElement(System.Numerics.Vector<ulong> mask, ulong defaultValues, System.Numerics.Vector<ulong> data) { throw null; }
public static System.Numerics.Vector<byte> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<byte> mask, System.Numerics.Vector<byte> defaultScalar, System.Numerics.Vector<byte> data) { throw null; }
public static System.Numerics.Vector<double> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<double> mask, System.Numerics.Vector<double> defaultScalar, System.Numerics.Vector<double> data) { throw null; }
public static System.Numerics.Vector<short> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<short> mask, System.Numerics.Vector<short> defaultScalar, System.Numerics.Vector<short> data) { throw null; }
public static System.Numerics.Vector<int> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<int> mask, System.Numerics.Vector<int> defaultScalar, System.Numerics.Vector<int> data) { throw null; }
public static System.Numerics.Vector<long> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<long> mask, System.Numerics.Vector<long> defaultScalar, System.Numerics.Vector<long> data) { throw null; }
public static System.Numerics.Vector<sbyte> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<sbyte> mask, System.Numerics.Vector<sbyte> defaultScalar, System.Numerics.Vector<sbyte> data) { throw null; }
public static System.Numerics.Vector<float> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<float> mask, System.Numerics.Vector<float> defaultScalar, System.Numerics.Vector<float> data) { throw null; }
public static System.Numerics.Vector<ushort> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<ushort> mask, System.Numerics.Vector<ushort> defaultScalar, System.Numerics.Vector<ushort> data) { throw null; }
public static System.Numerics.Vector<uint> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<uint> mask, System.Numerics.Vector<uint> defaultScalar, System.Numerics.Vector<uint> data) { throw null; }
public static System.Numerics.Vector<ulong> ConditionalExtractAfterLastActiveElementAndReplicate(System.Numerics.Vector<ulong> mask, System.Numerics.Vector<ulong> defaultScalar, System.Numerics.Vector<ulong> data) { throw null; }
public static System.Numerics.Vector<byte> ConditionalExtractLastActiveElement(System.Numerics.Vector<byte> mask, System.Numerics.Vector<byte> defaultValue, System.Numerics.Vector<byte> data) { throw null; }
public static byte ConditionalExtractLastActiveElement(System.Numerics.Vector<byte> mask, byte defaultValues, System.Numerics.Vector<byte> data) { throw null; }
public static System.Numerics.Vector<double> ConditionalExtractLastActiveElement(System.Numerics.Vector<double> mask, System.Numerics.Vector<double> defaultValue, System.Numerics.Vector<double> data) { throw null; }
public static double ConditionalExtractLastActiveElement(System.Numerics.Vector<double> mask, double defaultValues, System.Numerics.Vector<double> data) { throw null; }
public static System.Numerics.Vector<short> ConditionalExtractLastActiveElement(System.Numerics.Vector<short> mask, System.Numerics.Vector<short> defaultValue, System.Numerics.Vector<short> data) { throw null; }
public static short ConditionalExtractLastActiveElement(System.Numerics.Vector<short> mask, short defaultValues, System.Numerics.Vector<short> data) { throw null; }
public static System.Numerics.Vector<int> ConditionalExtractLastActiveElement(System.Numerics.Vector<int> mask, System.Numerics.Vector<int> defaultValue, System.Numerics.Vector<int> data) { throw null; }
public static int ConditionalExtractLastActiveElement(System.Numerics.Vector<int> mask, int defaultValues, System.Numerics.Vector<int> data) { throw null; }
public static System.Numerics.Vector<long> ConditionalExtractLastActiveElement(System.Numerics.Vector<long> mask, System.Numerics.Vector<long> defaultValue, System.Numerics.Vector<long> data) { throw null; }
public static long ConditionalExtractLastActiveElement(System.Numerics.Vector<long> mask, long defaultValues, System.Numerics.Vector<long> data) { throw null; }
public static System.Numerics.Vector<sbyte> ConditionalExtractLastActiveElement(System.Numerics.Vector<sbyte> mask, System.Numerics.Vector<sbyte> defaultValue, System.Numerics.Vector<sbyte> data) { throw null; }
public static sbyte ConditionalExtractLastActiveElement(System.Numerics.Vector<sbyte> mask, sbyte defaultValues, System.Numerics.Vector<sbyte> data) { throw null; }
public static System.Numerics.Vector<float> ConditionalExtractLastActiveElement(System.Numerics.Vector<float> mask, System.Numerics.Vector<float> defaultValue, System.Numerics.Vector<float> data) { throw null; }
public static float ConditionalExtractLastActiveElement(System.Numerics.Vector<float> mask, float defaultValues, System.Numerics.Vector<float> data) { throw null; }
public static System.Numerics.Vector<ushort> ConditionalExtractLastActiveElement(System.Numerics.Vector<ushort> mask, System.Numerics.Vector<ushort> defaultValue, System.Numerics.Vector<ushort> data) { throw null; }
public static ushort ConditionalExtractLastActiveElement(System.Numerics.Vector<ushort> mask, ushort defaultValues, System.Numerics.Vector<ushort> data) { throw null; }
public static System.Numerics.Vector<uint> ConditionalExtractLastActiveElement(System.Numerics.Vector<uint> mask, System.Numerics.Vector<uint> defaultValue, System.Numerics.Vector<uint> data) { throw null; }
public static uint ConditionalExtractLastActiveElement(System.Numerics.Vector<uint> mask, uint defaultValues, System.Numerics.Vector<uint> data) { throw null; }
public static System.Numerics.Vector<ulong> ConditionalExtractLastActiveElement(System.Numerics.Vector<ulong> mask, System.Numerics.Vector<ulong> defaultValue, System.Numerics.Vector<ulong> data) { throw null; }
public static ulong ConditionalExtractLastActiveElement(System.Numerics.Vector<ulong> mask, ulong defaultValues, System.Numerics.Vector<ulong> data) { throw null; }
public static System.Numerics.Vector<byte> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<byte> mask, System.Numerics.Vector<byte> fallback, System.Numerics.Vector<byte> data) { throw null; }
public static System.Numerics.Vector<double> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<double> mask, System.Numerics.Vector<double> fallback, System.Numerics.Vector<double> data) { throw null; }
public static System.Numerics.Vector<short> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<short> mask, System.Numerics.Vector<short> fallback, System.Numerics.Vector<short> data) { throw null; }
public static System.Numerics.Vector<int> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<int> mask, System.Numerics.Vector<int> fallback, System.Numerics.Vector<int> data) { throw null; }
public static System.Numerics.Vector<long> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<long> mask, System.Numerics.Vector<long> fallback, System.Numerics.Vector<long> data) { throw null; }
public static System.Numerics.Vector<sbyte> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<sbyte> mask, System.Numerics.Vector<sbyte> fallback, System.Numerics.Vector<sbyte> data) { throw null; }
public static System.Numerics.Vector<float> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<float> mask, System.Numerics.Vector<float> fallback, System.Numerics.Vector<float> data) { throw null; }
public static System.Numerics.Vector<ushort> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<ushort> mask, System.Numerics.Vector<ushort> fallback, System.Numerics.Vector<ushort> data) { throw null; }
public static System.Numerics.Vector<uint> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<uint> mask, System.Numerics.Vector<uint> fallback, System.Numerics.Vector<uint> data) { throw null; }
public static System.Numerics.Vector<ulong> ConditionalExtractLastActiveElementAndReplicate(System.Numerics.Vector<ulong> mask, System.Numerics.Vector<ulong> fallback, System.Numerics.Vector<ulong> data) { throw null; }
public static System.Numerics.Vector<sbyte> ConditionalSelect(System.Numerics.Vector<sbyte> mask, System.Numerics.Vector<sbyte> left, System.Numerics.Vector<sbyte> right) { throw null; }
public static System.Numerics.Vector<short> ConditionalSelect(System.Numerics.Vector<short> mask, System.Numerics.Vector<short> left, System.Numerics.Vector<short> right) { throw null; }
public static System.Numerics.Vector<int> ConditionalSelect(System.Numerics.Vector<int> mask, System.Numerics.Vector<int> left, System.Numerics.Vector<int> right) { throw null; }

64
src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs
View file

@ -58,6 +58,8 @@ const string SimpleVecOpTest_ValidationLogicForNarrowing = @"for (var i = 0; i <
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 @@ const string SecureHashOpTest_ValidationLogic = @"{RetBaseType}[] expectedResult
("_SveImmTernOpTestTemplate.template", "SveVecImmTernOpTest.template", new Dictionary<string, string> { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic, ["TemplateValidationLogicForCndSel"] = SimpleTernVecOpTest_ValidationLogicForCndSel, ["TemplateValidationLogicForCndSel_FalseValue"] = SimpleTernVecOpTest_ValidationLogicForCndSel_FalseValue }),
("_SveTernOpMaskedOpTestTemplate.template", "SveVecTernOpMaskedTest.template", new Dictionary<string, string> { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic, ["TemplateValidationLogicForCndSel"] = SimpleTernVecOpTest_ValidationLogicForCndSel, ["TemplateValidationLogicForCndSel_FalseValue"] = SimpleTernVecOpTest_ValidationLogicForCndSel_FalseValue }),
("_SveImmTernOpFirstArgTestTemplate.template", "SveVecImmTernOpFirstArgTest.template", new Dictionary<string, string> { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic, ["TemplateValidationLogicForCndSel"] = SimpleTernVecOpTest_ValidationLogicForCndSel, ["TemplateValidationLogicForCndSel_FalseValue"] = SimpleTernVecOpTest_ValidationLogicForCndSel_FalseValue }),
("_SveScalarTernOpTestTemplate.template", "SveScalarTernOpTest.template", new Dictionary<string, string> { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleScalarOpTest_ValidationLogic }),
("_SveImm2UnaryOpTestTemplate.template", "SveVecImm2UnOpTest.template", new Dictionary<string, string> { ["TemplateName"] = "Imm", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic }),
("_SveMinimalUnaryOpTestTemplate.template", "SveVecReduceUnOpTest.template", new Dictionary<string, string> { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = VecReduceOpTest_ValidationLogic }),
("_SveMasklessUnaryOpTestTemplate.template", "SveMasklessSimpleVecOpTest.template", new Dictionary<string, string> { ["TemplateName"] = "Simple", ["TemplateValidationLogic"] = SimpleVecOpTest_ValidationLogic }),
@ -4176,6 +4179,67 @@ const string SecureHashOpTest_ValidationLogic = @"{RetBaseType}[] expectedResult
("SveVecReduceUnOpTest.template",new Dictionary<string, string> {["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<string, string> {["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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<string, string> { ["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]"}),

882
src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs
View file

@ -168,6 +168,30 @@ namespace JIT.HardwareIntrinsics.Arm
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 @@ namespace JIT.HardwareIntrinsics.Arm
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 @@ namespace JIT.HardwareIntrinsics.Arm
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 @@ namespace JIT.HardwareIntrinsics.Arm
return -1;
}
private static int LastActiveElement(float[] v)
{
for (int i = v.Length - 1; i >= 0; i--)
{
if (Unsafe.BitCast<float, int>(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<double, long>(v[i]) != 0)
{
return i;
}
}
return -1;
}
public static byte[] CreateMaskForNextActiveElement(byte[] mask, byte[] srcMask)
{
var count = srcMask.Length;
@ -7889,5 +7961,815 @@ namespace JIT.HardwareIntrinsics.Arm
}
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<byte>(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<sbyte>(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<short>(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<ushort>(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<int>(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<uint>(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<long>(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<ulong>(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<float>(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<double>(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);
}
}
}

338
src/tests/JIT/HardwareIntrinsics/Arm/Shared/_SveScalarTernOpTestTemplate.template Normal file
View file

@ -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<byte>(inArray1Ptr), ref Unsafe.As<{Op1BaseType}, byte>(ref inArray1[0]), (uint)sizeOfinArray1);
Unsafe.CopyBlockUnaligned(ref Unsafe.AsRef<byte>(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<byte>(op1), (uint)Unsafe.SizeOf<{Op1VectorType}<{Op1BaseType}>>());
inScalar2 = op2;
Unsafe.CopyBlockUnaligned(ref Unsafe.As<{Op3BaseType}, byte>(ref inArray3[0]), ref Unsafe.AsRef<byte>(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;
}
}
}
}