diff --git a/src/coreclr/jit/hwintrinsic.cpp b/src/coreclr/jit/hwintrinsic.cpp index dff22e36bc4565..aed5d2f236e6d3 100644 --- a/src/coreclr/jit/hwintrinsic.cpp +++ b/src/coreclr/jit/hwintrinsic.cpp @@ -2447,6 +2447,26 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, case NI_Sve_CreateWhileLessThanOrEqualMaskUInt16: case NI_Sve_CreateWhileLessThanOrEqualMaskUInt32: case NI_Sve_CreateWhileLessThanOrEqualMaskUInt64: + case NI_Sve2_CreateWhileGreaterThanMaskByte: + case NI_Sve2_CreateWhileGreaterThanMaskDouble: + case NI_Sve2_CreateWhileGreaterThanMaskInt16: + case NI_Sve2_CreateWhileGreaterThanMaskInt32: + case NI_Sve2_CreateWhileGreaterThanMaskInt64: + case NI_Sve2_CreateWhileGreaterThanMaskSByte: + case NI_Sve2_CreateWhileGreaterThanMaskSingle: + case NI_Sve2_CreateWhileGreaterThanMaskUInt16: + case NI_Sve2_CreateWhileGreaterThanMaskUInt32: + case NI_Sve2_CreateWhileGreaterThanMaskUInt64: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskByte: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskDouble: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskInt16: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskInt32: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskInt64: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskSByte: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskSingle: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskUInt16: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskUInt32: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskUInt64: retNode->AsHWIntrinsic()->SetAuxiliaryType(JitType2PreciseVarType(sigReader.op1JitType)); break; diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index bba6a1630c015e..b08224fe910e8c 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -267,6 +267,28 @@ void CodeGen::HWIntrinsicImmOpHelper::EmitCaseEnd() } //------------------------------------------------------------------------ +//------------------------------------------------------------------------ +// Emit helper for SVE+SVE2 WHILE* intrinsics - these set the width +// (emitSize) based on the scalar operand +// +static void genEmitCreateWhileMask(emitter* emit, + GenTreeHWIntrinsic* node, + instruction ins, + instruction unsignedIns, + regNumber targetReg, + regNumber op1Reg, + regNumber op2Reg, + insOpts opt) +{ + var_types auxType = node->GetAuxiliaryType(); + emitAttr emitSize = emitActualTypeSize(auxType); + if (varTypeIsUnsigned(auxType)) + { + ins = unsignedIns; + } + emit->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); +} + // genHWIntrinsic: Generates the code for a given hardware intrinsic node. // // Arguments: @@ -2138,18 +2160,8 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_CreateWhileLessThanMaskUInt16: case NI_Sve_CreateWhileLessThanMaskUInt32: case NI_Sve_CreateWhileLessThanMaskUInt64: - { - // Emit size and instruction is based on the scalar operands. - var_types auxType = node->GetAuxiliaryType(); - emitSize = emitActualTypeSize(auxType); - if (varTypeIsUnsigned(auxType)) - { - ins = INS_sve_whilelo; - } - - GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); + genEmitCreateWhileMask(GetEmitter(), node, ins, INS_sve_whilelo, targetReg, op1Reg, op2Reg, opt); break; - } case NI_Sve_CreateWhileLessThanOrEqualMaskByte: case NI_Sve_CreateWhileLessThanOrEqualMaskDouble: @@ -2161,18 +2173,49 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) case NI_Sve_CreateWhileLessThanOrEqualMaskUInt16: case NI_Sve_CreateWhileLessThanOrEqualMaskUInt32: case NI_Sve_CreateWhileLessThanOrEqualMaskUInt64: - { - // Emit size and instruction is based on the scalar operands. - var_types auxType = node->GetAuxiliaryType(); - emitSize = emitActualTypeSize(auxType); - if (varTypeIsUnsigned(auxType)) - { - ins = INS_sve_whilels; - } - - GetEmitter()->emitIns_R_R_R(ins, emitSize, targetReg, op1Reg, op2Reg, opt); + genEmitCreateWhileMask(GetEmitter(), node, ins, INS_sve_whilels, targetReg, op1Reg, op2Reg, opt); + break; + + case NI_Sve2_CreateWhileGreaterThanMaskByte: + case NI_Sve2_CreateWhileGreaterThanMaskDouble: + case NI_Sve2_CreateWhileGreaterThanMaskInt16: + case NI_Sve2_CreateWhileGreaterThanMaskInt32: + case NI_Sve2_CreateWhileGreaterThanMaskInt64: + case NI_Sve2_CreateWhileGreaterThanMaskSByte: + case NI_Sve2_CreateWhileGreaterThanMaskSingle: + case NI_Sve2_CreateWhileGreaterThanMaskUInt16: + case NI_Sve2_CreateWhileGreaterThanMaskUInt32: + case NI_Sve2_CreateWhileGreaterThanMaskUInt64: + genEmitCreateWhileMask(GetEmitter(), node, ins, INS_sve_whilehi, targetReg, op1Reg, op2Reg, opt); + break; + + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskByte: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskDouble: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskInt16: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskInt32: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskInt64: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskSByte: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskSingle: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskUInt16: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskUInt32: + case NI_Sve2_CreateWhileGreaterThanOrEqualMaskUInt64: + genEmitCreateWhileMask(GetEmitter(), node, ins, INS_sve_whilehs, targetReg, op1Reg, op2Reg, opt); + break; + + case NI_Sve2_CreateWhileReadAfterWriteMaskByte: + case NI_Sve2_CreateWhileReadAfterWriteMaskDouble: + case NI_Sve2_CreateWhileReadAfterWriteMaskInt16: + case NI_Sve2_CreateWhileReadAfterWriteMaskInt32: + case NI_Sve2_CreateWhileReadAfterWriteMaskInt64: + case NI_Sve2_CreateWhileReadAfterWriteMaskSByte: + case NI_Sve2_CreateWhileReadAfterWriteMaskSingle: + case NI_Sve2_CreateWhileReadAfterWriteMaskUInt16: + case NI_Sve2_CreateWhileReadAfterWriteMaskUInt32: + case NI_Sve2_CreateWhileReadAfterWriteMaskUInt64: + // WHILERW operands are always pointers (64-bit), so emitSize is always EA_8BYTE. + // No signed/unsigned instruction variant exists. + GetEmitter()->emitIns_R_R_R(ins, EA_8BYTE, targetReg, op1Reg, op2Reg, opt); break; - } case NI_Sve_GatherPrefetch8Bit: case NI_Sve_GatherPrefetch16Bit: diff --git a/src/coreclr/jit/hwintrinsiclistarm64sve.h b/src/coreclr/jit/hwintrinsiclistarm64sve.h index 84e490e6490188..a636c5901c804e 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64sve.h +++ b/src/coreclr/jit/hwintrinsiclistarm64sve.h @@ -358,6 +358,36 @@ HARDWARE_INTRINSIC(Sve2, ConvertToSingleOdd, HARDWARE_INTRINSIC(Sve2, ConvertToSingleOddRoundToOdd, -1, -1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_fcvtxnt, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_EmbeddedMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve2, CountMatchingElements, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_histcnt, INS_sve_histcnt, INS_sve_histcnt, INS_sve_histcnt, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_ExplicitMaskedOperation|HW_Flag_LowMaskedOperation|HW_Flag_ZeroingMaskedOperation) HARDWARE_INTRINSIC(Sve2, CountMatchingElementsIn128BitSegments, -1, 2, {INS_sve_histseg, INS_sve_histseg, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskByte, -1, 2, {INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskDouble, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskSByte, -1, 2, {INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskSingle, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanMaskUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilegt, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskByte, -1, 2, {INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskDouble, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskSByte, -1, 2, {INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskSingle, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileGreaterThanOrEqualMaskUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilege, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskByte, -1, 2, {INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskDouble, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskSByte, -1, 2, {INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskSingle, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve2, CreateWhileReadAfterWriteMaskUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilerw, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve2, DotProductRotateComplex, -1, 4, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_cdot, INS_invalid, INS_sve_cdot, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasRMWSemantics|HW_Flag_SpecialCodeGen|HW_Flag_HasImmediateOperand) HARDWARE_INTRINSIC(Sve2, DotProductRotateComplexBySelectedIndex, -1, 5, {INS_sve_cdot, INS_invalid, INS_sve_cdot, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasRMWSemantics|HW_Flag_SpecialCodeGen|HW_Flag_HasImmediateOperand|HW_Flag_LowVectorOperation|HW_Flag_SpecialImport|HW_Flag_BaseTypeFromSecondArg) HARDWARE_INTRINSIC(Sve2, FusedAddHalving, -1, -1, {INS_sve_shadd, INS_sve_uhadd, INS_sve_shadd, INS_sve_uhadd, INS_sve_shadd, INS_sve_uhadd, INS_sve_shadd, INS_sve_uhadd, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.PlatformNotSupported.cs index 1c127f42f7597a..492f4c19ca8547 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.PlatformNotSupported.cs @@ -1232,6 +1232,609 @@ internal Arm64() { } public static Vector CountMatchingElementsIn128BitSegments(Vector left, Vector right) { throw new PlatformNotSupportedException(); } + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilegt_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehi_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilege_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilehs_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While read-after-write ordering + + /// + /// svbool_t svwhilerw[_u8](const uint8_t *op1, const uint8_t *op2) + /// WHILERW Presult.B, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskByte(byte* left, byte* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_f64](const float64_t *op1, const float64_t *op2) + /// WHILERW Presult.D, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskDouble(double* left, double* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_s16](const int16_t *op1, const int16_t *op2) + /// WHILERW Presult.H, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskInt16(short* left, short* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_s32](const int32_t *op1, const int32_t *op2) + /// WHILERW Presult.S, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskInt32(int* left, int* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_s64](const int64_t *op1, const int64_t *op2) + /// WHILERW Presult.D, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskInt64(long* left, long* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_s8](const int8_t *op1, const int8_t *op2) + /// WHILERW Presult.B, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskSByte(sbyte* left, sbyte* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_f32](const float32_t *op1, const float32_t *op2) + /// WHILERW Presult.S, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskSingle(float* left, float* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_u16](const uint16_t *op1, const uint16_t *op2) + /// WHILERW Presult.H, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskUInt16(ushort* left, ushort* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_u32](const uint32_t *op1, const uint32_t *op2) + /// WHILERW Presult.S, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskUInt32(uint* left, uint* right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilerw[_u64](const uint64_t *op1, const uint64_t *op2) + /// WHILERW Presult.D, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskUInt64(ulong* left, ulong* right) { throw new PlatformNotSupportedException(); } + + // Complex dot product /// diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.cs index 18d5abcc2b5746..a1bb87b2f912db 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve2.cs @@ -1232,6 +1232,609 @@ internal Arm64() { } public static Vector CountMatchingElementsIn128BitSegments(Vector left, Vector right) => CountMatchingElementsIn128BitSegments(left, right); + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(int left, int right) => CreateWhileGreaterThanMaskByte(left, right); + + /// + /// svbool_t svwhilegt_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(long left, long right) => CreateWhileGreaterThanMaskByte(left, right); + + /// + /// svbool_t svwhilehi_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(uint left, uint right) => CreateWhileGreaterThanMaskByte(left, right); + + /// + /// svbool_t svwhilehi_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskByte(ulong left, ulong right) => CreateWhileGreaterThanMaskByte(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(int left, int right) => CreateWhileGreaterThanMaskDouble(left, right); + + /// + /// svbool_t svwhilegt_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(long left, long right) => CreateWhileGreaterThanMaskDouble(left, right); + + /// + /// svbool_t svwhilehi_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(uint left, uint right) => CreateWhileGreaterThanMaskDouble(left, right); + + /// + /// svbool_t svwhilehi_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskDouble(ulong left, ulong right) => CreateWhileGreaterThanMaskDouble(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(int left, int right) => CreateWhileGreaterThanMaskInt16(left, right); + + /// + /// svbool_t svwhilegt_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(long left, long right) => CreateWhileGreaterThanMaskInt16(left, right); + + /// + /// svbool_t svwhilehi_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(uint left, uint right) => CreateWhileGreaterThanMaskInt16(left, right); + + /// + /// svbool_t svwhilehi_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt16(ulong left, ulong right) => CreateWhileGreaterThanMaskInt16(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(int left, int right) => CreateWhileGreaterThanMaskInt32(left, right); + + /// + /// svbool_t svwhilegt_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(long left, long right) => CreateWhileGreaterThanMaskInt32(left, right); + + /// + /// svbool_t svwhilehi_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(uint left, uint right) => CreateWhileGreaterThanMaskInt32(left, right); + + /// + /// svbool_t svwhilehi_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt32(ulong left, ulong right) => CreateWhileGreaterThanMaskInt32(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(int left, int right) => CreateWhileGreaterThanMaskInt64(left, right); + + /// + /// svbool_t svwhilegt_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(long left, long right) => CreateWhileGreaterThanMaskInt64(left, right); + + /// + /// svbool_t svwhilehi_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(uint left, uint right) => CreateWhileGreaterThanMaskInt64(left, right); + + /// + /// svbool_t svwhilehi_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskInt64(ulong left, ulong right) => CreateWhileGreaterThanMaskInt64(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(int left, int right) => CreateWhileGreaterThanMaskSByte(left, right); + + /// + /// svbool_t svwhilegt_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(long left, long right) => CreateWhileGreaterThanMaskSByte(left, right); + + /// + /// svbool_t svwhilehi_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(uint left, uint right) => CreateWhileGreaterThanMaskSByte(left, right); + + /// + /// svbool_t svwhilehi_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSByte(ulong left, ulong right) => CreateWhileGreaterThanMaskSByte(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(int left, int right) => CreateWhileGreaterThanMaskSingle(left, right); + + /// + /// svbool_t svwhilegt_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(long left, long right) => CreateWhileGreaterThanMaskSingle(left, right); + + /// + /// svbool_t svwhilehi_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(uint left, uint right) => CreateWhileGreaterThanMaskSingle(left, right); + + /// + /// svbool_t svwhilehi_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskSingle(ulong left, ulong right) => CreateWhileGreaterThanMaskSingle(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(int left, int right) => CreateWhileGreaterThanMaskUInt16(left, right); + + /// + /// svbool_t svwhilegt_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(long left, long right) => CreateWhileGreaterThanMaskUInt16(left, right); + + /// + /// svbool_t svwhilehi_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(uint left, uint right) => CreateWhileGreaterThanMaskUInt16(left, right); + + /// + /// svbool_t svwhilehi_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt16(ulong left, ulong right) => CreateWhileGreaterThanMaskUInt16(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(int left, int right) => CreateWhileGreaterThanMaskUInt32(left, right); + + /// + /// svbool_t svwhilegt_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(long left, long right) => CreateWhileGreaterThanMaskUInt32(left, right); + + /// + /// svbool_t svwhilehi_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(uint left, uint right) => CreateWhileGreaterThanMaskUInt32(left, right); + + /// + /// svbool_t svwhilehi_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt32(ulong left, ulong right) => CreateWhileGreaterThanMaskUInt32(left, right); + + + // While decrementing scalar is greater than + + /// + /// svbool_t svwhilegt_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(int left, int right) => CreateWhileGreaterThanMaskUInt64(left, right); + + /// + /// svbool_t svwhilegt_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(long left, long right) => CreateWhileGreaterThanMaskUInt64(left, right); + + /// + /// svbool_t svwhilehi_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHI Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(uint left, uint right) => CreateWhileGreaterThanMaskUInt64(left, right); + + /// + /// svbool_t svwhilehi_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHI Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanMaskUInt64(ulong left, ulong right) => CreateWhileGreaterThanMaskUInt64(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(int left, int right) => CreateWhileGreaterThanOrEqualMaskByte(left, right); + + /// + /// svbool_t svwhilege_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(long left, long right) => CreateWhileGreaterThanOrEqualMaskByte(left, right); + + /// + /// svbool_t svwhilehs_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskByte(left, right); + + /// + /// svbool_t svwhilehs_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskByte(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskByte(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(int left, int right) => CreateWhileGreaterThanOrEqualMaskDouble(left, right); + + /// + /// svbool_t svwhilege_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(long left, long right) => CreateWhileGreaterThanOrEqualMaskDouble(left, right); + + /// + /// svbool_t svwhilehs_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskDouble(left, right); + + /// + /// svbool_t svwhilehs_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskDouble(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskDouble(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(int left, int right) => CreateWhileGreaterThanOrEqualMaskInt16(left, right); + + /// + /// svbool_t svwhilege_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(long left, long right) => CreateWhileGreaterThanOrEqualMaskInt16(left, right); + + /// + /// svbool_t svwhilehs_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskInt16(left, right); + + /// + /// svbool_t svwhilehs_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt16(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskInt16(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(int left, int right) => CreateWhileGreaterThanOrEqualMaskInt32(left, right); + + /// + /// svbool_t svwhilege_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(long left, long right) => CreateWhileGreaterThanOrEqualMaskInt32(left, right); + + /// + /// svbool_t svwhilehs_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskInt32(left, right); + + /// + /// svbool_t svwhilehs_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt32(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskInt32(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(int left, int right) => CreateWhileGreaterThanOrEqualMaskInt64(left, right); + + /// + /// svbool_t svwhilege_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(long left, long right) => CreateWhileGreaterThanOrEqualMaskInt64(left, right); + + /// + /// svbool_t svwhilehs_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskInt64(left, right); + + /// + /// svbool_t svwhilehs_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskInt64(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskInt64(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b8[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(int left, int right) => CreateWhileGreaterThanOrEqualMaskSByte(left, right); + + /// + /// svbool_t svwhilege_b8[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(long left, long right) => CreateWhileGreaterThanOrEqualMaskSByte(left, right); + + /// + /// svbool_t svwhilehs_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskSByte(left, right); + + /// + /// svbool_t svwhilehs_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSByte(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskSByte(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(int left, int right) => CreateWhileGreaterThanOrEqualMaskSingle(left, right); + + /// + /// svbool_t svwhilege_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(long left, long right) => CreateWhileGreaterThanOrEqualMaskSingle(left, right); + + /// + /// svbool_t svwhilehs_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskSingle(left, right); + + /// + /// svbool_t svwhilehs_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskSingle(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskSingle(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b16[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(int left, int right) => CreateWhileGreaterThanOrEqualMaskUInt16(left, right); + + /// + /// svbool_t svwhilege_b16[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(long left, long right) => CreateWhileGreaterThanOrEqualMaskUInt16(left, right); + + /// + /// svbool_t svwhilehs_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskUInt16(left, right); + + /// + /// svbool_t svwhilehs_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt16(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskUInt16(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b32[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(int left, int right) => CreateWhileGreaterThanOrEqualMaskUInt32(left, right); + + /// + /// svbool_t svwhilege_b32[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(long left, long right) => CreateWhileGreaterThanOrEqualMaskUInt32(left, right); + + /// + /// svbool_t svwhilehs_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskUInt32(left, right); + + /// + /// svbool_t svwhilehs_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt32(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskUInt32(left, right); + + + // While decrementing scalar is greater than or equal to + + /// + /// svbool_t svwhilege_b64[_s32](int32_t op1, int32_t op2) + /// WHILEGE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(int left, int right) => CreateWhileGreaterThanOrEqualMaskUInt64(left, right); + + /// + /// svbool_t svwhilege_b64[_s64](int64_t op1, int64_t op2) + /// WHILEGE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(long left, long right) => CreateWhileGreaterThanOrEqualMaskUInt64(left, right); + + /// + /// svbool_t svwhilehs_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILEHS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(uint left, uint right) => CreateWhileGreaterThanOrEqualMaskUInt64(left, right); + + /// + /// svbool_t svwhilehs_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILEHS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileGreaterThanOrEqualMaskUInt64(ulong left, ulong right) => CreateWhileGreaterThanOrEqualMaskUInt64(left, right); + + + // While free of read-after-write conflicts + + /// + /// svbool_t svwhilerw[_u8](const uint8_t *op1, const uint8_t *op2) + /// WHILERW Presult.B, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskByte(byte* left, byte* right) => CreateWhileReadAfterWriteMaskByte(left, right); + + /// + /// svbool_t svwhilerw[_f64](const float64_t *op1, const float64_t *op2) + /// WHILERW Presult.D, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskDouble(double* left, double* right) => CreateWhileReadAfterWriteMaskDouble(left, right); + + /// + /// svbool_t svwhilerw[_s16](const int16_t *op1, const int16_t *op2) + /// WHILERW Presult.H, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskInt16(short* left, short* right) => CreateWhileReadAfterWriteMaskInt16(left, right); + + /// + /// svbool_t svwhilerw[_s32](const int32_t *op1, const int32_t *op2) + /// WHILERW Presult.S, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskInt32(int* left, int* right) => CreateWhileReadAfterWriteMaskInt32(left, right); + + /// + /// svbool_t svwhilerw[_s64](const int64_t *op1, const int64_t *op2) + /// WHILERW Presult.D, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskInt64(long* left, long* right) => CreateWhileReadAfterWriteMaskInt64(left, right); + + /// + /// svbool_t svwhilerw[_s8](const int8_t *op1, const int8_t *op2) + /// WHILERW Presult.B, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskSByte(sbyte* left, sbyte* right) => CreateWhileReadAfterWriteMaskSByte(left, right); + + /// + /// svbool_t svwhilerw[_f32](const float32_t *op1, const float32_t *op2) + /// WHILERW Presult.S, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskSingle(float* left, float* right) => CreateWhileReadAfterWriteMaskSingle(left, right); + + /// + /// svbool_t svwhilerw[_u16](const uint16_t *op1, const uint16_t *op2) + /// WHILERW Presult.H, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskUInt16(ushort* left, ushort* right) => CreateWhileReadAfterWriteMaskUInt16(left, right); + + /// + /// svbool_t svwhilerw[_u32](const uint32_t *op1, const uint32_t *op2) + /// WHILERW Presult.S, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskUInt32(uint* left, uint* right) => CreateWhileReadAfterWriteMaskUInt32(left, right); + + /// + /// svbool_t svwhilerw[_u64](const uint64_t *op1, const uint64_t *op2) + /// WHILERW Presult.D, Xop1, Xop2 + /// + public static unsafe Vector CreateWhileReadAfterWriteMaskUInt64(ulong* left, ulong* right) => CreateWhileReadAfterWriteMaskUInt64(left, right); + + // Complex dot product /// diff --git a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs index de7788351ca6da..f7992fdedf357f 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -7473,6 +7473,96 @@ internal Arm64() { } public static System.Numerics.Vector CountMatchingElements(System.Numerics.Vector mask, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector CountMatchingElementsIn128BitSegments(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector CountMatchingElementsIn128BitSegments(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskDouble(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskDouble(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskDouble(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskDouble(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskInt64(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSingle(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSingle(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSingle(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskSingle(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanMaskUInt64(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskDouble(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskDouble(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskDouble(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskDouble(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskInt64(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSingle(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSingle(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSingle(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskSingle(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileGreaterThanOrEqualMaskUInt64(ulong left, ulong right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskByte(byte* left, byte* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskDouble(double* left, double* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskInt16(short* left, short* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskInt32(int* left, int* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskInt64(long* left, long* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskSByte(sbyte* left, sbyte* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskSingle(float* left, float* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskUInt16(ushort* left, ushort* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskUInt32(uint* left, uint* right) { throw null; } + public static unsafe System.Numerics.Vector CreateWhileReadAfterWriteMaskUInt64(ulong* left, ulong* right) { throw null; } public static System.Numerics.Vector DotProductRotateComplex(System.Numerics.Vector addend, System.Numerics.Vector left, System.Numerics.Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw null; } public static System.Numerics.Vector DotProductRotateComplex(System.Numerics.Vector addend, System.Numerics.Vector left, System.Numerics.Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw null; } public static System.Numerics.Vector DotProductRotateComplexBySelectedIndex(System.Numerics.Vector addend, System.Numerics.Vector left, System.Numerics.Vector right, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rightIndex, [ConstantExpected(Min = 0, Max = (byte)(3))] byte rotation) { throw null; } diff --git a/src/tests/Common/GenerateHWIntrinsicTests/Arm/Sve2Tests.cs b/src/tests/Common/GenerateHWIntrinsicTests/Arm/Sve2Tests.cs index a39293f8d7f325..209a50431f081c 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/Arm/Sve2Tests.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/Arm/Sve2Tests.cs @@ -236,7 +236,99 @@ static class Sve2Tests (Templates.SveVecBinOpDifferentRetType, new Dictionary { ["TestName"] = "Sve2_CountMatchingElementsIn128BitSegments_sbyte", ["Method"] = "CountMatchingElementsIn128BitSegments", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "SByte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.CountMatchingElementsIn128BitSegments(left, right, i) != result[i]", ["GetIterResult"] = "Helpers.CountMatchingElementsIn128BitSegments(left, right, i)"}), (Templates.SveVecBinOpDifferentRetType, new Dictionary { ["TestName"] = "Sve2_CountMatchingElementsIn128BitSegments_byte", ["Method"] = "CountMatchingElementsIn128BitSegments", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Byte", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetByte()", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.CountMatchingElementsIn128BitSegments(left, right, i) != result[i]", ["GetIterResult"] = "Helpers.CountMatchingElementsIn128BitSegments(left, right, i)"}), - (Templates.SveVecImmTernOpFirstArgTest, new Dictionary { ["TestName"] = "Sve2_DotProductRotateComplex_int_sbyte_0", ["Method"] = "DotProductRotateComplex", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["Op4BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "0", ["InvalidImm"] = "4", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm) != result[i]", ["GetIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm)"}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskByte_Int32", ["Method"] = "CreateWhileGreaterThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskByte_Int64", ["Method"] = "CreateWhileGreaterThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskByte_UInt32", ["Method"] = "CreateWhileGreaterThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskByte_UInt64", ["Method"] = "CreateWhileGreaterThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskDouble_Int32", ["Method"] = "CreateWhileGreaterThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskDouble_Int64", ["Method"] = "CreateWhileGreaterThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskDouble_UInt32",["Method"] = "CreateWhileGreaterThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskDouble_UInt64",["Method"] = "CreateWhileGreaterThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.UInt64BitsToDouble(Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt16_Int32", ["Method"] = "CreateWhileGreaterThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt16_Int64", ["Method"] = "CreateWhileGreaterThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt16_UInt32", ["Method"] = "CreateWhileGreaterThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt16_UInt64", ["Method"] = "CreateWhileGreaterThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt32_Int32", ["Method"] = "CreateWhileGreaterThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt32_Int64", ["Method"] = "CreateWhileGreaterThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt32_UInt32", ["Method"] = "CreateWhileGreaterThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt32_UInt64", ["Method"] = "CreateWhileGreaterThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt64_Int32", ["Method"] = "CreateWhileGreaterThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt64_Int64", ["Method"] = "CreateWhileGreaterThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt64_UInt32", ["Method"] = "CreateWhileGreaterThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskInt64_UInt64", ["Method"] = "CreateWhileGreaterThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSByte_Int32", ["Method"] = "CreateWhileGreaterThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSByte_Int64", ["Method"] = "CreateWhileGreaterThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSByte_UInt32", ["Method"] = "CreateWhileGreaterThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSByte_UInt64", ["Method"] = "CreateWhileGreaterThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSingle_Int32", ["Method"] = "CreateWhileGreaterThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle(Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSingle_Int64", ["Method"] = "CreateWhileGreaterThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSingle_UInt32", ["Method"] = "CreateWhileGreaterThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.UInt32BitsToSingle(Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskSingle_UInt64", ["Method"] = "CreateWhileGreaterThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt16_Int32", ["Method"] = "CreateWhileGreaterThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt16_Int64", ["Method"] = "CreateWhileGreaterThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt16_UInt32", ["Method"] = "CreateWhileGreaterThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt16_UInt64", ["Method"] = "CreateWhileGreaterThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt32_Int32", ["Method"] = "CreateWhileGreaterThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt32_Int64", ["Method"] = "CreateWhileGreaterThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt32_UInt32", ["Method"] = "CreateWhileGreaterThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt32_UInt64", ["Method"] = "CreateWhileGreaterThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt64_Int32", ["Method"] = "CreateWhileGreaterThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt64_Int64", ["Method"] = "CreateWhileGreaterThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt64_UInt32", ["Method"] = "CreateWhileGreaterThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanMaskUInt64_UInt64", ["Method"] = "CreateWhileGreaterThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskByte_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskByte_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskByte_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskByte_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskDouble_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskDouble_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskDouble_UInt32",["Method"] = "CreateWhileGreaterThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskDouble_UInt64",["Method"] = "CreateWhileGreaterThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.UInt64BitsToDouble(Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt16_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt16_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt16_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt16_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt32_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt32_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt32_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt32_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt64_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt64_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt64_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskInt64_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSByte_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSByte_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSByte_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSByte_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSingle_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle(Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSingle_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSingle_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.UInt32BitsToSingle(Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskSingle_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt16_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt16_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt16_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt16_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt32_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt32_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt32_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt32_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt64_Int32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanOrEqualMask(left - (Int32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt64_Int64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanOrEqualMask(left - (Int64)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt64_UInt32", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanOrEqualMask(left - (UInt32)(RetElementCount - 1 - i), right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve2_CreateWhileGreaterThanOrEqualMaskUInt64_UInt64", ["Method"] = "CreateWhileGreaterThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileGreaterThanOrEqualMask(left - (UInt64)(RetElementCount - 1 - i), right) != result[i]",}), + + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskByte", ["Method"] = "CreateWhileReadAfterWriteMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Byte" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskSByte", ["Method"] = "CreateWhileReadAfterWriteMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "SByte" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskInt16", ["Method"] = "CreateWhileReadAfterWriteMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int16" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskInt32", ["Method"] = "CreateWhileReadAfterWriteMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int32" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskInt64", ["Method"] = "CreateWhileReadAfterWriteMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int64" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskUInt16", ["Method"] = "CreateWhileReadAfterWriteMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt16" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskUInt32", ["Method"] = "CreateWhileReadAfterWriteMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskUInt64", ["Method"] = "CreateWhileReadAfterWriteMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskSingle", ["Method"] = "CreateWhileReadAfterWriteMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Single" }), + (Templates.SveCreateWhileRWMaskTest, new Dictionary { ["TestName"] = "Sve2_CreateWhileReadAfterWriteMaskDouble", ["Method"] = "CreateWhileReadAfterWriteMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Double" }), + + (Templates.SveVecImmTernOpFirstArgTest,new Dictionary { ["TestName"] = "Sve2_DotProductRotateComplex_int_sbyte_0", ["Method"] = "DotProductRotateComplex", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["Op4BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "0", ["InvalidImm"] = "4", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm) != result[i]", ["GetIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm)"}), (Templates.SveVecImmTernOpFirstArgTest, new Dictionary { ["TestName"] = "Sve2_DotProductRotateComplex_int_sbyte_1", ["Method"] = "DotProductRotateComplex", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["Op4BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "1", ["InvalidImm"] = "4", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm) != result[i]", ["GetIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm)"}), (Templates.SveVecImmTernOpFirstArgTest, new Dictionary { ["TestName"] = "Sve2_DotProductRotateComplex_int_sbyte_2", ["Method"] = "DotProductRotateComplex", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["Op4BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "2", ["InvalidImm"] = "4", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm) != result[i]", ["GetIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm)"}), (Templates.SveVecImmTernOpFirstArgTest, new Dictionary { ["TestName"] = "Sve2_DotProductRotateComplex_int_sbyte_3", ["Method"] = "DotProductRotateComplex", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int32", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "SByte", ["Op3VectorType"] = "Vector", ["Op3BaseType"] = "SByte", ["Op4BaseType"] = "Byte", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["NextValueOp3"] = "TestLibrary.Generator.GetSByte()", ["Imm"] = "3", ["InvalidImm"] = "4", ["ConvertFunc"] = "", ["ValidateIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm) != result[i]", ["GetIterResult"] = "Helpers.DotProductRotateComplex(first[i], second, 4 * i, third, Imm)"}), diff --git a/src/tests/Common/GenerateHWIntrinsicTests/Arm/Templates.cs b/src/tests/Common/GenerateHWIntrinsicTests/Arm/Templates.cs index f88b2bb93c01d9..d4b700be3b2f63 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/Arm/Templates.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/Arm/Templates.cs @@ -412,4 +412,5 @@ static class Templates public static TemplateConfig VectorLookup_2Test = new TemplateConfig("VectorLookup_2Test.template"); public static TemplateConfig VectorLookup_3Test = new TemplateConfig("VectorLookup_3Test.template"); public static TemplateConfig VectorLookup_4Test = new TemplateConfig("VectorLookup_4Test.template"); + public static TemplateConfig SveCreateWhileRWMaskTest = new TemplateConfig("SveCreateWhileRWMaskTest.template"); } diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs index 52589b3c069dcd..39bda4df7cd7e8 100644 --- a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/Helpers.cs @@ -6299,6 +6299,46 @@ public static ulong WhileLessThanOrEqualMask(ulong op1, ulong op2) return (ulong)((op1 <= op2) ? 1 : 0); } + public static int WhileGreaterThanMask(int op1, int op2) + { + return (op1 > op2) ? 1 : 0; + } + + public static uint WhileGreaterThanMask(uint op1, uint op2) + { + return (uint)((op1 > op2) ? 1 : 0); + } + + public static long WhileGreaterThanMask(long op1, long op2) + { + return (op1 > op2) ? 1 : 0; + } + + public static ulong WhileGreaterThanMask(ulong op1, ulong op2) + { + return (ulong)((op1 > op2) ? 1 : 0); + } + + public static int WhileGreaterThanOrEqualMask(int op1, int op2) + { + return (op1 >= op2) ? 1 : 0; + } + + public static uint WhileGreaterThanOrEqualMask(uint op1, uint op2) + { + return (uint)((op1 >= op2) ? 1 : 0); + } + + public static long WhileGreaterThanOrEqualMask(long op1, long op2) + { + return (op1 >= op2) ? 1 : 0; + } + + public static ulong WhileGreaterThanOrEqualMask(ulong op1, ulong op2) + { + return (ulong)((op1 >= op2) ? 1 : 0); + } + public static ulong MaskBothSet(byte[] op1, byte[] op2) { ulong acc = 0; diff --git a/src/tests/JIT/HardwareIntrinsics/Arm/Shared/SveCreateWhileRWMaskTest.template b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/SveCreateWhileRWMaskTest.template new file mode 100644 index 00000000000000..f9a646c8b41463 --- /dev/null +++ b/src/tests/JIT/HardwareIntrinsics/Arm/Shared/SveCreateWhileRWMaskTest.template @@ -0,0 +1,151 @@ +// 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.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Runtime.Intrinsics; +using System.Runtime.Intrinsics.Arm; +using Xunit; + +namespace {Namespace} +{ + public static partial class Program + { + [Fact] + public static void {TestName}() + { + var test = new CreateWhileRWMaskTest__{TestName}(); + + if (test.IsSupported) + { + // Validates that same-address produces an all-true mask + test.RunSameAddressScenario(); + + // Validates calling via reflection works + test.RunReflectionScenario(); + + // Validates that an offset of one element produces a single-true mask + test.RunOffsetByOneScenario(); + } + 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 CreateWhileRWMaskTest__{TestName} + { + public bool IsSupported => {Isa}.IsSupported; + + public bool Succeeded { get; set; } = true; + + public void RunSameAddressScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunSameAddressScenario)); + + {Op1BaseType}* ptr = stackalloc {Op1BaseType}[{RetVectorType}<{RetBaseType}>.Count]; + {RetVectorType}<{RetBaseType}> mask = {Isa}.{Method}(ptr, ptr); + + for (int i = 0; i < {RetVectorType}<{RetBaseType}>.Count; i++) + { + if (mask.GetElement(i) == 0) + { + TestLibrary.TestFramework.LogInformation( + $"{nameof({Isa})}.{nameof({Isa}.{Method})}(ptr, ptr): Expected all elements true, but element {i} was false."); + Succeeded = false; + return; + } + } + } + + public void RunReflectionScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario)); + + {Op1BaseType}* ptr = stackalloc {Op1BaseType}[{RetVectorType}<{RetBaseType}>.Count]; + var result = typeof({Isa}).GetMethod(nameof({Isa}.{Method}), new Type[] { typeof({Op1BaseType}*), typeof({Op1BaseType}*) }) + .Invoke(null, new object[] { + Pointer.Box(ptr, typeof({Op1BaseType}*)), + Pointer.Box(ptr, typeof({Op1BaseType}*)) + }); + + {RetVectorType}<{RetBaseType}> mask = ({RetVectorType}<{RetBaseType}>)result; + + for (int i = 0; i < {RetVectorType}<{RetBaseType}>.Count; i++) + { + if (mask.GetElement(i) == 0) + { + TestLibrary.TestFramework.LogInformation( + $"{nameof({Isa})}.{nameof({Isa}.{Method})}(ptr, ptr) via reflection: Expected all elements true, but element {i} was false."); + Succeeded = false; + return; + } + } + } + + public void RunOffsetByOneScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunOffsetByOneScenario)); + + {Op1BaseType}* ptr = stackalloc {Op1BaseType}[{RetVectorType}<{RetBaseType}>.Count + 1]; + {RetVectorType}<{RetBaseType}> mask = {Isa}.{Method}(ptr, ptr + 1); + + if (mask.GetElement(0) == 0) + { + TestLibrary.TestFramework.LogInformation( + $"{nameof({Isa})}.{nameof({Isa}.{Method})}(ptr, ptr+1): Expected element 0 to be true, but was false."); + Succeeded = false; + return; + } + + for (int i = 1; i < {RetVectorType}<{RetBaseType}>.Count; i++) + { + if (mask.GetElement(i) != 0) + { + TestLibrary.TestFramework.LogInformation( + $"{nameof({Isa})}.{nameof({Isa}.{Method})}(ptr, ptr+1): Expected element {i} to be false, but was true."); + Succeeded = false; + return; + } + } + } + + public void RunUnsupportedScenario() + { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + + bool succeeded = false; + + try + { + RunSameAddressScenario(); + } + catch (PlatformNotSupportedException) + { + succeeded = true; + } + + if (!succeeded) + { + Succeeded = false; + } + } + } +}