From 4cef667079ffaa2b3e60bfbee2745f0442080696 Mon Sep 17 00:00:00 2001 From: Alan Hayward Date: Wed, 4 Feb 2026 12:09:05 +0000 Subject: [PATCH] Sve: Expand CreateWhile APIs Fixes #108233 Follows on from #123947 *Rename CreateWhile APIs to make it clear they are Unsigned *Add Signed variants *Add Double and Single variants --- src/coreclr/jit/hwintrinsic.cpp | 28 +- src/coreclr/jit/hwintrinsiccodegenarm64.cpp | 28 +- src/coreclr/jit/hwintrinsiclistarm64sve.h | 28 +- .../Arm/Sve.PlatformNotSupported.cs | 388 ++++++++++++++++-- .../src/System/Runtime/Intrinsics/Arm/Sve.cs | 388 ++++++++++++++++-- .../ref/System.Runtime.Intrinsics.cs | 112 +++-- ...iCompatBaseline.NetCoreAppLatestStable.xml | 192 +++++++++ .../GenerateHWIntrinsicTests/Arm/SveTests.cs | 112 +++-- .../JitBlue/Runtime_118377/Runtime_118377.cs | 2 +- src/tests/JIT/opt/SVE/ChangeMaskUse.cs | 2 +- src/tests/JIT/opt/SVE/MaskUse.cs | 2 +- 11 files changed, 1127 insertions(+), 155 deletions(-) diff --git a/src/coreclr/jit/hwintrinsic.cpp b/src/coreclr/jit/hwintrinsic.cpp index 6305c49818756f..d434ffaa9f9013 100644 --- a/src/coreclr/jit/hwintrinsic.cpp +++ b/src/coreclr/jit/hwintrinsic.cpp @@ -2402,14 +2402,26 @@ GenTree* Compiler::impHWIntrinsic(NamedIntrinsic intrinsic, } break; - case NI_Sve_CreateWhileLessThanMask8Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask8Bit: - case NI_Sve_CreateWhileLessThanMask16Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask16Bit: - case NI_Sve_CreateWhileLessThanMask32Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask32Bit: - case NI_Sve_CreateWhileLessThanMask64Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask64Bit: + case NI_Sve_CreateWhileLessThanMaskByte: + case NI_Sve_CreateWhileLessThanMaskDouble: + case NI_Sve_CreateWhileLessThanMaskInt16: + case NI_Sve_CreateWhileLessThanMaskInt32: + case NI_Sve_CreateWhileLessThanMaskInt64: + case NI_Sve_CreateWhileLessThanMaskSByte: + case NI_Sve_CreateWhileLessThanMaskSingle: + case NI_Sve_CreateWhileLessThanMaskUInt16: + case NI_Sve_CreateWhileLessThanMaskUInt32: + case NI_Sve_CreateWhileLessThanMaskUInt64: + case NI_Sve_CreateWhileLessThanOrEqualMaskByte: + case NI_Sve_CreateWhileLessThanOrEqualMaskDouble: + case NI_Sve_CreateWhileLessThanOrEqualMaskInt16: + case NI_Sve_CreateWhileLessThanOrEqualMaskInt32: + case NI_Sve_CreateWhileLessThanOrEqualMaskInt64: + case NI_Sve_CreateWhileLessThanOrEqualMaskSByte: + case NI_Sve_CreateWhileLessThanOrEqualMaskSingle: + case NI_Sve_CreateWhileLessThanOrEqualMaskUInt16: + case NI_Sve_CreateWhileLessThanOrEqualMaskUInt32: + case NI_Sve_CreateWhileLessThanOrEqualMaskUInt64: retNode->AsHWIntrinsic()->SetAuxiliaryJitType(sigReader.op1JitType); break; diff --git a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp index 6c39b15d6d531e..25609028a66fb1 100644 --- a/src/coreclr/jit/hwintrinsiccodegenarm64.cpp +++ b/src/coreclr/jit/hwintrinsiccodegenarm64.cpp @@ -2085,10 +2085,16 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) GetEmitter()->emitIns_R_PATTERN(ins, emitSize, targetReg, opt, SVE_PATTERN_ALL); break; - case NI_Sve_CreateWhileLessThanMask8Bit: - case NI_Sve_CreateWhileLessThanMask16Bit: - case NI_Sve_CreateWhileLessThanMask32Bit: - case NI_Sve_CreateWhileLessThanMask64Bit: + case NI_Sve_CreateWhileLessThanMaskByte: + case NI_Sve_CreateWhileLessThanMaskDouble: + case NI_Sve_CreateWhileLessThanMaskInt16: + case NI_Sve_CreateWhileLessThanMaskInt32: + case NI_Sve_CreateWhileLessThanMaskInt64: + case NI_Sve_CreateWhileLessThanMaskSByte: + case NI_Sve_CreateWhileLessThanMaskSingle: + 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(); @@ -2102,10 +2108,16 @@ void CodeGen::genHWIntrinsic(GenTreeHWIntrinsic* node) break; } - case NI_Sve_CreateWhileLessThanOrEqualMask8Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask16Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask32Bit: - case NI_Sve_CreateWhileLessThanOrEqualMask64Bit: + case NI_Sve_CreateWhileLessThanOrEqualMaskByte: + case NI_Sve_CreateWhileLessThanOrEqualMaskDouble: + case NI_Sve_CreateWhileLessThanOrEqualMaskInt16: + case NI_Sve_CreateWhileLessThanOrEqualMaskInt32: + case NI_Sve_CreateWhileLessThanOrEqualMaskInt64: + case NI_Sve_CreateWhileLessThanOrEqualMaskSByte: + case NI_Sve_CreateWhileLessThanOrEqualMaskSingle: + 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(); diff --git a/src/coreclr/jit/hwintrinsiclistarm64sve.h b/src/coreclr/jit/hwintrinsiclistarm64sve.h index cc2c5d1b875274..fc813722c2ea80 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64sve.h +++ b/src/coreclr/jit/hwintrinsiclistarm64sve.h @@ -85,14 +85,26 @@ HARDWARE_INTRINSIC(Sve, CreateTrueMaskSingle, HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt16, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialImport) HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt32, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialImport) HARDWARE_INTRINSIC(Sve, CreateTrueMaskUInt64, -1, 1, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_ptrue, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasImmediateOperand|HW_Flag_SpecialImport) -HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMask16Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, 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(Sve, CreateWhileLessThanMask32Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMask64Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMask8Bit, -1, 2, {INS_invalid, INS_sve_whilelt, 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(Sve, CreateWhileLessThanOrEqualMask16Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, 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(Sve, CreateWhileLessThanOrEqualMask32Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMask64Bit, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) -HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMask8Bit, -1, 2, {INS_invalid, INS_sve_whilele, 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(Sve, CreateWhileLessThanMaskByte, -1, 2, {INS_invalid, INS_sve_whilelt, 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(Sve, CreateWhileLessThanMaskDouble, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMaskInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_whilelt, 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(Sve, CreateWhileLessThanMaskInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMaskInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMaskSByte, -1, 2, {INS_sve_whilelt, 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(Sve, CreateWhileLessThanMaskSingle, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMaskUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, 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(Sve, CreateWhileLessThanMaskUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanMaskUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilelt, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMaskByte, -1, 2, {INS_invalid, INS_sve_whilele, 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(Sve, CreateWhileLessThanOrEqualMaskDouble, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMaskInt16, -1, 2, {INS_invalid, INS_invalid, INS_sve_whilele, 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(Sve, CreateWhileLessThanOrEqualMaskInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMaskInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMaskSByte, -1, 2, {INS_sve_whilele, 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(Sve, CreateWhileLessThanOrEqualMaskSingle, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMaskUInt16, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, 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(Sve, CreateWhileLessThanOrEqualMaskUInt32, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid, INS_invalid, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) +HARDWARE_INTRINSIC(Sve, CreateWhileLessThanOrEqualMaskUInt64, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_whilele, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_SpecialCodeGen|HW_Flag_ReturnsPerElementMask) HARDWARE_INTRINSIC(Sve, Divide, -1, 2, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sdiv, INS_sve_udiv, INS_sve_sdiv, INS_sve_udiv, INS_sve_fdiv, INS_sve_fdiv}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_EmbeddedMaskedOperation|HW_Flag_HasRMWSemantics|HW_Flag_LowMaskedOperation) HARDWARE_INTRINSIC(Sve, DotProduct, -1, 3, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sdot, INS_sve_udot, INS_sve_sdot, INS_sve_udot, INS_invalid, INS_invalid}, HW_Category_SIMD, HW_Flag_Scalable|HW_Flag_HasRMWSemantics) HARDWARE_INTRINSIC(Sve, DotProductBySelectedScalar, -1, 4, {INS_invalid, INS_invalid, INS_invalid, INS_invalid, INS_sve_sdot, INS_sve_udot, INS_sve_sdot, INS_sve_udot, INS_invalid, INS_invalid}, HW_Category_SIMDByIndexedElement, HW_Flag_Scalable|HW_Flag_BaseTypeFromFirstArg|HW_Flag_HasImmediateOperand|HW_Flag_HasRMWSemantics|HW_Flag_LowVectorOperation) diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs index 819b72cec57008..8d5c20c53a35d0 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.PlatformNotSupported.cs @@ -2669,31 +2669,85 @@ internal Arm64() { } public static Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw new PlatformNotSupportedException(); } + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskByte(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskByte(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskByte(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskDouble(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskDouble(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskDouble(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskDouble(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + // While incrementing scalar is less than /// /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask16Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt16(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask16Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt16(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask16Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than @@ -2702,25 +2756,25 @@ internal Arm64() { } /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask32Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt32(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask32Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt32(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask32Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than @@ -2729,25 +2783,25 @@ internal Arm64() { } /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask64Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt64(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask64Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt64(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask64Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than @@ -2756,25 +2810,187 @@ internal Arm64() { } /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask8Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskSByte(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask8Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskSByte(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask8Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskSByte(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanMaskSByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskSingle(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskSingle(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskSingle(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskSingle(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to @@ -2783,25 +2999,25 @@ internal Arm64() { } /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt16(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt16(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to @@ -2810,25 +3026,25 @@ internal Arm64() { } /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt32(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt32(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to @@ -2837,25 +3053,25 @@ internal Arm64() { } /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt64(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt64(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // While incrementing scalar is less than or equal to @@ -2864,25 +3080,133 @@ internal Arm64() { } /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskSByte(int left, int right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskSByte(long left, long right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskSByte(uint left, uint right) { throw new PlatformNotSupportedException(); } /// /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + public static Vector CreateWhileLessThanOrEqualMaskSByte(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(ulong left, ulong right) { throw new PlatformNotSupportedException(); } + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(int left, int right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(long left, long right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(uint left, uint right) { throw new PlatformNotSupportedException(); } + + /// + /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(ulong left, ulong right) { throw new PlatformNotSupportedException(); } // Divide diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs index 69d4375549fd7d..ebdecd60e4d764 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/Sve.cs @@ -2666,31 +2666,85 @@ internal Arm64() { } public static Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) => CreateTrueMaskUInt64(pattern); + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskByte(int left, int right) => CreateWhileLessThanMaskByte(left, right); + + /// + /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskByte(long left, long right) => CreateWhileLessThanMaskByte(left, right); + + /// + /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskByte(uint left, uint right) => CreateWhileLessThanMaskByte(left, right); + + /// + /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskByte(ulong left, ulong right) => CreateWhileLessThanMaskByte(left, right); + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskDouble(int left, int right) => CreateWhileLessThanMaskDouble(left, right); + + /// + /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskDouble(long left, long right) => CreateWhileLessThanMaskDouble(left, right); + + /// + /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskDouble(uint left, uint right) => CreateWhileLessThanMaskDouble(left, right); + + /// + /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskDouble(ulong left, ulong right) => CreateWhileLessThanMaskDouble(left, right); + + // While incrementing scalar is less than /// /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask16Bit(int left, int right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMaskInt16(int left, int right) => CreateWhileLessThanMaskInt16(left, right); /// /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask16Bit(long left, long right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMaskInt16(long left, long right) => CreateWhileLessThanMaskInt16(left, right); /// /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask16Bit(uint left, uint right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMaskInt16(uint left, uint right) => CreateWhileLessThanMaskInt16(left, right); /// /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) => CreateWhileLessThanMask16Bit(left, right); + public static Vector CreateWhileLessThanMaskInt16(ulong left, ulong right) => CreateWhileLessThanMaskInt16(left, right); // While incrementing scalar is less than @@ -2699,25 +2753,25 @@ internal Arm64() { } /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask32Bit(int left, int right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMaskInt32(int left, int right) => CreateWhileLessThanMaskInt32(left, right); /// /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask32Bit(long left, long right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMaskInt32(long left, long right) => CreateWhileLessThanMaskInt32(left, right); /// /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask32Bit(uint left, uint right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMaskInt32(uint left, uint right) => CreateWhileLessThanMaskInt32(left, right); /// /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) => CreateWhileLessThanMask32Bit(left, right); + public static Vector CreateWhileLessThanMaskInt32(ulong left, ulong right) => CreateWhileLessThanMaskInt32(left, right); // While incrementing scalar is less than @@ -2726,25 +2780,25 @@ internal Arm64() { } /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask64Bit(int left, int right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMaskInt64(int left, int right) => CreateWhileLessThanMaskInt64(left, right); /// /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask64Bit(long left, long right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMaskInt64(long left, long right) => CreateWhileLessThanMaskInt64(left, right); /// /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask64Bit(uint left, uint right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMaskInt64(uint left, uint right) => CreateWhileLessThanMaskInt64(left, right); /// /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) => CreateWhileLessThanMask64Bit(left, right); + public static Vector CreateWhileLessThanMaskInt64(ulong left, ulong right) => CreateWhileLessThanMaskInt64(left, right); // While incrementing scalar is less than @@ -2753,25 +2807,187 @@ internal Arm64() { } /// svbool_t svwhilelt_b8[_s32](int32_t op1, int32_t op2) /// WHILELT Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask8Bit(int left, int right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMaskSByte(int left, int right) => CreateWhileLessThanMaskSByte(left, right); /// /// svbool_t svwhilelt_b8[_s64](int64_t op1, int64_t op2) /// WHILELT Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask8Bit(long left, long right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMaskSByte(long left, long right) => CreateWhileLessThanMaskSByte(left, right); /// /// svbool_t svwhilelt_b8[_u32](uint32_t op1, uint32_t op2) /// WHILELO Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanMask8Bit(uint left, uint right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMaskSByte(uint left, uint right) => CreateWhileLessThanMaskSByte(left, right); /// /// svbool_t svwhilelt_b8[_u64](uint64_t op1, uint64_t op2) /// WHILELO Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) => CreateWhileLessThanMask8Bit(left, right); + public static Vector CreateWhileLessThanMaskSByte(ulong left, ulong right) => CreateWhileLessThanMaskSByte(left, right); + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskSingle(int left, int right) => CreateWhileLessThanMaskSingle(left, right); + + /// + /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskSingle(long left, long right) => CreateWhileLessThanMaskSingle(left, right); + + /// + /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskSingle(uint left, uint right) => CreateWhileLessThanMaskSingle(left, right); + + /// + /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskSingle(ulong left, ulong right) => CreateWhileLessThanMaskSingle(left, right); + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b16[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(int left, int right) => CreateWhileLessThanMaskUInt16(left, right); + + /// + /// svbool_t svwhilelt_b16[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(long left, long right) => CreateWhileLessThanMaskUInt16(left, right); + + /// + /// svbool_t svwhilelt_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(uint left, uint right) => CreateWhileLessThanMaskUInt16(left, right); + + /// + /// svbool_t svwhilelt_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt16(ulong left, ulong right) => CreateWhileLessThanMaskUInt16(left, right); + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b32[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(int left, int right) => CreateWhileLessThanMaskUInt32(left, right); + + /// + /// svbool_t svwhilelt_b32[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(long left, long right) => CreateWhileLessThanMaskUInt32(left, right); + + /// + /// svbool_t svwhilelt_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(uint left, uint right) => CreateWhileLessThanMaskUInt32(left, right); + + /// + /// svbool_t svwhilelt_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt32(ulong left, ulong right) => CreateWhileLessThanMaskUInt32(left, right); + + + // While incrementing scalar is less than + + /// + /// svbool_t svwhilelt_b64[_s32](int32_t op1, int32_t op2) + /// WHILELT Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(int left, int right) => CreateWhileLessThanMaskUInt64(left, right); + + /// + /// svbool_t svwhilelt_b64[_s64](int64_t op1, int64_t op2) + /// WHILELT Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(long left, long right) => CreateWhileLessThanMaskUInt64(left, right); + + /// + /// svbool_t svwhilelt_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELO Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(uint left, uint right) => CreateWhileLessThanMaskUInt64(left, right); + + /// + /// svbool_t svwhilelt_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELO Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanMaskUInt64(ulong left, ulong right) => CreateWhileLessThanMaskUInt64(left, right); + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(int left, int right) => CreateWhileLessThanOrEqualMaskByte(left, right); + + /// + /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(long left, long right) => CreateWhileLessThanOrEqualMaskByte(left, right); + + /// + /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.B, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(uint left, uint right) => CreateWhileLessThanOrEqualMaskByte(left, right); + + /// + /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.B, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskByte(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskByte(left, right); + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(int left, int right) => CreateWhileLessThanOrEqualMaskDouble(left, right); + + /// + /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(long left, long right) => CreateWhileLessThanOrEqualMaskDouble(left, right); + + /// + /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(uint left, uint right) => CreateWhileLessThanOrEqualMaskDouble(left, right); + + /// + /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskDouble(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskDouble(left, right); // While incrementing scalar is less than or equal to @@ -2780,25 +2996,25 @@ internal Arm64() { } /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt16(int left, int right) => CreateWhileLessThanOrEqualMaskInt16(left, right); /// /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt16(long left, long right) => CreateWhileLessThanOrEqualMaskInt16(left, right); /// /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.H, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt16(uint left, uint right) => CreateWhileLessThanOrEqualMaskInt16(left, right); /// /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.H, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask16Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt16(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskInt16(left, right); // While incrementing scalar is less than or equal to @@ -2807,25 +3023,25 @@ internal Arm64() { } /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt32(int left, int right) => CreateWhileLessThanOrEqualMaskInt32(left, right); /// /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt32(long left, long right) => CreateWhileLessThanOrEqualMaskInt32(left, right); /// /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.S, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt32(uint left, uint right) => CreateWhileLessThanOrEqualMaskInt32(left, right); /// /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.S, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask32Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt32(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskInt32(left, right); // While incrementing scalar is less than or equal to @@ -2834,25 +3050,25 @@ internal Arm64() { } /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt64(int left, int right) => CreateWhileLessThanOrEqualMaskInt64(left, right); /// /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt64(long left, long right) => CreateWhileLessThanOrEqualMaskInt64(left, right); /// /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.D, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt64(uint left, uint right) => CreateWhileLessThanOrEqualMaskInt64(left, right); /// /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.D, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask64Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskInt64(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskInt64(left, right); // While incrementing scalar is less than or equal to @@ -2861,25 +3077,133 @@ internal Arm64() { } /// svbool_t svwhilele_b8[_s32](int32_t op1, int32_t op2) /// WHILELE Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskSByte(int left, int right) => CreateWhileLessThanOrEqualMaskSByte(left, right); /// /// svbool_t svwhilele_b8[_s64](int64_t op1, int64_t op2) /// WHILELE Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskSByte(long left, long right) => CreateWhileLessThanOrEqualMaskSByte(left, right); /// /// svbool_t svwhilele_b8[_u32](uint32_t op1, uint32_t op2) /// WHILELS Presult.B, Wop1, Wop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskSByte(uint left, uint right) => CreateWhileLessThanOrEqualMaskSByte(left, right); /// /// svbool_t svwhilele_b8[_u64](uint64_t op1, uint64_t op2) /// WHILELS Presult.B, Xop1, Xop2 /// - public static Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) => CreateWhileLessThanOrEqualMask8Bit(left, right); + public static Vector CreateWhileLessThanOrEqualMaskSByte(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskSByte(left, right); + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(int left, int right) => CreateWhileLessThanOrEqualMaskSingle(left, right); + + /// + /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(long left, long right) => CreateWhileLessThanOrEqualMaskSingle(left, right); + + /// + /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(uint left, uint right) => CreateWhileLessThanOrEqualMaskSingle(left, right); + + /// + /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskSingle(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskSingle(left, right); + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b16[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(int left, int right) => CreateWhileLessThanOrEqualMaskUInt16(left, right); + + /// + /// svbool_t svwhilele_b16[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(long left, long right) => CreateWhileLessThanOrEqualMaskUInt16(left, right); + + /// + /// svbool_t svwhilele_b16[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.H, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(uint left, uint right) => CreateWhileLessThanOrEqualMaskUInt16(left, right); + + /// + /// svbool_t svwhilele_b16[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.H, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt16(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskUInt16(left, right); + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b32[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(int left, int right) => CreateWhileLessThanOrEqualMaskUInt32(left, right); + + /// + /// svbool_t svwhilele_b32[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(long left, long right) => CreateWhileLessThanOrEqualMaskUInt32(left, right); + + /// + /// svbool_t svwhilele_b32[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.S, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(uint left, uint right) => CreateWhileLessThanOrEqualMaskUInt32(left, right); + + /// + /// svbool_t svwhilele_b32[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.S, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt32(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskUInt32(left, right); + + + // While incrementing scalar is less than or equal to + + /// + /// svbool_t svwhilele_b64[_s32](int32_t op1, int32_t op2) + /// WHILELE Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(int left, int right) => CreateWhileLessThanOrEqualMaskUInt64(left, right); + + /// + /// svbool_t svwhilele_b64[_s64](int64_t op1, int64_t op2) + /// WHILELE Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(long left, long right) => CreateWhileLessThanOrEqualMaskUInt64(left, right); + + /// + /// svbool_t svwhilele_b64[_u32](uint32_t op1, uint32_t op2) + /// WHILELS Presult.D, Wop1, Wop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(uint left, uint right) => CreateWhileLessThanOrEqualMaskUInt64(left, right); + + /// + /// svbool_t svwhilele_b64[_u64](uint64_t op1, uint64_t op2) + /// WHILELS Presult.D, Xop1, Xop2 + /// + public static Vector CreateWhileLessThanOrEqualMaskUInt64(ulong left, ulong right) => CreateWhileLessThanOrEqualMaskUInt64(left, right); // Divide 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 4fdb9d778083c8..8d0a96e2e449f5 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -4960,38 +4960,86 @@ internal Arm64() { } public static System.Numerics.Vector CreateTrueMaskUInt16([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw null; } public static System.Numerics.Vector CreateTrueMaskUInt32([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw null; } public static System.Numerics.Vector CreateTrueMaskUInt64([ConstantExpected] SveMaskPattern pattern = SveMaskPattern.All) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask16Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask16Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask16Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask16Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask32Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask32Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask32Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask32Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask64Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask64Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask64Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask64Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask8Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask8Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask8Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanMask8Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask16Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask16Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask16Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask16Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask32Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask32Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask32Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask32Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask64Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask64Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask64Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask64Bit(ulong left, ulong right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask8Bit(int left, int right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask8Bit(long left, long right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask8Bit(uint left, uint right) { throw null; } - public static System.Numerics.Vector CreateWhileLessThanOrEqualMask8Bit(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskDouble(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskDouble(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskDouble(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskDouble(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskInt64(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSingle(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSingle(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSingle(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskSingle(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanMaskUInt64(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskDouble(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskDouble(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskDouble(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskDouble(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskInt64(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSByte(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSByte(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSByte(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSByte(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSingle(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSingle(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSingle(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskSingle(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt16(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt16(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt16(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt16(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt32(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt32(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt32(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt32(ulong left, ulong right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt64(int left, int right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt64(long left, long right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt64(uint left, uint right) { throw null; } + public static System.Numerics.Vector CreateWhileLessThanOrEqualMaskUInt64(ulong left, ulong right) { throw null; } public static System.Numerics.Vector Divide(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector Divide(System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } public static System.Numerics.Vector DotProduct(System.Numerics.Vector addend, System.Numerics.Vector left, System.Numerics.Vector right) { throw null; } diff --git a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml index c34164bf783cd0..96721ba0f31d7c 100644 --- a/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml +++ b/src/libraries/apicompat/ApiCompatBaseline.NetCoreAppLatestStable.xml @@ -1,6 +1,198 @@  + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask16Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask16Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask16Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask16Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask32Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask32Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask32Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask32Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask64Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask64Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask64Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask64Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask8Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask8Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask8Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanMask8Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask16Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask16Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask16Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask16Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask32Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask32Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask32Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask32Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask64Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask64Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask64Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask64Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask8Bit(System.Int32,System.Int32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask8Bit(System.Int64,System.Int64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask8Bit(System.UInt32,System.UInt32) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + + + CP0002 + M:System.Runtime.Intrinsics.Arm.Sve.CreateWhileLessThanOrEqualMask8Bit(System.UInt64,System.UInt64) + net10.0/System.Runtime.Intrinsics.dll + net11.0/System.Runtime.Intrinsics.dll + CP0014 T:System.Runtime.CompilerServices.AsyncHelpers:[T:System.Diagnostics.CodeAnalysis.ExperimentalAttribute] diff --git a/src/tests/Common/GenerateHWIntrinsicTests/Arm/SveTests.cs b/src/tests/Common/GenerateHWIntrinsicTests/Arm/SveTests.cs index a646a4603193e4..2ef970588ccb6f 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/Arm/SveTests.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/Arm/SveTests.cs @@ -293,38 +293,86 @@ static class SveTests (Templates.SveVecBinOpVecTest, new Dictionary { ["TestName"] = "Sve_CreateBreakPropagateMask_long", ["Method"] = "CreateBreakPropagateMask", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Int64", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "Helpers.getMaskInt64()", ["NextValueOp2"] = "Helpers.getMaskInt64()", ["ValidateVectorResult"] = "!result.SequenceEqual(Helpers.CreateBreakPropagateMask(left, right))", ["GetVectorResult"] = "Helpers.CreateBreakPropagateMask(left, right)"}), (Templates.SveVecBinOpVecTest, new Dictionary { ["TestName"] = "Sve_CreateBreakPropagateMask_float", ["Method"] = "CreateBreakPropagateMask", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "Helpers.getMaskSingle()", ["NextValueOp2"] = "Helpers.getMaskSingle()", ["ValidateVectorResult"] = "!result.SequenceEqual(Helpers.CreateBreakPropagateMask(left, right))", ["GetVectorResult"] = "Helpers.CreateBreakPropagateMask(left, right)"}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask16Bit_Int32", ["Method"] = "CreateWhileLessThanMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask16Bit_Int64", ["Method"] = "CreateWhileLessThanMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask16Bit_UInt32", ["Method"] = "CreateWhileLessThanMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask16Bit_UInt64", ["Method"] = "CreateWhileLessThanMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask32Bit_Int32", ["Method"] = "CreateWhileLessThanMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask32Bit_Int64", ["Method"] = "CreateWhileLessThanMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask32Bit_UInt32", ["Method"] = "CreateWhileLessThanMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask32Bit_UInt64", ["Method"] = "CreateWhileLessThanMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask64Bit_Int32", ["Method"] = "CreateWhileLessThanMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask64Bit_Int64", ["Method"] = "CreateWhileLessThanMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask64Bit_UInt32", ["Method"] = "CreateWhileLessThanMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask64Bit_UInt64", ["Method"] = "CreateWhileLessThanMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask8Bit_Int32", ["Method"] = "CreateWhileLessThanMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask8Bit_Int64", ["Method"] = "CreateWhileLessThanMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask8Bit_UInt32", ["Method"] = "CreateWhileLessThanMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMask8Bit_UInt64", ["Method"] = "CreateWhileLessThanMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask16Bit_Int32", ["Method"] = "CreateWhileLessThanOrEqualMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask16Bit_Int64", ["Method"] = "CreateWhileLessThanOrEqualMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask16Bit_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask16Bit_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMask16Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask32Bit_Int32", ["Method"] = "CreateWhileLessThanOrEqualMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask32Bit_Int64", ["Method"] = "CreateWhileLessThanOrEqualMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask32Bit_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask32Bit_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMask32Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask64Bit_Int32", ["Method"] = "CreateWhileLessThanOrEqualMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask64Bit_Int64", ["Method"] = "CreateWhileLessThanOrEqualMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask64Bit_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask64Bit_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMask64Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != (UInt64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask8Bit_Int32", ["Method"] = "CreateWhileLessThanOrEqualMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != (Int32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask8Bit_Int64", ["Method"] = "CreateWhileLessThanOrEqualMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != (Int64)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask8Bit_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != (UInt32)result[i]",}), - (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMask8Bit_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMask8Bit", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != (UInt64)result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskByte_Int32", ["Method"] = "CreateWhileLessThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskByte_Int64", ["Method"] = "CreateWhileLessThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskByte_UInt32", ["Method"] = "CreateWhileLessThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskByte_UInt64", ["Method"] = "CreateWhileLessThanMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskDouble_Int32", ["Method"] = "CreateWhileLessThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileLessThanMask(left + (Int32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskDouble_Int64", ["Method"] = "CreateWhileLessThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileLessThanMask(left + (Int64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskDouble_UInt32", ["Method"] = "CreateWhileLessThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileLessThanMask(left + (UInt32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskDouble_UInt64", ["Method"] = "CreateWhileLessThanMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.UInt64BitsToDouble(Helpers.WhileLessThanMask(left + (UInt64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt16_Int32", ["Method"] = "CreateWhileLessThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt16_Int64", ["Method"] = "CreateWhileLessThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt16_UInt32", ["Method"] = "CreateWhileLessThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt16_UInt64", ["Method"] = "CreateWhileLessThanMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt32_Int32", ["Method"] = "CreateWhileLessThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt32_Int64", ["Method"] = "CreateWhileLessThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt32_UInt32", ["Method"] = "CreateWhileLessThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt32_UInt64", ["Method"] = "CreateWhileLessThanMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt64_Int32", ["Method"] = "CreateWhileLessThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt64_Int64", ["Method"] = "CreateWhileLessThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt64_UInt32", ["Method"] = "CreateWhileLessThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskInt64_UInt64", ["Method"] = "CreateWhileLessThanMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSByte_Int32", ["Method"] = "CreateWhileLessThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSByte_Int64", ["Method"] = "CreateWhileLessThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSByte_UInt32", ["Method"] = "CreateWhileLessThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSByte_UInt64", ["Method"] = "CreateWhileLessThanMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSingle_Int32", ["Method"] = "CreateWhileLessThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle(Helpers.WhileLessThanMask(left + (Int32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSingle_Int64", ["Method"] = "CreateWhileLessThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileLessThanMask(left + (Int64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSingle_UInt32", ["Method"] = "CreateWhileLessThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.UInt32BitsToSingle(Helpers.WhileLessThanMask(left + (UInt32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskSingle_UInt64", ["Method"] = "CreateWhileLessThanMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileLessThanMask(left + (UInt64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt16_Int32", ["Method"] = "CreateWhileLessThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt16_Int64", ["Method"] = "CreateWhileLessThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt16_UInt32", ["Method"] = "CreateWhileLessThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt16_UInt64", ["Method"] = "CreateWhileLessThanMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt32_Int32", ["Method"] = "CreateWhileLessThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt32_Int64", ["Method"] = "CreateWhileLessThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt32_UInt32", ["Method"] = "CreateWhileLessThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt32_UInt64", ["Method"] = "CreateWhileLessThanMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt64_Int32", ["Method"] = "CreateWhileLessThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt64_Int64", ["Method"] = "CreateWhileLessThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt64_UInt32", ["Method"] = "CreateWhileLessThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanMaskUInt64_UInt64", ["Method"] = "CreateWhileLessThanMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskByte_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskByte_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskByte_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskByte_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Byte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Byte)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskDouble_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskDouble_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskDouble_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.Int64BitsToDouble(Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskDouble_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskDouble", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.UInt64BitsToDouble(Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt16_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt16_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt16_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt16_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int16)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt32_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt32_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt32_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt32_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int32)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt64_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt64_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt64_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskInt64_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Int64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(Int64)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSByte_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSByte_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSByte_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSByte_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskSByte", ["RetVectorType"] = "Vector", ["RetBaseType"] = "SByte", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(SByte)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSingle_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle(Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSingle_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSingle_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "BitConverter.UInt32BitsToSingle(Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskSingle_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskSingle", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "BitConverter.Int32BitsToSingle((int)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right)) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt16_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt16_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt16_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt16_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt16", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt16", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt16)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt32_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt32_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt32_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt32_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt32", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt32", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt32)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt64_Int32", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int32", ["Op2BaseType"] = "Int32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanOrEqualMask(left + (Int32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt64_Int64", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "Int64", ["Op2BaseType"] = "Int64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanOrEqualMask(left + (Int64)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt64_UInt32", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt32", ["Op2BaseType"] = "UInt32", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanOrEqualMask(left + (UInt32)i, right) != result[i]",}), + (Templates.ScalarBinOpRetVecTest,new Dictionary {["TestName"] = "Sve_CreateWhileLessThanOrEqualMaskUInt64_UInt64", ["Method"] = "CreateWhileLessThanOrEqualMaskUInt64", ["RetVectorType"] = "Vector", ["RetBaseType"] = "UInt64", ["Op1BaseType"] = "UInt64", ["Op2BaseType"] = "UInt64", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "(UInt64)Helpers.WhileLessThanOrEqualMask(left + (UInt64)i, right) != result[i]",}), (Templates.SveVecBinOpTest, new Dictionary { ["TestName"] = "Sve_Divide_float", ["Method"] = "Divide", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Single", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Single", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "Helpers.Divide(left[i], right[i]) != result[i]", ["GetIterResult"] = "Helpers.Divide(left[i], right[i])"}), (Templates.SveVecBinOpTest, new Dictionary { ["TestName"] = "Sve_Divide_double", ["Method"] = "Divide", ["RetVectorType"] = "Vector", ["RetBaseType"] = "Double", ["Op1VectorType"] = "Vector", ["Op1BaseType"] = "Double", ["Op2VectorType"] = "Vector", ["Op2BaseType"] = "Double", ["LargestVectorSize"] = "64", ["NextValueOp1"] = "TestLibrary.Generator.GetDouble()", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "Helpers.Divide(left[i], right[i]) != result[i]", ["GetIterResult"] = "Helpers.Divide(left[i], right[i])"}), diff --git a/src/tests/JIT/Regression/JitBlue/Runtime_118377/Runtime_118377.cs b/src/tests/JIT/Regression/JitBlue/Runtime_118377/Runtime_118377.cs index 60843e248c2243..2d8ff5e00487f9 100644 --- a/src/tests/JIT/Regression/JitBlue/Runtime_118377/Runtime_118377.cs +++ b/src/tests/JIT/Regression/JitBlue/Runtime_118377/Runtime_118377.cs @@ -23,7 +23,7 @@ public class Runtime_118377 [MethodImpl(MethodImplOptions.NoInlining)] private static Vector M4() { - var vr3 = Sve.CreateWhileLessThanMask64Bit(0, 0); + var vr3 = Sve.CreateWhileLessThanMaskUInt64(0, 0); var vr5 = Vector.Create(s_4); var vr1 = Sve.CreateBreakPropagateMask(vr3, vr5); var vr7 = Vector.Create(0); diff --git a/src/tests/JIT/opt/SVE/ChangeMaskUse.cs b/src/tests/JIT/opt/SVE/ChangeMaskUse.cs index db46a9bcd7a0fb..f9395c6cf406ab 100644 --- a/src/tests/JIT/opt/SVE/ChangeMaskUse.cs +++ b/src/tests/JIT/opt/SVE/ChangeMaskUse.cs @@ -74,7 +74,7 @@ private static void UseMaskAsVector() [MethodImpl(MethodImplOptions.NoInlining)] private static void UseMaskAsMaskAndVector() { - Vector mask1 = Sve.CreateWhileLessThanOrEqualMask8Bit(2, 9); // Create lcl mask + Vector mask1 = Sve.CreateWhileLessThanOrEqualMaskByte(2, 9); // Create lcl mask Vector vec1 = Vector.Create(3); Vector vec2 = Vector.Create(4); Vector vec3 = Sve.ConditionalExtractAfterLastActiveElement(mask1, vec1, vec2); // Use as mask diff --git a/src/tests/JIT/opt/SVE/MaskUse.cs b/src/tests/JIT/opt/SVE/MaskUse.cs index f03e1c63a2755d..0230e157cb6644 100644 --- a/src/tests/JIT/opt/SVE/MaskUse.cs +++ b/src/tests/JIT/opt/SVE/MaskUse.cs @@ -51,7 +51,7 @@ public static void TestEntryPoint() [MethodImpl(MethodImplOptions.NoInlining)] private static void UseMask1() { - Vector mask1 = Sve.CreateWhileLessThanMask64Bit(2, 9); // Create local mask + Vector mask1 = Sve.CreateWhileLessThanMaskUInt64(2, 9); // Create local mask Vector vec1 = Vector.Create(5); Vector vec2 = Sve.Compact(mask1, vec1); // Use as mask Consume(vec2);