aboutsummaryrefslogtreecommitdiff
path: root/src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs
diff options
context:
space:
mode:
Diffstat (limited to 'src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs')
-rw-r--r--src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs689
1 files changed, 689 insertions, 0 deletions
diff --git a/src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs b/src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs
new file mode 100644
index 00000000..e1e81a00
--- /dev/null
+++ b/src/Ryujinx.Tests/Cpu/CpuTestSimdIns.cs
@@ -0,0 +1,689 @@
+#define SimdIns
+
+using ARMeilleure.State;
+using NUnit.Framework;
+
+namespace Ryujinx.Tests.Cpu
+{
+ [Category("SimdIns")]
+ public sealed class CpuTestSimdIns : CpuTest
+ {
+#if SimdIns
+
+#region "ValueSource"
+ private static ulong[] _1D_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
+ 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+
+ private static ulong[] _2S_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7FFFFFFF7FFFFFFFul,
+ 0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+
+ private static ulong[] _4H_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7FFF7FFF7FFF7FFFul,
+ 0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+
+ private static ulong[] _8B_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
+ 0x8080808080808080ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+
+ private static ulong[] _8B4H_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
+ 0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
+ 0x8000800080008000ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+
+ private static ulong[] _8B4H2S_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7F7F7F7F7F7F7F7Ful,
+ 0x8080808080808080ul, 0x7FFF7FFF7FFF7FFFul,
+ 0x8000800080008000ul, 0x7FFFFFFF7FFFFFFFul,
+ 0x8000000080000000ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+
+ private static uint[] _W_()
+ {
+ return new[] { 0x00000000u, 0x0000007Fu,
+ 0x00000080u, 0x000000FFu,
+ 0x00007FFFu, 0x00008000u,
+ 0x0000FFFFu, 0x7FFFFFFFu,
+ 0x80000000u, 0xFFFFFFFFu };
+ }
+
+ private static ulong[] _X_()
+ {
+ return new[] { 0x0000000000000000ul, 0x7FFFFFFFFFFFFFFFul,
+ 0x8000000000000000ul, 0xFFFFFFFFFFFFFFFFul };
+ }
+#endregion
+
+ [Test, Pairwise, Description("DUP <Vd>.<T>, W<n>")]
+ public void Dup_Gp_W([Values(0u)] uint rd,
+ [Values(1u, 31u)] uint rn,
+ [ValueSource(nameof(_W_))] uint wn,
+ [Values(0, 1, 2)] int size, // Q0: <8B, 4H, 2S>
+ [Values(0b0u, 0b1u)] uint q) // Q1: <16B, 8H, 4S>
+ {
+ uint imm5 = (1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E000C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= ((q & 1) << 30);
+
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+
+ SingleOpcode(opcode, x1: wn, x31: w31, v0: v0);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP <Vd>.<T>, X<n>")]
+ public void Dup_Gp_X([Values(0u)] uint rd,
+ [Values(1u, 31u)] uint rn,
+ [ValueSource(nameof(_X_))] ulong xn)
+ {
+ uint opcode = 0x4E080C00; // DUP V0.2D, X0
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+
+ ulong x31 = TestContext.CurrentContext.Random.NextULong();
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+
+ SingleOpcode(opcode, x1: xn, x31: x31, v0: v0);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP B0, V1.B[<index>]")]
+ public void Dup_S_B([ValueSource(nameof(_8B_))] ulong a,
+ [Values(0u, 15u)] uint index)
+ {
+ const int size = 0;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x5E000420; // RESERVED
+ opcode |= (imm5 << 16);
+
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP H0, V1.H[<index>]")]
+ public void Dup_S_H([ValueSource(nameof(_4H_))] ulong a,
+ [Values(0u, 7u)] uint index)
+ {
+ const int size = 1;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x5E000420; // RESERVED
+ opcode |= (imm5 << 16);
+
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP S0, V1.S[<index>]")]
+ public void Dup_S_S([ValueSource(nameof(_2S_))] ulong a,
+ [Values(0u, 1u, 2u, 3u)] uint index)
+ {
+ const int size = 2;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x5E000420; // RESERVED
+ opcode |= (imm5 << 16);
+
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP D0, V1.D[<index>]")]
+ public void Dup_S_D([ValueSource(nameof(_1D_))] ulong a,
+ [Values(0u, 1u)] uint index)
+ {
+ const int size = 3;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x5E000420; // RESERVED
+ opcode |= (imm5 << 16);
+
+ ulong z = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP <Vd>.<T>, <Vn>.B[<index>]")]
+ public void Dup_V_8B_16B([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_8B_))] ulong z,
+ [ValueSource(nameof(_8B_))] ulong a,
+ [Values(0u, 15u)] uint index,
+ [Values(0b0u, 0b1u)] uint q) // <8B, 16B>
+ {
+ const int size = 0;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= ((q & 1) << 30);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP <Vd>.<T>, <Vn>.H[<index>]")]
+ public void Dup_V_4H_8H([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_4H_))] ulong z,
+ [ValueSource(nameof(_4H_))] ulong a,
+ [Values(0u, 7u)] uint index,
+ [Values(0b0u, 0b1u)] uint q) // <4H, 8H>
+ {
+ const int size = 1;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= ((q & 1) << 30);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP <Vd>.<T>, <Vn>.S[<index>]")]
+ public void Dup_V_2S_4S([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_2S_))] ulong z,
+ [ValueSource(nameof(_2S_))] ulong a,
+ [Values(0u, 1u, 2u, 3u)] uint index,
+ [Values(0b0u, 0b1u)] uint q) // <2S, 4S>
+ {
+ const int size = 2;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= ((q & 1) << 30);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("DUP <Vd>.<T>, <Vn>.D[<index>]")]
+ public void Dup_V_2D([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_1D_))] ulong z,
+ [ValueSource(nameof(_1D_))] ulong a,
+ [Values(0u, 1u)] uint index,
+ [Values(0b1u)] uint q) // <2D>
+ {
+ const int size = 3;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= ((q & 1) << 30);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.B[<index>], W<n>")]
+ public void Ins_Gp_WB([Values(0u)] uint rd,
+ [Values(1u, 31u)] uint rn,
+ [ValueSource(nameof(_8B_))] ulong z,
+ [ValueSource(nameof(_W_))] uint wn,
+ [Values(0u, 15u)] uint index)
+ {
+ const int size = 0;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E001C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v0 = MakeVectorE0E1(z, z);
+
+ SingleOpcode(opcode, x1: wn, x31: w31, v0: v0);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.H[<index>], W<n>")]
+ public void Ins_Gp_WH([Values(0u)] uint rd,
+ [Values(1u, 31u)] uint rn,
+ [ValueSource(nameof(_4H_))] ulong z,
+ [ValueSource(nameof(_W_))] uint wn,
+ [Values(0u, 7u)] uint index)
+ {
+ const int size = 1;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E001C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v0 = MakeVectorE0E1(z, z);
+
+ SingleOpcode(opcode, x1: wn, x31: w31, v0: v0);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.S[<index>], W<n>")]
+ public void Ins_Gp_WS([Values(0u)] uint rd,
+ [Values(1u, 31u)] uint rn,
+ [ValueSource(nameof(_2S_))] ulong z,
+ [ValueSource(nameof(_W_))] uint wn,
+ [Values(0u, 1u, 2u, 3u)] uint index)
+ {
+ const int size = 2;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E001C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v0 = MakeVectorE0E1(z, z);
+
+ SingleOpcode(opcode, x1: wn, x31: w31, v0: v0);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.D[<index>], X<n>")]
+ public void Ins_Gp_XD([Values(0u)] uint rd,
+ [Values(1u, 31u)] uint rn,
+ [ValueSource(nameof(_1D_))] ulong z,
+ [ValueSource(nameof(_X_))] ulong xn,
+ [Values(0u, 1u)] uint index)
+ {
+ const int size = 3;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E001C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x31 = TestContext.CurrentContext.Random.NextULong();
+ V128 v0 = MakeVectorE0E1(z, z);
+
+ SingleOpcode(opcode, x1: xn, x31: x31, v0: v0);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.B[<index1>], <Vn>.B[<index2>]")]
+ public void Ins_V_BB([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_8B_))] ulong z,
+ [ValueSource(nameof(_8B_))] ulong a,
+ [Values(0u, 15u)] uint dstIndex,
+ [Values(0u, 15u)] uint srcIndex)
+ {
+ const int size = 0;
+
+ uint imm5 = (dstIndex << (size + 1) | 1u << size) & 0x1Fu;
+ uint imm4 = (srcIndex << size) & 0xFu;
+
+ uint opcode = 0x6E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= (imm4 << 11);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.H[<index1>], <Vn>.H[<index2>]")]
+ public void Ins_V_HH([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_4H_))] ulong z,
+ [ValueSource(nameof(_4H_))] ulong a,
+ [Values(0u, 7u)] uint dstIndex,
+ [Values(0u, 7u)] uint srcIndex)
+ {
+ const int size = 1;
+
+ uint imm5 = (dstIndex << (size + 1) | 1u << size) & 0x1Fu;
+ uint imm4 = (srcIndex << size) & 0xFu;
+
+ uint opcode = 0x6E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= (imm4 << 11);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.S[<index1>], <Vn>.S[<index2>]")]
+ public void Ins_V_SS([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_2S_))] ulong z,
+ [ValueSource(nameof(_2S_))] ulong a,
+ [Values(0u, 1u, 2u, 3u)] uint dstIndex,
+ [Values(0u, 1u, 2u, 3u)] uint srcIndex)
+ {
+ const int size = 2;
+
+ uint imm5 = (dstIndex << (size + 1) | 1u << size) & 0x1Fu;
+ uint imm4 = (srcIndex << size) & 0xFu;
+
+ uint opcode = 0x6E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= (imm4 << 11);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("INS <Vd>.D[<index1>], <Vn>.D[<index2>]")]
+ public void Ins_V_DD([Values(0u)] uint rd,
+ [Values(1u, 0u)] uint rn,
+ [ValueSource(nameof(_1D_))] ulong z,
+ [ValueSource(nameof(_1D_))] ulong a,
+ [Values(0u, 1u)] uint dstIndex,
+ [Values(0u, 1u)] uint srcIndex)
+ {
+ const int size = 3;
+
+ uint imm5 = (dstIndex << (size + 1) | 1u << size) & 0x1Fu;
+ uint imm4 = (srcIndex << size) & 0xFu;
+
+ uint opcode = 0x6E000400; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+ opcode |= (imm4 << 11);
+
+ V128 v0 = MakeVectorE0E1(z, z);
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, v0: v0, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("SMOV <Wd>, <Vn>.B[<index>]")]
+ public void Smov_S_BW([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_8B_))] ulong a,
+ [Values(0u, 15u)] uint index)
+ {
+ const int size = 0;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E002C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x0 = (ulong)TestContext.CurrentContext.Random.NextUInt() << 32;
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x0: x0, x31: w31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("SMOV <Wd>, <Vn>.H[<index>]")]
+ public void Smov_S_HW([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_4H_))] ulong a,
+ [Values(0u, 7u)] uint index)
+ {
+ const int size = 1;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E002C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x0 = (ulong)TestContext.CurrentContext.Random.NextUInt() << 32;
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x0: x0, x31: w31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("SMOV <Xd>, <Vn>.B[<index>]")]
+ public void Smov_S_BX([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_8B_))] ulong a,
+ [Values(0u, 15u)] uint index)
+ {
+ const int size = 0;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E002C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x31 = TestContext.CurrentContext.Random.NextULong();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x31: x31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("SMOV <Xd>, <Vn>.H[<index>]")]
+ public void Smov_S_HX([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_4H_))] ulong a,
+ [Values(0u, 7u)] uint index)
+ {
+ const int size = 1;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E002C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x31 = TestContext.CurrentContext.Random.NextULong();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x31: x31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("SMOV <Xd>, <Vn>.S[<index>]")]
+ public void Smov_S_SX([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_2S_))] ulong a,
+ [Values(0u, 1u, 2u, 3u)] uint index)
+ {
+ const int size = 2;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E002C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x31 = TestContext.CurrentContext.Random.NextULong();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x31: x31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("UMOV <Wd>, <Vn>.B[<index>]")]
+ public void Umov_S_BW([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_8B_))] ulong a,
+ [Values(0u, 15u)] uint index)
+ {
+ const int size = 0;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E003C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x0 = (ulong)TestContext.CurrentContext.Random.NextUInt() << 32;
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x0: x0, x31: w31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("UMOV <Wd>, <Vn>.H[<index>]")]
+ public void Umov_S_HW([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_4H_))] ulong a,
+ [Values(0u, 7u)] uint index)
+ {
+ const int size = 1;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E003C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x0 = (ulong)TestContext.CurrentContext.Random.NextUInt() << 32;
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x0: x0, x31: w31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("UMOV <Wd>, <Vn>.S[<index>]")]
+ public void Umov_S_SW([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_2S_))] ulong a,
+ [Values(0u, 1u, 2u, 3u)] uint index)
+ {
+ const int size = 2;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x0E003C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x0 = (ulong)TestContext.CurrentContext.Random.NextUInt() << 32;
+ uint w31 = TestContext.CurrentContext.Random.NextUInt();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x0: x0, x31: w31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+
+ [Test, Pairwise, Description("UMOV <Xd>, <Vn>.D[<index>]")]
+ public void Umov_S_DX([Values(0u, 31u)] uint rd,
+ [Values(1u)] uint rn,
+ [ValueSource(nameof(_1D_))] ulong a,
+ [Values(0u, 1u)] uint index)
+ {
+ const int size = 3;
+
+ uint imm5 = (index << (size + 1) | 1u << size) & 0x1Fu;
+
+ uint opcode = 0x4E003C00; // RESERVED
+ opcode |= ((rn & 31) << 5) | ((rd & 31) << 0);
+ opcode |= (imm5 << 16);
+
+ ulong x31 = TestContext.CurrentContext.Random.NextULong();
+ V128 v1 = MakeVectorE0E1(a, a);
+
+ SingleOpcode(opcode, x31: x31, v1: v1);
+
+ CompareAgainstUnicorn();
+ }
+#endif
+ }
+} \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-08 21:39:37 +0000