From 4b5756da32d94c77d8d2d9beb03135503c74cdf2 Mon Sep 17 00:00:00 2001 From: Will Smith Date: Mon, 30 Oct 2023 14:32:52 -0700 Subject: [PATCH] Arm64: Implement LoadVector64x*AndUnzip and LoadVector128x*AndUnzip APIs (#94128) * Initial LoadVector64/128AndUnzip APIs * Added hwintrinsics * Added generating tests * Fix semi * Whitespace * Whitespace * Whitespace * Whitespace * Whitespace * Whitespace * Fix test generation * fix missing cases in gentree * Minor formatting of the test generator * Fix comments * Fixing up tests * Use the right register variants --- src/coreclr/jit/gentree.cpp | 6 + src/coreclr/jit/hwintrinsic.h | 6 + src/coreclr/jit/hwintrinsicarm64.cpp | 6 + src/coreclr/jit/hwintrinsiclistarm64.h | 6 + src/coreclr/jit/lsraarm64.cpp | 6 + .../Arm/AdvSimd.PlatformNotSupported.cs | 255 ++++++++++++++++++ .../System/Runtime/Intrinsics/Arm/AdvSimd.cs | 255 ++++++++++++++++++ .../ref/System.Runtime.Intrinsics.cs | 51 ++++ .../GenerateHWIntrinsicTests_Arm.cs | 53 +++- 9 files changed, 643 insertions(+), 1 deletion(-) diff --git a/src/coreclr/jit/gentree.cpp b/src/coreclr/jit/gentree.cpp index 1d5ed98d0b491..48d76cf396edb 100644 --- a/src/coreclr/jit/gentree.cpp +++ b/src/coreclr/jit/gentree.cpp @@ -25852,6 +25852,7 @@ ClassLayout* GenTreeHWIntrinsic::GetLayout(Compiler* compiler) const case NI_AdvSimd_Arm64_LoadPairScalarVector64NonTemporal: case NI_AdvSimd_Arm64_LoadPairVector64: case NI_AdvSimd_Arm64_LoadPairVector64NonTemporal: + case NI_AdvSimd_LoadVector64x2AndUnzip: case NI_AdvSimd_LoadVector64x2: case NI_AdvSimd_LoadAndInsertScalarVector64x2: case NI_AdvSimd_LoadAndReplicateToVector64x2: @@ -25859,24 +25860,29 @@ ClassLayout* GenTreeHWIntrinsic::GetLayout(Compiler* compiler) const case NI_AdvSimd_Arm64_LoadPairVector128: case NI_AdvSimd_Arm64_LoadPairVector128NonTemporal: + case NI_AdvSimd_Arm64_LoadVector128x2AndUnzip: case NI_AdvSimd_Arm64_LoadVector128x2: case NI_AdvSimd_LoadVector64x4: + case NI_AdvSimd_LoadVector64x4AndUnzip: case NI_AdvSimd_LoadAndReplicateToVector64x4: case NI_AdvSimd_Arm64_LoadAndReplicateToVector128x2: case NI_AdvSimd_Arm64_LoadAndInsertScalarVector128x2: case NI_AdvSimd_LoadAndInsertScalarVector64x4: return compiler->typGetBlkLayout(32); + case NI_AdvSimd_LoadVector64x3AndUnzip: case NI_AdvSimd_LoadVector64x3: case NI_AdvSimd_LoadAndInsertScalarVector64x3: case NI_AdvSimd_LoadAndReplicateToVector64x3: return compiler->typGetBlkLayout(24); + case NI_AdvSimd_Arm64_LoadVector128x3AndUnzip: case NI_AdvSimd_Arm64_LoadVector128x3: case NI_AdvSimd_Arm64_LoadAndInsertScalarVector128x3: case NI_AdvSimd_Arm64_LoadAndReplicateToVector128x3: return compiler->typGetBlkLayout(48); + case NI_AdvSimd_Arm64_LoadVector128x4AndUnzip: case NI_AdvSimd_Arm64_LoadVector128x4: case NI_AdvSimd_Arm64_LoadAndInsertScalarVector128x4: case NI_AdvSimd_Arm64_LoadAndReplicateToVector128x4: diff --git a/src/coreclr/jit/hwintrinsic.h b/src/coreclr/jit/hwintrinsic.h index 4695af2a77096..d3dc426133d36 100644 --- a/src/coreclr/jit/hwintrinsic.h +++ b/src/coreclr/jit/hwintrinsic.h @@ -768,6 +768,8 @@ struct HWIntrinsicInfo case NI_AdvSimd_Arm64_LoadPairVector64NonTemporal: case NI_AdvSimd_Arm64_LoadPairVector128: case NI_AdvSimd_Arm64_LoadPairVector128NonTemporal: + case NI_AdvSimd_LoadVector64x2AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x2AndUnzip: case NI_AdvSimd_LoadVector64x2: case NI_AdvSimd_Arm64_LoadVector128x2: case NI_AdvSimd_LoadAndInsertScalarVector64x2: @@ -776,6 +778,8 @@ struct HWIntrinsicInfo case NI_AdvSimd_Arm64_LoadAndReplicateToVector128x2: return 2; + case NI_AdvSimd_LoadVector64x3AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x3AndUnzip: case NI_AdvSimd_LoadVector64x3: case NI_AdvSimd_Arm64_LoadVector128x3: case NI_AdvSimd_LoadAndInsertScalarVector64x3: @@ -784,6 +788,8 @@ struct HWIntrinsicInfo case NI_AdvSimd_Arm64_LoadAndReplicateToVector128x3: return 3; + case NI_AdvSimd_LoadVector64x4AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x4AndUnzip: case NI_AdvSimd_LoadVector64x4: case NI_AdvSimd_Arm64_LoadVector128x4: case NI_AdvSimd_LoadAndInsertScalarVector64x4: diff --git a/src/coreclr/jit/hwintrinsicarm64.cpp b/src/coreclr/jit/hwintrinsicarm64.cpp index 01f64f47ce3cc..15b9510b0f4b6 100644 --- a/src/coreclr/jit/hwintrinsicarm64.cpp +++ b/src/coreclr/jit/hwintrinsicarm64.cpp @@ -1883,6 +1883,12 @@ GenTree* Compiler::impSpecialIntrinsic(NamedIntrinsic intrinsic, break; } + case NI_AdvSimd_LoadVector64x2AndUnzip: + case NI_AdvSimd_LoadVector64x3AndUnzip: + case NI_AdvSimd_LoadVector64x4AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x2AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x3AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x4AndUnzip: case NI_AdvSimd_LoadVector64x2: case NI_AdvSimd_LoadVector64x3: case NI_AdvSimd_LoadVector64x4: diff --git a/src/coreclr/jit/hwintrinsiclistarm64.h b/src/coreclr/jit/hwintrinsiclistarm64.h index c704f4e080c51..c68ddab429cea 100644 --- a/src/coreclr/jit/hwintrinsiclistarm64.h +++ b/src/coreclr/jit/hwintrinsiclistarm64.h @@ -326,6 +326,9 @@ HARDWARE_INTRINSIC(AdvSimd, LoadAndReplicateToVector64x3, HARDWARE_INTRINSIC(AdvSimd, LoadAndReplicateToVector64x4, 8, 1, true, {INS_ld4r, INS_ld4r, INS_ld4r, INS_ld4r, INS_ld4r, INS_ld4r, INS_invalid, INS_invalid, INS_ld4r, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd, LoadVector64, 8, 1, true, {INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen) HARDWARE_INTRINSIC(AdvSimd, LoadVector128, 16, 1, true, {INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1, INS_ld1}, HW_Category_Helper, HW_Flag_SpecialImport|HW_Flag_NoCodeGen) +HARDWARE_INTRINSIC(AdvSimd, LoadVector64x2AndUnzip, 8, 1, true, {INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_invalid, INS_invalid, INS_ld1_2regs, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd, LoadVector64x3AndUnzip, 8, 1, true, {INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_invalid, INS_invalid, INS_ld1_3regs, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd, LoadVector64x4AndUnzip, 8, 1, true, {INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_invalid, INS_invalid, INS_ld1_4regs, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd, LoadVector64x2, 8, 1, true, {INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_invalid, INS_invalid, INS_ld2, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd, LoadVector64x3, 8, 1, true, {INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_invalid, INS_invalid, INS_ld3, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd, LoadVector64x4, 8, 1, true, {INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_invalid, INS_invalid, INS_ld4, INS_invalid}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) @@ -589,6 +592,9 @@ HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadAndInsertScalar, HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadAndInsertScalarVector128x2, 16, 3, true, {INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2}, HW_Category_MemoryLoad, HW_Flag_HasImmediateOperand|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadAndInsertScalarVector128x3, 16, 3, true, {INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3}, HW_Category_MemoryLoad, HW_Flag_HasImmediateOperand|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadAndInsertScalarVector128x4, 16, 3, true, {INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4}, HW_Category_MemoryLoad, HW_Flag_HasImmediateOperand|HW_Flag_SpecialImport|HW_Flag_HasRMWSemantics|HW_Flag_SIMDScalar|HW_Flag_SpecialCodeGen|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadVector128x2AndUnzip, 16, 1, true, {INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs, INS_ld1_2regs}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadVector128x3AndUnzip, 16, 1, true, {INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs, INS_ld1_3regs}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) +HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadVector128x4AndUnzip, 16, 1, true, {INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs, INS_ld1_4regs}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadVector128x2, 16, 1, true, {INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2, INS_ld2}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadVector128x3, 16, 1, true, {INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3, INS_ld3}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) HARDWARE_INTRINSIC(AdvSimd_Arm64, LoadVector128x4, 16, 1, true, {INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4, INS_ld4}, HW_Category_MemoryLoad, HW_Flag_BaseTypeFromFirstArg|HW_Flag_SpecialImport|HW_Flag_MultiReg|HW_Flag_NeedsConsecutiveRegisters) diff --git a/src/coreclr/jit/lsraarm64.cpp b/src/coreclr/jit/lsraarm64.cpp index 81bdd5334a54e..e1907d4a3fa55 100644 --- a/src/coreclr/jit/lsraarm64.cpp +++ b/src/coreclr/jit/lsraarm64.cpp @@ -1632,6 +1632,12 @@ int LinearScan::BuildHWIntrinsic(GenTreeHWIntrinsic* intrinsicTree, int* pDstCou assert(intrinsicTree->OperIsMemoryLoadOrStore()); srcCount += BuildAddrUses(intrin.op3); FALLTHROUGH; + case NI_AdvSimd_LoadVector64x2AndUnzip: + case NI_AdvSimd_LoadVector64x3AndUnzip: + case NI_AdvSimd_LoadVector64x4AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x2AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x3AndUnzip: + case NI_AdvSimd_Arm64_LoadVector128x4AndUnzip: case NI_AdvSimd_LoadVector64x2: case NI_AdvSimd_LoadVector64x3: case NI_AdvSimd_LoadVector64x4: diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs index d386e1c299ee6..57fc22b034313 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.PlatformNotSupported.cs @@ -2098,6 +2098,156 @@ internal Arm64() { } /// public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(ulong* address) { throw new PlatformNotSupportedException(); } + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(short* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(int* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(long* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(short* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(int* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(long* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(double* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(short* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(int* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(long* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(ulong* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(double* address) { throw new PlatformNotSupportedException(); } + /// /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] /// @@ -9037,6 +9187,111 @@ internal Arm64() { } /// public static unsafe Vector128 LoadVector128(ulong* address) { throw new PlatformNotSupportedException(); } + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(short* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(int* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(short* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(int* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(float* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(byte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(sbyte* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(short* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(ushort* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(int* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(uint* address) { throw new PlatformNotSupportedException(); } + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(float* address) { throw new PlatformNotSupportedException(); } + /// /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] /// diff --git a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs index 7ad85399285d1..b8243b0693aa6 100644 --- a/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs +++ b/src/libraries/System.Private.CoreLib/src/System/Runtime/Intrinsics/Arm/AdvSimd.cs @@ -2096,6 +2096,156 @@ internal Arm64() { } /// public static unsafe (Vector128 Value1, Vector128 Value2) LoadPairVector128NonTemporal(ulong* address) => LoadPairVector128NonTemporal(address); + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(byte* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(sbyte* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(short* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(ushort* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(int* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(uint* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(long* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(ulong* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(float* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2) LoadVector128x2AndUnzip(double* address) => LoadVector128x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(byte* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(sbyte* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(short* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(ushort* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(int* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(uint* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(long* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(ulong* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(float* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3) LoadVector128x3AndUnzip(double* address) => LoadVector128x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(byte* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B, Vn+3.16B }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(sbyte* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(short* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H, Vn+3.8H }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(ushort* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(int* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(uint* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(long* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(ulong* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S, Vn+3.4S }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(float* address) => LoadVector128x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.2D, Vn+1.2D, Vn+2.2D, Vn+3.2D }, [Xn] + /// + public static unsafe (Vector128 Value1, Vector128 Value2, Vector128 Value3, Vector128 Value4) LoadVector128x4AndUnzip(double* address) => LoadVector128x4AndUnzip(address); + /// /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] /// @@ -9034,6 +9184,111 @@ internal Arm64() { } /// public static unsafe Vector128 LoadVector128(ulong* address) => LoadVector128(address); + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(byte* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(sbyte* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(short* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(ushort* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(int* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(uint* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2) LoadVector64x2AndUnzip(float* address) => LoadVector64x2AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(byte* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(sbyte* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(short* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(ushort* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(int* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(uint* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3) LoadVector64x3AndUnzip(float* address) => LoadVector64x3AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(byte* address) => LoadVector64x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.16B, Vn+1.16B, Vn+2.16B }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(sbyte* address) => LoadVector64x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(short* address) => LoadVector64x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.8H, Vn+1.8H, Vn+2.8H }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(ushort* address) => LoadVector64x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(int* address) => LoadVector64x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(uint* address) => LoadVector64x4AndUnzip(address); + + /// + /// A64: LD1 { Vn.4S, Vn+1.4S, Vn+2.4S }, [Xn] + /// + public static unsafe (Vector64 Value1, Vector64 Value2, Vector64 Value3, Vector64 Value4) LoadVector64x4AndUnzip(float* address) => LoadVector64x4AndUnzip(address); + /// /// A64: LD2 { Vn.16B, Vn+1.16B }, [Xn] /// 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 8e9a0a50fbf27..e0f07a1441e24 100644 --- a/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs +++ b/src/libraries/System.Runtime.Intrinsics/ref/System.Runtime.Intrinsics.cs @@ -1960,6 +1960,27 @@ internal AdvSimd() { } public static unsafe System.Runtime.Intrinsics.Vector64 LoadVector64(ushort* address) { throw null; } public static unsafe System.Runtime.Intrinsics.Vector64 LoadVector64(uint* address) { throw null; } public static unsafe System.Runtime.Intrinsics.Vector64 LoadVector64(ulong* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(byte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(sbyte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(short* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(ushort* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(int* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(uint* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2AndUnzip(float* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(byte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(sbyte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(short* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(ushort* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(int* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(uint* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3) LoadVector64x3AndUnzip(float* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(byte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(sbyte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(short* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(ushort* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(int* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(uint* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2, System.Runtime.Intrinsics.Vector64 Value3, System.Runtime.Intrinsics.Vector64 Value4) LoadVector64x4AndUnzip(float* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2(byte* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2(sbyte* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadVector64x2(short* address) { throw null; } @@ -3335,6 +3356,36 @@ internal Arm64() { } public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadPairVector64NonTemporal(ushort* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadPairVector64NonTemporal(uint* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector64 Value1, System.Runtime.Intrinsics.Vector64 Value2) LoadPairVector64NonTemporal(ulong* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(byte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(sbyte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(short* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(ushort* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(int* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(uint* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(long* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(ulong* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(float* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2AndUnzip(double* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(byte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(sbyte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(short* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(ushort* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(int* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(uint* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(long* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(ulong* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(float* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3) LoadVector128x3AndUnzip(double* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(byte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(sbyte* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(short* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(ushort* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(int* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(uint* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(long* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(ulong* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(float* address) { throw null; } + public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2, System.Runtime.Intrinsics.Vector128 Value3, System.Runtime.Intrinsics.Vector128 Value4) LoadVector128x4AndUnzip(double* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2(byte* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2(sbyte* address) { throw null; } public static unsafe (System.Runtime.Intrinsics.Vector128 Value1, System.Runtime.Intrinsics.Vector128 Value2) LoadVector128x2(short* address) { throw null; } diff --git a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs index 894fb2b159eb9..1510d5f84581f 100644 --- a/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs +++ b/src/tests/Common/GenerateHWIntrinsicTests/GenerateHWIntrinsicTests_Arm.cs @@ -790,6 +790,27 @@ ("LoadUnOpTest.template", new Dictionary { ["TestName"] = "LoadVector128_UInt16", ["Isa"] = "AdvSimd", ["Method"] = "LoadVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), ("LoadUnOpTest.template", new Dictionary { ["TestName"] = "LoadVector128_UInt32", ["Isa"] = "AdvSimd", ["Method"] = "LoadVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), ("LoadUnOpTest.template", new Dictionary { ["TestName"] = "LoadVector128_UInt64", ["Isa"] = "AdvSimd", ["Method"] = "LoadVector128", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipSByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipUShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipUInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2AndUnzipFloat", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "float", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipSByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipUShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipUInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector64x3AndUnzipFloat", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x3AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "float", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipSByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2] || result4[i] != input[i + 8 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2] || result4[i] != input[i + 8 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipUShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2] || result4[i] != input[i + 4 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2] || result4[i] != input[i + 4 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipUInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2] || result4[i] != input[i + 2 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipInt32", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2] || result4[i] != input[i + 2 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector64x4AndUnzipFloat", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x4AndUnzip", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "float", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2] || result4[i] != input[i + 2 * 3]"}), ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2SByte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i * 2] || result2[i] != input[(i * 2) + 1]"}), ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2Byte", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i * 2] || result2[i] != input[(i * 2) + 1]"}), ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector64x2UShort", ["Isa"] = "AdvSimd", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector64x2", ["Op1VectorType"] = "Vector64", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "8", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i * 2] || result2[i] != input[(i * 2) + 1]"}), @@ -2167,7 +2188,37 @@ ("LoadPairVectorTest.template", new Dictionary { ["TestName"] = "LoadPairVector128NonTemporal_Single", ["Isa"] = "AdvSimd.Arm64", ["Method"] = "LoadPairVector128NonTemporal", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "Single", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Single", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "BitConverter.DoubleToInt64Bits(firstOp[i]) != BitConverter.DoubleToInt64Bits(result[i])"}), ("LoadPairVectorTest.template", new Dictionary { ["TestName"] = "LoadPairVector128NonTemporal_UInt16", ["Isa"] = "AdvSimd.Arm64", ["Method"] = "LoadPairVector128NonTemporal", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt16", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), ("LoadPairVectorTest.template", new Dictionary { ["TestName"] = "LoadPairVector128NonTemporal_UInt32", ["Isa"] = "AdvSimd.Arm64", ["Method"] = "LoadPairVector128NonTemporal", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt32", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), - ("LoadPairVectorTest.template", new Dictionary { ["TestName"] = "LoadPairVector128NonTemporal_UInt64", ["Isa"] = "AdvSimd.Arm64", ["Method"] = "LoadPairVector128NonTemporal", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), + ("LoadPairVectorTest.template", new Dictionary { ["TestName"] = "LoadPairVector128NonTemporal_UInt64", ["Isa"] = "AdvSimd.Arm64", ["Method"] = "LoadPairVector128NonTemporal", ["RetVectorType"] = "Vector128", ["RetBaseType"] = "UInt64", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "32", ["NextValueOp1"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "firstOp[i] != result[i]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipSByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 16]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 16]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipUShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipUInt32", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipInt32", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipUInt64", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipInt64", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipFloat", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "float", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4]"}), + ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2AndUnzipDouble", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "double", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipSByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 16] || result3[i] != input[i + 16 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 16] || result3[i] != input[i + 16 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipUShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipUInt32", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipInt32", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipUInt64", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipInt64", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipFloat", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "float", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2]"}), + ("LoadVectorx3Test.template", new Dictionary { ["TestName"] = "LoadVector128x3AndUnzipDouble", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x3AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "double", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipSByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 16] || result3[i] != input[i + 16 * 2] || result4[i] != input[i + 16 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 16] || result3[i] != input[i + 16 * 2] || result4[i] != input[i + 16 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipUShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2] || result4[i] != input[i + 8 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt16()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 8] || result3[i] != input[i + 8 * 2] || result4[i] != input[i + 8 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipUInt32", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt32", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2] || result4[i] != input[i + 4 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipInt32", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int32", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt32()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2] || result4[i] != input[i + 4 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipUInt64", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt64", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt64()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2] || result4[i] != input[i + 2 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipInt64", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Int64", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetInt64()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2] || result4[i] != input[i + 2 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipFloat", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "float", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSingle()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 4] || result3[i] != input[i + 4 * 2] || result4[i] != input[i + 4 * 3]"}), + ("LoadVectorx4Test.template", new Dictionary { ["TestName"] = "LoadVector128x4AndUnzipDouble", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x4AndUnzip", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "double", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetDouble()", ["ValidateIterResult"] = "result1[i] != input[i] || result2[i] != input[i + 2] || result3[i] != input[i + 2 * 2] || result4[i] != input[i + 2 * 3]"}), ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2SByte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "SByte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetSByte()", ["ValidateIterResult"] = "result1[i] != input[i * 2] || result2[i] != input[(i * 2) + 1]"}), ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2Byte", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "Byte", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetByte()", ["ValidateIterResult"] = "result1[i] != input[i * 2] || result2[i] != input[(i * 2) + 1]"}), ("LoadVectorx2Test.template", new Dictionary { ["TestName"] = "LoadVector128x2UShort", ["Isa"] = "AdvSimd.Arm64", ["LoadIsa"] = "AdvSimd", ["Method"] = "LoadVector128x2", ["Op1VectorType"] = "Vector128", ["Op1BaseType"] = "UInt16", ["LargestVectorSize"] = "16", ["NextValueOp2"] = "TestLibrary.Generator.GetUInt16()", ["ValidateIterResult"] = "result1[i] != input[i * 2] || result2[i] != input[(i * 2) + 1]"}),