aboutsummaryrefslogtreecommitdiff
path: root/test/aarch64
diff options
context:
space:
mode:
authorPierre Langlois <pierre.langlois@arm.com>2017-01-24 19:04:12 +0000
committerPierre Langlois <pierre.langlois@arm.com>2017-01-25 11:10:17 +0000
commit59bfe1ca76d3155c56ab97fba60646a734aeb01b (patch)
treeaac17a769d66031f74264573211f0a8d9e647ccf /test/aarch64
parentbde2e4b5ce376456d50a972b6f3aaee3475f8786 (diff)
downloadvixl-59bfe1ca76d3155c56ab97fba60646a734aeb01b.tar.gz
[aarch64] Do not mix the Assembler and MacroAssembler in tests
Cleanup all of vixl64's test to stop use ExactAssemblyScope instead of CodeBufferCheckScope. The latter allows for mixing the assembler and macro-assembler. Fixing the disassembler tests were not completely obvious. We used to have a different SETUP macro for the Assembler and MacroAssembler. It's much simpler to have a single SETUP macro that always creates a MacroAssembler and then use COMPARE or COMPARE_MACRO to define the tests. The former allows the Assembler with an ExactAssemblyScope while the latter does not. Change-Id: Ic37c25742b77767f257f88e06c7e4106ea55425f
Diffstat (limited to 'test/aarch64')
-rw-r--r--test/aarch64/test-assembler-aarch64.cc805
-rw-r--r--test/aarch64/test-disasm-aarch64.cc5375
-rw-r--r--test/aarch64/test-trace-aarch64.cc16
3 files changed, 3490 insertions, 2706 deletions
diff --git a/test/aarch64/test-assembler-aarch64.cc b/test/aarch64/test-assembler-aarch64.cc
index be936f06..50e78005 100644
--- a/test/aarch64/test-assembler-aarch64.cc
+++ b/test/aarch64/test-assembler-aarch64.cc
@@ -121,11 +121,6 @@ namespace aarch64 {
disassembler_decoder.AppendVisitor(&disasm); \
RegisterDump core
-// This is a convenience macro to avoid creating a scope for every assembler
-// function called. It will still assert the buffer hasn't been exceeded.
-#define ALLOW_ASM() \
- CodeBufferCheckScope guard(&masm, masm.GetBuffer()->GetCapacity())
-
#define START() \
masm.Reset(); \
simulator->ResetState(); \
@@ -194,11 +189,6 @@ namespace aarch64 {
RegisterDump core; \
CPU::SetUp()
-// This is a convenience macro to avoid creating a scope for every assembler
-// function called. It will still assert the buffer hasn't been exceeded.
-#define ALLOW_ASM() \
- CodeBufferCheckScope guard(&masm, masm.GetBuffer()->GetCapacity())
-
#define START() \
masm.Reset(); \
__ PushCalleeSavedRegisters()
@@ -465,7 +455,6 @@ TEST(mov_imm_x) {
TEST(mov) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(x0, 0xffffffffffffffff);
@@ -475,9 +464,12 @@ TEST(mov) {
__ Mov(x0, 0x0123456789abcdef);
- __ movz(x1, UINT64_C(0xabcd) << 16);
- __ movk(x2, UINT64_C(0xabcd) << 32);
- __ movn(x3, UINT64_C(0xabcd) << 48);
+ {
+ ExactAssemblyScope scope(&masm, 3 * kInstructionSize);
+ __ movz(x1, UINT64_C(0xabcd) << 16);
+ __ movk(x2, UINT64_C(0xabcd) << 32);
+ __ movn(x3, UINT64_C(0xabcd) << 48);
+ }
__ Mov(x4, 0x0123456789abcdef);
__ Mov(x5, x4);
@@ -2032,7 +2024,6 @@ TEST(adrp_offset) {
TEST(branch_cond) {
SETUP();
- ALLOW_ASM();
Label done, wrong;
@@ -2098,13 +2089,19 @@ TEST(branch_cond) {
// The MacroAssembler does not allow al as a branch condition.
Label ok_5;
- __ b(&ok_5, al);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ b(&ok_5, al);
+ }
__ Mov(x0, 0x0);
__ Bind(&ok_5);
// The MacroAssembler does not allow nv as a branch condition.
Label ok_6;
- __ b(&ok_6, nv);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ b(&ok_6, nv);
+ }
__ Mov(x0, 0x0);
__ Bind(&ok_6);
@@ -7312,16 +7309,19 @@ TEST(ldr_literal_values_s) {
TEST(ldr_literal_custom) {
SETUP();
- ALLOW_ASM();
Label end_of_pool_before;
Label end_of_pool_after;
+
+ const size_t kSizeOfPoolInBytes = 44;
+
Literal<uint64_t> before_x(0x1234567890abcdef);
Literal<uint32_t> before_w(0xfedcba09);
Literal<uint32_t> before_sx(0x80000000);
Literal<uint64_t> before_q(0x1234000056780000, 0xabcd0000ef000000);
Literal<double> before_d(1.234);
Literal<float> before_s(2.5);
+
Literal<uint64_t> after_x(0x1234567890abcdef);
Literal<uint32_t> after_w(0xfedcba09);
Literal<uint32_t> after_sx(0x80000000);
@@ -7333,36 +7333,45 @@ TEST(ldr_literal_custom) {
// Manually generate a pool.
__ B(&end_of_pool_before);
- __ place(&before_x);
- __ place(&before_w);
- __ place(&before_sx);
- __ place(&before_q);
- __ place(&before_d);
- __ place(&before_s);
+ {
+ ExactAssemblyScope scope(&masm, kSizeOfPoolInBytes);
+ __ place(&before_x);
+ __ place(&before_w);
+ __ place(&before_sx);
+ __ place(&before_q);
+ __ place(&before_d);
+ __ place(&before_s);
+ }
__ Bind(&end_of_pool_before);
- __ ldr(x2, &before_x);
- __ ldr(w3, &before_w);
- __ ldrsw(x5, &before_sx);
- __ ldr(q11, &before_q);
- __ ldr(d13, &before_d);
- __ ldr(s25, &before_s);
+ {
+ ExactAssemblyScope scope(&masm, 12 * kInstructionSize);
+ __ ldr(x2, &before_x);
+ __ ldr(w3, &before_w);
+ __ ldrsw(x5, &before_sx);
+ __ ldr(q11, &before_q);
+ __ ldr(d13, &before_d);
+ __ ldr(s25, &before_s);
- __ ldr(x6, &after_x);
- __ ldr(w7, &after_w);
- __ ldrsw(x8, &after_sx);
- __ ldr(q18, &after_q);
- __ ldr(d14, &after_d);
- __ ldr(s26, &after_s);
+ __ ldr(x6, &after_x);
+ __ ldr(w7, &after_w);
+ __ ldrsw(x8, &after_sx);
+ __ ldr(q18, &after_q);
+ __ ldr(d14, &after_d);
+ __ ldr(s26, &after_s);
+ }
// Manually generate a pool.
__ B(&end_of_pool_after);
- __ place(&after_x);
- __ place(&after_w);
- __ place(&after_sx);
- __ place(&after_q);
- __ place(&after_d);
- __ place(&after_s);
+ {
+ ExactAssemblyScope scope(&masm, kSizeOfPoolInBytes);
+ __ place(&after_x);
+ __ place(&after_w);
+ __ place(&after_sx);
+ __ place(&after_q);
+ __ place(&after_d);
+ __ place(&after_s);
+ }
__ Bind(&end_of_pool_after);
END();
@@ -7389,15 +7398,18 @@ TEST(ldr_literal_custom) {
TEST(ldr_literal_custom_shared) {
SETUP();
- ALLOW_ASM();
Label end_of_pool_before;
Label end_of_pool_after;
+
+ const size_t kSizeOfPoolInBytes = 40;
+
Literal<uint64_t> before_x(0x1234567890abcdef);
Literal<uint32_t> before_w(0xfedcba09);
Literal<uint64_t> before_q(0x1234000056780000, 0xabcd0000ef000000);
Literal<double> before_d(1.234);
Literal<float> before_s(2.5);
+
Literal<uint64_t> after_x(0x1234567890abcdef);
Literal<uint32_t> after_w(0xfedcba09);
Literal<uint64_t> after_q(0x1234000056780000, 0xabcd0000ef000000);
@@ -7408,15 +7420,19 @@ TEST(ldr_literal_custom_shared) {
// Manually generate a pool.
__ B(&end_of_pool_before);
- __ place(&before_x);
- __ place(&before_w);
- __ place(&before_q);
- __ place(&before_d);
- __ place(&before_s);
+ {
+ ExactAssemblyScope scope(&masm, kSizeOfPoolInBytes);
+ __ place(&before_x);
+ __ place(&before_w);
+ __ place(&before_q);
+ __ place(&before_d);
+ __ place(&before_s);
+ }
__ Bind(&end_of_pool_before);
// Load the entries several times to test that literals can be shared.
for (int i = 0; i < 50; i++) {
+ ExactAssemblyScope scope(&masm, 12 * kInstructionSize);
__ ldr(x2, &before_x);
__ ldr(w3, &before_w);
__ ldrsw(x5, &before_w); // Re-use before_w.
@@ -7434,11 +7450,14 @@ TEST(ldr_literal_custom_shared) {
// Manually generate a pool.
__ B(&end_of_pool_after);
- __ place(&after_x);
- __ place(&after_w);
- __ place(&after_q);
- __ place(&after_d);
- __ place(&after_s);
+ {
+ ExactAssemblyScope scope(&masm, kSizeOfPoolInBytes);
+ __ place(&after_x);
+ __ place(&after_w);
+ __ place(&after_q);
+ __ place(&after_d);
+ __ place(&after_s);
+ }
__ Bind(&end_of_pool_after);
END();
@@ -7542,13 +7561,13 @@ TEST(prfm_regoffset) {
TEST(prfm_literal_imm19) {
SETUP();
- ALLOW_ASM();
START();
for (int i = 0; i < (1 << ImmPrefetchOperation_width); i++) {
// Unallocated prefetch operations are ignored, so test all of them.
PrefetchOperation op = static_cast<PrefetchOperation>(i);
+ ExactAssemblyScope scope(&masm, 7 * kInstructionSize);
// The address used in prfm doesn't have to be valid.
__ prfm(op, INT64_C(0));
__ prfm(op, 1);
@@ -7567,7 +7586,6 @@ TEST(prfm_literal_imm19) {
TEST(prfm_literal) {
SETUP();
- ALLOW_ASM();
Label end_of_pool_before;
Label end_of_pool_after;
@@ -7578,21 +7596,27 @@ TEST(prfm_literal) {
// Manually generate a pool.
__ B(&end_of_pool_before);
- __ place(&before);
+ {
+ ExactAssemblyScope scope(&masm, before.GetSize());
+ __ place(&before);
+ }
__ Bind(&end_of_pool_before);
for (int i = 0; i < (1 << ImmPrefetchOperation_width); i++) {
// Unallocated prefetch operations are ignored, so test all of them.
PrefetchOperation op = static_cast<PrefetchOperation>(i);
- CodeBufferCheckScope guard(&masm, 2 * kInstructionSize);
+ ExactAssemblyScope guard(&masm, 2 * kInstructionSize);
__ prfm(op, &before);
__ prfm(op, &after);
}
// Manually generate a pool.
__ B(&end_of_pool_after);
- __ place(&after);
+ {
+ ExactAssemblyScope scope(&masm, after.GetSize());
+ __ place(&after);
+ }
__ Bind(&end_of_pool_after);
END();
@@ -7627,10 +7651,12 @@ TEST(prfm_wide) {
TEST(load_prfm_literal) {
// Test literals shared between both prfm and ldr.
SETUP();
- ALLOW_ASM();
Label end_of_pool_before;
Label end_of_pool_after;
+
+ const size_t kSizeOfPoolInBytes = 28;
+
Literal<uint64_t> before_x(0x1234567890abcdef);
Literal<uint32_t> before_w(0xfedcba09);
Literal<uint32_t> before_sx(0x80000000);
@@ -7646,16 +7672,20 @@ TEST(load_prfm_literal) {
// Manually generate a pool.
__ B(&end_of_pool_before);
- __ place(&before_x);
- __ place(&before_w);
- __ place(&before_sx);
- __ place(&before_d);
- __ place(&before_s);
+ {
+ ExactAssemblyScope scope(&masm, kSizeOfPoolInBytes);
+ __ place(&before_x);
+ __ place(&before_w);
+ __ place(&before_sx);
+ __ place(&before_d);
+ __ place(&before_s);
+ }
__ Bind(&end_of_pool_before);
for (int i = 0; i < (1 << ImmPrefetchOperation_width); i++) {
// Unallocated prefetch operations are ignored, so test all of them.
PrefetchOperation op = static_cast<PrefetchOperation>(i);
+ ExactAssemblyScope scope(&masm, 10 * kInstructionSize);
__ prfm(op, &before_x);
__ prfm(op, &before_w);
@@ -7670,25 +7700,31 @@ TEST(load_prfm_literal) {
__ prfm(op, &after_s);
}
- __ ldr(x2, &before_x);
- __ ldr(w3, &before_w);
- __ ldrsw(x5, &before_sx);
- __ ldr(d13, &before_d);
- __ ldr(s25, &before_s);
+ {
+ ExactAssemblyScope scope(&masm, 10 * kInstructionSize);
+ __ ldr(x2, &before_x);
+ __ ldr(w3, &before_w);
+ __ ldrsw(x5, &before_sx);
+ __ ldr(d13, &before_d);
+ __ ldr(s25, &before_s);
- __ ldr(x6, &after_x);
- __ ldr(w7, &after_w);
- __ ldrsw(x8, &after_sx);
- __ ldr(d14, &after_d);
- __ ldr(s26, &after_s);
+ __ ldr(x6, &after_x);
+ __ ldr(w7, &after_w);
+ __ ldrsw(x8, &after_sx);
+ __ ldr(d14, &after_d);
+ __ ldr(s26, &after_s);
+ }
// Manually generate a pool.
__ B(&end_of_pool_after);
- __ place(&after_x);
- __ place(&after_w);
- __ place(&after_sx);
- __ place(&after_d);
- __ place(&after_s);
+ {
+ ExactAssemblyScope scope(&masm, kSizeOfPoolInBytes);
+ __ place(&after_x);
+ __ place(&after_w);
+ __ place(&after_sx);
+ __ place(&after_d);
+ __ place(&after_s);
+ }
__ Bind(&end_of_pool_after);
END();
@@ -8957,7 +8993,6 @@ TEST(cmp_extend) {
TEST(ccmp) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(w16, 0);
@@ -8979,11 +9014,17 @@ TEST(ccmp) {
__ Mrs(x3, NZCV);
// The MacroAssembler does not allow al as a condition.
- __ ccmp(x16, x16, NZCVFlag, al);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ ccmp(x16, x16, NZCVFlag, al);
+ }
__ Mrs(x4, NZCV);
// The MacroAssembler does not allow nv as a condition.
- __ ccmp(x16, x16, NZCVFlag, nv);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ ccmp(x16, x16, NZCVFlag, nv);
+ }
__ Mrs(x5, NZCV);
END();
@@ -9070,7 +9111,6 @@ TEST(ccmp_shift_extend) {
TEST(csel_reg) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(x16, 0);
@@ -9084,8 +9124,11 @@ TEST(csel_reg) {
__ Csinc(w3, w24, w25, pl);
// The MacroAssembler does not allow al or nv as a condition.
- __ csel(w13, w24, w25, al);
- __ csel(x14, x24, x25, nv);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ csel(w13, w24, w25, al);
+ __ csel(x14, x24, x25, nv);
+ }
__ Cmp(x16, Operand(1));
__ Csinv(x4, x24, x25, gt);
@@ -9100,8 +9143,11 @@ TEST(csel_reg) {
__ Cneg(x12, x24, ne);
// The MacroAssembler does not allow al or nv as a condition.
- __ csel(w15, w24, w25, al);
- __ csel(x17, x24, x25, nv);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ csel(w15, w24, w25, al);
+ __ csel(x17, x24, x25, nv);
+ }
END();
@@ -9218,7 +9264,6 @@ TEST(csel_mixed) {
TEST(lslv) {
SETUP();
- ALLOW_ASM();
uint64_t value = 0x0123456789abcdef;
int shift[] = {1, 3, 5, 9, 17, 33};
@@ -9233,7 +9278,10 @@ TEST(lslv) {
__ Mov(w6, shift[5]);
// The MacroAssembler does not allow zr as an argument.
- __ lslv(x0, x0, xzr);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ lslv(x0, x0, xzr);
+ }
__ Lsl(x16, x0, x1);
__ Lsl(x17, x0, x2);
@@ -9272,7 +9320,6 @@ TEST(lslv) {
TEST(lsrv) {
SETUP();
- ALLOW_ASM();
uint64_t value = 0x0123456789abcdef;
int shift[] = {1, 3, 5, 9, 17, 33};
@@ -9287,7 +9334,10 @@ TEST(lsrv) {
__ Mov(w6, shift[5]);
// The MacroAssembler does not allow zr as an argument.
- __ lsrv(x0, x0, xzr);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ lsrv(x0, x0, xzr);
+ }
__ Lsr(x16, x0, x1);
__ Lsr(x17, x0, x2);
@@ -9328,7 +9378,6 @@ TEST(lsrv) {
TEST(asrv) {
SETUP();
- ALLOW_ASM();
int64_t value = 0xfedcba98fedcba98;
int shift[] = {1, 3, 5, 9, 17, 33};
@@ -9343,7 +9392,10 @@ TEST(asrv) {
__ Mov(w6, shift[5]);
// The MacroAssembler does not allow zr as an argument.
- __ asrv(x0, x0, xzr);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ asrv(x0, x0, xzr);
+ }
__ Asr(x16, x0, x1);
__ Asr(x17, x0, x2);
@@ -9384,7 +9436,6 @@ TEST(asrv) {
TEST(rorv) {
SETUP();
- ALLOW_ASM();
uint64_t value = 0x0123456789abcdef;
int shift[] = {4, 8, 12, 16, 24, 36};
@@ -9399,7 +9450,10 @@ TEST(rorv) {
__ Mov(w6, shift[5]);
// The MacroAssembler does not allow zr as an argument.
- __ rorv(x0, x0, xzr);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ rorv(x0, x0, xzr);
+ }
__ Ror(x16, x0, x1);
__ Ror(x17, x0, x2);
@@ -9438,7 +9492,6 @@ TEST(rorv) {
TEST(bfm) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(x1, 0x0123456789abcdef);
@@ -9450,7 +9503,6 @@ TEST(bfm) {
__ Mov(w20, 0x88888888);
__ Mov(w21, 0x88888888);
- // There are no macro instruction for bfm.
__ Bfm(x10, x1, 16, 31);
__ Bfm(x11, x1, 32, 15);
@@ -9480,13 +9532,11 @@ TEST(bfm) {
TEST(sbfm) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(x1, 0x0123456789abcdef);
__ Mov(x2, 0xfedcba9876543210);
- // There are no macro instruction for sbfm.
__ Sbfm(x10, x1, 16, 31);
__ Sbfm(x11, x1, 32, 15);
__ Sbfm(x12, x1, 32, 47);
@@ -9544,7 +9594,6 @@ TEST(sbfm) {
TEST(ubfm) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(x1, 0x0123456789abcdef);
@@ -9553,7 +9602,6 @@ TEST(ubfm) {
__ Mov(x10, 0x8888888888888888);
__ Mov(x11, 0x8888888888888888);
- // There are no macro instruction for ubfm.
__ Ubfm(x10, x1, 16, 31);
__ Ubfm(x11, x1, 32, 15);
__ Ubfm(x12, x1, 32, 47);
@@ -10576,7 +10624,6 @@ TEST(fmax_fmin_s) {
TEST(fccmp) {
SETUP();
- ALLOW_ASM();
START();
__ Fmov(s16, 0.0);
@@ -10622,10 +10669,16 @@ TEST(fccmp) {
__ Mrs(x7, NZCV);
// The Macro Assembler does not allow al or nv as condition.
- __ fccmp(s16, s16, NFlag, al);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ fccmp(s16, s16, NFlag, al);
+ }
__ Mrs(x8, NZCV);
- __ fccmp(d18, d18, NFlag, nv);
+ {
+ ExactAssemblyScope scope(&masm, kInstructionSize);
+ __ fccmp(d18, d18, NFlag, nv);
+ }
__ Mrs(x9, NZCV);
__ Cmp(x20, 0);
@@ -10767,7 +10820,6 @@ TEST(fcmp) {
TEST(fcsel) {
SETUP();
- ALLOW_ASM();
START();
__ Mov(x16, 0);
@@ -10782,8 +10834,11 @@ TEST(fcsel) {
__ Fcsel(d2, d18, d19, eq);
__ Fcsel(d3, d18, d19, ne);
// The Macro Assembler does not allow al or nv as condition.
- __ fcsel(s4, s16, s17, al);
- __ fcsel(d5, d18, d19, nv);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ fcsel(s4, s16, s17, al);
+ __ fcsel(d5, d18, d19, nv);
+ }
END();
RUN();
@@ -13168,7 +13223,6 @@ TEST(system_nop) {
TEST(zero_dest) {
SETUP();
- ALLOW_ASM();
RegisterDump before;
START();
@@ -13185,33 +13239,36 @@ TEST(zero_dest) {
// All of these instructions should be NOPs in these forms, but have
// alternate forms which can write into the stack pointer.
- __ add(xzr, x0, x1);
- __ add(xzr, x1, xzr);
- __ add(xzr, xzr, x1);
-
- __ and_(xzr, x0, x2);
- __ and_(xzr, x2, xzr);
- __ and_(xzr, xzr, x2);
-
- __ bic(xzr, x0, x3);
- __ bic(xzr, x3, xzr);
- __ bic(xzr, xzr, x3);
-
- __ eon(xzr, x0, x4);
- __ eon(xzr, x4, xzr);
- __ eon(xzr, xzr, x4);
-
- __ eor(xzr, x0, x5);
- __ eor(xzr, x5, xzr);
- __ eor(xzr, xzr, x5);
-
- __ orr(xzr, x0, x6);
- __ orr(xzr, x6, xzr);
- __ orr(xzr, xzr, x6);
-
- __ sub(xzr, x0, x7);
- __ sub(xzr, x7, xzr);
- __ sub(xzr, xzr, x7);
+ {
+ ExactAssemblyScope scope(&masm, 3 * 7 * kInstructionSize);
+ __ add(xzr, x0, x1);
+ __ add(xzr, x1, xzr);
+ __ add(xzr, xzr, x1);
+
+ __ and_(xzr, x0, x2);
+ __ and_(xzr, x2, xzr);
+ __ and_(xzr, xzr, x2);
+
+ __ bic(xzr, x0, x3);
+ __ bic(xzr, x3, xzr);
+ __ bic(xzr, xzr, x3);
+
+ __ eon(xzr, x0, x4);
+ __ eon(xzr, x4, xzr);
+ __ eon(xzr, xzr, x4);
+
+ __ eor(xzr, x0, x5);
+ __ eor(xzr, x5, xzr);
+ __ eor(xzr, xzr, x5);
+
+ __ orr(xzr, x0, x6);
+ __ orr(xzr, x6, xzr);
+ __ orr(xzr, xzr, x6);
+
+ __ sub(xzr, x0, x7);
+ __ sub(xzr, x7, xzr);
+ __ sub(xzr, xzr, x7);
+ }
// Swap the saved stack pointer with the real one. If sp was written
// during the test, it will show up in x30. This is done because the test
@@ -13235,7 +13292,6 @@ TEST(zero_dest) {
TEST(zero_dest_setflags) {
SETUP();
- ALLOW_ASM();
RegisterDump before;
START();
@@ -13252,31 +13308,43 @@ TEST(zero_dest_setflags) {
// All of these instructions should only write to the flags in these forms,
// but have alternate forms which can write into the stack pointer.
- __ adds(xzr, x0, Operand(x1, UXTX));
- __ adds(xzr, x1, Operand(xzr, UXTX));
- __ adds(xzr, x1, 1234);
- __ adds(xzr, x0, x1);
- __ adds(xzr, x1, xzr);
- __ adds(xzr, xzr, x1);
-
- __ ands(xzr, x2, ~0xf);
- __ ands(xzr, xzr, ~0xf);
- __ ands(xzr, x0, x2);
- __ ands(xzr, x2, xzr);
- __ ands(xzr, xzr, x2);
-
- __ bics(xzr, x3, ~0xf);
- __ bics(xzr, xzr, ~0xf);
- __ bics(xzr, x0, x3);
- __ bics(xzr, x3, xzr);
- __ bics(xzr, xzr, x3);
-
- __ subs(xzr, x0, Operand(x3, UXTX));
- __ subs(xzr, x3, Operand(xzr, UXTX));
- __ subs(xzr, x3, 1234);
- __ subs(xzr, x0, x3);
- __ subs(xzr, x3, xzr);
- __ subs(xzr, xzr, x3);
+ {
+ ExactAssemblyScope scope(&masm, 6 * kInstructionSize);
+ __ adds(xzr, x0, Operand(x1, UXTX));
+ __ adds(xzr, x1, Operand(xzr, UXTX));
+ __ adds(xzr, x1, 1234);
+ __ adds(xzr, x0, x1);
+ __ adds(xzr, x1, xzr);
+ __ adds(xzr, xzr, x1);
+ }
+
+ {
+ ExactAssemblyScope scope(&masm, 5 * kInstructionSize);
+ __ ands(xzr, x2, ~0xf);
+ __ ands(xzr, xzr, ~0xf);
+ __ ands(xzr, x0, x2);
+ __ ands(xzr, x2, xzr);
+ __ ands(xzr, xzr, x2);
+ }
+
+ {
+ ExactAssemblyScope scope(&masm, 5 * kInstructionSize);
+ __ bics(xzr, x3, ~0xf);
+ __ bics(xzr, xzr, ~0xf);
+ __ bics(xzr, x0, x3);
+ __ bics(xzr, x3, xzr);
+ __ bics(xzr, xzr, x3);
+ }
+
+ {
+ ExactAssemblyScope scope(&masm, 6 * kInstructionSize);
+ __ subs(xzr, x0, Operand(x3, UXTX));
+ __ subs(xzr, x3, Operand(xzr, UXTX));
+ __ subs(xzr, x3, 1234);
+ __ subs(xzr, x0, x3);
+ __ subs(xzr, x3, xzr);
+ __ subs(xzr, xzr, x3);
+ }
// Swap the saved stack pointer with the real one. If sp was written
// during the test, it will show up in x30. This is done because the test
@@ -16340,7 +16408,6 @@ TEST(load_store_tagged_immediate_offset) {
memset(dst, 0, kMaxDataLength);
SETUP();
- ALLOW_ASM();
START();
__ Mov(x0, src_tagged);
@@ -16349,94 +16416,160 @@ TEST(load_store_tagged_immediate_offset) {
int offset = 0;
// Scaled-immediate offsets.
- __ ldp(q0, q1, MemOperand(x0, offset));
- __ stp(q0, q1, MemOperand(x1, offset));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(q0, q1, MemOperand(x0, offset));
+ __ stp(q0, q1, MemOperand(x1, offset));
+ }
offset += 2 * kQRegSizeInBytes;
- __ ldp(x2, x3, MemOperand(x0, offset));
- __ stp(x2, x3, MemOperand(x1, offset));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(x2, x3, MemOperand(x0, offset));
+ __ stp(x2, x3, MemOperand(x1, offset));
+ }
offset += 2 * kXRegSizeInBytes;
- __ ldpsw(x2, x3, MemOperand(x0, offset));
- __ stp(w2, w3, MemOperand(x1, offset));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldpsw(x2, x3, MemOperand(x0, offset));
+ __ stp(w2, w3, MemOperand(x1, offset));
+ }
offset += 2 * kWRegSizeInBytes;
- __ ldp(d0, d1, MemOperand(x0, offset));
- __ stp(d0, d1, MemOperand(x1, offset));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(d0, d1, MemOperand(x0, offset));
+ __ stp(d0, d1, MemOperand(x1, offset));
+ }
offset += 2 * kDRegSizeInBytes;
- __ ldp(w2, w3, MemOperand(x0, offset));
- __ stp(w2, w3, MemOperand(x1, offset));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(w2, w3, MemOperand(x0, offset));
+ __ stp(w2, w3, MemOperand(x1, offset));
+ }
offset += 2 * kWRegSizeInBytes;
- __ ldp(s0, s1, MemOperand(x0, offset));
- __ stp(s0, s1, MemOperand(x1, offset));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(s0, s1, MemOperand(x0, offset));
+ __ stp(s0, s1, MemOperand(x1, offset));
+ }
offset += 2 * kSRegSizeInBytes;
- __ ldr(x2, MemOperand(x0, offset), RequireScaledOffset);
- __ str(x2, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(x2, MemOperand(x0, offset), RequireScaledOffset);
+ __ str(x2, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += kXRegSizeInBytes;
- __ ldr(d0, MemOperand(x0, offset), RequireScaledOffset);
- __ str(d0, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(d0, MemOperand(x0, offset), RequireScaledOffset);
+ __ str(d0, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += kDRegSizeInBytes;
- __ ldr(w2, MemOperand(x0, offset), RequireScaledOffset);
- __ str(w2, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(w2, MemOperand(x0, offset), RequireScaledOffset);
+ __ str(w2, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += kWRegSizeInBytes;
- __ ldr(s0, MemOperand(x0, offset), RequireScaledOffset);
- __ str(s0, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(s0, MemOperand(x0, offset), RequireScaledOffset);
+ __ str(s0, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += kSRegSizeInBytes;
- __ ldrh(w2, MemOperand(x0, offset), RequireScaledOffset);
- __ strh(w2, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrh(w2, MemOperand(x0, offset), RequireScaledOffset);
+ __ strh(w2, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += 2;
- __ ldrsh(w2, MemOperand(x0, offset), RequireScaledOffset);
- __ strh(w2, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsh(w2, MemOperand(x0, offset), RequireScaledOffset);
+ __ strh(w2, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += 2;
- __ ldrb(w2, MemOperand(x0, offset), RequireScaledOffset);
- __ strb(w2, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrb(w2, MemOperand(x0, offset), RequireScaledOffset);
+ __ strb(w2, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += 1;
- __ ldrsb(w2, MemOperand(x0, offset), RequireScaledOffset);
- __ strb(w2, MemOperand(x1, offset), RequireScaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsb(w2, MemOperand(x0, offset), RequireScaledOffset);
+ __ strb(w2, MemOperand(x1, offset), RequireScaledOffset);
+ }
offset += 1;
// Unscaled-immediate offsets.
- __ ldur(x2, MemOperand(x0, offset), RequireUnscaledOffset);
- __ stur(x2, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldur(x2, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ stur(x2, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += kXRegSizeInBytes;
- __ ldur(d0, MemOperand(x0, offset), RequireUnscaledOffset);
- __ stur(d0, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldur(d0, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ stur(d0, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += kDRegSizeInBytes;
- __ ldur(w2, MemOperand(x0, offset), RequireUnscaledOffset);
- __ stur(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldur(w2, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ stur(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += kWRegSizeInBytes;
- __ ldur(s0, MemOperand(x0, offset), RequireUnscaledOffset);
- __ stur(s0, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldur(s0, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ stur(s0, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += kSRegSizeInBytes;
- __ ldurh(w2, MemOperand(x0, offset), RequireUnscaledOffset);
- __ sturh(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldurh(w2, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ sturh(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += 2;
- __ ldursh(w2, MemOperand(x0, offset), RequireUnscaledOffset);
- __ sturh(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldursh(w2, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ sturh(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += 2;
- __ ldurb(w2, MemOperand(x0, offset), RequireUnscaledOffset);
- __ sturb(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldurb(w2, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ sturb(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += 1;
- __ ldursb(w2, MemOperand(x0, offset), RequireUnscaledOffset);
- __ sturb(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldursb(w2, MemOperand(x0, offset), RequireUnscaledOffset);
+ __ sturb(w2, MemOperand(x1, offset), RequireUnscaledOffset);
+ }
offset += 1;
// Extract the tag (so we can test that it was preserved correctly).
@@ -16488,7 +16621,6 @@ TEST(load_store_tagged_immediate_preindex) {
}
SETUP();
- ALLOW_ASM();
START();
// Each MemOperand must apply a pre-index equal to the size of the
@@ -16501,73 +16633,115 @@ TEST(load_store_tagged_immediate_preindex) {
__ Mov(x0, src_tagged - preindex);
__ Mov(x1, dst_tagged - preindex);
- __ ldp(q0, q1, MemOperand(x0, preindex, PreIndex));
- __ stp(q0, q1, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(q0, q1, MemOperand(x0, preindex, PreIndex));
+ __ stp(q0, q1, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2 * kQRegSizeInBytes;
data_length = preindex;
- __ ldp(x2, x3, MemOperand(x0, preindex, PreIndex));
- __ stp(x2, x3, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(x2, x3, MemOperand(x0, preindex, PreIndex));
+ __ stp(x2, x3, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2 * kXRegSizeInBytes;
data_length += preindex;
- __ ldpsw(x2, x3, MemOperand(x0, preindex, PreIndex));
- __ stp(w2, w3, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldpsw(x2, x3, MemOperand(x0, preindex, PreIndex));
+ __ stp(w2, w3, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2 * kWRegSizeInBytes;
data_length += preindex;
- __ ldp(d0, d1, MemOperand(x0, preindex, PreIndex));
- __ stp(d0, d1, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(d0, d1, MemOperand(x0, preindex, PreIndex));
+ __ stp(d0, d1, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2 * kDRegSizeInBytes;
data_length += preindex;
- __ ldp(w2, w3, MemOperand(x0, preindex, PreIndex));
- __ stp(w2, w3, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(w2, w3, MemOperand(x0, preindex, PreIndex));
+ __ stp(w2, w3, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2 * kWRegSizeInBytes;
data_length += preindex;
- __ ldp(s0, s1, MemOperand(x0, preindex, PreIndex));
- __ stp(s0, s1, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(s0, s1, MemOperand(x0, preindex, PreIndex));
+ __ stp(s0, s1, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2 * kSRegSizeInBytes;
data_length += preindex;
- __ ldr(x2, MemOperand(x0, preindex, PreIndex));
- __ str(x2, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(x2, MemOperand(x0, preindex, PreIndex));
+ __ str(x2, MemOperand(x1, preindex, PreIndex));
+ }
preindex = kXRegSizeInBytes;
data_length += preindex;
- __ ldr(d0, MemOperand(x0, preindex, PreIndex));
- __ str(d0, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(d0, MemOperand(x0, preindex, PreIndex));
+ __ str(d0, MemOperand(x1, preindex, PreIndex));
+ }
preindex = kDRegSizeInBytes;
data_length += preindex;
- __ ldr(w2, MemOperand(x0, preindex, PreIndex));
- __ str(w2, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(w2, MemOperand(x0, preindex, PreIndex));
+ __ str(w2, MemOperand(x1, preindex, PreIndex));
+ }
preindex = kWRegSizeInBytes;
data_length += preindex;
- __ ldr(s0, MemOperand(x0, preindex, PreIndex));
- __ str(s0, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(s0, MemOperand(x0, preindex, PreIndex));
+ __ str(s0, MemOperand(x1, preindex, PreIndex));
+ }
preindex = kSRegSizeInBytes;
data_length += preindex;
- __ ldrh(w2, MemOperand(x0, preindex, PreIndex));
- __ strh(w2, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrh(w2, MemOperand(x0, preindex, PreIndex));
+ __ strh(w2, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2;
data_length += preindex;
- __ ldrsh(w2, MemOperand(x0, preindex, PreIndex));
- __ strh(w2, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsh(w2, MemOperand(x0, preindex, PreIndex));
+ __ strh(w2, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 2;
data_length += preindex;
- __ ldrb(w2, MemOperand(x0, preindex, PreIndex));
- __ strb(w2, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrb(w2, MemOperand(x0, preindex, PreIndex));
+ __ strb(w2, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 1;
data_length += preindex;
- __ ldrsb(w2, MemOperand(x0, preindex, PreIndex));
- __ strb(w2, MemOperand(x1, preindex, PreIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsb(w2, MemOperand(x0, preindex, PreIndex));
+ __ strb(w2, MemOperand(x1, preindex, PreIndex));
+ }
preindex = 1;
data_length += preindex;
@@ -16618,7 +16792,6 @@ TEST(load_store_tagged_immediate_postindex) {
}
SETUP();
- ALLOW_ASM();
START();
int postindex = 2 * kXRegSizeInBytes;
@@ -16627,73 +16800,115 @@ TEST(load_store_tagged_immediate_postindex) {
__ Mov(x0, src_tagged);
__ Mov(x1, dst_tagged);
- __ ldp(x2, x3, MemOperand(x0, postindex, PostIndex));
- __ stp(x2, x3, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(x2, x3, MemOperand(x0, postindex, PostIndex));
+ __ stp(x2, x3, MemOperand(x1, postindex, PostIndex));
+ }
data_length = postindex;
postindex = 2 * kQRegSizeInBytes;
- __ ldp(q0, q1, MemOperand(x0, postindex, PostIndex));
- __ stp(q0, q1, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(q0, q1, MemOperand(x0, postindex, PostIndex));
+ __ stp(q0, q1, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 2 * kWRegSizeInBytes;
- __ ldpsw(x2, x3, MemOperand(x0, postindex, PostIndex));
- __ stp(w2, w3, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldpsw(x2, x3, MemOperand(x0, postindex, PostIndex));
+ __ stp(w2, w3, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 2 * kDRegSizeInBytes;
- __ ldp(d0, d1, MemOperand(x0, postindex, PostIndex));
- __ stp(d0, d1, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(d0, d1, MemOperand(x0, postindex, PostIndex));
+ __ stp(d0, d1, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 2 * kWRegSizeInBytes;
- __ ldp(w2, w3, MemOperand(x0, postindex, PostIndex));
- __ stp(w2, w3, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(w2, w3, MemOperand(x0, postindex, PostIndex));
+ __ stp(w2, w3, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 2 * kSRegSizeInBytes;
- __ ldp(s0, s1, MemOperand(x0, postindex, PostIndex));
- __ stp(s0, s1, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldp(s0, s1, MemOperand(x0, postindex, PostIndex));
+ __ stp(s0, s1, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = kXRegSizeInBytes;
- __ ldr(x2, MemOperand(x0, postindex, PostIndex));
- __ str(x2, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(x2, MemOperand(x0, postindex, PostIndex));
+ __ str(x2, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = kDRegSizeInBytes;
- __ ldr(d0, MemOperand(x0, postindex, PostIndex));
- __ str(d0, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(d0, MemOperand(x0, postindex, PostIndex));
+ __ str(d0, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = kWRegSizeInBytes;
- __ ldr(w2, MemOperand(x0, postindex, PostIndex));
- __ str(w2, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(w2, MemOperand(x0, postindex, PostIndex));
+ __ str(w2, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = kSRegSizeInBytes;
- __ ldr(s0, MemOperand(x0, postindex, PostIndex));
- __ str(s0, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(s0, MemOperand(x0, postindex, PostIndex));
+ __ str(s0, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 2;
- __ ldrh(w2, MemOperand(x0, postindex, PostIndex));
- __ strh(w2, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrh(w2, MemOperand(x0, postindex, PostIndex));
+ __ strh(w2, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 2;
- __ ldrsh(w2, MemOperand(x0, postindex, PostIndex));
- __ strh(w2, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsh(w2, MemOperand(x0, postindex, PostIndex));
+ __ strh(w2, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 1;
- __ ldrb(w2, MemOperand(x0, postindex, PostIndex));
- __ strb(w2, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrb(w2, MemOperand(x0, postindex, PostIndex));
+ __ strb(w2, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
postindex = 1;
- __ ldrsb(w2, MemOperand(x0, postindex, PostIndex));
- __ strb(w2, MemOperand(x1, postindex, PostIndex));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsb(w2, MemOperand(x0, postindex, PostIndex));
+ __ strb(w2, MemOperand(x1, postindex, PostIndex));
+ }
data_length += postindex;
VIXL_ASSERT(kMaxDataLength >= data_length);
@@ -16748,50 +16963,73 @@ TEST(load_store_tagged_register_offset) {
}
SETUP();
- ALLOW_ASM();
START();
__ Mov(x0, src_tagged);
__ Mov(x1, dst_tagged);
__ Mov(x10, offset_base + data_length);
- __ ldr(x2, MemOperand(x0, x10));
- __ str(x2, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(x2, MemOperand(x0, x10));
+ __ str(x2, MemOperand(x1, x10));
+ }
data_length += kXRegSizeInBytes;
__ Mov(x10, offset_base + data_length);
- __ ldr(d0, MemOperand(x0, x10));
- __ str(d0, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(d0, MemOperand(x0, x10));
+ __ str(d0, MemOperand(x1, x10));
+ }
data_length += kDRegSizeInBytes;
__ Mov(x10, offset_base + data_length);
- __ ldr(w2, MemOperand(x0, x10));
- __ str(w2, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(w2, MemOperand(x0, x10));
+ __ str(w2, MemOperand(x1, x10));
+ }
data_length += kWRegSizeInBytes;
__ Mov(x10, offset_base + data_length);
- __ ldr(s0, MemOperand(x0, x10));
- __ str(s0, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldr(s0, MemOperand(x0, x10));
+ __ str(s0, MemOperand(x1, x10));
+ }
data_length += kSRegSizeInBytes;
__ Mov(x10, offset_base + data_length);
- __ ldrh(w2, MemOperand(x0, x10));
- __ strh(w2, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrh(w2, MemOperand(x0, x10));
+ __ strh(w2, MemOperand(x1, x10));
+ }
data_length += 2;
__ Mov(x10, offset_base + data_length);
- __ ldrsh(w2, MemOperand(x0, x10));
- __ strh(w2, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsh(w2, MemOperand(x0, x10));
+ __ strh(w2, MemOperand(x1, x10));
+ }
data_length += 2;
__ Mov(x10, offset_base + data_length);
- __ ldrb(w2, MemOperand(x0, x10));
- __ strb(w2, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrb(w2, MemOperand(x0, x10));
+ __ strb(w2, MemOperand(x1, x10));
+ }
data_length += 1;
__ Mov(x10, offset_base + data_length);
- __ ldrsb(w2, MemOperand(x0, x10));
- __ strb(w2, MemOperand(x1, x10));
+ {
+ ExactAssemblyScope scope(&masm, 2 * kInstructionSize);
+ __ ldrsb(w2, MemOperand(x0, x10));
+ __ strb(w2, MemOperand(x1, x10));
+ }
data_length += 1;
VIXL_ASSERT(kMaxDataLength >= data_length);
@@ -22617,10 +22855,7 @@ TEST(ldr_literal_explicit) {
Literal<int64_t> automatically_placed_literal(1, masm.GetLiteralPool());
Literal<int64_t> manually_placed_literal(2);
{
- CodeBufferCheckScope scope(&masm,
- kInstructionSize + sizeof(int64_t),
- CodeBufferCheckScope::kReserveBufferSpace,
- CodeBufferCheckScope::kExactSize);
+ ExactAssemblyScope scope(&masm, kInstructionSize + sizeof(int64_t));
Label over_literal;
__ b(&over_literal);
__ place(&manually_placed_literal);
diff --git a/test/aarch64/test-disasm-aarch64.cc b/test/aarch64/test-disasm-aarch64.cc
index 438b8aae..824eb1e9 100644
--- a/test/aarch64/test-disasm-aarch64.cc
+++ b/test/aarch64/test-disasm-aarch64.cc
@@ -36,24 +36,22 @@
#define TEST(name) TEST_(AARCH64_DISASM_##name)
-#define SETUP_CLASS(ASMCLASS) \
- uint32_t encoding = 0; \
- ASMCLASS masm; \
- Decoder decoder; \
- Disassembler disasm; \
+#define SETUP_COMMON() \
+ uint32_t encoding = 0; \
+ MacroAssembler masm; \
+ Decoder decoder; \
+ Disassembler disasm; \
decoder.AppendVisitor(&disasm)
-#define SETUP() SETUP_CLASS(Assembler)
-
#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
// Run tests with the simulator.
-#define SETUP_MACRO() \
- SETUP_CLASS(MacroAssembler); \
+#define SETUP() \
+ SETUP_COMMON(); \
masm.SetGenerateSimulatorCode(true)
#else // ifdef VIXL_INCLUDE_SIMULATOR_AARCH64.
-#define SETUP_MACRO() \
- SETUP_CLASS(MacroAssembler); \
+#define SETUP() \
+ SETUP_COMMON(); \
masm.SetGenerateSimulatorCode(false)
#endif // ifdef VIXL_INCLUDE_SIMULATOR_AARCH64.
@@ -65,7 +63,9 @@
#define COMPARE(ASM, EXP) \
masm.Reset(); \
{ \
- CodeBufferCheckScope guard(&masm, MAX_SIZE_GENERATED); \
+ ExactAssemblyScope guard(&masm, \
+ MAX_SIZE_GENERATED, \
+ ExactAssemblyScope::kMaximumSize); \
masm.ASM; \
} \
masm.FinalizeCode(); \
@@ -85,7 +85,9 @@
#define COMPARE_PREFIX(ASM, EXP) \
masm.Reset(); \
{ \
- CodeBufferCheckScope guard(&masm, MAX_SIZE_GENERATED); \
+ ExactAssemblyScope guard(&masm, \
+ MAX_SIZE_GENERATED, \
+ ExactAssemblyScope::kMaximumSize); \
masm.ASM; \
} \
masm.FinalizeCode(); \
@@ -178,25 +180,25 @@ TEST(bootstrap) {
TEST(mov_mvn) {
- SETUP_MACRO();
-
- COMPARE(Mov(w0, Operand(0x1234)), "mov w0, #0x1234");
- COMPARE(Mov(x1, Operand(0x1234)), "mov x1, #0x1234");
- COMPARE(Mov(w2, Operand(w3)), "mov w2, w3");
- COMPARE(Mov(x4, Operand(x5)), "mov x4, x5");
- COMPARE(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5");
- COMPARE(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42");
- COMPARE(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11");
- COMPARE(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8");
- COMPARE(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16");
- COMPARE(Mov(x16, Operand(x17, SXTW, 3)), "sbfiz x16, x17, #3, #32");
-
- COMPARE(Mvn(w0, Operand(0x101)), "mov w0, #0xfffffefe");
- COMPARE(Mvn(x1, Operand(0xfff1)), "mov x1, #0xffffffffffff000e");
- COMPARE(Mvn(w2, Operand(w3)), "mvn w2, w3");
- COMPARE(Mvn(x4, Operand(x5)), "mvn x4, x5");
- COMPARE(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12");
- COMPARE(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63");
+ SETUP();
+
+ COMPARE_MACRO(Mov(w0, Operand(0x1234)), "mov w0, #0x1234");
+ COMPARE_MACRO(Mov(x1, Operand(0x1234)), "mov x1, #0x1234");
+ COMPARE_MACRO(Mov(w2, Operand(w3)), "mov w2, w3");
+ COMPARE_MACRO(Mov(x4, Operand(x5)), "mov x4, x5");
+ COMPARE_MACRO(Mov(w6, Operand(w7, LSL, 5)), "lsl w6, w7, #5");
+ COMPARE_MACRO(Mov(x8, Operand(x9, ASR, 42)), "asr x8, x9, #42");
+ COMPARE_MACRO(Mov(w10, Operand(w11, UXTB)), "uxtb w10, w11");
+ COMPARE_MACRO(Mov(x12, Operand(x13, UXTB, 1)), "ubfiz x12, x13, #1, #8");
+ COMPARE_MACRO(Mov(w14, Operand(w15, SXTH, 2)), "sbfiz w14, w15, #2, #16");
+ COMPARE_MACRO(Mov(x16, Operand(x17, SXTW, 3)), "sbfiz x16, x17, #3, #32");
+
+ COMPARE_MACRO(Mvn(w0, Operand(0x101)), "mov w0, #0xfffffefe");
+ COMPARE_MACRO(Mvn(x1, Operand(0xfff1)), "mov x1, #0xffffffffffff000e");
+ COMPARE_MACRO(Mvn(w2, Operand(w3)), "mvn w2, w3");
+ COMPARE_MACRO(Mvn(x4, Operand(x5)), "mvn x4, x5");
+ COMPARE_MACRO(Mvn(w6, Operand(w7, LSL, 12)), "mvn w6, w7, lsl #12");
+ COMPARE_MACRO(Mvn(x8, Operand(x9, ASR, 63)), "mvn x8, x9, asr #63");
CLEANUP();
}
@@ -244,56 +246,56 @@ TEST(move_immediate) {
TEST(move_immediate_2) {
- SETUP_MACRO();
+ SETUP();
// Move instructions expected for certain immediates. This is really a macro
// assembler test, to ensure it generates immediates efficiently.
- COMPARE(Mov(w0, 0), "mov w0, #0x0");
- COMPARE(Mov(w0, 0x0000ffff), "mov w0, #0xffff");
- COMPARE(Mov(w0, 0x00010000), "mov w0, #0x10000");
- COMPARE(Mov(w0, 0xffff0000), "mov w0, #0xffff0000");
- COMPARE(Mov(w0, 0x0001ffff), "mov w0, #0x1ffff");
- COMPARE(Mov(w0, 0xffff8000), "mov w0, #0xffff8000");
- COMPARE(Mov(w0, 0xfffffffe), "mov w0, #0xfffffffe");
- COMPARE(Mov(w0, 0xffffffff), "mov w0, #0xffffffff");
- COMPARE(Mov(w0, 0x00ffff00), "mov w0, #0xffff00");
- COMPARE(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff");
- COMPARE(Mov(w0, 0xfffeffff), "mov w0, #0xfffeffff");
- COMPARE(Mov(w0, 0xffff7fff), "mov w0, #0xffff7fff");
-
- COMPARE(Mov(x0, 0), "mov x0, #0x0");
- COMPARE(Mov(x0, 0x0000ffff), "mov x0, #0xffff");
- COMPARE(Mov(x0, 0x00010000), "mov x0, #0x10000");
- COMPARE(Mov(x0, 0xffff0000), "mov x0, #0xffff0000");
- COMPARE(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff");
- COMPARE(Mov(x0, 0xffff8000), "mov x0, #0xffff8000");
- COMPARE(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe");
- COMPARE(Mov(x0, 0xffffffff), "mov x0, #0xffffffff");
- COMPARE(Mov(x0, 0x00ffff00), "mov x0, #0xffff00");
- COMPARE(Mov(x0, 0xffff000000000000), "mov x0, #0xffff000000000000");
- COMPARE(Mov(x0, 0x0000ffff00000000), "mov x0, #0xffff00000000");
- COMPARE(Mov(x0, 0x00000000ffff0000), "mov x0, #0xffff0000");
- COMPARE(Mov(x0, 0xffffffffffff0000), "mov x0, #0xffffffffffff0000");
- COMPARE(Mov(x0, 0xffffffff0000ffff), "mov x0, #0xffffffff0000ffff");
- COMPARE(Mov(x0, 0xffff0000ffffffff), "mov x0, #0xffff0000ffffffff");
- COMPARE(Mov(x0, 0x0000ffffffffffff), "mov x0, #0xffffffffffff");
- COMPARE(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff");
- COMPARE(Mov(x0, 0xfffeffffffffffff), "mov x0, #0xfffeffffffffffff");
- COMPARE(Mov(x0, 0xffff7fffffffffff), "mov x0, #0xffff7fffffffffff");
- COMPARE(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff");
- COMPARE(Mov(x0, 0xfffffffeffffffff), "mov x0, #0xfffffffeffffffff");
- COMPARE(Mov(x0, 0xffffffff7fffffff), "mov x0, #0xffffffff7fffffff");
- COMPARE(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff");
- COMPARE(Mov(x0, 0xfffffffffffeffff), "mov x0, #0xfffffffffffeffff");
- COMPARE(Mov(x0, 0xffffffffffff7fff), "mov x0, #0xffffffffffff7fff");
- COMPARE(Mov(x0, 0xffffffffffffffff), "mov x0, #0xffffffffffffffff");
-
- COMPARE(Movk(w0, 0x1234, 0), "movk w0, #0x1234");
- COMPARE(Movk(x1, 0x2345, 0), "movk x1, #0x2345");
- COMPARE(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16");
- COMPARE(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16");
- COMPARE(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32");
- COMPARE(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48");
+ COMPARE_MACRO(Mov(w0, 0), "mov w0, #0x0");
+ COMPARE_MACRO(Mov(w0, 0x0000ffff), "mov w0, #0xffff");
+ COMPARE_MACRO(Mov(w0, 0x00010000), "mov w0, #0x10000");
+ COMPARE_MACRO(Mov(w0, 0xffff0000), "mov w0, #0xffff0000");
+ COMPARE_MACRO(Mov(w0, 0x0001ffff), "mov w0, #0x1ffff");
+ COMPARE_MACRO(Mov(w0, 0xffff8000), "mov w0, #0xffff8000");
+ COMPARE_MACRO(Mov(w0, 0xfffffffe), "mov w0, #0xfffffffe");
+ COMPARE_MACRO(Mov(w0, 0xffffffff), "mov w0, #0xffffffff");
+ COMPARE_MACRO(Mov(w0, 0x00ffff00), "mov w0, #0xffff00");
+ COMPARE_MACRO(Mov(w0, 0xfffe7fff), "mov w0, #0xfffe7fff");
+ COMPARE_MACRO(Mov(w0, 0xfffeffff), "mov w0, #0xfffeffff");
+ COMPARE_MACRO(Mov(w0, 0xffff7fff), "mov w0, #0xffff7fff");
+
+ COMPARE_MACRO(Mov(x0, 0), "mov x0, #0x0");
+ COMPARE_MACRO(Mov(x0, 0x0000ffff), "mov x0, #0xffff");
+ COMPARE_MACRO(Mov(x0, 0x00010000), "mov x0, #0x10000");
+ COMPARE_MACRO(Mov(x0, 0xffff0000), "mov x0, #0xffff0000");
+ COMPARE_MACRO(Mov(x0, 0x0001ffff), "mov x0, #0x1ffff");
+ COMPARE_MACRO(Mov(x0, 0xffff8000), "mov x0, #0xffff8000");
+ COMPARE_MACRO(Mov(x0, 0xfffffffe), "mov x0, #0xfffffffe");
+ COMPARE_MACRO(Mov(x0, 0xffffffff), "mov x0, #0xffffffff");
+ COMPARE_MACRO(Mov(x0, 0x00ffff00), "mov x0, #0xffff00");
+ COMPARE_MACRO(Mov(x0, 0xffff000000000000), "mov x0, #0xffff000000000000");
+ COMPARE_MACRO(Mov(x0, 0x0000ffff00000000), "mov x0, #0xffff00000000");
+ COMPARE_MACRO(Mov(x0, 0x00000000ffff0000), "mov x0, #0xffff0000");
+ COMPARE_MACRO(Mov(x0, 0xffffffffffff0000), "mov x0, #0xffffffffffff0000");
+ COMPARE_MACRO(Mov(x0, 0xffffffff0000ffff), "mov x0, #0xffffffff0000ffff");
+ COMPARE_MACRO(Mov(x0, 0xffff0000ffffffff), "mov x0, #0xffff0000ffffffff");
+ COMPARE_MACRO(Mov(x0, 0x0000ffffffffffff), "mov x0, #0xffffffffffff");
+ COMPARE_MACRO(Mov(x0, 0xfffe7fffffffffff), "mov x0, #0xfffe7fffffffffff");
+ COMPARE_MACRO(Mov(x0, 0xfffeffffffffffff), "mov x0, #0xfffeffffffffffff");
+ COMPARE_MACRO(Mov(x0, 0xffff7fffffffffff), "mov x0, #0xffff7fffffffffff");
+ COMPARE_MACRO(Mov(x0, 0xfffffffe7fffffff), "mov x0, #0xfffffffe7fffffff");
+ COMPARE_MACRO(Mov(x0, 0xfffffffeffffffff), "mov x0, #0xfffffffeffffffff");
+ COMPARE_MACRO(Mov(x0, 0xffffffff7fffffff), "mov x0, #0xffffffff7fffffff");
+ COMPARE_MACRO(Mov(x0, 0xfffffffffffe7fff), "mov x0, #0xfffffffffffe7fff");
+ COMPARE_MACRO(Mov(x0, 0xfffffffffffeffff), "mov x0, #0xfffffffffffeffff");
+ COMPARE_MACRO(Mov(x0, 0xffffffffffff7fff), "mov x0, #0xffffffffffff7fff");
+ COMPARE_MACRO(Mov(x0, 0xffffffffffffffff), "mov x0, #0xffffffffffffffff");
+
+ COMPARE_MACRO(Movk(w0, 0x1234, 0), "movk w0, #0x1234");
+ COMPARE_MACRO(Movk(x1, 0x2345, 0), "movk x1, #0x2345");
+ COMPARE_MACRO(Movk(w2, 0x3456, 16), "movk w2, #0x3456, lsl #16");
+ COMPARE_MACRO(Movk(x3, 0x4567, 16), "movk x3, #0x4567, lsl #16");
+ COMPARE_MACRO(Movk(x4, 0x5678, 32), "movk x4, #0x5678, lsl #32");
+ COMPARE_MACRO(Movk(x5, 0x6789, 48), "movk x5, #0x6789, lsl #48");
CLEANUP();
}
@@ -1883,18 +1885,18 @@ TEST(load_store_pair_nontemp) {
TEST(load_literal_macro) {
- SETUP_MACRO();
+ SETUP();
// In each case, the literal will be placed at PC+8:
// ldr x10, pc+8 // Test instruction.
// ldr xzr, pc+12 // Pool marker.
// .word64 #0x1234567890abcdef // Test literal.
- COMPARE_PREFIX(Ldr(x10, 0x1234567890abcdef), "ldr x10, pc+8");
- COMPARE_PREFIX(Ldr(w20, 0xfedcba09), "ldr w20, pc+8");
- COMPARE_PREFIX(Ldr(d11, 1.234), "ldr d11, pc+8");
- COMPARE_PREFIX(Ldr(s22, 2.5f), "ldr s22, pc+8");
- COMPARE_PREFIX(Ldrsw(x21, 0x80000000), "ldrsw x21, pc+8");
+ COMPARE_MACRO_PREFIX(Ldr(x10, 0x1234567890abcdef), "ldr x10, pc+8");
+ COMPARE_MACRO_PREFIX(Ldr(w20, 0xfedcba09), "ldr w20, pc+8");
+ COMPARE_MACRO_PREFIX(Ldr(d11, 1.234), "ldr d11, pc+8");
+ COMPARE_MACRO_PREFIX(Ldr(s22, 2.5f), "ldr s22, pc+8");
+ COMPARE_MACRO_PREFIX(Ldrsw(x21, 0x80000000), "ldrsw x21, pc+8");
CLEANUP();
}
@@ -2180,7 +2182,7 @@ TEST(cond_select) {
TEST(cond_select_macro) {
- SETUP_MACRO();
+ SETUP();
// In the tests below we also test the `GetCselSynthesisInformation()` helper.
// These tests are here (rather than in test-assembler-aarch64.cc) because the
@@ -2188,7 +2190,7 @@ TEST(cond_select_macro) {
bool synthesises_left = false;
bool synthesises_right = false;
- COMPARE(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq");
+ COMPARE_MACRO(Csel(w0, w1, -1, eq), "csinv w0, w1, wzr, eq");
MacroAssembler::GetCselSynthesisInformation(w0,
w1,
-1,
@@ -2196,7 +2198,7 @@ TEST(cond_select_macro) {
&synthesises_right);
VIXL_CHECK(!synthesises_left && !synthesises_right);
- COMPARE(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne");
+ COMPARE_MACRO(Csel(w2, w3, 0, ne), "csel w2, w3, wzr, ne");
MacroAssembler::GetCselSynthesisInformation(w2,
w3,
wzr,
@@ -2204,7 +2206,7 @@ TEST(cond_select_macro) {
&synthesises_right);
VIXL_CHECK(!synthesises_left && !synthesises_right);
- COMPARE(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs");
+ COMPARE_MACRO(Csel(w4, w5, 1, hs), "csinc w4, w5, wzr, hs");
MacroAssembler::GetCselSynthesisInformation(w4,
w5,
1,
@@ -2212,7 +2214,7 @@ TEST(cond_select_macro) {
&synthesises_right);
VIXL_CHECK(!synthesises_left && !synthesises_right);
- COMPARE(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo");
+ COMPARE_MACRO(Csel(x6, x7, -1, lo), "csinv x6, x7, xzr, lo");
MacroAssembler::GetCselSynthesisInformation(x6,
x7,
xzr,
@@ -2220,7 +2222,7 @@ TEST(cond_select_macro) {
&synthesises_right);
VIXL_CHECK(!synthesises_left && !synthesises_right);
- COMPARE(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi");
+ COMPARE_MACRO(Csel(x8, x9, 0, mi), "csel x8, x9, xzr, mi");
MacroAssembler::GetCselSynthesisInformation(x8,
x9,
xzr,
@@ -2228,7 +2230,7 @@ TEST(cond_select_macro) {
&synthesises_right);
VIXL_CHECK(!synthesises_left && !synthesises_right);
- COMPARE(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl");
+ COMPARE_MACRO(Csel(x10, x11, 1, pl), "csinc x10, x11, xzr, pl");
MacroAssembler::GetCselSynthesisInformation(x10,
x11,
xzr,
@@ -2485,12 +2487,12 @@ TEST(cond_cmp) {
TEST(cond_cmp_macro) {
- SETUP_MACRO();
+ SETUP();
- COMPARE(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi");
- COMPARE(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge");
- COMPARE(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt");
- COMPARE(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls");
+ COMPARE_MACRO(Ccmp(w0, -1, VFlag, hi), "ccmn w0, #1, #nzcV, hi");
+ COMPARE_MACRO(Ccmp(x1, -31, CFlag, ge), "ccmn x1, #31, #nzCv, ge");
+ COMPARE_MACRO(Ccmn(w2, -1, CVFlag, gt), "ccmp w2, #1, #nzCV, gt");
+ COMPARE_MACRO(Ccmn(x3, -31, ZCVFlag, ls), "ccmp x3, #31, #nZCV, ls");
CLEANUP();
}
@@ -2850,13 +2852,13 @@ TEST(system_nop) {
TEST(unreachable) {
- SETUP_MACRO();
+ SETUP();
#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
VIXL_ASSERT(kUnreachableOpcode == 0xdeb0);
- COMPARE(Unreachable(), "hlt #0xdeb0");
+ COMPARE_MACRO(Unreachable(), "hlt #0xdeb0");
#else
- COMPARE(Unreachable(), "blr xzr");
+ COMPARE_MACRO(Unreachable(), "blr xzr");
#endif
CLEANUP();
@@ -2865,7 +2867,7 @@ TEST(unreachable) {
#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
TEST(trace) {
- SETUP_MACRO();
+ SETUP();
VIXL_ASSERT(kTraceOpcode == 0xdeb2);
@@ -2880,7 +2882,7 @@ TEST(trace) {
#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64
TEST(log) {
- SETUP_MACRO();
+ SETUP();
VIXL_ASSERT(kLogOpcode == 0xdeb3);
@@ -2927,130 +2929,131 @@ TEST(svc) {
TEST(add_sub_negative) {
- SETUP_MACRO();
+ SETUP();
- COMPARE(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)");
- COMPARE(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)");
- COMPARE(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)");
+ COMPARE_MACRO(Add(x10, x0, -42), "sub x10, x0, #0x2a (42)");
+ COMPARE_MACRO(Add(x11, x1, -687), "sub x11, x1, #0x2af (687)");
+ COMPARE_MACRO(Add(x12, x2, -0x88), "sub x12, x2, #0x88 (136)");
- COMPARE(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)");
- COMPARE(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)");
- COMPARE(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)");
+ COMPARE_MACRO(Sub(x13, x0, -600), "add x13, x0, #0x258 (600)");
+ COMPARE_MACRO(Sub(x14, x1, -313), "add x14, x1, #0x139 (313)");
+ COMPARE_MACRO(Sub(x15, x2, -0x555), "add x15, x2, #0x555 (1365)");
- COMPARE(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)");
- COMPARE(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)");
+ COMPARE_MACRO(Add(w19, w3, -0x344), "sub w19, w3, #0x344 (836)");
+ COMPARE_MACRO(Add(w20, w4, -2000), "sub w20, w4, #0x7d0 (2000)");
- COMPARE(Add(w0, w1, 5, LeaveFlags), "add w0, w1, #0x5 (5)");
- COMPARE(Add(w1, w2, 15, SetFlags), "adds w1, w2, #0xf (15)");
+ COMPARE_MACRO(Add(w0, w1, 5, LeaveFlags), "add w0, w1, #0x5 (5)");
+ COMPARE_MACRO(Add(w1, w2, 15, SetFlags), "adds w1, w2, #0xf (15)");
- COMPARE(Sub(w0, w1, 5, LeaveFlags), "sub w0, w1, #0x5 (5)");
- COMPARE(Sub(w1, w2, 15, SetFlags), "subs w1, w2, #0xf (15)");
+ COMPARE_MACRO(Sub(w0, w1, 5, LeaveFlags), "sub w0, w1, #0x5 (5)");
+ COMPARE_MACRO(Sub(w1, w2, 15, SetFlags), "subs w1, w2, #0xf (15)");
- COMPARE(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)");
- COMPARE(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)");
+ COMPARE_MACRO(Sub(w21, w3, -0xbc), "add w21, w3, #0xbc (188)");
+ COMPARE_MACRO(Sub(w22, w4, -2000), "add w22, w4, #0x7d0 (2000)");
- COMPARE(Cmp(w0, -1), "cmn w0, #0x1 (1)");
- COMPARE(Cmp(x1, -1), "cmn x1, #0x1 (1)");
- COMPARE(Cmp(w2, -4095), "cmn w2, #0xfff (4095)");
- COMPARE(Cmp(x3, -4095), "cmn x3, #0xfff (4095)");
+ COMPARE_MACRO(Cmp(w0, -1), "cmn w0, #0x1 (1)");
+ COMPARE_MACRO(Cmp(x1, -1), "cmn x1, #0x1 (1)");
+ COMPARE_MACRO(Cmp(w2, -4095), "cmn w2, #0xfff (4095)");
+ COMPARE_MACRO(Cmp(x3, -4095), "cmn x3, #0xfff (4095)");
- COMPARE(Cmn(w0, -1), "cmp w0, #0x1 (1)");
- COMPARE(Cmn(x1, -1), "cmp x1, #0x1 (1)");
- COMPARE(Cmn(w2, -4095), "cmp w2, #0xfff (4095)");
- COMPARE(Cmn(x3, -4095), "cmp x3, #0xfff (4095)");
+ COMPARE_MACRO(Cmn(w0, -1), "cmp w0, #0x1 (1)");
+ COMPARE_MACRO(Cmn(x1, -1), "cmp x1, #0x1 (1)");
+ COMPARE_MACRO(Cmn(w2, -4095), "cmp w2, #0xfff (4095)");
+ COMPARE_MACRO(Cmn(x3, -4095), "cmp x3, #0xfff (4095)");
CLEANUP();
}
TEST(logical_immediate_move) {
- SETUP_MACRO();
-
- COMPARE(And(w0, w1, 0), "mov w0, #0x0");
- COMPARE(And(x0, x1, 0), "mov x0, #0x0");
- COMPARE(Orr(w2, w3, 0), "mov w2, w3");
- COMPARE(Orr(x2, x3, 0), "mov x2, x3");
- COMPARE(Eor(w4, w5, 0), "mov w4, w5");
- COMPARE(Eor(x4, x5, 0), "mov x4, x5");
- COMPARE(Bic(w6, w7, 0), "mov w6, w7");
- COMPARE(Bic(x6, x7, 0), "mov x6, x7");
- COMPARE(Orn(w8, w9, 0), "mov w8, #0xffffffff");
- COMPARE(Orn(x8, x9, 0), "mov x8, #0xffffffffffffffff");
- COMPARE(Eon(w10, w11, 0), "mvn w10, w11");
- COMPARE(Eon(x10, x11, 0), "mvn x10, x11");
-
- COMPARE(And(w12, w13, 0xffffffff), "mov w12, w13");
- COMPARE(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff");
- COMPARE(And(x12, x13, 0xffffffffffffffff), "mov x12, x13");
- COMPARE(Orr(w14, w15, 0xffffffff), "mov w14, #0xffffffff");
- COMPARE(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff");
- COMPARE(Orr(x14, x15, 0xffffffffffffffff), "mov x14, #0xffffffffffffffff");
- COMPARE(Eor(w16, w17, 0xffffffff), "mvn w16, w17");
- COMPARE(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff");
- COMPARE(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17");
- COMPARE(Bic(w18, w19, 0xffffffff), "mov w18, #0x0");
- COMPARE(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000");
- COMPARE(Bic(x18, x19, 0xffffffffffffffff), "mov x18, #0x0");
- COMPARE(Orn(w20, w21, 0xffffffff), "mov w20, w21");
- COMPARE(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000");
- COMPARE(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21");
- COMPARE(Eon(w22, w23, 0xffffffff), "mov w22, w23");
- COMPARE(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000");
- COMPARE(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23");
+ SETUP();
+
+ COMPARE_MACRO(And(w0, w1, 0), "mov w0, #0x0");
+ COMPARE_MACRO(And(x0, x1, 0), "mov x0, #0x0");
+ COMPARE_MACRO(Orr(w2, w3, 0), "mov w2, w3");
+ COMPARE_MACRO(Orr(x2, x3, 0), "mov x2, x3");
+ COMPARE_MACRO(Eor(w4, w5, 0), "mov w4, w5");
+ COMPARE_MACRO(Eor(x4, x5, 0), "mov x4, x5");
+ COMPARE_MACRO(Bic(w6, w7, 0), "mov w6, w7");
+ COMPARE_MACRO(Bic(x6, x7, 0), "mov x6, x7");
+ COMPARE_MACRO(Orn(w8, w9, 0), "mov w8, #0xffffffff");
+ COMPARE_MACRO(Orn(x8, x9, 0), "mov x8, #0xffffffffffffffff");
+ COMPARE_MACRO(Eon(w10, w11, 0), "mvn w10, w11");
+ COMPARE_MACRO(Eon(x10, x11, 0), "mvn x10, x11");
+
+ COMPARE_MACRO(And(w12, w13, 0xffffffff), "mov w12, w13");
+ COMPARE_MACRO(And(x12, x13, 0xffffffff), "and x12, x13, #0xffffffff");
+ COMPARE_MACRO(And(x12, x13, 0xffffffffffffffff), "mov x12, x13");
+ COMPARE_MACRO(Orr(w14, w15, 0xffffffff), "mov w14, #0xffffffff");
+ COMPARE_MACRO(Orr(x14, x15, 0xffffffff), "orr x14, x15, #0xffffffff");
+ COMPARE_MACRO(Orr(x14, x15, 0xffffffffffffffff),
+ "mov x14, #0xffffffffffffffff");
+ COMPARE_MACRO(Eor(w16, w17, 0xffffffff), "mvn w16, w17");
+ COMPARE_MACRO(Eor(x16, x17, 0xffffffff), "eor x16, x17, #0xffffffff");
+ COMPARE_MACRO(Eor(x16, x17, 0xffffffffffffffff), "mvn x16, x17");
+ COMPARE_MACRO(Bic(w18, w19, 0xffffffff), "mov w18, #0x0");
+ COMPARE_MACRO(Bic(x18, x19, 0xffffffff), "and x18, x19, #0xffffffff00000000");
+ COMPARE_MACRO(Bic(x18, x19, 0xffffffffffffffff), "mov x18, #0x0");
+ COMPARE_MACRO(Orn(w20, w21, 0xffffffff), "mov w20, w21");
+ COMPARE_MACRO(Orn(x20, x21, 0xffffffff), "orr x20, x21, #0xffffffff00000000");
+ COMPARE_MACRO(Orn(x20, x21, 0xffffffffffffffff), "mov x20, x21");
+ COMPARE_MACRO(Eon(w22, w23, 0xffffffff), "mov w22, w23");
+ COMPARE_MACRO(Eon(x22, x23, 0xffffffff), "eor x22, x23, #0xffffffff00000000");
+ COMPARE_MACRO(Eon(x22, x23, 0xffffffffffffffff), "mov x22, x23");
CLEANUP();
}
TEST(barriers) {
- SETUP_MACRO();
+ SETUP();
// DMB
- COMPARE(Dmb(FullSystem, BarrierAll), "dmb sy");
- COMPARE(Dmb(FullSystem, BarrierReads), "dmb ld");
- COMPARE(Dmb(FullSystem, BarrierWrites), "dmb st");
+ COMPARE_MACRO(Dmb(FullSystem, BarrierAll), "dmb sy");
+ COMPARE_MACRO(Dmb(FullSystem, BarrierReads), "dmb ld");
+ COMPARE_MACRO(Dmb(FullSystem, BarrierWrites), "dmb st");
- COMPARE(Dmb(InnerShareable, BarrierAll), "dmb ish");
- COMPARE(Dmb(InnerShareable, BarrierReads), "dmb ishld");
- COMPARE(Dmb(InnerShareable, BarrierWrites), "dmb ishst");
+ COMPARE_MACRO(Dmb(InnerShareable, BarrierAll), "dmb ish");
+ COMPARE_MACRO(Dmb(InnerShareable, BarrierReads), "dmb ishld");
+ COMPARE_MACRO(Dmb(InnerShareable, BarrierWrites), "dmb ishst");
- COMPARE(Dmb(NonShareable, BarrierAll), "dmb nsh");
- COMPARE(Dmb(NonShareable, BarrierReads), "dmb nshld");
- COMPARE(Dmb(NonShareable, BarrierWrites), "dmb nshst");
+ COMPARE_MACRO(Dmb(NonShareable, BarrierAll), "dmb nsh");
+ COMPARE_MACRO(Dmb(NonShareable, BarrierReads), "dmb nshld");
+ COMPARE_MACRO(Dmb(NonShareable, BarrierWrites), "dmb nshst");
- COMPARE(Dmb(OuterShareable, BarrierAll), "dmb osh");
- COMPARE(Dmb(OuterShareable, BarrierReads), "dmb oshld");
- COMPARE(Dmb(OuterShareable, BarrierWrites), "dmb oshst");
+ COMPARE_MACRO(Dmb(OuterShareable, BarrierAll), "dmb osh");
+ COMPARE_MACRO(Dmb(OuterShareable, BarrierReads), "dmb oshld");
+ COMPARE_MACRO(Dmb(OuterShareable, BarrierWrites), "dmb oshst");
- COMPARE(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)");
- COMPARE(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)");
- COMPARE(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)");
- COMPARE(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)");
+ COMPARE_MACRO(Dmb(FullSystem, BarrierOther), "dmb sy (0b1100)");
+ COMPARE_MACRO(Dmb(InnerShareable, BarrierOther), "dmb sy (0b1000)");
+ COMPARE_MACRO(Dmb(NonShareable, BarrierOther), "dmb sy (0b0100)");
+ COMPARE_MACRO(Dmb(OuterShareable, BarrierOther), "dmb sy (0b0000)");
// DSB
- COMPARE(Dsb(FullSystem, BarrierAll), "dsb sy");
- COMPARE(Dsb(FullSystem, BarrierReads), "dsb ld");
- COMPARE(Dsb(FullSystem, BarrierWrites), "dsb st");
+ COMPARE_MACRO(Dsb(FullSystem, BarrierAll), "dsb sy");
+ COMPARE_MACRO(Dsb(FullSystem, BarrierReads), "dsb ld");
+ COMPARE_MACRO(Dsb(FullSystem, BarrierWrites), "dsb st");
- COMPARE(Dsb(InnerShareable, BarrierAll), "dsb ish");
- COMPARE(Dsb(InnerShareable, BarrierReads), "dsb ishld");
- COMPARE(Dsb(InnerShareable, BarrierWrites), "dsb ishst");
+ COMPARE_MACRO(Dsb(InnerShareable, BarrierAll), "dsb ish");
+ COMPARE_MACRO(Dsb(InnerShareable, BarrierReads), "dsb ishld");
+ COMPARE_MACRO(Dsb(InnerShareable, BarrierWrites), "dsb ishst");
- COMPARE(Dsb(NonShareable, BarrierAll), "dsb nsh");
- COMPARE(Dsb(NonShareable, BarrierReads), "dsb nshld");
- COMPARE(Dsb(NonShareable, BarrierWrites), "dsb nshst");
+ COMPARE_MACRO(Dsb(NonShareable, BarrierAll), "dsb nsh");
+ COMPARE_MACRO(Dsb(NonShareable, BarrierReads), "dsb nshld");
+ COMPARE_MACRO(Dsb(NonShareable, BarrierWrites), "dsb nshst");
- COMPARE(Dsb(OuterShareable, BarrierAll), "dsb osh");
- COMPARE(Dsb(OuterShareable, BarrierReads), "dsb oshld");
- COMPARE(Dsb(OuterShareable, BarrierWrites), "dsb oshst");
+ COMPARE_MACRO(Dsb(OuterShareable, BarrierAll), "dsb osh");
+ COMPARE_MACRO(Dsb(OuterShareable, BarrierReads), "dsb oshld");
+ COMPARE_MACRO(Dsb(OuterShareable, BarrierWrites), "dsb oshst");
- COMPARE(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)");
- COMPARE(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)");
- COMPARE(Dsb(NonShareable, BarrierOther), "dsb sy (0b0100)");
- COMPARE(Dsb(OuterShareable, BarrierOther), "dsb sy (0b0000)");
+ COMPARE_MACRO(Dsb(FullSystem, BarrierOther), "dsb sy (0b1100)");
+ COMPARE_MACRO(Dsb(InnerShareable, BarrierOther), "dsb sy (0b1000)");
+ COMPARE_MACRO(Dsb(NonShareable, BarrierOther), "dsb sy (0b0100)");
+ COMPARE_MACRO(Dsb(OuterShareable, BarrierOther), "dsb sy (0b0000)");
// ISB
- COMPARE(Isb(), "isb");
+ COMPARE_MACRO(Isb(), "isb");
CLEANUP();
}
@@ -3106,212 +3109,242 @@ TEST(barriers) {
V(V4S(), "4s")
TEST(neon_load_store_vector) {
- SETUP_MACRO();
-
-#define DISASM_INST(M, S) \
- COMPARE(Ld1(v0.M, MemOperand(x15)), "ld1 {v0." S "}, [x15]"); \
- COMPARE(Ld1(v1.M, v2.M, MemOperand(x16)), \
- "ld1 {v1." S ", v2." S "}, [x16]"); \
- COMPARE(Ld1(v3.M, v4.M, v5.M, MemOperand(x17)), \
- "ld1 {v3." S ", v4." S ", v5." S "}, [x17]"); \
- COMPARE(Ld1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18)), \
- "ld1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18]") \
- COMPARE(Ld1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
- "ld1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \
- COMPARE(Ld2(v1.M, v2.M, MemOperand(x16)), \
- "ld2 {v1." S ", v2." S "}, [x16]"); \
- COMPARE(Ld3(v3.M, v4.M, v5.M, MemOperand(x17)), \
- "ld3 {v3." S ", v4." S ", v5." S "}, [x17]"); \
- COMPARE(Ld4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18)), \
- "ld4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18]") \
- COMPARE(Ld4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
- "ld4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \
+ SETUP();
+
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Ld1(v0.M, MemOperand(x15)), "ld1 {v0." S "}, [x15]"); \
+ COMPARE_MACRO(Ld1(v1.M, v2.M, MemOperand(x16)), \
+ "ld1 {v1." S ", v2." S "}, [x16]"); \
+ COMPARE_MACRO(Ld1(v3.M, v4.M, v5.M, MemOperand(x17)), \
+ "ld1 {v3." S ", v4." S ", v5." S "}, [x17]"); \
+ COMPARE_MACRO(Ld1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18)), \
+ "ld1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18]") \
+ COMPARE_MACRO(Ld1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
+ "ld1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \
+ COMPARE_MACRO(Ld2(v1.M, v2.M, MemOperand(x16)), \
+ "ld2 {v1." S ", v2." S "}, [x16]"); \
+ COMPARE_MACRO(Ld3(v3.M, v4.M, v5.M, MemOperand(x17)), \
+ "ld3 {v3." S ", v4." S ", v5." S "}, [x17]"); \
+ COMPARE_MACRO(Ld4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18)), \
+ "ld4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18]") \
+ COMPARE_MACRO(Ld4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
+ "ld4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \
NEON_FORMAT_LIST(DISASM_INST);
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Ld1(v0.M, MemOperand(x15, x20, PostIndex)), \
- "ld1 {v0." S "}, [x15], x20"); \
- COMPARE(Ld1(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
- "ld1 {v1." S ", v2." S "}, [x16], x21"); \
- COMPARE(Ld1(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
- "ld1 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
- COMPARE(Ld1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
- "ld1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
- COMPARE(Ld1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
- "ld1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \
- COMPARE(Ld2(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
- "ld2 {v1." S ", v2." S "}, [x16], x21"); \
- COMPARE(Ld3(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
- "ld3 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
- COMPARE(Ld4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
- "ld4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
- COMPARE(Ld4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
- "ld4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Ld1(v0.M, MemOperand(x15, x20, PostIndex)), \
+ "ld1 {v0." S "}, [x15], x20"); \
+ COMPARE_MACRO(Ld1(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
+ "ld1 {v1." S ", v2." S "}, [x16], x21"); \
+ COMPARE_MACRO(Ld1(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
+ "ld1 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
+ COMPARE_MACRO(Ld1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
+ "ld1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
+ COMPARE_MACRO(Ld1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
+ "ld1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \
+ COMPARE_MACRO(Ld2(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
+ "ld2 {v1." S ", v2." S "}, [x16], x21"); \
+ COMPARE_MACRO(Ld3(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
+ "ld3 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
+ COMPARE_MACRO(Ld4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
+ "ld4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
+ COMPARE_MACRO(Ld4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
+ "ld4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \
NEON_FORMAT_LIST(DISASM_INST);
#undef DISASM_INST
- COMPARE(Ld1(v0.V8B(), MemOperand(x15, 8, PostIndex)),
- "ld1 {v0.8b}, [x15], #8");
- COMPARE(Ld1(v1.V16B(), MemOperand(x16, 16, PostIndex)),
- "ld1 {v1.16b}, [x16], #16");
- COMPARE(Ld1(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
- "ld1 {v2.4h, v3.4h}, [x17], #16");
- COMPARE(Ld1(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
- "ld1 {v4.8h, v5.8h}, [x18], #32");
- COMPARE(Ld1(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)),
- "ld1 {v16.2s, v17.2s, v18.2s}, [x19], #24");
- COMPARE(Ld1(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)),
- "ld1 {v16.4s, v17.4s, v18.4s}, [x19], #48");
- COMPARE(Ld1(v19.V2S(),
- v20.V2S(),
- v21.V2S(),
- v22.V2S(),
- MemOperand(x20, 32, PostIndex)),
- "ld1 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
- COMPARE(Ld1(v23.V2D(),
- v24.V2D(),
- v25.V2D(),
- v26.V2D(),
- MemOperand(x21, 64, PostIndex)),
- "ld1 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
-
- COMPARE(Ld2(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
- "ld2 {v2.4h, v3.4h}, [x17], #16");
- COMPARE(Ld2(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
- "ld2 {v4.8h, v5.8h}, [x18], #32");
- COMPARE(Ld3(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)),
- "ld3 {v16.2s, v17.2s, v18.2s}, [x19], #24");
- COMPARE(Ld3(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)),
- "ld3 {v16.4s, v17.4s, v18.4s}, [x19], #48");
- COMPARE(Ld4(v19.V2S(),
- v20.V2S(),
- v21.V2S(),
- v22.V2S(),
- MemOperand(x20, 32, PostIndex)),
- "ld4 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
- COMPARE(Ld4(v23.V2D(),
- v24.V2D(),
- v25.V2D(),
- v26.V2D(),
- MemOperand(x21, 64, PostIndex)),
- "ld4 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
-
- COMPARE(Ld1(v0.V1D(), MemOperand(x16)), "ld1 {v0.1d}, [x16]");
- COMPARE(Ld1(v1.V1D(), v2.V1D(), MemOperand(x17, 16, PostIndex)),
- "ld1 {v1.1d, v2.1d}, [x17], #16");
- COMPARE(Ld1(v3.V1D(), v4.V1D(), v5.V1D(), MemOperand(x18, x19, PostIndex)),
- "ld1 {v3.1d, v4.1d, v5.1d}, [x18], x19");
- COMPARE(Ld1(v30.V1D(),
- v31.V1D(),
- v0.V1D(),
- v1.V1D(),
- MemOperand(x20, 32, PostIndex)),
- "ld1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x20], #32");
- COMPARE(Ld1(d30, d31, d0, d1, MemOperand(x21, x22, PostIndex)),
- "ld1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x21], x22");
-
-#define DISASM_INST(M, S) \
- COMPARE(St1(v20.M, MemOperand(x15)), "st1 {v20." S "}, [x15]"); \
- COMPARE(St1(v21.M, v22.M, MemOperand(x16)), \
- "st1 {v21." S ", v22." S "}, [x16]"); \
- COMPARE(St1(v23.M, v24.M, v25.M, MemOperand(x17)), \
- "st1 {v23." S ", v24." S ", v25." S "}, [x17]"); \
- COMPARE(St1(v26.M, v27.M, v28.M, v29.M, MemOperand(x18)), \
- "st1 {v26." S ", v27." S ", v28." S ", v29." S "}, [x18]") \
- COMPARE(St1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
- "st1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \
- COMPARE(St2(VLIST2(v21.M), MemOperand(x16)), \
- "st2 {v21." S ", v22." S "}, [x16]"); \
- COMPARE(St3(v23.M, v24.M, v25.M, MemOperand(x17)), \
- "st3 {v23." S ", v24." S ", v25." S "}, [x17]"); \
- COMPARE(St4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
- "st4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]")
+ COMPARE_MACRO(Ld1(v0.V8B(), MemOperand(x15, 8, PostIndex)),
+ "ld1 {v0.8b}, [x15], #8");
+ COMPARE_MACRO(Ld1(v1.V16B(), MemOperand(x16, 16, PostIndex)),
+ "ld1 {v1.16b}, [x16], #16");
+ COMPARE_MACRO(Ld1(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
+ "ld1 {v2.4h, v3.4h}, [x17], #16");
+ COMPARE_MACRO(Ld1(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
+ "ld1 {v4.8h, v5.8h}, [x18], #32");
+ COMPARE_MACRO(Ld1(v16.V2S(),
+ v17.V2S(),
+ v18.V2S(),
+ MemOperand(x19, 24, PostIndex)),
+ "ld1 {v16.2s, v17.2s, v18.2s}, [x19], #24");
+ COMPARE_MACRO(Ld1(v16.V4S(),
+ v17.V4S(),
+ v18.V4S(),
+ MemOperand(x19, 48, PostIndex)),
+ "ld1 {v16.4s, v17.4s, v18.4s}, [x19], #48");
+ COMPARE_MACRO(Ld1(v19.V2S(),
+ v20.V2S(),
+ v21.V2S(),
+ v22.V2S(),
+ MemOperand(x20, 32, PostIndex)),
+ "ld1 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
+ COMPARE_MACRO(Ld1(v23.V2D(),
+ v24.V2D(),
+ v25.V2D(),
+ v26.V2D(),
+ MemOperand(x21, 64, PostIndex)),
+ "ld1 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
+
+ COMPARE_MACRO(Ld2(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
+ "ld2 {v2.4h, v3.4h}, [x17], #16");
+ COMPARE_MACRO(Ld2(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
+ "ld2 {v4.8h, v5.8h}, [x18], #32");
+ COMPARE_MACRO(Ld3(v16.V2S(),
+ v17.V2S(),
+ v18.V2S(),
+ MemOperand(x19, 24, PostIndex)),
+ "ld3 {v16.2s, v17.2s, v18.2s}, [x19], #24");
+ COMPARE_MACRO(Ld3(v16.V4S(),
+ v17.V4S(),
+ v18.V4S(),
+ MemOperand(x19, 48, PostIndex)),
+ "ld3 {v16.4s, v17.4s, v18.4s}, [x19], #48");
+ COMPARE_MACRO(Ld4(v19.V2S(),
+ v20.V2S(),
+ v21.V2S(),
+ v22.V2S(),
+ MemOperand(x20, 32, PostIndex)),
+ "ld4 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
+ COMPARE_MACRO(Ld4(v23.V2D(),
+ v24.V2D(),
+ v25.V2D(),
+ v26.V2D(),
+ MemOperand(x21, 64, PostIndex)),
+ "ld4 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
+
+ COMPARE_MACRO(Ld1(v0.V1D(), MemOperand(x16)), "ld1 {v0.1d}, [x16]");
+ COMPARE_MACRO(Ld1(v1.V1D(), v2.V1D(), MemOperand(x17, 16, PostIndex)),
+ "ld1 {v1.1d, v2.1d}, [x17], #16");
+ COMPARE_MACRO(Ld1(v3.V1D(),
+ v4.V1D(),
+ v5.V1D(),
+ MemOperand(x18, x19, PostIndex)),
+ "ld1 {v3.1d, v4.1d, v5.1d}, [x18], x19");
+ COMPARE_MACRO(Ld1(v30.V1D(),
+ v31.V1D(),
+ v0.V1D(),
+ v1.V1D(),
+ MemOperand(x20, 32, PostIndex)),
+ "ld1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x20], #32");
+ COMPARE_MACRO(Ld1(d30, d31, d0, d1, MemOperand(x21, x22, PostIndex)),
+ "ld1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x21], x22");
+
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(St1(v20.M, MemOperand(x15)), "st1 {v20." S "}, [x15]"); \
+ COMPARE_MACRO(St1(v21.M, v22.M, MemOperand(x16)), \
+ "st1 {v21." S ", v22." S "}, [x16]"); \
+ COMPARE_MACRO(St1(v23.M, v24.M, v25.M, MemOperand(x17)), \
+ "st1 {v23." S ", v24." S ", v25." S "}, [x17]"); \
+ COMPARE_MACRO(St1(v26.M, v27.M, v28.M, v29.M, MemOperand(x18)), \
+ "st1 {v26." S ", v27." S ", v28." S ", v29." S "}, [x18]") \
+ COMPARE_MACRO(St1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
+ "st1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]") \
+ COMPARE_MACRO(St2(VLIST2(v21.M), MemOperand(x16)), \
+ "st2 {v21." S ", v22." S "}, [x16]"); \
+ COMPARE_MACRO(St3(v23.M, v24.M, v25.M, MemOperand(x17)), \
+ "st3 {v23." S ", v24." S ", v25." S "}, [x17]"); \
+ COMPARE_MACRO(St4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp)), \
+ "st4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp]")
NEON_FORMAT_LIST(DISASM_INST);
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(St1(v0.M, MemOperand(x15, x20, PostIndex)), \
- "st1 {v0." S "}, [x15], x20"); \
- COMPARE(St1(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
- "st1 {v1." S ", v2." S "}, [x16], x21"); \
- COMPARE(St1(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
- "st1 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
- COMPARE(St1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
- "st1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
- COMPARE(St1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
- "st1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \
- COMPARE(St2(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
- "st2 {v1." S ", v2." S "}, [x16], x21"); \
- COMPARE(St3(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
- "st3 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
- COMPARE(St4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
- "st4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
- COMPARE(St4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
- "st4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24")
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(St1(v0.M, MemOperand(x15, x20, PostIndex)), \
+ "st1 {v0." S "}, [x15], x20"); \
+ COMPARE_MACRO(St1(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
+ "st1 {v1." S ", v2." S "}, [x16], x21"); \
+ COMPARE_MACRO(St1(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
+ "st1 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
+ COMPARE_MACRO(St1(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
+ "st1 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
+ COMPARE_MACRO(St1(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
+ "st1 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24") \
+ COMPARE_MACRO(St2(v1.M, v2.M, MemOperand(x16, x21, PostIndex)), \
+ "st2 {v1." S ", v2." S "}, [x16], x21"); \
+ COMPARE_MACRO(St3(v3.M, v4.M, v5.M, MemOperand(x17, x22, PostIndex)), \
+ "st3 {v3." S ", v4." S ", v5." S "}, [x17], x22"); \
+ COMPARE_MACRO(St4(v6.M, v7.M, v8.M, v9.M, MemOperand(x18, x23, PostIndex)), \
+ "st4 {v6." S ", v7." S ", v8." S ", v9." S "}, [x18], x23") \
+ COMPARE_MACRO(St4(v30.M, v31.M, v0.M, v1.M, MemOperand(sp, x24, PostIndex)), \
+ "st4 {v30." S ", v31." S ", v0." S ", v1." S "}, [sp], x24")
NEON_FORMAT_LIST(DISASM_INST);
#undef DISASM_INST
- COMPARE(St1(v0.V8B(), MemOperand(x15, 8, PostIndex)),
- "st1 {v0.8b}, [x15], #8");
- COMPARE(St1(v1.V16B(), MemOperand(x16, 16, PostIndex)),
- "st1 {v1.16b}, [x16], #16");
- COMPARE(St1(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
- "st1 {v2.4h, v3.4h}, [x17], #16");
- COMPARE(St1(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
- "st1 {v4.8h, v5.8h}, [x18], #32");
- COMPARE(St1(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)),
- "st1 {v16.2s, v17.2s, v18.2s}, [x19], #24");
- COMPARE(St1(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)),
- "st1 {v16.4s, v17.4s, v18.4s}, [x19], #48");
- COMPARE(St1(v19.V2S(),
- v20.V2S(),
- v21.V2S(),
- v22.V2S(),
- MemOperand(x20, 32, PostIndex)),
- "st1 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
- COMPARE(St1(v23.V2D(),
- v24.V2D(),
- v25.V2D(),
- v26.V2D(),
- MemOperand(x21, 64, PostIndex)),
- "st1 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
- COMPARE(St2(v1.V16B(), v2.V16B(), MemOperand(x16, 32, PostIndex)),
- "st2 {v1.16b, v2.16b}, [x16], #32");
- COMPARE(St2(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
- "st2 {v2.4h, v3.4h}, [x17], #16");
- COMPARE(St2(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
- "st2 {v4.8h, v5.8h}, [x18], #32");
- COMPARE(St3(v16.V2S(), v17.V2S(), v18.V2S(), MemOperand(x19, 24, PostIndex)),
- "st3 {v16.2s, v17.2s, v18.2s}, [x19], #24");
- COMPARE(St3(v16.V4S(), v17.V4S(), v18.V4S(), MemOperand(x19, 48, PostIndex)),
- "st3 {v16.4s, v17.4s, v18.4s}, [x19], #48");
- COMPARE(St4(v19.V2S(),
- v20.V2S(),
- v21.V2S(),
- v22.V2S(),
- MemOperand(x20, 32, PostIndex)),
- "st4 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
- COMPARE(St4(v23.V2D(),
- v24.V2D(),
- v25.V2D(),
- v26.V2D(),
- MemOperand(x21, 64, PostIndex)),
- "st4 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
-
- COMPARE(St1(v0.V1D(), MemOperand(x16)), "st1 {v0.1d}, [x16]");
- COMPARE(St1(v1.V1D(), v2.V1D(), MemOperand(x17, 16, PostIndex)),
- "st1 {v1.1d, v2.1d}, [x17], #16");
- COMPARE(St1(v3.V1D(), v4.V1D(), v5.V1D(), MemOperand(x18, x19, PostIndex)),
- "st1 {v3.1d, v4.1d, v5.1d}, [x18], x19");
- COMPARE(St1(v30.V1D(),
- v31.V1D(),
- v0.V1D(),
- v1.V1D(),
- MemOperand(x20, 32, PostIndex)),
- "st1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x20], #32");
- COMPARE(St1(d30, d31, d0, d1, MemOperand(x21, x22, PostIndex)),
- "st1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x21], x22");
+ COMPARE_MACRO(St1(v0.V8B(), MemOperand(x15, 8, PostIndex)),
+ "st1 {v0.8b}, [x15], #8");
+ COMPARE_MACRO(St1(v1.V16B(), MemOperand(x16, 16, PostIndex)),
+ "st1 {v1.16b}, [x16], #16");
+ COMPARE_MACRO(St1(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
+ "st1 {v2.4h, v3.4h}, [x17], #16");
+ COMPARE_MACRO(St1(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
+ "st1 {v4.8h, v5.8h}, [x18], #32");
+ COMPARE_MACRO(St1(v16.V2S(),
+ v17.V2S(),
+ v18.V2S(),
+ MemOperand(x19, 24, PostIndex)),
+ "st1 {v16.2s, v17.2s, v18.2s}, [x19], #24");
+ COMPARE_MACRO(St1(v16.V4S(),
+ v17.V4S(),
+ v18.V4S(),
+ MemOperand(x19, 48, PostIndex)),
+ "st1 {v16.4s, v17.4s, v18.4s}, [x19], #48");
+ COMPARE_MACRO(St1(v19.V2S(),
+ v20.V2S(),
+ v21.V2S(),
+ v22.V2S(),
+ MemOperand(x20, 32, PostIndex)),
+ "st1 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
+ COMPARE_MACRO(St1(v23.V2D(),
+ v24.V2D(),
+ v25.V2D(),
+ v26.V2D(),
+ MemOperand(x21, 64, PostIndex)),
+ "st1 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
+ COMPARE_MACRO(St2(v1.V16B(), v2.V16B(), MemOperand(x16, 32, PostIndex)),
+ "st2 {v1.16b, v2.16b}, [x16], #32");
+ COMPARE_MACRO(St2(v2.V4H(), v3.V4H(), MemOperand(x17, 16, PostIndex)),
+ "st2 {v2.4h, v3.4h}, [x17], #16");
+ COMPARE_MACRO(St2(v4.V8H(), v5.V8H(), MemOperand(x18, 32, PostIndex)),
+ "st2 {v4.8h, v5.8h}, [x18], #32");
+ COMPARE_MACRO(St3(v16.V2S(),
+ v17.V2S(),
+ v18.V2S(),
+ MemOperand(x19, 24, PostIndex)),
+ "st3 {v16.2s, v17.2s, v18.2s}, [x19], #24");
+ COMPARE_MACRO(St3(v16.V4S(),
+ v17.V4S(),
+ v18.V4S(),
+ MemOperand(x19, 48, PostIndex)),
+ "st3 {v16.4s, v17.4s, v18.4s}, [x19], #48");
+ COMPARE_MACRO(St4(v19.V2S(),
+ v20.V2S(),
+ v21.V2S(),
+ v22.V2S(),
+ MemOperand(x20, 32, PostIndex)),
+ "st4 {v19.2s, v20.2s, v21.2s, v22.2s}, [x20], #32");
+ COMPARE_MACRO(St4(v23.V2D(),
+ v24.V2D(),
+ v25.V2D(),
+ v26.V2D(),
+ MemOperand(x21, 64, PostIndex)),
+ "st4 {v23.2d, v24.2d, v25.2d, v26.2d}, [x21], #64");
+
+ COMPARE_MACRO(St1(v0.V1D(), MemOperand(x16)), "st1 {v0.1d}, [x16]");
+ COMPARE_MACRO(St1(v1.V1D(), v2.V1D(), MemOperand(x17, 16, PostIndex)),
+ "st1 {v1.1d, v2.1d}, [x17], #16");
+ COMPARE_MACRO(St1(v3.V1D(),
+ v4.V1D(),
+ v5.V1D(),
+ MemOperand(x18, x19, PostIndex)),
+ "st1 {v3.1d, v4.1d, v5.1d}, [x18], x19");
+ COMPARE_MACRO(St1(v30.V1D(),
+ v31.V1D(),
+ v0.V1D(),
+ v1.V1D(),
+ MemOperand(x20, 32, PostIndex)),
+ "st1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x20], #32");
+ COMPARE_MACRO(St1(d30, d31, d0, d1, MemOperand(x21, x22, PostIndex)),
+ "st1 {v30.1d, v31.1d, v0.1d, v1.1d}, [x21], x22");
CLEANUP();
}
@@ -3383,454 +3416,515 @@ TEST(neon_load_store_vector_unallocated) {
TEST(neon_load_store_lane) {
- SETUP_MACRO();
-
- COMPARE(Ld1(v0.V8B(), 0, MemOperand(x15)), "ld1 {v0.b}[0], [x15]");
- COMPARE(Ld1(v1.V16B(), 1, MemOperand(x16)), "ld1 {v1.b}[1], [x16]");
- COMPARE(Ld1(v2.V4H(), 2, MemOperand(x17)), "ld1 {v2.h}[2], [x17]");
- COMPARE(Ld1(v3.V8H(), 3, MemOperand(x18)), "ld1 {v3.h}[3], [x18]");
- COMPARE(Ld1(v4.V2S(), 0, MemOperand(x19)), "ld1 {v4.s}[0], [x19]");
- COMPARE(Ld1(v5.V4S(), 1, MemOperand(x20)), "ld1 {v5.s}[1], [x20]");
- COMPARE(Ld1(v6.V2D(), 0, MemOperand(x21)), "ld1 {v6.d}[0], [x21]");
- COMPARE(Ld1(v7.B(), 7, MemOperand(x22)), "ld1 {v7.b}[7], [x22]");
- COMPARE(Ld1(v8.B(), 15, MemOperand(x23)), "ld1 {v8.b}[15], [x23]");
- COMPARE(Ld1(v9.H(), 3, MemOperand(x24)), "ld1 {v9.h}[3], [x24]");
- COMPARE(Ld1(v10.H(), 7, MemOperand(x25)), "ld1 {v10.h}[7], [x25]");
- COMPARE(Ld1(v11.S(), 1, MemOperand(x26)), "ld1 {v11.s}[1], [x26]");
- COMPARE(Ld1(v12.S(), 3, MemOperand(x27)), "ld1 {v12.s}[3], [x27]");
- COMPARE(Ld1(v13.D(), 1, MemOperand(sp)), "ld1 {v13.d}[1], [sp]");
-
- COMPARE(Ld1(v0.V8B(), 0, MemOperand(x15, x0, PostIndex)),
- "ld1 {v0.b}[0], [x15], x0");
- COMPARE(Ld1(v1.V16B(), 1, MemOperand(x16, 1, PostIndex)),
- "ld1 {v1.b}[1], [x16], #1");
- COMPARE(Ld1(v2.V4H(), 2, MemOperand(x17, 2, PostIndex)),
- "ld1 {v2.h}[2], [x17], #2");
- COMPARE(Ld1(v3.V8H(), 3, MemOperand(x18, x1, PostIndex)),
- "ld1 {v3.h}[3], [x18], x1");
- COMPARE(Ld1(v4.V2S(), 0, MemOperand(x19, x2, PostIndex)),
- "ld1 {v4.s}[0], [x19], x2");
- COMPARE(Ld1(v5.V4S(), 1, MemOperand(x20, 4, PostIndex)),
- "ld1 {v5.s}[1], [x20], #4");
- COMPARE(Ld1(v6.V2D(), 0, MemOperand(x21, 8, PostIndex)),
- "ld1 {v6.d}[0], [x21], #8");
- COMPARE(Ld1(v7.B(), 7, MemOperand(x22, 1, PostIndex)),
- "ld1 {v7.b}[7], [x22], #1");
- COMPARE(Ld1(v8.B(), 15, MemOperand(x23, x3, PostIndex)),
- "ld1 {v8.b}[15], [x23], x3");
- COMPARE(Ld1(v9.H(), 3, MemOperand(x24, x4, PostIndex)),
- "ld1 {v9.h}[3], [x24], x4");
- COMPARE(Ld1(v10.H(), 7, MemOperand(x25, 2, PostIndex)),
- "ld1 {v10.h}[7], [x25], #2");
- COMPARE(Ld1(v11.S(), 1, MemOperand(x26, 4, PostIndex)),
- "ld1 {v11.s}[1], [x26], #4");
- COMPARE(Ld1(v12.S(), 3, MemOperand(x27, x5, PostIndex)),
- "ld1 {v12.s}[3], [x27], x5");
- COMPARE(Ld1(v12.S(), 3, MemOperand(x27, 4, PostIndex)),
- "ld1 {v12.s}[3], [x27], #4");
- COMPARE(Ld1(v13.D(), 1, MemOperand(sp, x6, PostIndex)),
- "ld1 {v13.d}[1], [sp], x6");
- COMPARE(Ld1(v13.D(), 1, MemOperand(sp, 8, PostIndex)),
- "ld1 {v13.d}[1], [sp], #8");
-
- COMPARE(Ld2(v0.V8B(), v1.V8B(), 0, MemOperand(x15)),
- "ld2 {v0.b, v1.b}[0], [x15]");
- COMPARE(Ld2(v1.V16B(), v2.V16B(), 1, MemOperand(x16)),
- "ld2 {v1.b, v2.b}[1], [x16]");
- COMPARE(Ld2(v2.V4H(), v3.V4H(), 2, MemOperand(x17)),
- "ld2 {v2.h, v3.h}[2], [x17]");
- COMPARE(Ld2(v3.V8H(), v4.V8H(), 3, MemOperand(x18)),
- "ld2 {v3.h, v4.h}[3], [x18]");
- COMPARE(Ld2(v4.V2S(), v5.V2S(), 0, MemOperand(x19)),
- "ld2 {v4.s, v5.s}[0], [x19]");
- COMPARE(Ld2(v5.V4S(), v6.V4S(), 1, MemOperand(x20)),
- "ld2 {v5.s, v6.s}[1], [x20]");
- COMPARE(Ld2(v6.V2D(), v7.V2D(), 0, MemOperand(x21)),
- "ld2 {v6.d, v7.d}[0], [x21]");
- COMPARE(Ld2(v7.B(), v8.B(), 7, MemOperand(x22)),
- "ld2 {v7.b, v8.b}[7], [x22]");
- COMPARE(Ld2(v8.B(), v9.B(), 15, MemOperand(x23)),
- "ld2 {v8.b, v9.b}[15], [x23]");
- COMPARE(Ld2(v9.H(), v10.H(), 3, MemOperand(x24)),
- "ld2 {v9.h, v10.h}[3], [x24]");
- COMPARE(Ld2(v10.H(), v11.H(), 7, MemOperand(x25)),
- "ld2 {v10.h, v11.h}[7], [x25]");
- COMPARE(Ld2(v11.S(), v12.S(), 1, MemOperand(x26)),
- "ld2 {v11.s, v12.s}[1], [x26]");
- COMPARE(Ld2(v12.S(), v13.S(), 3, MemOperand(x27)),
- "ld2 {v12.s, v13.s}[3], [x27]");
- COMPARE(Ld2(v13.D(), v14.D(), 1, MemOperand(sp)),
- "ld2 {v13.d, v14.d}[1], [sp]");
-
- COMPARE(Ld2(v0.V8B(), v1.V8B(), 0, MemOperand(x15, x0, PostIndex)),
- "ld2 {v0.b, v1.b}[0], [x15], x0");
- COMPARE(Ld2(v1.V16B(), v2.V16B(), 1, MemOperand(x16, 2, PostIndex)),
- "ld2 {v1.b, v2.b}[1], [x16], #2");
- COMPARE(Ld2(v2.V4H(), v3.V4H(), 2, MemOperand(x17, 4, PostIndex)),
- "ld2 {v2.h, v3.h}[2], [x17], #4");
- COMPARE(Ld2(v3.V8H(), v4.V8H(), 3, MemOperand(x18, x1, PostIndex)),
- "ld2 {v3.h, v4.h}[3], [x18], x1");
- COMPARE(Ld2(v4.V2S(), v5.V2S(), 0, MemOperand(x19, x2, PostIndex)),
- "ld2 {v4.s, v5.s}[0], [x19], x2");
- COMPARE(Ld2(v5.V4S(), v6.V4S(), 1, MemOperand(x20, 8, PostIndex)),
- "ld2 {v5.s, v6.s}[1], [x20], #8");
- COMPARE(Ld2(v6.V2D(), v7.V2D(), 0, MemOperand(x21, 16, PostIndex)),
- "ld2 {v6.d, v7.d}[0], [x21], #16");
- COMPARE(Ld2(v7.B(), v8.B(), 7, MemOperand(x22, 2, PostIndex)),
- "ld2 {v7.b, v8.b}[7], [x22], #2");
- COMPARE(Ld2(v8.B(), v9.B(), 15, MemOperand(x23, x3, PostIndex)),
- "ld2 {v8.b, v9.b}[15], [x23], x3");
- COMPARE(Ld2(v9.H(), v10.H(), 3, MemOperand(x24, x4, PostIndex)),
- "ld2 {v9.h, v10.h}[3], [x24], x4");
- COMPARE(Ld2(v10.H(), v11.H(), 7, MemOperand(x25, 4, PostIndex)),
- "ld2 {v10.h, v11.h}[7], [x25], #4");
- COMPARE(Ld2(v11.S(), v12.S(), 1, MemOperand(x26, 8, PostIndex)),
- "ld2 {v11.s, v12.s}[1], [x26], #8");
- COMPARE(Ld2(v12.S(), v13.S(), 3, MemOperand(x27, x5, PostIndex)),
- "ld2 {v12.s, v13.s}[3], [x27], x5");
- COMPARE(Ld2(v11.S(), v12.S(), 3, MemOperand(x26, 8, PostIndex)),
- "ld2 {v11.s, v12.s}[3], [x26], #8");
- COMPARE(Ld2(v13.D(), v14.D(), 1, MemOperand(sp, x6, PostIndex)),
- "ld2 {v13.d, v14.d}[1], [sp], x6");
- COMPARE(Ld2(v13.D(), v14.D(), 1, MemOperand(sp, 16, PostIndex)),
- "ld2 {v13.d, v14.d}[1], [sp], #16");
-
- COMPARE(Ld3(v0.V8B(), v1.V8B(), v2.V8B(), 0, MemOperand(x15)),
- "ld3 {v0.b, v1.b, v2.b}[0], [x15]");
- COMPARE(Ld3(v1.V16B(), v2.V16B(), v3.V16B(), 1, MemOperand(x16)),
- "ld3 {v1.b, v2.b, v3.b}[1], [x16]");
- COMPARE(Ld3(v2.V4H(), v3.V4H(), v4.V4H(), 2, MemOperand(x17)),
- "ld3 {v2.h, v3.h, v4.h}[2], [x17]");
- COMPARE(Ld3(v3.V8H(), v4.V8H(), v5.V8H(), 3, MemOperand(x18)),
- "ld3 {v3.h, v4.h, v5.h}[3], [x18]");
- COMPARE(Ld3(v4.V2S(), v5.V2S(), v6.V2S(), 0, MemOperand(x19)),
- "ld3 {v4.s, v5.s, v6.s}[0], [x19]");
- COMPARE(Ld3(v5.V4S(), v6.V4S(), v7.V4S(), 1, MemOperand(x20)),
- "ld3 {v5.s, v6.s, v7.s}[1], [x20]");
- COMPARE(Ld3(v6.V2D(), v7.V2D(), v8.V2D(), 0, MemOperand(x21)),
- "ld3 {v6.d, v7.d, v8.d}[0], [x21]");
- COMPARE(Ld3(v7.B(), v8.B(), v9.B(), 7, MemOperand(x22)),
- "ld3 {v7.b, v8.b, v9.b}[7], [x22]");
- COMPARE(Ld3(v8.B(), v9.B(), v10.B(), 15, MemOperand(x23)),
- "ld3 {v8.b, v9.b, v10.b}[15], [x23]");
- COMPARE(Ld3(v9.H(), v10.H(), v11.H(), 3, MemOperand(x24)),
- "ld3 {v9.h, v10.h, v11.h}[3], [x24]");
- COMPARE(Ld3(v10.H(), v11.H(), v12.H(), 7, MemOperand(x25)),
- "ld3 {v10.h, v11.h, v12.h}[7], [x25]");
- COMPARE(Ld3(v11.S(), v12.S(), v13.S(), 1, MemOperand(x26)),
- "ld3 {v11.s, v12.s, v13.s}[1], [x26]");
- COMPARE(Ld3(v12.S(), v13.S(), v14.S(), 3, MemOperand(x27)),
- "ld3 {v12.s, v13.s, v14.s}[3], [x27]");
- COMPARE(Ld3(v13.D(), v14.D(), v15.D(), 1, MemOperand(sp)),
- "ld3 {v13.d, v14.d, v15.d}[1], [sp]");
-
- COMPARE(Ld3(v0.V8B(), v1.V8B(), v2.V8B(), 0, MemOperand(x15, x0, PostIndex)),
- "ld3 {v0.b, v1.b, v2.b}[0], [x15], x0");
- COMPARE(Ld3(v1.V16B(),
- v2.V16B(),
- v3.V16B(),
- 1,
- MemOperand(x16, 3, PostIndex)),
- "ld3 {v1.b, v2.b, v3.b}[1], [x16], #3");
- COMPARE(Ld3(v2.V4H(), v3.V4H(), v4.V4H(), 2, MemOperand(x17, 6, PostIndex)),
- "ld3 {v2.h, v3.h, v4.h}[2], [x17], #6");
- COMPARE(Ld3(v3.V8H(), v4.V8H(), v5.V8H(), 3, MemOperand(x18, x1, PostIndex)),
- "ld3 {v3.h, v4.h, v5.h}[3], [x18], x1");
- COMPARE(Ld3(v4.V2S(), v5.V2S(), v6.V2S(), 0, MemOperand(x19, x2, PostIndex)),
- "ld3 {v4.s, v5.s, v6.s}[0], [x19], x2");
- COMPARE(Ld3(v5.V4S(), v6.V4S(), v7.V4S(), 1, MemOperand(x20, 12, PostIndex)),
- "ld3 {v5.s, v6.s, v7.s}[1], [x20], #12");
- COMPARE(Ld3(v6.V2D(), v7.V2D(), v8.V2D(), 0, MemOperand(x21, 24, PostIndex)),
- "ld3 {v6.d, v7.d, v8.d}[0], [x21], #24");
- COMPARE(Ld3(v7.B(), v8.B(), v9.B(), 7, MemOperand(x22, 3, PostIndex)),
- "ld3 {v7.b, v8.b, v9.b}[7], [x22], #3");
- COMPARE(Ld3(v8.B(), v9.B(), v10.B(), 15, MemOperand(x23, x3, PostIndex)),
- "ld3 {v8.b, v9.b, v10.b}[15], [x23], x3");
- COMPARE(Ld3(v9.H(), v10.H(), v11.H(), 3, MemOperand(x24, x4, PostIndex)),
- "ld3 {v9.h, v10.h, v11.h}[3], [x24], x4");
- COMPARE(Ld3(v10.H(), v11.H(), v12.H(), 7, MemOperand(x25, 6, PostIndex)),
- "ld3 {v10.h, v11.h, v12.h}[7], [x25], #6");
- COMPARE(Ld3(v11.S(), v12.S(), v13.S(), 1, MemOperand(x26, 12, PostIndex)),
- "ld3 {v11.s, v12.s, v13.s}[1], [x26], #12");
- COMPARE(Ld3(v12.S(), v13.S(), v14.S(), 3, MemOperand(x27, x5, PostIndex)),
- "ld3 {v12.s, v13.s, v14.s}[3], [x27], x5");
- COMPARE(Ld3(v12.S(), v13.S(), v14.S(), 3, MemOperand(x27, 12, PostIndex)),
- "ld3 {v12.s, v13.s, v14.s}[3], [x27], #12");
- COMPARE(Ld3(v13.D(), v14.D(), v15.D(), 1, MemOperand(sp, x6, PostIndex)),
- "ld3 {v13.d, v14.d, v15.d}[1], [sp], x6");
- COMPARE(Ld3(v13.D(), v14.D(), v15.D(), 1, MemOperand(sp, 24, PostIndex)),
- "ld3 {v13.d, v14.d, v15.d}[1], [sp], #24");
-
- COMPARE(Ld4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), 0, MemOperand(x15)),
- "ld4 {v0.b, v1.b, v2.b, v3.b}[0], [x15]");
- COMPARE(Ld4(v1.V16B(), v2.V16B(), v3.V16B(), v4.V16B(), 1, MemOperand(x16)),
- "ld4 {v1.b, v2.b, v3.b, v4.b}[1], [x16]");
- COMPARE(Ld4(v2.V4H(), v3.V4H(), v4.V4H(), v5.V4H(), 2, MemOperand(x17)),
- "ld4 {v2.h, v3.h, v4.h, v5.h}[2], [x17]");
- COMPARE(Ld4(v3.V8H(), v4.V8H(), v5.V8H(), v6.V8H(), 3, MemOperand(x18)),
- "ld4 {v3.h, v4.h, v5.h, v6.h}[3], [x18]");
- COMPARE(Ld4(v4.V2S(), v5.V2S(), v6.V2S(), v7.V2S(), 0, MemOperand(x19)),
- "ld4 {v4.s, v5.s, v6.s, v7.s}[0], [x19]");
- COMPARE(Ld4(v5.V4S(), v6.V4S(), v7.V4S(), v8.V4S(), 1, MemOperand(x20)),
- "ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x20]");
- COMPARE(Ld4(v6.V2D(), v7.V2D(), v8.V2D(), v9.V2D(), 0, MemOperand(x21)),
- "ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x21]");
- COMPARE(Ld4(v7.B(), v8.B(), v9.B(), v10.B(), 7, MemOperand(x22)),
- "ld4 {v7.b, v8.b, v9.b, v10.b}[7], [x22]");
- COMPARE(Ld4(v8.B(), v9.B(), v10.B(), v11.B(), 15, MemOperand(x23)),
- "ld4 {v8.b, v9.b, v10.b, v11.b}[15], [x23]");
- COMPARE(Ld4(v9.H(), v10.H(), v11.H(), v12.H(), 3, MemOperand(x24)),
- "ld4 {v9.h, v10.h, v11.h, v12.h}[3], [x24]");
- COMPARE(Ld4(v10.H(), v11.H(), v12.H(), v13.H(), 7, MemOperand(x25)),
- "ld4 {v10.h, v11.h, v12.h, v13.h}[7], [x25]");
- COMPARE(Ld4(v11.S(), v12.S(), v13.S(), v14.S(), 1, MemOperand(x26)),
- "ld4 {v11.s, v12.s, v13.s, v14.s}[1], [x26]");
- COMPARE(Ld4(v12.S(), v13.S(), v14.S(), v15.S(), 3, MemOperand(x27)),
- "ld4 {v12.s, v13.s, v14.s, v15.s}[3], [x27]");
- COMPARE(Ld4(v13.D(), v14.D(), v15.D(), v16.D(), 1, MemOperand(sp)),
- "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp]");
-
- COMPARE(Ld4(v0.V8B(),
- v1.V8B(),
- v2.V8B(),
- v3.V8B(),
- 0,
- MemOperand(x15, x0, PostIndex)),
- "ld4 {v0.b, v1.b, v2.b, v3.b}[0], [x15], x0");
- COMPARE(Ld4(v1.V16B(),
- v2.V16B(),
- v3.V16B(),
- v4.V16B(),
- 1,
- MemOperand(x16, 4, PostIndex)),
- "ld4 {v1.b, v2.b, v3.b, v4.b}[1], [x16], #4");
- COMPARE(Ld4(v2.V4H(),
- v3.V4H(),
- v4.V4H(),
- v5.V4H(),
- 2,
- MemOperand(x17, 8, PostIndex)),
- "ld4 {v2.h, v3.h, v4.h, v5.h}[2], [x17], #8");
- COMPARE(Ld4(v3.V8H(),
- v4.V8H(),
- v5.V8H(),
- v6.V8H(),
- 3,
- MemOperand(x18, x1, PostIndex)),
- "ld4 {v3.h, v4.h, v5.h, v6.h}[3], [x18], x1");
- COMPARE(Ld4(v4.V2S(),
- v5.V2S(),
- v6.V2S(),
- v7.V2S(),
- 0,
- MemOperand(x19, x2, PostIndex)),
- "ld4 {v4.s, v5.s, v6.s, v7.s}[0], [x19], x2");
- COMPARE(Ld4(v5.V4S(),
- v6.V4S(),
- v7.V4S(),
- v8.V4S(),
- 1,
- MemOperand(x20, 16, PostIndex)),
- "ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x20], #16");
- COMPARE(Ld4(v6.V2D(),
- v7.V2D(),
- v8.V2D(),
- v9.V2D(),
- 0,
- MemOperand(x21, 32, PostIndex)),
- "ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x21], #32");
- COMPARE(Ld4(v7.B(),
- v8.B(),
- v9.B(),
- v10.B(),
- 7,
- MemOperand(x22, 4, PostIndex)),
- "ld4 {v7.b, v8.b, v9.b, v10.b}[7], [x22], #4");
- COMPARE(Ld4(v8.B(),
- v9.B(),
- v10.B(),
- v11.B(),
- 15,
- MemOperand(x23, x3, PostIndex)),
- "ld4 {v8.b, v9.b, v10.b, v11.b}[15], [x23], x3");
- COMPARE(Ld4(v9.H(),
- v10.H(),
- v11.H(),
- v12.H(),
- 3,
- MemOperand(x24, x4, PostIndex)),
- "ld4 {v9.h, v10.h, v11.h, v12.h}[3], [x24], x4");
- COMPARE(Ld4(v10.H(),
- v11.H(),
- v12.H(),
- v13.H(),
- 7,
- MemOperand(x25, 8, PostIndex)),
- "ld4 {v10.h, v11.h, v12.h, v13.h}[7], [x25], #8");
- COMPARE(Ld4(v11.S(),
- v12.S(),
- v13.S(),
- v14.S(),
- 1,
- MemOperand(x26, 16, PostIndex)),
- "ld4 {v11.s, v12.s, v13.s, v14.s}[1], [x26], #16");
- COMPARE(Ld4(v12.S(),
- v13.S(),
- v14.S(),
- v15.S(),
- 3,
- MemOperand(x27, x5, PostIndex)),
- "ld4 {v12.s, v13.s, v14.s, v15.s}[3], [x27], x5");
- COMPARE(Ld4(v11.S(),
- v12.S(),
- v13.S(),
- v14.S(),
- 3,
- MemOperand(x26, 16, PostIndex)),
- "ld4 {v11.s, v12.s, v13.s, v14.s}[3], [x26], #16");
- COMPARE(Ld4(v13.D(),
- v14.D(),
- v15.D(),
- v16.D(),
- 1,
- MemOperand(sp, x6, PostIndex)),
- "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], x6");
- COMPARE(Ld4(v13.D(),
- v14.D(),
- v15.D(),
- v16.D(),
- 1,
- MemOperand(sp, 32, PostIndex)),
- "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], #32");
-
- COMPARE(St1(v0.V8B(), 0, MemOperand(x15)), "st1 {v0.b}[0], [x15]");
- COMPARE(St1(v1.V16B(), 1, MemOperand(x16)), "st1 {v1.b}[1], [x16]");
- COMPARE(St1(v2.V4H(), 2, MemOperand(x17)), "st1 {v2.h}[2], [x17]");
- COMPARE(St1(v3.V8H(), 3, MemOperand(x18)), "st1 {v3.h}[3], [x18]");
- COMPARE(St1(v4.V2S(), 0, MemOperand(x19)), "st1 {v4.s}[0], [x19]");
- COMPARE(St1(v5.V4S(), 1, MemOperand(x20)), "st1 {v5.s}[1], [x20]");
- COMPARE(St1(v6.V2D(), 0, MemOperand(x21)), "st1 {v6.d}[0], [x21]");
- COMPARE(St1(v7.B(), 7, MemOperand(x22)), "st1 {v7.b}[7], [x22]");
- COMPARE(St1(v8.B(), 15, MemOperand(x23)), "st1 {v8.b}[15], [x23]");
- COMPARE(St1(v9.H(), 3, MemOperand(x24)), "st1 {v9.h}[3], [x24]");
- COMPARE(St1(v10.H(), 7, MemOperand(x25)), "st1 {v10.h}[7], [x25]");
- COMPARE(St1(v11.S(), 1, MemOperand(x26)), "st1 {v11.s}[1], [x26]");
- COMPARE(St1(v12.S(), 3, MemOperand(x27)), "st1 {v12.s}[3], [x27]");
- COMPARE(St1(v13.D(), 1, MemOperand(sp)), "st1 {v13.d}[1], [sp]");
-
- COMPARE(St1(v0.V8B(), 0, MemOperand(x15, x0, PostIndex)),
- "st1 {v0.b}[0], [x15], x0");
- COMPARE(St1(v1.V16B(), 1, MemOperand(x16, 1, PostIndex)),
- "st1 {v1.b}[1], [x16], #1");
- COMPARE(St1(v2.V4H(), 2, MemOperand(x17, 2, PostIndex)),
- "st1 {v2.h}[2], [x17], #2");
- COMPARE(St1(v3.V8H(), 3, MemOperand(x18, x1, PostIndex)),
- "st1 {v3.h}[3], [x18], x1");
- COMPARE(St1(v4.V2S(), 0, MemOperand(x19, x2, PostIndex)),
- "st1 {v4.s}[0], [x19], x2");
- COMPARE(St1(v5.V4S(), 1, MemOperand(x20, 4, PostIndex)),
- "st1 {v5.s}[1], [x20], #4");
- COMPARE(St1(v6.V2D(), 0, MemOperand(x21, 8, PostIndex)),
- "st1 {v6.d}[0], [x21], #8");
- COMPARE(St1(v7.B(), 7, MemOperand(x22, 1, PostIndex)),
- "st1 {v7.b}[7], [x22], #1");
- COMPARE(St1(v8.B(), 15, MemOperand(x23, x3, PostIndex)),
- "st1 {v8.b}[15], [x23], x3");
- COMPARE(St1(v9.H(), 3, MemOperand(x24, x4, PostIndex)),
- "st1 {v9.h}[3], [x24], x4");
- COMPARE(St1(v10.H(), 7, MemOperand(x25, 2, PostIndex)),
- "st1 {v10.h}[7], [x25], #2");
- COMPARE(St1(v11.S(), 1, MemOperand(x26, 4, PostIndex)),
- "st1 {v11.s}[1], [x26], #4");
- COMPARE(St1(v12.S(), 3, MemOperand(x27, x5, PostIndex)),
- "st1 {v12.s}[3], [x27], x5");
- COMPARE(St1(v13.D(), 1, MemOperand(sp, x6, PostIndex)),
- "st1 {v13.d}[1], [sp], x6");
- COMPARE(St2(v0.V8B(), v1.V8B(), 0, MemOperand(x15, x0, PostIndex)),
- "st2 {v0.b, v1.b}[0], [x15], x0");
- COMPARE(St2(v1.V16B(), v2.V16B(), 1, MemOperand(x16, 2, PostIndex)),
- "st2 {v1.b, v2.b}[1], [x16], #2");
- COMPARE(St2(v2.V4H(), v3.V4H(), 2, MemOperand(x17, 4, PostIndex)),
- "st2 {v2.h, v3.h}[2], [x17], #4");
- COMPARE(St2(v3.V8H(), v4.V8H(), 3, MemOperand(x18, x1, PostIndex)),
- "st2 {v3.h, v4.h}[3], [x18], x1");
- COMPARE(St2(v4.V2S(), v5.V2S(), 0, MemOperand(x19, x2, PostIndex)),
- "st2 {v4.s, v5.s}[0], [x19], x2");
- COMPARE(St2(v5.V4S(), v6.V4S(), 1, MemOperand(x20, 8, PostIndex)),
- "st2 {v5.s, v6.s}[1], [x20], #8");
- COMPARE(St2(v6.V2D(), v7.V2D(), 0, MemOperand(x21, 16, PostIndex)),
- "st2 {v6.d, v7.d}[0], [x21], #16");
- COMPARE(St2(v7.B(), v8.B(), 7, MemOperand(x22, 2, PostIndex)),
- "st2 {v7.b, v8.b}[7], [x22], #2");
- COMPARE(St2(v8.B(), v9.B(), 15, MemOperand(x23, x3, PostIndex)),
- "st2 {v8.b, v9.b}[15], [x23], x3");
- COMPARE(St2(v9.H(), v10.H(), 3, MemOperand(x24, x4, PostIndex)),
- "st2 {v9.h, v10.h}[3], [x24], x4");
- COMPARE(St2(v10.H(), v11.H(), 7, MemOperand(x25, 4, PostIndex)),
- "st2 {v10.h, v11.h}[7], [x25], #4");
- COMPARE(St2(v11.S(), v12.S(), 1, MemOperand(x26, 8, PostIndex)),
- "st2 {v11.s, v12.s}[1], [x26], #8");
- COMPARE(St2(v12.S(), v13.S(), 3, MemOperand(x27, x5, PostIndex)),
- "st2 {v12.s, v13.s}[3], [x27], x5");
- COMPARE(St2(v13.D(), v14.D(), 1, MemOperand(sp, x6, PostIndex)),
- "st2 {v13.d, v14.d}[1], [sp], x6");
- COMPARE(St3(VLIST3(v0.V8B()), 0, MemOperand(x15, x0, PostIndex)),
- "st3 {v0.b, v1.b, v2.b}[0], [x15], x0");
- COMPARE(St3(VLIST3(v1.V16B()), 1, MemOperand(x16, 3, PostIndex)),
- "st3 {v1.b, v2.b, v3.b}[1], [x16], #3");
- COMPARE(St3(VLIST3(v2.V4H()), 2, MemOperand(x17, 6, PostIndex)),
- "st3 {v2.h, v3.h, v4.h}[2], [x17], #6");
- COMPARE(St3(VLIST3(v3.V8H()), 3, MemOperand(x18, x1, PostIndex)),
- "st3 {v3.h, v4.h, v5.h}[3], [x18], x1");
- COMPARE(St3(VLIST3(v4.V2S()), 0, MemOperand(x19, x2, PostIndex)),
- "st3 {v4.s, v5.s, v6.s}[0], [x19], x2");
- COMPARE(St3(VLIST3(v5.V4S()), 1, MemOperand(x20, 12, PostIndex)),
- "st3 {v5.s, v6.s, v7.s}[1], [x20], #12");
- COMPARE(St3(VLIST3(v6.V2D()), 0, MemOperand(x21, 24, PostIndex)),
- "st3 {v6.d, v7.d, v8.d}[0], [x21], #24");
- COMPARE(St3(VLIST3(v7.B()), 7, MemOperand(x22, 3, PostIndex)),
- "st3 {v7.b, v8.b, v9.b}[7], [x22], #3");
- COMPARE(St3(VLIST3(v8.B()), 15, MemOperand(x23, x3, PostIndex)),
- "st3 {v8.b, v9.b, v10.b}[15], [x23], x3");
- COMPARE(St3(VLIST3(v9.H()), 3, MemOperand(x24, x4, PostIndex)),
- "st3 {v9.h, v10.h, v11.h}[3], [x24], x4");
- COMPARE(St3(VLIST3(v10.H()), 7, MemOperand(x25, 6, PostIndex)),
- "st3 {v10.h, v11.h, v12.h}[7], [x25], #6");
- COMPARE(St3(VLIST3(v11.S()), 1, MemOperand(x26, 12, PostIndex)),
- "st3 {v11.s, v12.s, v13.s}[1], [x26], #12");
- COMPARE(St3(VLIST3(v12.S()), 3, MemOperand(x27, x5, PostIndex)),
- "st3 {v12.s, v13.s, v14.s}[3], [x27], x5");
- COMPARE(St3(VLIST3(v13.D()), 1, MemOperand(sp, x6, PostIndex)),
- "st3 {v13.d, v14.d, v15.d}[1], [sp], x6");
-
- COMPARE(St4(VLIST4(v0.V8B()), 0, MemOperand(x15, x0, PostIndex)),
- "st4 {v0.b, v1.b, v2.b, v3.b}[0], [x15], x0");
- COMPARE(St4(VLIST4(v1.V16B()), 1, MemOperand(x16, 4, PostIndex)),
- "st4 {v1.b, v2.b, v3.b, v4.b}[1], [x16], #4");
- COMPARE(St4(VLIST4(v2.V4H()), 2, MemOperand(x17, 8, PostIndex)),
- "st4 {v2.h, v3.h, v4.h, v5.h}[2], [x17], #8");
- COMPARE(St4(VLIST4(v3.V8H()), 3, MemOperand(x18, x1, PostIndex)),
- "st4 {v3.h, v4.h, v5.h, v6.h}[3], [x18], x1");
- COMPARE(St4(VLIST4(v4.V2S()), 0, MemOperand(x19, x2, PostIndex)),
- "st4 {v4.s, v5.s, v6.s, v7.s}[0], [x19], x2");
- COMPARE(St4(VLIST4(v5.V4S()), 1, MemOperand(x20, 16, PostIndex)),
- "st4 {v5.s, v6.s, v7.s, v8.s}[1], [x20], #16");
- COMPARE(St4(VLIST4(v6.V2D()), 0, MemOperand(x21, 32, PostIndex)),
- "st4 {v6.d, v7.d, v8.d, v9.d}[0], [x21], #32");
- COMPARE(St4(VLIST4(v7.B()), 7, MemOperand(x22, 4, PostIndex)),
- "st4 {v7.b, v8.b, v9.b, v10.b}[7], [x22], #4");
- COMPARE(St4(VLIST4(v8.B()), 15, MemOperand(x23, x3, PostIndex)),
- "st4 {v8.b, v9.b, v10.b, v11.b}[15], [x23], x3");
- COMPARE(St4(VLIST4(v9.H()), 3, MemOperand(x24, x4, PostIndex)),
- "st4 {v9.h, v10.h, v11.h, v12.h}[3], [x24], x4");
- COMPARE(St4(VLIST4(v10.H()), 7, MemOperand(x25, 8, PostIndex)),
- "st4 {v10.h, v11.h, v12.h, v13.h}[7], [x25], #8");
- COMPARE(St4(VLIST4(v11.S()), 1, MemOperand(x26, 16, PostIndex)),
- "st4 {v11.s, v12.s, v13.s, v14.s}[1], [x26], #16");
- COMPARE(St4(VLIST4(v12.S()), 3, MemOperand(x27, x5, PostIndex)),
- "st4 {v12.s, v13.s, v14.s, v15.s}[3], [x27], x5");
- COMPARE(St4(VLIST4(v13.D()), 1, MemOperand(sp, x6, PostIndex)),
- "st4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], x6");
+ SETUP();
+
+ COMPARE_MACRO(Ld1(v0.V8B(), 0, MemOperand(x15)), "ld1 {v0.b}[0], [x15]");
+ COMPARE_MACRO(Ld1(v1.V16B(), 1, MemOperand(x16)), "ld1 {v1.b}[1], [x16]");
+ COMPARE_MACRO(Ld1(v2.V4H(), 2, MemOperand(x17)), "ld1 {v2.h}[2], [x17]");
+ COMPARE_MACRO(Ld1(v3.V8H(), 3, MemOperand(x18)), "ld1 {v3.h}[3], [x18]");
+ COMPARE_MACRO(Ld1(v4.V2S(), 0, MemOperand(x19)), "ld1 {v4.s}[0], [x19]");
+ COMPARE_MACRO(Ld1(v5.V4S(), 1, MemOperand(x20)), "ld1 {v5.s}[1], [x20]");
+ COMPARE_MACRO(Ld1(v6.V2D(), 0, MemOperand(x21)), "ld1 {v6.d}[0], [x21]");
+ COMPARE_MACRO(Ld1(v7.B(), 7, MemOperand(x22)), "ld1 {v7.b}[7], [x22]");
+ COMPARE_MACRO(Ld1(v8.B(), 15, MemOperand(x23)), "ld1 {v8.b}[15], [x23]");
+ COMPARE_MACRO(Ld1(v9.H(), 3, MemOperand(x24)), "ld1 {v9.h}[3], [x24]");
+ COMPARE_MACRO(Ld1(v10.H(), 7, MemOperand(x25)), "ld1 {v10.h}[7], [x25]");
+ COMPARE_MACRO(Ld1(v11.S(), 1, MemOperand(x26)), "ld1 {v11.s}[1], [x26]");
+ COMPARE_MACRO(Ld1(v12.S(), 3, MemOperand(x27)), "ld1 {v12.s}[3], [x27]");
+ COMPARE_MACRO(Ld1(v13.D(), 1, MemOperand(sp)), "ld1 {v13.d}[1], [sp]");
+
+ COMPARE_MACRO(Ld1(v0.V8B(), 0, MemOperand(x15, x0, PostIndex)),
+ "ld1 {v0.b}[0], [x15], x0");
+ COMPARE_MACRO(Ld1(v1.V16B(), 1, MemOperand(x16, 1, PostIndex)),
+ "ld1 {v1.b}[1], [x16], #1");
+ COMPARE_MACRO(Ld1(v2.V4H(), 2, MemOperand(x17, 2, PostIndex)),
+ "ld1 {v2.h}[2], [x17], #2");
+ COMPARE_MACRO(Ld1(v3.V8H(), 3, MemOperand(x18, x1, PostIndex)),
+ "ld1 {v3.h}[3], [x18], x1");
+ COMPARE_MACRO(Ld1(v4.V2S(), 0, MemOperand(x19, x2, PostIndex)),
+ "ld1 {v4.s}[0], [x19], x2");
+ COMPARE_MACRO(Ld1(v5.V4S(), 1, MemOperand(x20, 4, PostIndex)),
+ "ld1 {v5.s}[1], [x20], #4");
+ COMPARE_MACRO(Ld1(v6.V2D(), 0, MemOperand(x21, 8, PostIndex)),
+ "ld1 {v6.d}[0], [x21], #8");
+ COMPARE_MACRO(Ld1(v7.B(), 7, MemOperand(x22, 1, PostIndex)),
+ "ld1 {v7.b}[7], [x22], #1");
+ COMPARE_MACRO(Ld1(v8.B(), 15, MemOperand(x23, x3, PostIndex)),
+ "ld1 {v8.b}[15], [x23], x3");
+ COMPARE_MACRO(Ld1(v9.H(), 3, MemOperand(x24, x4, PostIndex)),
+ "ld1 {v9.h}[3], [x24], x4");
+ COMPARE_MACRO(Ld1(v10.H(), 7, MemOperand(x25, 2, PostIndex)),
+ "ld1 {v10.h}[7], [x25], #2");
+ COMPARE_MACRO(Ld1(v11.S(), 1, MemOperand(x26, 4, PostIndex)),
+ "ld1 {v11.s}[1], [x26], #4");
+ COMPARE_MACRO(Ld1(v12.S(), 3, MemOperand(x27, x5, PostIndex)),
+ "ld1 {v12.s}[3], [x27], x5");
+ COMPARE_MACRO(Ld1(v12.S(), 3, MemOperand(x27, 4, PostIndex)),
+ "ld1 {v12.s}[3], [x27], #4");
+ COMPARE_MACRO(Ld1(v13.D(), 1, MemOperand(sp, x6, PostIndex)),
+ "ld1 {v13.d}[1], [sp], x6");
+ COMPARE_MACRO(Ld1(v13.D(), 1, MemOperand(sp, 8, PostIndex)),
+ "ld1 {v13.d}[1], [sp], #8");
+
+ COMPARE_MACRO(Ld2(v0.V8B(), v1.V8B(), 0, MemOperand(x15)),
+ "ld2 {v0.b, v1.b}[0], [x15]");
+ COMPARE_MACRO(Ld2(v1.V16B(), v2.V16B(), 1, MemOperand(x16)),
+ "ld2 {v1.b, v2.b}[1], [x16]");
+ COMPARE_MACRO(Ld2(v2.V4H(), v3.V4H(), 2, MemOperand(x17)),
+ "ld2 {v2.h, v3.h}[2], [x17]");
+ COMPARE_MACRO(Ld2(v3.V8H(), v4.V8H(), 3, MemOperand(x18)),
+ "ld2 {v3.h, v4.h}[3], [x18]");
+ COMPARE_MACRO(Ld2(v4.V2S(), v5.V2S(), 0, MemOperand(x19)),
+ "ld2 {v4.s, v5.s}[0], [x19]");
+ COMPARE_MACRO(Ld2(v5.V4S(), v6.V4S(), 1, MemOperand(x20)),
+ "ld2 {v5.s, v6.s}[1], [x20]");
+ COMPARE_MACRO(Ld2(v6.V2D(), v7.V2D(), 0, MemOperand(x21)),
+ "ld2 {v6.d, v7.d}[0], [x21]");
+ COMPARE_MACRO(Ld2(v7.B(), v8.B(), 7, MemOperand(x22)),
+ "ld2 {v7.b, v8.b}[7], [x22]");
+ COMPARE_MACRO(Ld2(v8.B(), v9.B(), 15, MemOperand(x23)),
+ "ld2 {v8.b, v9.b}[15], [x23]");
+ COMPARE_MACRO(Ld2(v9.H(), v10.H(), 3, MemOperand(x24)),
+ "ld2 {v9.h, v10.h}[3], [x24]");
+ COMPARE_MACRO(Ld2(v10.H(), v11.H(), 7, MemOperand(x25)),
+ "ld2 {v10.h, v11.h}[7], [x25]");
+ COMPARE_MACRO(Ld2(v11.S(), v12.S(), 1, MemOperand(x26)),
+ "ld2 {v11.s, v12.s}[1], [x26]");
+ COMPARE_MACRO(Ld2(v12.S(), v13.S(), 3, MemOperand(x27)),
+ "ld2 {v12.s, v13.s}[3], [x27]");
+ COMPARE_MACRO(Ld2(v13.D(), v14.D(), 1, MemOperand(sp)),
+ "ld2 {v13.d, v14.d}[1], [sp]");
+
+ COMPARE_MACRO(Ld2(v0.V8B(), v1.V8B(), 0, MemOperand(x15, x0, PostIndex)),
+ "ld2 {v0.b, v1.b}[0], [x15], x0");
+ COMPARE_MACRO(Ld2(v1.V16B(), v2.V16B(), 1, MemOperand(x16, 2, PostIndex)),
+ "ld2 {v1.b, v2.b}[1], [x16], #2");
+ COMPARE_MACRO(Ld2(v2.V4H(), v3.V4H(), 2, MemOperand(x17, 4, PostIndex)),
+ "ld2 {v2.h, v3.h}[2], [x17], #4");
+ COMPARE_MACRO(Ld2(v3.V8H(), v4.V8H(), 3, MemOperand(x18, x1, PostIndex)),
+ "ld2 {v3.h, v4.h}[3], [x18], x1");
+ COMPARE_MACRO(Ld2(v4.V2S(), v5.V2S(), 0, MemOperand(x19, x2, PostIndex)),
+ "ld2 {v4.s, v5.s}[0], [x19], x2");
+ COMPARE_MACRO(Ld2(v5.V4S(), v6.V4S(), 1, MemOperand(x20, 8, PostIndex)),
+ "ld2 {v5.s, v6.s}[1], [x20], #8");
+ COMPARE_MACRO(Ld2(v6.V2D(), v7.V2D(), 0, MemOperand(x21, 16, PostIndex)),
+ "ld2 {v6.d, v7.d}[0], [x21], #16");
+ COMPARE_MACRO(Ld2(v7.B(), v8.B(), 7, MemOperand(x22, 2, PostIndex)),
+ "ld2 {v7.b, v8.b}[7], [x22], #2");
+ COMPARE_MACRO(Ld2(v8.B(), v9.B(), 15, MemOperand(x23, x3, PostIndex)),
+ "ld2 {v8.b, v9.b}[15], [x23], x3");
+ COMPARE_MACRO(Ld2(v9.H(), v10.H(), 3, MemOperand(x24, x4, PostIndex)),
+ "ld2 {v9.h, v10.h}[3], [x24], x4");
+ COMPARE_MACRO(Ld2(v10.H(), v11.H(), 7, MemOperand(x25, 4, PostIndex)),
+ "ld2 {v10.h, v11.h}[7], [x25], #4");
+ COMPARE_MACRO(Ld2(v11.S(), v12.S(), 1, MemOperand(x26, 8, PostIndex)),
+ "ld2 {v11.s, v12.s}[1], [x26], #8");
+ COMPARE_MACRO(Ld2(v12.S(), v13.S(), 3, MemOperand(x27, x5, PostIndex)),
+ "ld2 {v12.s, v13.s}[3], [x27], x5");
+ COMPARE_MACRO(Ld2(v11.S(), v12.S(), 3, MemOperand(x26, 8, PostIndex)),
+ "ld2 {v11.s, v12.s}[3], [x26], #8");
+ COMPARE_MACRO(Ld2(v13.D(), v14.D(), 1, MemOperand(sp, x6, PostIndex)),
+ "ld2 {v13.d, v14.d}[1], [sp], x6");
+ COMPARE_MACRO(Ld2(v13.D(), v14.D(), 1, MemOperand(sp, 16, PostIndex)),
+ "ld2 {v13.d, v14.d}[1], [sp], #16");
+
+ COMPARE_MACRO(Ld3(v0.V8B(), v1.V8B(), v2.V8B(), 0, MemOperand(x15)),
+ "ld3 {v0.b, v1.b, v2.b}[0], [x15]");
+ COMPARE_MACRO(Ld3(v1.V16B(), v2.V16B(), v3.V16B(), 1, MemOperand(x16)),
+ "ld3 {v1.b, v2.b, v3.b}[1], [x16]");
+ COMPARE_MACRO(Ld3(v2.V4H(), v3.V4H(), v4.V4H(), 2, MemOperand(x17)),
+ "ld3 {v2.h, v3.h, v4.h}[2], [x17]");
+ COMPARE_MACRO(Ld3(v3.V8H(), v4.V8H(), v5.V8H(), 3, MemOperand(x18)),
+ "ld3 {v3.h, v4.h, v5.h}[3], [x18]");
+ COMPARE_MACRO(Ld3(v4.V2S(), v5.V2S(), v6.V2S(), 0, MemOperand(x19)),
+ "ld3 {v4.s, v5.s, v6.s}[0], [x19]");
+ COMPARE_MACRO(Ld3(v5.V4S(), v6.V4S(), v7.V4S(), 1, MemOperand(x20)),
+ "ld3 {v5.s, v6.s, v7.s}[1], [x20]");
+ COMPARE_MACRO(Ld3(v6.V2D(), v7.V2D(), v8.V2D(), 0, MemOperand(x21)),
+ "ld3 {v6.d, v7.d, v8.d}[0], [x21]");
+ COMPARE_MACRO(Ld3(v7.B(), v8.B(), v9.B(), 7, MemOperand(x22)),
+ "ld3 {v7.b, v8.b, v9.b}[7], [x22]");
+ COMPARE_MACRO(Ld3(v8.B(), v9.B(), v10.B(), 15, MemOperand(x23)),
+ "ld3 {v8.b, v9.b, v10.b}[15], [x23]");
+ COMPARE_MACRO(Ld3(v9.H(), v10.H(), v11.H(), 3, MemOperand(x24)),
+ "ld3 {v9.h, v10.h, v11.h}[3], [x24]");
+ COMPARE_MACRO(Ld3(v10.H(), v11.H(), v12.H(), 7, MemOperand(x25)),
+ "ld3 {v10.h, v11.h, v12.h}[7], [x25]");
+ COMPARE_MACRO(Ld3(v11.S(), v12.S(), v13.S(), 1, MemOperand(x26)),
+ "ld3 {v11.s, v12.s, v13.s}[1], [x26]");
+ COMPARE_MACRO(Ld3(v12.S(), v13.S(), v14.S(), 3, MemOperand(x27)),
+ "ld3 {v12.s, v13.s, v14.s}[3], [x27]");
+ COMPARE_MACRO(Ld3(v13.D(), v14.D(), v15.D(), 1, MemOperand(sp)),
+ "ld3 {v13.d, v14.d, v15.d}[1], [sp]");
+
+ COMPARE_MACRO(Ld3(v0.V8B(),
+ v1.V8B(),
+ v2.V8B(),
+ 0,
+ MemOperand(x15, x0, PostIndex)),
+ "ld3 {v0.b, v1.b, v2.b}[0], [x15], x0");
+ COMPARE_MACRO(Ld3(v1.V16B(),
+ v2.V16B(),
+ v3.V16B(),
+ 1,
+ MemOperand(x16, 3, PostIndex)),
+ "ld3 {v1.b, v2.b, v3.b}[1], [x16], #3");
+ COMPARE_MACRO(Ld3(v2.V4H(),
+ v3.V4H(),
+ v4.V4H(),
+ 2,
+ MemOperand(x17, 6, PostIndex)),
+ "ld3 {v2.h, v3.h, v4.h}[2], [x17], #6");
+ COMPARE_MACRO(Ld3(v3.V8H(),
+ v4.V8H(),
+ v5.V8H(),
+ 3,
+ MemOperand(x18, x1, PostIndex)),
+ "ld3 {v3.h, v4.h, v5.h}[3], [x18], x1");
+ COMPARE_MACRO(Ld3(v4.V2S(),
+ v5.V2S(),
+ v6.V2S(),
+ 0,
+ MemOperand(x19, x2, PostIndex)),
+ "ld3 {v4.s, v5.s, v6.s}[0], [x19], x2");
+ COMPARE_MACRO(Ld3(v5.V4S(),
+ v6.V4S(),
+ v7.V4S(),
+ 1,
+ MemOperand(x20, 12, PostIndex)),
+ "ld3 {v5.s, v6.s, v7.s}[1], [x20], #12");
+ COMPARE_MACRO(Ld3(v6.V2D(),
+ v7.V2D(),
+ v8.V2D(),
+ 0,
+ MemOperand(x21, 24, PostIndex)),
+ "ld3 {v6.d, v7.d, v8.d}[0], [x21], #24");
+ COMPARE_MACRO(Ld3(v7.B(), v8.B(), v9.B(), 7, MemOperand(x22, 3, PostIndex)),
+ "ld3 {v7.b, v8.b, v9.b}[7], [x22], #3");
+ COMPARE_MACRO(Ld3(v8.B(),
+ v9.B(),
+ v10.B(),
+ 15,
+ MemOperand(x23, x3, PostIndex)),
+ "ld3 {v8.b, v9.b, v10.b}[15], [x23], x3");
+ COMPARE_MACRO(Ld3(v9.H(),
+ v10.H(),
+ v11.H(),
+ 3,
+ MemOperand(x24, x4, PostIndex)),
+ "ld3 {v9.h, v10.h, v11.h}[3], [x24], x4");
+ COMPARE_MACRO(Ld3(v10.H(),
+ v11.H(),
+ v12.H(),
+ 7,
+ MemOperand(x25, 6, PostIndex)),
+ "ld3 {v10.h, v11.h, v12.h}[7], [x25], #6");
+ COMPARE_MACRO(Ld3(v11.S(),
+ v12.S(),
+ v13.S(),
+ 1,
+ MemOperand(x26, 12, PostIndex)),
+ "ld3 {v11.s, v12.s, v13.s}[1], [x26], #12");
+ COMPARE_MACRO(Ld3(v12.S(),
+ v13.S(),
+ v14.S(),
+ 3,
+ MemOperand(x27, x5, PostIndex)),
+ "ld3 {v12.s, v13.s, v14.s}[3], [x27], x5");
+ COMPARE_MACRO(Ld3(v12.S(),
+ v13.S(),
+ v14.S(),
+ 3,
+ MemOperand(x27, 12, PostIndex)),
+ "ld3 {v12.s, v13.s, v14.s}[3], [x27], #12");
+ COMPARE_MACRO(Ld3(v13.D(),
+ v14.D(),
+ v15.D(),
+ 1,
+ MemOperand(sp, x6, PostIndex)),
+ "ld3 {v13.d, v14.d, v15.d}[1], [sp], x6");
+ COMPARE_MACRO(Ld3(v13.D(),
+ v14.D(),
+ v15.D(),
+ 1,
+ MemOperand(sp, 24, PostIndex)),
+ "ld3 {v13.d, v14.d, v15.d}[1], [sp], #24");
+
+ COMPARE_MACRO(Ld4(v0.V8B(), v1.V8B(), v2.V8B(), v3.V8B(), 0, MemOperand(x15)),
+ "ld4 {v0.b, v1.b, v2.b, v3.b}[0], [x15]");
+ COMPARE_MACRO(Ld4(v1.V16B(),
+ v2.V16B(),
+ v3.V16B(),
+ v4.V16B(),
+ 1,
+ MemOperand(x16)),
+ "ld4 {v1.b, v2.b, v3.b, v4.b}[1], [x16]");
+ COMPARE_MACRO(Ld4(v2.V4H(), v3.V4H(), v4.V4H(), v5.V4H(), 2, MemOperand(x17)),
+ "ld4 {v2.h, v3.h, v4.h, v5.h}[2], [x17]");
+ COMPARE_MACRO(Ld4(v3.V8H(), v4.V8H(), v5.V8H(), v6.V8H(), 3, MemOperand(x18)),
+ "ld4 {v3.h, v4.h, v5.h, v6.h}[3], [x18]");
+ COMPARE_MACRO(Ld4(v4.V2S(), v5.V2S(), v6.V2S(), v7.V2S(), 0, MemOperand(x19)),
+ "ld4 {v4.s, v5.s, v6.s, v7.s}[0], [x19]");
+ COMPARE_MACRO(Ld4(v5.V4S(), v6.V4S(), v7.V4S(), v8.V4S(), 1, MemOperand(x20)),
+ "ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x20]");
+ COMPARE_MACRO(Ld4(v6.V2D(), v7.V2D(), v8.V2D(), v9.V2D(), 0, MemOperand(x21)),
+ "ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x21]");
+ COMPARE_MACRO(Ld4(v7.B(), v8.B(), v9.B(), v10.B(), 7, MemOperand(x22)),
+ "ld4 {v7.b, v8.b, v9.b, v10.b}[7], [x22]");
+ COMPARE_MACRO(Ld4(v8.B(), v9.B(), v10.B(), v11.B(), 15, MemOperand(x23)),
+ "ld4 {v8.b, v9.b, v10.b, v11.b}[15], [x23]");
+ COMPARE_MACRO(Ld4(v9.H(), v10.H(), v11.H(), v12.H(), 3, MemOperand(x24)),
+ "ld4 {v9.h, v10.h, v11.h, v12.h}[3], [x24]");
+ COMPARE_MACRO(Ld4(v10.H(), v11.H(), v12.H(), v13.H(), 7, MemOperand(x25)),
+ "ld4 {v10.h, v11.h, v12.h, v13.h}[7], [x25]");
+ COMPARE_MACRO(Ld4(v11.S(), v12.S(), v13.S(), v14.S(), 1, MemOperand(x26)),
+ "ld4 {v11.s, v12.s, v13.s, v14.s}[1], [x26]");
+ COMPARE_MACRO(Ld4(v12.S(), v13.S(), v14.S(), v15.S(), 3, MemOperand(x27)),
+ "ld4 {v12.s, v13.s, v14.s, v15.s}[3], [x27]");
+ COMPARE_MACRO(Ld4(v13.D(), v14.D(), v15.D(), v16.D(), 1, MemOperand(sp)),
+ "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp]");
+
+ COMPARE_MACRO(Ld4(v0.V8B(),
+ v1.V8B(),
+ v2.V8B(),
+ v3.V8B(),
+ 0,
+ MemOperand(x15, x0, PostIndex)),
+ "ld4 {v0.b, v1.b, v2.b, v3.b}[0], [x15], x0");
+ COMPARE_MACRO(Ld4(v1.V16B(),
+ v2.V16B(),
+ v3.V16B(),
+ v4.V16B(),
+ 1,
+ MemOperand(x16, 4, PostIndex)),
+ "ld4 {v1.b, v2.b, v3.b, v4.b}[1], [x16], #4");
+ COMPARE_MACRO(Ld4(v2.V4H(),
+ v3.V4H(),
+ v4.V4H(),
+ v5.V4H(),
+ 2,
+ MemOperand(x17, 8, PostIndex)),
+ "ld4 {v2.h, v3.h, v4.h, v5.h}[2], [x17], #8");
+ COMPARE_MACRO(Ld4(v3.V8H(),
+ v4.V8H(),
+ v5.V8H(),
+ v6.V8H(),
+ 3,
+ MemOperand(x18, x1, PostIndex)),
+ "ld4 {v3.h, v4.h, v5.h, v6.h}[3], [x18], x1");
+ COMPARE_MACRO(Ld4(v4.V2S(),
+ v5.V2S(),
+ v6.V2S(),
+ v7.V2S(),
+ 0,
+ MemOperand(x19, x2, PostIndex)),
+ "ld4 {v4.s, v5.s, v6.s, v7.s}[0], [x19], x2");
+ COMPARE_MACRO(Ld4(v5.V4S(),
+ v6.V4S(),
+ v7.V4S(),
+ v8.V4S(),
+ 1,
+ MemOperand(x20, 16, PostIndex)),
+ "ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x20], #16");
+ COMPARE_MACRO(Ld4(v6.V2D(),
+ v7.V2D(),
+ v8.V2D(),
+ v9.V2D(),
+ 0,
+ MemOperand(x21, 32, PostIndex)),
+ "ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x21], #32");
+ COMPARE_MACRO(Ld4(v7.B(),
+ v8.B(),
+ v9.B(),
+ v10.B(),
+ 7,
+ MemOperand(x22, 4, PostIndex)),
+ "ld4 {v7.b, v8.b, v9.b, v10.b}[7], [x22], #4");
+ COMPARE_MACRO(Ld4(v8.B(),
+ v9.B(),
+ v10.B(),
+ v11.B(),
+ 15,
+ MemOperand(x23, x3, PostIndex)),
+ "ld4 {v8.b, v9.b, v10.b, v11.b}[15], [x23], x3");
+ COMPARE_MACRO(Ld4(v9.H(),
+ v10.H(),
+ v11.H(),
+ v12.H(),
+ 3,
+ MemOperand(x24, x4, PostIndex)),
+ "ld4 {v9.h, v10.h, v11.h, v12.h}[3], [x24], x4");
+ COMPARE_MACRO(Ld4(v10.H(),
+ v11.H(),
+ v12.H(),
+ v13.H(),
+ 7,
+ MemOperand(x25, 8, PostIndex)),
+ "ld4 {v10.h, v11.h, v12.h, v13.h}[7], [x25], #8");
+ COMPARE_MACRO(Ld4(v11.S(),
+ v12.S(),
+ v13.S(),
+ v14.S(),
+ 1,
+ MemOperand(x26, 16, PostIndex)),
+ "ld4 {v11.s, v12.s, v13.s, v14.s}[1], [x26], #16");
+ COMPARE_MACRO(Ld4(v12.S(),
+ v13.S(),
+ v14.S(),
+ v15.S(),
+ 3,
+ MemOperand(x27, x5, PostIndex)),
+ "ld4 {v12.s, v13.s, v14.s, v15.s}[3], [x27], x5");
+ COMPARE_MACRO(Ld4(v11.S(),
+ v12.S(),
+ v13.S(),
+ v14.S(),
+ 3,
+ MemOperand(x26, 16, PostIndex)),
+ "ld4 {v11.s, v12.s, v13.s, v14.s}[3], [x26], #16");
+ COMPARE_MACRO(Ld4(v13.D(),
+ v14.D(),
+ v15.D(),
+ v16.D(),
+ 1,
+ MemOperand(sp, x6, PostIndex)),
+ "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], x6");
+ COMPARE_MACRO(Ld4(v13.D(),
+ v14.D(),
+ v15.D(),
+ v16.D(),
+ 1,
+ MemOperand(sp, 32, PostIndex)),
+ "ld4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], #32");
+
+ COMPARE_MACRO(St1(v0.V8B(), 0, MemOperand(x15)), "st1 {v0.b}[0], [x15]");
+ COMPARE_MACRO(St1(v1.V16B(), 1, MemOperand(x16)), "st1 {v1.b}[1], [x16]");
+ COMPARE_MACRO(St1(v2.V4H(), 2, MemOperand(x17)), "st1 {v2.h}[2], [x17]");
+ COMPARE_MACRO(St1(v3.V8H(), 3, MemOperand(x18)), "st1 {v3.h}[3], [x18]");
+ COMPARE_MACRO(St1(v4.V2S(), 0, MemOperand(x19)), "st1 {v4.s}[0], [x19]");
+ COMPARE_MACRO(St1(v5.V4S(), 1, MemOperand(x20)), "st1 {v5.s}[1], [x20]");
+ COMPARE_MACRO(St1(v6.V2D(), 0, MemOperand(x21)), "st1 {v6.d}[0], [x21]");
+ COMPARE_MACRO(St1(v7.B(), 7, MemOperand(x22)), "st1 {v7.b}[7], [x22]");
+ COMPARE_MACRO(St1(v8.B(), 15, MemOperand(x23)), "st1 {v8.b}[15], [x23]");
+ COMPARE_MACRO(St1(v9.H(), 3, MemOperand(x24)), "st1 {v9.h}[3], [x24]");
+ COMPARE_MACRO(St1(v10.H(), 7, MemOperand(x25)), "st1 {v10.h}[7], [x25]");
+ COMPARE_MACRO(St1(v11.S(), 1, MemOperand(x26)), "st1 {v11.s}[1], [x26]");
+ COMPARE_MACRO(St1(v12.S(), 3, MemOperand(x27)), "st1 {v12.s}[3], [x27]");
+ COMPARE_MACRO(St1(v13.D(), 1, MemOperand(sp)), "st1 {v13.d}[1], [sp]");
+
+ COMPARE_MACRO(St1(v0.V8B(), 0, MemOperand(x15, x0, PostIndex)),
+ "st1 {v0.b}[0], [x15], x0");
+ COMPARE_MACRO(St1(v1.V16B(), 1, MemOperand(x16, 1, PostIndex)),
+ "st1 {v1.b}[1], [x16], #1");
+ COMPARE_MACRO(St1(v2.V4H(), 2, MemOperand(x17, 2, PostIndex)),
+ "st1 {v2.h}[2], [x17], #2");
+ COMPARE_MACRO(St1(v3.V8H(), 3, MemOperand(x18, x1, PostIndex)),
+ "st1 {v3.h}[3], [x18], x1");
+ COMPARE_MACRO(St1(v4.V2S(), 0, MemOperand(x19, x2, PostIndex)),
+ "st1 {v4.s}[0], [x19], x2");
+ COMPARE_MACRO(St1(v5.V4S(), 1, MemOperand(x20, 4, PostIndex)),
+ "st1 {v5.s}[1], [x20], #4");
+ COMPARE_MACRO(St1(v6.V2D(), 0, MemOperand(x21, 8, PostIndex)),
+ "st1 {v6.d}[0], [x21], #8");
+ COMPARE_MACRO(St1(v7.B(), 7, MemOperand(x22, 1, PostIndex)),
+ "st1 {v7.b}[7], [x22], #1");
+ COMPARE_MACRO(St1(v8.B(), 15, MemOperand(x23, x3, PostIndex)),
+ "st1 {v8.b}[15], [x23], x3");
+ COMPARE_MACRO(St1(v9.H(), 3, MemOperand(x24, x4, PostIndex)),
+ "st1 {v9.h}[3], [x24], x4");
+ COMPARE_MACRO(St1(v10.H(), 7, MemOperand(x25, 2, PostIndex)),
+ "st1 {v10.h}[7], [x25], #2");
+ COMPARE_MACRO(St1(v11.S(), 1, MemOperand(x26, 4, PostIndex)),
+ "st1 {v11.s}[1], [x26], #4");
+ COMPARE_MACRO(St1(v12.S(), 3, MemOperand(x27, x5, PostIndex)),
+ "st1 {v12.s}[3], [x27], x5");
+ COMPARE_MACRO(St1(v13.D(), 1, MemOperand(sp, x6, PostIndex)),
+ "st1 {v13.d}[1], [sp], x6");
+ COMPARE_MACRO(St2(v0.V8B(), v1.V8B(), 0, MemOperand(x15, x0, PostIndex)),
+ "st2 {v0.b, v1.b}[0], [x15], x0");
+ COMPARE_MACRO(St2(v1.V16B(), v2.V16B(), 1, MemOperand(x16, 2, PostIndex)),
+ "st2 {v1.b, v2.b}[1], [x16], #2");
+ COMPARE_MACRO(St2(v2.V4H(), v3.V4H(), 2, MemOperand(x17, 4, PostIndex)),
+ "st2 {v2.h, v3.h}[2], [x17], #4");
+ COMPARE_MACRO(St2(v3.V8H(), v4.V8H(), 3, MemOperand(x18, x1, PostIndex)),
+ "st2 {v3.h, v4.h}[3], [x18], x1");
+ COMPARE_MACRO(St2(v4.V2S(), v5.V2S(), 0, MemOperand(x19, x2, PostIndex)),
+ "st2 {v4.s, v5.s}[0], [x19], x2");
+ COMPARE_MACRO(St2(v5.V4S(), v6.V4S(), 1, MemOperand(x20, 8, PostIndex)),
+ "st2 {v5.s, v6.s}[1], [x20], #8");
+ COMPARE_MACRO(St2(v6.V2D(), v7.V2D(), 0, MemOperand(x21, 16, PostIndex)),
+ "st2 {v6.d, v7.d}[0], [x21], #16");
+ COMPARE_MACRO(St2(v7.B(), v8.B(), 7, MemOperand(x22, 2, PostIndex)),
+ "st2 {v7.b, v8.b}[7], [x22], #2");
+ COMPARE_MACRO(St2(v8.B(), v9.B(), 15, MemOperand(x23, x3, PostIndex)),
+ "st2 {v8.b, v9.b}[15], [x23], x3");
+ COMPARE_MACRO(St2(v9.H(), v10.H(), 3, MemOperand(x24, x4, PostIndex)),
+ "st2 {v9.h, v10.h}[3], [x24], x4");
+ COMPARE_MACRO(St2(v10.H(), v11.H(), 7, MemOperand(x25, 4, PostIndex)),
+ "st2 {v10.h, v11.h}[7], [x25], #4");
+ COMPARE_MACRO(St2(v11.S(), v12.S(), 1, MemOperand(x26, 8, PostIndex)),
+ "st2 {v11.s, v12.s}[1], [x26], #8");
+ COMPARE_MACRO(St2(v12.S(), v13.S(), 3, MemOperand(x27, x5, PostIndex)),
+ "st2 {v12.s, v13.s}[3], [x27], x5");
+ COMPARE_MACRO(St2(v13.D(), v14.D(), 1, MemOperand(sp, x6, PostIndex)),
+ "st2 {v13.d, v14.d}[1], [sp], x6");
+ COMPARE_MACRO(St3(VLIST3(v0.V8B()), 0, MemOperand(x15, x0, PostIndex)),
+ "st3 {v0.b, v1.b, v2.b}[0], [x15], x0");
+ COMPARE_MACRO(St3(VLIST3(v1.V16B()), 1, MemOperand(x16, 3, PostIndex)),
+ "st3 {v1.b, v2.b, v3.b}[1], [x16], #3");
+ COMPARE_MACRO(St3(VLIST3(v2.V4H()), 2, MemOperand(x17, 6, PostIndex)),
+ "st3 {v2.h, v3.h, v4.h}[2], [x17], #6");
+ COMPARE_MACRO(St3(VLIST3(v3.V8H()), 3, MemOperand(x18, x1, PostIndex)),
+ "st3 {v3.h, v4.h, v5.h}[3], [x18], x1");
+ COMPARE_MACRO(St3(VLIST3(v4.V2S()), 0, MemOperand(x19, x2, PostIndex)),
+ "st3 {v4.s, v5.s, v6.s}[0], [x19], x2");
+ COMPARE_MACRO(St3(VLIST3(v5.V4S()), 1, MemOperand(x20, 12, PostIndex)),
+ "st3 {v5.s, v6.s, v7.s}[1], [x20], #12");
+ COMPARE_MACRO(St3(VLIST3(v6.V2D()), 0, MemOperand(x21, 24, PostIndex)),
+ "st3 {v6.d, v7.d, v8.d}[0], [x21], #24");
+ COMPARE_MACRO(St3(VLIST3(v7.B()), 7, MemOperand(x22, 3, PostIndex)),
+ "st3 {v7.b, v8.b, v9.b}[7], [x22], #3");
+ COMPARE_MACRO(St3(VLIST3(v8.B()), 15, MemOperand(x23, x3, PostIndex)),
+ "st3 {v8.b, v9.b, v10.b}[15], [x23], x3");
+ COMPARE_MACRO(St3(VLIST3(v9.H()), 3, MemOperand(x24, x4, PostIndex)),
+ "st3 {v9.h, v10.h, v11.h}[3], [x24], x4");
+ COMPARE_MACRO(St3(VLIST3(v10.H()), 7, MemOperand(x25, 6, PostIndex)),
+ "st3 {v10.h, v11.h, v12.h}[7], [x25], #6");
+ COMPARE_MACRO(St3(VLIST3(v11.S()), 1, MemOperand(x26, 12, PostIndex)),
+ "st3 {v11.s, v12.s, v13.s}[1], [x26], #12");
+ COMPARE_MACRO(St3(VLIST3(v12.S()), 3, MemOperand(x27, x5, PostIndex)),
+ "st3 {v12.s, v13.s, v14.s}[3], [x27], x5");
+ COMPARE_MACRO(St3(VLIST3(v13.D()), 1, MemOperand(sp, x6, PostIndex)),
+ "st3 {v13.d, v14.d, v15.d}[1], [sp], x6");
+
+ COMPARE_MACRO(St4(VLIST4(v0.V8B()), 0, MemOperand(x15, x0, PostIndex)),
+ "st4 {v0.b, v1.b, v2.b, v3.b}[0], [x15], x0");
+ COMPARE_MACRO(St4(VLIST4(v1.V16B()), 1, MemOperand(x16, 4, PostIndex)),
+ "st4 {v1.b, v2.b, v3.b, v4.b}[1], [x16], #4");
+ COMPARE_MACRO(St4(VLIST4(v2.V4H()), 2, MemOperand(x17, 8, PostIndex)),
+ "st4 {v2.h, v3.h, v4.h, v5.h}[2], [x17], #8");
+ COMPARE_MACRO(St4(VLIST4(v3.V8H()), 3, MemOperand(x18, x1, PostIndex)),
+ "st4 {v3.h, v4.h, v5.h, v6.h}[3], [x18], x1");
+ COMPARE_MACRO(St4(VLIST4(v4.V2S()), 0, MemOperand(x19, x2, PostIndex)),
+ "st4 {v4.s, v5.s, v6.s, v7.s}[0], [x19], x2");
+ COMPARE_MACRO(St4(VLIST4(v5.V4S()), 1, MemOperand(x20, 16, PostIndex)),
+ "st4 {v5.s, v6.s, v7.s, v8.s}[1], [x20], #16");
+ COMPARE_MACRO(St4(VLIST4(v6.V2D()), 0, MemOperand(x21, 32, PostIndex)),
+ "st4 {v6.d, v7.d, v8.d, v9.d}[0], [x21], #32");
+ COMPARE_MACRO(St4(VLIST4(v7.B()), 7, MemOperand(x22, 4, PostIndex)),
+ "st4 {v7.b, v8.b, v9.b, v10.b}[7], [x22], #4");
+ COMPARE_MACRO(St4(VLIST4(v8.B()), 15, MemOperand(x23, x3, PostIndex)),
+ "st4 {v8.b, v9.b, v10.b, v11.b}[15], [x23], x3");
+ COMPARE_MACRO(St4(VLIST4(v9.H()), 3, MemOperand(x24, x4, PostIndex)),
+ "st4 {v9.h, v10.h, v11.h, v12.h}[3], [x24], x4");
+ COMPARE_MACRO(St4(VLIST4(v10.H()), 7, MemOperand(x25, 8, PostIndex)),
+ "st4 {v10.h, v11.h, v12.h, v13.h}[7], [x25], #8");
+ COMPARE_MACRO(St4(VLIST4(v11.S()), 1, MemOperand(x26, 16, PostIndex)),
+ "st4 {v11.s, v12.s, v13.s, v14.s}[1], [x26], #16");
+ COMPARE_MACRO(St4(VLIST4(v12.S()), 3, MemOperand(x27, x5, PostIndex)),
+ "st4 {v12.s, v13.s, v14.s, v15.s}[3], [x27], x5");
+ COMPARE_MACRO(St4(VLIST4(v13.D()), 1, MemOperand(sp, x6, PostIndex)),
+ "st4 {v13.d, v14.d, v15.d, v16.d}[1], [sp], x6");
CLEANUP();
}
@@ -3912,154 +4006,197 @@ TEST(neon_load_store_lane_unallocated) {
TEST(neon_load_all_lanes) {
- SETUP_MACRO();
-
- COMPARE(Ld1r(v14.V8B(), MemOperand(x0)), "ld1r {v14.8b}, [x0]");
- COMPARE(Ld1r(v15.V16B(), MemOperand(x1)), "ld1r {v15.16b}, [x1]");
- COMPARE(Ld1r(v16.V4H(), MemOperand(x2)), "ld1r {v16.4h}, [x2]");
- COMPARE(Ld1r(v17.V8H(), MemOperand(x3)), "ld1r {v17.8h}, [x3]");
- COMPARE(Ld1r(v18.V2S(), MemOperand(x4)), "ld1r {v18.2s}, [x4]");
- COMPARE(Ld1r(v19.V4S(), MemOperand(x5)), "ld1r {v19.4s}, [x5]");
- COMPARE(Ld1r(v20.V2D(), MemOperand(sp)), "ld1r {v20.2d}, [sp]");
- COMPARE(Ld1r(v21.V1D(), MemOperand(x30)), "ld1r {v21.1d}, [x30]");
-
- COMPARE(Ld1r(v22.V8B(), MemOperand(x6, 1, PostIndex)),
- "ld1r {v22.8b}, [x6], #1");
- COMPARE(Ld1r(v23.V16B(), MemOperand(x7, x16, PostIndex)),
- "ld1r {v23.16b}, [x7], x16");
- COMPARE(Ld1r(v24.V4H(), MemOperand(x8, x17, PostIndex)),
- "ld1r {v24.4h}, [x8], x17");
- COMPARE(Ld1r(v25.V8H(), MemOperand(x9, 2, PostIndex)),
- "ld1r {v25.8h}, [x9], #2");
- COMPARE(Ld1r(v26.V2S(), MemOperand(x10, 4, PostIndex)),
- "ld1r {v26.2s}, [x10], #4");
- COMPARE(Ld1r(v27.V4S(), MemOperand(x11, x18, PostIndex)),
- "ld1r {v27.4s}, [x11], x18");
- COMPARE(Ld1r(v28.V2D(), MemOperand(x12, 8, PostIndex)),
- "ld1r {v28.2d}, [x12], #8");
- COMPARE(Ld1r(v29.V1D(), MemOperand(x13, 8, PostIndex)),
- "ld1r {v29.1d}, [x13], #8");
-
- COMPARE(Ld2r(v14.V8B(), v15.V8B(), MemOperand(x0)),
- "ld2r {v14.8b, v15.8b}, [x0]");
- COMPARE(Ld2r(v15.V16B(), v16.V16B(), MemOperand(x1)),
- "ld2r {v15.16b, v16.16b}, [x1]");
- COMPARE(Ld2r(v16.V4H(), v17.V4H(), MemOperand(x2)),
- "ld2r {v16.4h, v17.4h}, [x2]");
- COMPARE(Ld2r(v17.V8H(), v18.V8H(), MemOperand(x3)),
- "ld2r {v17.8h, v18.8h}, [x3]");
- COMPARE(Ld2r(v18.V2S(), v19.V2S(), MemOperand(x4)),
- "ld2r {v18.2s, v19.2s}, [x4]");
- COMPARE(Ld2r(v19.V4S(), v20.V4S(), MemOperand(x5)),
- "ld2r {v19.4s, v20.4s}, [x5]");
- COMPARE(Ld2r(v20.V2D(), v21.V2D(), MemOperand(sp)),
- "ld2r {v20.2d, v21.2d}, [sp]");
- COMPARE(Ld2r(v21.V8B(), v22.V8B(), MemOperand(x6, 2, PostIndex)),
- "ld2r {v21.8b, v22.8b}, [x6], #2");
- COMPARE(Ld2r(v22.V16B(), v23.V16B(), MemOperand(x7, x16, PostIndex)),
- "ld2r {v22.16b, v23.16b}, [x7], x16");
- COMPARE(Ld2r(v23.V4H(), v24.V4H(), MemOperand(x8, x17, PostIndex)),
- "ld2r {v23.4h, v24.4h}, [x8], x17");
- COMPARE(Ld2r(v24.V8H(), v25.V8H(), MemOperand(x9, 4, PostIndex)),
- "ld2r {v24.8h, v25.8h}, [x9], #4");
- COMPARE(Ld2r(v25.V2S(), v26.V2S(), MemOperand(x10, 8, PostIndex)),
- "ld2r {v25.2s, v26.2s}, [x10], #8");
- COMPARE(Ld2r(v26.V4S(), v27.V4S(), MemOperand(x11, x18, PostIndex)),
- "ld2r {v26.4s, v27.4s}, [x11], x18");
- COMPARE(Ld2r(v27.V2D(), v28.V2D(), MemOperand(x12, 16, PostIndex)),
- "ld2r {v27.2d, v28.2d}, [x12], #16");
-
- COMPARE(Ld3r(v14.V8B(), v15.V8B(), v16.V8B(), MemOperand(x0)),
- "ld3r {v14.8b, v15.8b, v16.8b}, [x0]");
- COMPARE(Ld3r(v15.V16B(), v16.V16B(), v17.V16B(), MemOperand(x1)),
- "ld3r {v15.16b, v16.16b, v17.16b}, [x1]");
- COMPARE(Ld3r(v16.V4H(), v17.V4H(), v18.V4H(), MemOperand(x2)),
- "ld3r {v16.4h, v17.4h, v18.4h}, [x2]");
- COMPARE(Ld3r(v17.V8H(), v18.V8H(), v19.V8H(), MemOperand(x3)),
- "ld3r {v17.8h, v18.8h, v19.8h}, [x3]");
- COMPARE(Ld3r(v18.V2S(), v19.V2S(), v20.V2S(), MemOperand(x4)),
- "ld3r {v18.2s, v19.2s, v20.2s}, [x4]");
- COMPARE(Ld3r(v19.V4S(), v20.V4S(), v21.V4S(), MemOperand(x5)),
- "ld3r {v19.4s, v20.4s, v21.4s}, [x5]");
- COMPARE(Ld3r(v20.V2D(), v21.V2D(), v22.V2D(), MemOperand(sp)),
- "ld3r {v20.2d, v21.2d, v22.2d}, [sp]");
- COMPARE(Ld3r(v21.V8B(), v22.V8B(), v23.V8B(), MemOperand(x6, 3, PostIndex)),
- "ld3r {v21.8b, v22.8b, v23.8b}, [x6], #3");
- COMPARE(Ld3r(v22.V16B(),
- v23.V16B(),
- v24.V16B(),
- MemOperand(x7, x16, PostIndex)),
- "ld3r {v22.16b, v23.16b, v24.16b}, [x7], x16");
- COMPARE(Ld3r(v23.V4H(), v24.V4H(), v25.V4H(), MemOperand(x8, x17, PostIndex)),
- "ld3r {v23.4h, v24.4h, v25.4h}, [x8], x17");
- COMPARE(Ld3r(v24.V8H(), v25.V8H(), v26.V8H(), MemOperand(x9, 6, PostIndex)),
- "ld3r {v24.8h, v25.8h, v26.8h}, [x9], #6");
- COMPARE(Ld3r(v25.V2S(), v26.V2S(), v27.V2S(), MemOperand(x10, 12, PostIndex)),
- "ld3r {v25.2s, v26.2s, v27.2s}, [x10], #12");
- COMPARE(Ld3r(v26.V4S(),
- v27.V4S(),
- v28.V4S(),
- MemOperand(x11, x18, PostIndex)),
- "ld3r {v26.4s, v27.4s, v28.4s}, [x11], x18");
- COMPARE(Ld3r(v27.V2D(), v28.V2D(), v29.V2D(), MemOperand(x12, 24, PostIndex)),
- "ld3r {v27.2d, v28.2d, v29.2d}, [x12], #24");
-
- COMPARE(Ld4r(v14.V8B(), v15.V8B(), v16.V8B(), v17.V8B(), MemOperand(x0)),
- "ld4r {v14.8b, v15.8b, v16.8b, v17.8b}, [x0]");
- COMPARE(Ld4r(v15.V16B(), v16.V16B(), v17.V16B(), v18.V16B(), MemOperand(x1)),
- "ld4r {v15.16b, v16.16b, v17.16b, v18.16b}, [x1]");
- COMPARE(Ld4r(v16.V4H(), v17.V4H(), v18.V4H(), v19.V4H(), MemOperand(x2)),
- "ld4r {v16.4h, v17.4h, v18.4h, v19.4h}, [x2]");
- COMPARE(Ld4r(v17.V8H(), v18.V8H(), v19.V8H(), v20.V8H(), MemOperand(x3)),
- "ld4r {v17.8h, v18.8h, v19.8h, v20.8h}, [x3]");
- COMPARE(Ld4r(v18.V2S(), v19.V2S(), v20.V2S(), v21.V2S(), MemOperand(x4)),
- "ld4r {v18.2s, v19.2s, v20.2s, v21.2s}, [x4]");
- COMPARE(Ld4r(v19.V4S(), v20.V4S(), v21.V4S(), v22.V4S(), MemOperand(x5)),
- "ld4r {v19.4s, v20.4s, v21.4s, v22.4s}, [x5]");
- COMPARE(Ld4r(v20.V2D(), v21.V2D(), v22.V2D(), v23.V2D(), MemOperand(sp)),
- "ld4r {v20.2d, v21.2d, v22.2d, v23.2d}, [sp]");
- COMPARE(Ld4r(v21.V8B(),
- v22.V8B(),
- v23.V8B(),
- v24.V8B(),
- MemOperand(x6, 4, PostIndex)),
- "ld4r {v21.8b, v22.8b, v23.8b, v24.8b}, [x6], #4");
- COMPARE(Ld4r(v22.V16B(),
- v23.V16B(),
- v24.V16B(),
- v25.V16B(),
- MemOperand(x7, x16, PostIndex)),
- "ld4r {v22.16b, v23.16b, v24.16b, v25.16b}, [x7], x16");
- COMPARE(Ld4r(v23.V4H(),
- v24.V4H(),
- v25.V4H(),
- v26.V4H(),
- MemOperand(x8, x17, PostIndex)),
- "ld4r {v23.4h, v24.4h, v25.4h, v26.4h}, [x8], x17");
- COMPARE(Ld4r(v24.V8H(),
- v25.V8H(),
- v26.V8H(),
- v27.V8H(),
- MemOperand(x9, 8, PostIndex)),
- "ld4r {v24.8h, v25.8h, v26.8h, v27.8h}, [x9], #8");
- COMPARE(Ld4r(v25.V2S(),
- v26.V2S(),
- v27.V2S(),
- v28.V2S(),
- MemOperand(x10, 16, PostIndex)),
- "ld4r {v25.2s, v26.2s, v27.2s, v28.2s}, [x10], #16");
- COMPARE(Ld4r(v26.V4S(),
- v27.V4S(),
- v28.V4S(),
- v29.V4S(),
- MemOperand(x11, x18, PostIndex)),
- "ld4r {v26.4s, v27.4s, v28.4s, v29.4s}, [x11], x18");
- COMPARE(Ld4r(v27.V2D(),
- v28.V2D(),
- v29.V2D(),
- v30.V2D(),
- MemOperand(x12, 32, PostIndex)),
- "ld4r {v27.2d, v28.2d, v29.2d, v30.2d}, [x12], #32");
+ SETUP();
+
+ COMPARE_MACRO(Ld1r(v14.V8B(), MemOperand(x0)), "ld1r {v14.8b}, [x0]");
+ COMPARE_MACRO(Ld1r(v15.V16B(), MemOperand(x1)), "ld1r {v15.16b}, [x1]");
+ COMPARE_MACRO(Ld1r(v16.V4H(), MemOperand(x2)), "ld1r {v16.4h}, [x2]");
+ COMPARE_MACRO(Ld1r(v17.V8H(), MemOperand(x3)), "ld1r {v17.8h}, [x3]");
+ COMPARE_MACRO(Ld1r(v18.V2S(), MemOperand(x4)), "ld1r {v18.2s}, [x4]");
+ COMPARE_MACRO(Ld1r(v19.V4S(), MemOperand(x5)), "ld1r {v19.4s}, [x5]");
+ COMPARE_MACRO(Ld1r(v20.V2D(), MemOperand(sp)), "ld1r {v20.2d}, [sp]");
+ COMPARE_MACRO(Ld1r(v21.V1D(), MemOperand(x30)), "ld1r {v21.1d}, [x30]");
+
+ COMPARE_MACRO(Ld1r(v22.V8B(), MemOperand(x6, 1, PostIndex)),
+ "ld1r {v22.8b}, [x6], #1");
+ COMPARE_MACRO(Ld1r(v23.V16B(), MemOperand(x7, x16, PostIndex)),
+ "ld1r {v23.16b}, [x7], x16");
+ COMPARE_MACRO(Ld1r(v24.V4H(), MemOperand(x8, x17, PostIndex)),
+ "ld1r {v24.4h}, [x8], x17");
+ COMPARE_MACRO(Ld1r(v25.V8H(), MemOperand(x9, 2, PostIndex)),
+ "ld1r {v25.8h}, [x9], #2");
+ COMPARE_MACRO(Ld1r(v26.V2S(), MemOperand(x10, 4, PostIndex)),
+ "ld1r {v26.2s}, [x10], #4");
+ COMPARE_MACRO(Ld1r(v27.V4S(), MemOperand(x11, x18, PostIndex)),
+ "ld1r {v27.4s}, [x11], x18");
+ COMPARE_MACRO(Ld1r(v28.V2D(), MemOperand(x12, 8, PostIndex)),
+ "ld1r {v28.2d}, [x12], #8");
+ COMPARE_MACRO(Ld1r(v29.V1D(), MemOperand(x13, 8, PostIndex)),
+ "ld1r {v29.1d}, [x13], #8");
+
+ COMPARE_MACRO(Ld2r(v14.V8B(), v15.V8B(), MemOperand(x0)),
+ "ld2r {v14.8b, v15.8b}, [x0]");
+ COMPARE_MACRO(Ld2r(v15.V16B(), v16.V16B(), MemOperand(x1)),
+ "ld2r {v15.16b, v16.16b}, [x1]");
+ COMPARE_MACRO(Ld2r(v16.V4H(), v17.V4H(), MemOperand(x2)),
+ "ld2r {v16.4h, v17.4h}, [x2]");
+ COMPARE_MACRO(Ld2r(v17.V8H(), v18.V8H(), MemOperand(x3)),
+ "ld2r {v17.8h, v18.8h}, [x3]");
+ COMPARE_MACRO(Ld2r(v18.V2S(), v19.V2S(), MemOperand(x4)),
+ "ld2r {v18.2s, v19.2s}, [x4]");
+ COMPARE_MACRO(Ld2r(v19.V4S(), v20.V4S(), MemOperand(x5)),
+ "ld2r {v19.4s, v20.4s}, [x5]");
+ COMPARE_MACRO(Ld2r(v20.V2D(), v21.V2D(), MemOperand(sp)),
+ "ld2r {v20.2d, v21.2d}, [sp]");
+ COMPARE_MACRO(Ld2r(v21.V8B(), v22.V8B(), MemOperand(x6, 2, PostIndex)),
+ "ld2r {v21.8b, v22.8b}, [x6], #2");
+ COMPARE_MACRO(Ld2r(v22.V16B(), v23.V16B(), MemOperand(x7, x16, PostIndex)),
+ "ld2r {v22.16b, v23.16b}, [x7], x16");
+ COMPARE_MACRO(Ld2r(v23.V4H(), v24.V4H(), MemOperand(x8, x17, PostIndex)),
+ "ld2r {v23.4h, v24.4h}, [x8], x17");
+ COMPARE_MACRO(Ld2r(v24.V8H(), v25.V8H(), MemOperand(x9, 4, PostIndex)),
+ "ld2r {v24.8h, v25.8h}, [x9], #4");
+ COMPARE_MACRO(Ld2r(v25.V2S(), v26.V2S(), MemOperand(x10, 8, PostIndex)),
+ "ld2r {v25.2s, v26.2s}, [x10], #8");
+ COMPARE_MACRO(Ld2r(v26.V4S(), v27.V4S(), MemOperand(x11, x18, PostIndex)),
+ "ld2r {v26.4s, v27.4s}, [x11], x18");
+ COMPARE_MACRO(Ld2r(v27.V2D(), v28.V2D(), MemOperand(x12, 16, PostIndex)),
+ "ld2r {v27.2d, v28.2d}, [x12], #16");
+
+ COMPARE_MACRO(Ld3r(v14.V8B(), v15.V8B(), v16.V8B(), MemOperand(x0)),
+ "ld3r {v14.8b, v15.8b, v16.8b}, [x0]");
+ COMPARE_MACRO(Ld3r(v15.V16B(), v16.V16B(), v17.V16B(), MemOperand(x1)),
+ "ld3r {v15.16b, v16.16b, v17.16b}, [x1]");
+ COMPARE_MACRO(Ld3r(v16.V4H(), v17.V4H(), v18.V4H(), MemOperand(x2)),
+ "ld3r {v16.4h, v17.4h, v18.4h}, [x2]");
+ COMPARE_MACRO(Ld3r(v17.V8H(), v18.V8H(), v19.V8H(), MemOperand(x3)),
+ "ld3r {v17.8h, v18.8h, v19.8h}, [x3]");
+ COMPARE_MACRO(Ld3r(v18.V2S(), v19.V2S(), v20.V2S(), MemOperand(x4)),
+ "ld3r {v18.2s, v19.2s, v20.2s}, [x4]");
+ COMPARE_MACRO(Ld3r(v19.V4S(), v20.V4S(), v21.V4S(), MemOperand(x5)),
+ "ld3r {v19.4s, v20.4s, v21.4s}, [x5]");
+ COMPARE_MACRO(Ld3r(v20.V2D(), v21.V2D(), v22.V2D(), MemOperand(sp)),
+ "ld3r {v20.2d, v21.2d, v22.2d}, [sp]");
+ COMPARE_MACRO(Ld3r(v21.V8B(),
+ v22.V8B(),
+ v23.V8B(),
+ MemOperand(x6, 3, PostIndex)),
+ "ld3r {v21.8b, v22.8b, v23.8b}, [x6], #3");
+ COMPARE_MACRO(Ld3r(v22.V16B(),
+ v23.V16B(),
+ v24.V16B(),
+ MemOperand(x7, x16, PostIndex)),
+ "ld3r {v22.16b, v23.16b, v24.16b}, [x7], x16");
+ COMPARE_MACRO(Ld3r(v23.V4H(),
+ v24.V4H(),
+ v25.V4H(),
+ MemOperand(x8, x17, PostIndex)),
+ "ld3r {v23.4h, v24.4h, v25.4h}, [x8], x17");
+ COMPARE_MACRO(Ld3r(v24.V8H(),
+ v25.V8H(),
+ v26.V8H(),
+ MemOperand(x9, 6, PostIndex)),
+ "ld3r {v24.8h, v25.8h, v26.8h}, [x9], #6");
+ COMPARE_MACRO(Ld3r(v25.V2S(),
+ v26.V2S(),
+ v27.V2S(),
+ MemOperand(x10, 12, PostIndex)),
+ "ld3r {v25.2s, v26.2s, v27.2s}, [x10], #12");
+ COMPARE_MACRO(Ld3r(v26.V4S(),
+ v27.V4S(),
+ v28.V4S(),
+ MemOperand(x11, x18, PostIndex)),
+ "ld3r {v26.4s, v27.4s, v28.4s}, [x11], x18");
+ COMPARE_MACRO(Ld3r(v27.V2D(),
+ v28.V2D(),
+ v29.V2D(),
+ MemOperand(x12, 24, PostIndex)),
+ "ld3r {v27.2d, v28.2d, v29.2d}, [x12], #24");
+
+ COMPARE_MACRO(Ld4r(v14.V8B(),
+ v15.V8B(),
+ v16.V8B(),
+ v17.V8B(),
+ MemOperand(x0)),
+ "ld4r {v14.8b, v15.8b, v16.8b, v17.8b}, [x0]");
+ COMPARE_MACRO(Ld4r(v15.V16B(),
+ v16.V16B(),
+ v17.V16B(),
+ v18.V16B(),
+ MemOperand(x1)),
+ "ld4r {v15.16b, v16.16b, v17.16b, v18.16b}, [x1]");
+ COMPARE_MACRO(Ld4r(v16.V4H(),
+ v17.V4H(),
+ v18.V4H(),
+ v19.V4H(),
+ MemOperand(x2)),
+ "ld4r {v16.4h, v17.4h, v18.4h, v19.4h}, [x2]");
+ COMPARE_MACRO(Ld4r(v17.V8H(),
+ v18.V8H(),
+ v19.V8H(),
+ v20.V8H(),
+ MemOperand(x3)),
+ "ld4r {v17.8h, v18.8h, v19.8h, v20.8h}, [x3]");
+ COMPARE_MACRO(Ld4r(v18.V2S(),
+ v19.V2S(),
+ v20.V2S(),
+ v21.V2S(),
+ MemOperand(x4)),
+ "ld4r {v18.2s, v19.2s, v20.2s, v21.2s}, [x4]");
+ COMPARE_MACRO(Ld4r(v19.V4S(),
+ v20.V4S(),
+ v21.V4S(),
+ v22.V4S(),
+ MemOperand(x5)),
+ "ld4r {v19.4s, v20.4s, v21.4s, v22.4s}, [x5]");
+ COMPARE_MACRO(Ld4r(v20.V2D(),
+ v21.V2D(),
+ v22.V2D(),
+ v23.V2D(),
+ MemOperand(sp)),
+ "ld4r {v20.2d, v21.2d, v22.2d, v23.2d}, [sp]");
+ COMPARE_MACRO(Ld4r(v21.V8B(),
+ v22.V8B(),
+ v23.V8B(),
+ v24.V8B(),
+ MemOperand(x6, 4, PostIndex)),
+ "ld4r {v21.8b, v22.8b, v23.8b, v24.8b}, [x6], #4");
+ COMPARE_MACRO(Ld4r(v22.V16B(),
+ v23.V16B(),
+ v24.V16B(),
+ v25.V16B(),
+ MemOperand(x7, x16, PostIndex)),
+ "ld4r {v22.16b, v23.16b, v24.16b, v25.16b}, [x7], x16");
+ COMPARE_MACRO(Ld4r(v23.V4H(),
+ v24.V4H(),
+ v25.V4H(),
+ v26.V4H(),
+ MemOperand(x8, x17, PostIndex)),
+ "ld4r {v23.4h, v24.4h, v25.4h, v26.4h}, [x8], x17");
+ COMPARE_MACRO(Ld4r(v24.V8H(),
+ v25.V8H(),
+ v26.V8H(),
+ v27.V8H(),
+ MemOperand(x9, 8, PostIndex)),
+ "ld4r {v24.8h, v25.8h, v26.8h, v27.8h}, [x9], #8");
+ COMPARE_MACRO(Ld4r(v25.V2S(),
+ v26.V2S(),
+ v27.V2S(),
+ v28.V2S(),
+ MemOperand(x10, 16, PostIndex)),
+ "ld4r {v25.2s, v26.2s, v27.2s, v28.2s}, [x10], #16");
+ COMPARE_MACRO(Ld4r(v26.V4S(),
+ v27.V4S(),
+ v28.V4S(),
+ v29.V4S(),
+ MemOperand(x11, x18, PostIndex)),
+ "ld4r {v26.4s, v27.4s, v28.4s, v29.4s}, [x11], x18");
+ COMPARE_MACRO(Ld4r(v27.V2D(),
+ v28.V2D(),
+ v29.V2D(),
+ v30.V2D(),
+ MemOperand(x12, 32, PostIndex)),
+ "ld4r {v27.2d, v28.2d, v29.2d, v30.2d}, [x12], #32");
CLEANUP();
}
@@ -4101,260 +4238,297 @@ TEST(neon_load_all_lanes_unallocated) {
TEST(neon_3same) {
- SETUP_MACRO();
+ SETUP();
#define DISASM_INST(M, S) \
- COMPARE(Cmeq(v0.M, v1.M, v2.M), "cmeq v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Cmeq(v0.M, v1.M, v2.M), "cmeq v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmge(v0.M, v1.M, v2.M), "cmge v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Cmge(v0.M, v1.M, v2.M), "cmge v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmgt(v0.M, v1.M, v2.M), "cmgt v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Cmgt(v0.M, v1.M, v2.M), "cmgt v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmhi(v0.M, v1.M, v2.M), "cmhi v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Cmhi(v0.M, v1.M, v2.M), "cmhi v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmhs(v0.M, v1.M, v2.M), "cmhs v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Cmhs(v0.M, v1.M, v2.M), "cmhs v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmtst(v0.M, v1.M, v2.M), "cmtst v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Cmtst(v0.M, v1.M, v2.M), "cmtst v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Add(v0.M, v1.M, v2.M), "add v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Add(v0.M, v1.M, v2.M), "add v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Sub(v3.M, v4.M, v5.M), "sub v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Sub(v3.M, v4.M, v5.M), "sub v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Sabd(v3.M, v4.M, v5.M), "sabd v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Sabd(v3.M, v4.M, v5.M), "sabd v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uabd(v3.M, v4.M, v5.M), "uabd v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Uabd(v3.M, v4.M, v5.M), "uabd v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Saba(v3.M, v4.M, v5.M), "saba v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Saba(v3.M, v4.M, v5.M), "saba v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uaba(v3.M, v4.M, v5.M), "uaba v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Uaba(v3.M, v4.M, v5.M), "uaba v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Smax(v3.M, v4.M, v5.M), "smax v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Smax(v3.M, v4.M, v5.M), "smax v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Smin(v3.M, v4.M, v5.M), "smin v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Smin(v3.M, v4.M, v5.M), "smin v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Umax(v3.M, v4.M, v5.M), "umax v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Umax(v3.M, v4.M, v5.M), "umax v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Umin(v3.M, v4.M, v5.M), "umin v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Umin(v3.M, v4.M, v5.M), "umin v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Smaxp(v3.M, v4.M, v5.M), "smaxp v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Smaxp(v3.M, v4.M, v5.M), "smaxp v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Sminp(v3.M, v4.M, v5.M), "sminp v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Sminp(v3.M, v4.M, v5.M), "sminp v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Umaxp(v3.M, v4.M, v5.M), "umaxp v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Umaxp(v3.M, v4.M, v5.M), "umaxp v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uminp(v3.M, v4.M, v5.M), "uminp v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Uminp(v3.M, v4.M, v5.M), "uminp v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uqadd(v6.M, v7.M, v8.M), "uqadd v6." S ", v7." S ", v8." S);
+ COMPARE_MACRO(Uqadd(v6.M, v7.M, v8.M), "uqadd v6." S ", v7." S ", v8." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sqadd(v9.M, v10.M, v11.M), "sqadd v9." S ", v10." S ", v11." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqadd(v9.M, v10.M, v11.M), \
+ "sqadd v9." S ", v10." S \
+ ", " \
+ "v11." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uqsub(v6.M, v7.M, v8.M), "uqsub v6." S ", v7." S ", v8." S);
+ COMPARE_MACRO(Uqsub(v6.M, v7.M, v8.M), "uqsub v6." S ", v7." S ", v8." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sqsub(v9.M, v10.M, v11.M), "sqsub v9." S ", v10." S ", v11." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqsub(v9.M, v10.M, v11.M), \
+ "sqsub v9." S ", v10." S \
+ ", " \
+ "v11." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sshl(v12.M, v13.M, v14.M), "sshl v12." S ", v13." S ", v14." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sshl(v12.M, v13.M, v14.M), \
+ "sshl v12." S ", v13." S \
+ ", " \
+ "v14." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Ushl(v15.M, v16.M, v17.M), "ushl v15." S ", v16." S ", v17." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Ushl(v15.M, v16.M, v17.M), \
+ "ushl v15." S ", v16." S \
+ ", " \
+ "v17." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sqshl(v18.M, v19.M, v20.M), "sqshl v18." S ", v19." S ", v20." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqshl(v18.M, v19.M, v20.M), \
+ "sqshl v18." S ", v19." S ", v20." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Uqshl(v21.M, v22.M, v23.M), "uqshl v21." S ", v22." S ", v23." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Uqshl(v21.M, v22.M, v23.M), \
+ "uqshl v21." S ", v22." S ", v23." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Srshl(v24.M, v25.M, v26.M), "srshl v24." S ", v25." S ", v26." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Srshl(v24.M, v25.M, v26.M), \
+ "srshl v24." S ", v25." S ", v26." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Urshl(v27.M, v28.M, v29.M), "urshl v27." S ", v28." S ", v29." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Urshl(v27.M, v28.M, v29.M), \
+ "urshl v27." S ", v28." S ", v29." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sqrshl(v30.M, v31.M, v0.M), "sqrshl v30." S ", v31." S ", v0." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqrshl(v30.M, v31.M, v0.M), \
+ "sqrshl v30." S ", v31." S ", v0." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uqrshl(v1.M, v2.M, v3.M), "uqrshl v1." S ", v2." S ", v3." S);
+ COMPARE_MACRO(Uqrshl(v1.M, v2.M, v3.M), "uqrshl v1." S ", v2." S ", v3." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Shadd(v4.M, v5.M, v6.M), "shadd v4." S ", v5." S ", v6." S);
+ COMPARE_MACRO(Shadd(v4.M, v5.M, v6.M), "shadd v4." S ", v5." S ", v6." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uhadd(v7.M, v8.M, v9.M), "uhadd v7." S ", v8." S ", v9." S);
+ COMPARE_MACRO(Uhadd(v7.M, v8.M, v9.M), "uhadd v7." S ", v8." S ", v9." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Srhadd(v10.M, v11.M, v12.M), "srhadd v10." S ", v11." S ", v12." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Srhadd(v10.M, v11.M, v12.M), \
+ "srhadd v10." S ", v11." S ", v12." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Urhadd(v13.M, v14.M, v15.M), "urhadd v13." S ", v14." S ", v15." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Urhadd(v13.M, v14.M, v15.M), \
+ "urhadd v13." S ", v14." S ", v15." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Shsub(v16.M, v17.M, v18.M), "shsub v16." S ", v17." S ", v18." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Shsub(v16.M, v17.M, v18.M), \
+ "shsub v16." S ", v17." S ", v18." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Uhsub(v19.M, v20.M, v21.M), "uhsub v19." S ", v20." S ", v21." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Uhsub(v19.M, v20.M, v21.M), \
+ "uhsub v19." S ", v20." S ", v21." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Addp(v19.M, v20.M, v21.M), "addp v19." S ", v20." S ", v21." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Addp(v19.M, v20.M, v21.M), \
+ "addp v19." S ", v20." S \
+ ", " \
+ "v21." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Mla(v19.M, v20.M, v21.M), "mla v19." S ", v20." S ", v21." S);
+ COMPARE_MACRO(Mla(v19.M, v20.M, v21.M), "mla v19." S ", v20." S ", v21." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Mls(v19.M, v20.M, v21.M), "mls v19." S ", v20." S ", v21." S);
+ COMPARE_MACRO(Mls(v19.M, v20.M, v21.M), "mls v19." S ", v20." S ", v21." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Mul(v19.M, v20.M, v21.M), "mul v19." S ", v20." S ", v21." S);
+ COMPARE_MACRO(Mul(v19.M, v20.M, v21.M), "mul v19." S ", v20." S ", v21." S);
NEON_FORMAT_LIST_BHS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sqdmulh(v1.M, v2.M, v3.M), "sqdmulh v1." S ", v2." S ", v3." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqdmulh(v1.M, v2.M, v3.M), \
+ "sqdmulh v1." S ", v2." S \
+ ", " \
+ "v3." S);
NEON_FORMAT_LIST_HS(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Sqrdmulh(v1.M, v2.M, v3.M), "sqrdmulh v1." S ", v2." S ", v3." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqrdmulh(v1.M, v2.M, v3.M), \
+ "sqrdmulh v1." S ", v2." S ", v3." S);
NEON_FORMAT_LIST_HS(DISASM_INST)
#undef DISASM_INST
- COMPARE(And(v6.V8B(), v7.V8B(), v8.V8B()), "and v6.8b, v7.8b, v8.8b");
- COMPARE(And(v6.V16B(), v7.V16B(), v8.V16B()), "and v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(And(v6.V8B(), v7.V8B(), v8.V8B()), "and v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(And(v6.V16B(), v7.V16B(), v8.V16B()),
+ "and v6.16b, v7.16b, v8.16b");
- COMPARE(Bic(v6.V8B(), v7.V8B(), v8.V8B()), "bic v6.8b, v7.8b, v8.8b");
- COMPARE(Bic(v6.V16B(), v7.V16B(), v8.V16B()), "bic v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Bic(v6.V8B(), v7.V8B(), v8.V8B()), "bic v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Bic(v6.V16B(), v7.V16B(), v8.V16B()),
+ "bic v6.16b, v7.16b, v8.16b");
- COMPARE(Orr(v6.V8B(), v7.V8B(), v8.V8B()), "orr v6.8b, v7.8b, v8.8b");
- COMPARE(Orr(v6.V16B(), v7.V16B(), v8.V16B()), "orr v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Orr(v6.V8B(), v7.V8B(), v8.V8B()), "orr v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Orr(v6.V16B(), v7.V16B(), v8.V16B()),
+ "orr v6.16b, v7.16b, v8.16b");
- COMPARE(Orr(v6.V8B(), v7.V8B(), v7.V8B()), "mov v6.8b, v7.8b");
- COMPARE(Orr(v6.V16B(), v7.V16B(), v7.V16B()), "mov v6.16b, v7.16b");
+ COMPARE_MACRO(Orr(v6.V8B(), v7.V8B(), v7.V8B()), "mov v6.8b, v7.8b");
+ COMPARE_MACRO(Orr(v6.V16B(), v7.V16B(), v7.V16B()), "mov v6.16b, v7.16b");
- COMPARE(Mov(v6.V8B(), v8.V8B()), "mov v6.8b, v8.8b");
- COMPARE(Mov(v6.V16B(), v8.V16B()), "mov v6.16b, v8.16b");
+ COMPARE_MACRO(Mov(v6.V8B(), v8.V8B()), "mov v6.8b, v8.8b");
+ COMPARE_MACRO(Mov(v6.V16B(), v8.V16B()), "mov v6.16b, v8.16b");
- COMPARE(Orn(v6.V8B(), v7.V8B(), v8.V8B()), "orn v6.8b, v7.8b, v8.8b");
- COMPARE(Orn(v6.V16B(), v7.V16B(), v8.V16B()), "orn v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Orn(v6.V8B(), v7.V8B(), v8.V8B()), "orn v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Orn(v6.V16B(), v7.V16B(), v8.V16B()),
+ "orn v6.16b, v7.16b, v8.16b");
- COMPARE(Eor(v6.V8B(), v7.V8B(), v8.V8B()), "eor v6.8b, v7.8b, v8.8b");
- COMPARE(Eor(v6.V16B(), v7.V16B(), v8.V16B()), "eor v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Eor(v6.V8B(), v7.V8B(), v8.V8B()), "eor v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Eor(v6.V16B(), v7.V16B(), v8.V16B()),
+ "eor v6.16b, v7.16b, v8.16b");
- COMPARE(Bif(v6.V8B(), v7.V8B(), v8.V8B()), "bif v6.8b, v7.8b, v8.8b");
- COMPARE(Bif(v6.V16B(), v7.V16B(), v8.V16B()), "bif v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Bif(v6.V8B(), v7.V8B(), v8.V8B()), "bif v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Bif(v6.V16B(), v7.V16B(), v8.V16B()),
+ "bif v6.16b, v7.16b, v8.16b");
- COMPARE(Bit(v6.V8B(), v7.V8B(), v8.V8B()), "bit v6.8b, v7.8b, v8.8b");
- COMPARE(Bit(v6.V16B(), v7.V16B(), v8.V16B()), "bit v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Bit(v6.V8B(), v7.V8B(), v8.V8B()), "bit v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Bit(v6.V16B(), v7.V16B(), v8.V16B()),
+ "bit v6.16b, v7.16b, v8.16b");
- COMPARE(Bsl(v6.V8B(), v7.V8B(), v8.V8B()), "bsl v6.8b, v7.8b, v8.8b");
- COMPARE(Bsl(v6.V16B(), v7.V16B(), v8.V16B()), "bsl v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Bsl(v6.V8B(), v7.V8B(), v8.V8B()), "bsl v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Bsl(v6.V16B(), v7.V16B(), v8.V16B()),
+ "bsl v6.16b, v7.16b, v8.16b");
- COMPARE(Pmul(v6.V8B(), v7.V8B(), v8.V8B()), "pmul v6.8b, v7.8b, v8.8b");
- COMPARE(Pmul(v6.V16B(), v7.V16B(), v8.V16B()), "pmul v6.16b, v7.16b, v8.16b");
+ COMPARE_MACRO(Pmul(v6.V8B(), v7.V8B(), v8.V8B()), "pmul v6.8b, v7.8b, v8.8b");
+ COMPARE_MACRO(Pmul(v6.V16B(), v7.V16B(), v8.V16B()),
+ "pmul v6.16b, v7.16b, v8.16b");
CLEANUP();
}
@@ -4366,134 +4540,148 @@ TEST(neon_3same) {
V(V2D(), "2d")
TEST(neon_fp_3same) {
- SETUP_MACRO();
+ SETUP();
#define DISASM_INST(M, S) \
- COMPARE(Fadd(v0.M, v1.M, v2.M), "fadd v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Fadd(v0.M, v1.M, v2.M), "fadd v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Fsub(v3.M, v4.M, v5.M), "fsub v3." S ", v4." S ", v5." S);
+ COMPARE_MACRO(Fsub(v3.M, v4.M, v5.M), "fsub v3." S ", v4." S ", v5." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Fmul(v6.M, v7.M, v8.M), "fmul v6." S ", v7." S ", v8." S);
+ COMPARE_MACRO(Fmul(v6.M, v7.M, v8.M), "fmul v6." S ", v7." S ", v8." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Fdiv(v9.M, v10.M, v11.M), "fdiv v9." S ", v10." S ", v11." S);
+ COMPARE_MACRO(Fdiv(v9.M, v10.M, v11.M), "fdiv v9." S ", v10." S ", v11." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fmin(v12.M, v13.M, v14.M), "fmin v12." S ", v13." S ", v14." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fmin(v12.M, v13.M, v14.M), \
+ "fmin v12." S ", v13." S \
+ ", " \
+ "v14." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fminnm(v15.M, v16.M, v17.M), "fminnm v15." S ", v16." S ", v17." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fminnm(v15.M, v16.M, v17.M), \
+ "fminnm v15." S ", v16." S ", v17." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fmax(v18.M, v19.M, v20.M), "fmax v18." S ", v19." S ", v20." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fmax(v18.M, v19.M, v20.M), \
+ "fmax v18." S ", v19." S \
+ ", " \
+ "v20." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fmaxnm(v21.M, v22.M, v23.M), "fmaxnm v21." S ", v22." S ", v23." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fmaxnm(v21.M, v22.M, v23.M), \
+ "fmaxnm v21." S ", v22." S ", v23." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Frecps(v24.M, v25.M, v26.M), "frecps v24." S ", v25." S ", v26." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Frecps(v24.M, v25.M, v26.M), \
+ "frecps v24." S ", v25." S ", v26." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Frsqrts(v27.M, v28.M, v29.M), \
- "frsqrts v27." S ", v28." S \
- ", " \
- "v29." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Frsqrts(v27.M, v28.M, v29.M), \
+ "frsqrts v27." S ", v28." S ", v29." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fmulx(v30.M, v31.M, v0.M), "fmulx v30." S ", v31." S ", v0." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fmulx(v30.M, v31.M, v0.M), \
+ "fmulx v30." S ", v31." S \
+ ", " \
+ "v0." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Fmla(v1.M, v2.M, v3.M), "fmla v1." S ", v2." S ", v3." S);
+ COMPARE_MACRO(Fmla(v1.M, v2.M, v3.M), "fmla v1." S ", v2." S ", v3." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Fmls(v4.M, v5.M, v6.M), "fmls v4." S ", v5." S ", v6." S);
+ COMPARE_MACRO(Fmls(v4.M, v5.M, v6.M), "fmls v4." S ", v5." S ", v6." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Fabd(v7.M, v8.M, v9.M), "fabd v7." S ", v8." S ", v9." S);
+ COMPARE_MACRO(Fabd(v7.M, v8.M, v9.M), "fabd v7." S ", v8." S ", v9." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Faddp(v10.M, v11.M, v12.M), "faddp v10." S ", v11." S ", v12." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Faddp(v10.M, v11.M, v12.M), \
+ "faddp v10." S ", v11." S ", v12." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fmaxp(v13.M, v14.M, v15.M), "fmaxp v13." S ", v14." S ", v15." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fmaxp(v13.M, v14.M, v15.M), \
+ "fmaxp v13." S ", v14." S ", v15." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fminp(v16.M, v17.M, v18.M), "fminp v16." S ", v17." S ", v18." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fminp(v16.M, v17.M, v18.M), \
+ "fminp v16." S ", v17." S ", v18." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fmaxnmp(v19.M, v20.M, v21.M), \
- "fmaxnmp v19." S ", v20." S \
- ", " \
- "v21." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fmaxnmp(v19.M, v20.M, v21.M), \
+ "fmaxnmp v19." S ", v20." S ", v21." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fminnmp(v22.M, v23.M, v24.M), \
- "fminnmp v22." S ", v23." S \
- ", " \
- "v24." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fminnmp(v22.M, v23.M, v24.M), \
+ "fminnmp v22." S ", v23." S ", v24." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fcmeq(v25.M, v26.M, v27.M), "fcmeq v25." S ", v26." S ", v27." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fcmeq(v25.M, v26.M, v27.M), \
+ "fcmeq v25." S ", v26." S ", v27." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fcmge(v25.M, v26.M, v27.M), "fcmge v25." S ", v26." S ", v27." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fcmge(v25.M, v26.M, v27.M), \
+ "fcmge v25." S ", v26." S ", v27." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Fcmgt(v25.M, v26.M, v27.M), "fcmgt v25." S ", v26." S ", v27." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Fcmgt(v25.M, v26.M, v27.M), \
+ "fcmgt v25." S ", v26." S ", v27." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Facge(v25.M, v26.M, v27.M), "facge v25." S ", v26." S ", v27." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Facge(v25.M, v26.M, v27.M), \
+ "facge v25." S ", v26." S ", v27." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, S) \
- COMPARE(Facgt(v25.M, v26.M, v27.M), "facgt v25." S ", v26." S ", v27." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Facgt(v25.M, v26.M, v27.M), \
+ "facgt v25." S ", v26." S ", v27." S);
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
@@ -4508,83 +4696,95 @@ TEST(neon_fp_3same) {
V(D(), "d")
TEST(neon_scalar_3same) {
- SETUP_MACRO();
+ SETUP();
// Instructions that only support D-sized scalar operations.
- COMPARE(Add(v0.D(), v1.D(), v2.D()), "add d0, d1, d2");
- COMPARE(Sub(v3.D(), v4.D(), v5.D()), "sub d3, d4, d5");
- COMPARE(Cmeq(v0.D(), v1.D(), v2.D()), "cmeq d0, d1, d2");
- COMPARE(Cmge(v3.D(), v4.D(), v5.D()), "cmge d3, d4, d5");
- COMPARE(Cmgt(v6.D(), v7.D(), v8.D()), "cmgt d6, d7, d8");
- COMPARE(Cmhi(v0.D(), v1.D(), v2.D()), "cmhi d0, d1, d2");
- COMPARE(Cmhs(v3.D(), v4.D(), v5.D()), "cmhs d3, d4, d5");
- COMPARE(Cmtst(v6.D(), v7.D(), v8.D()), "cmtst d6, d7, d8");
- COMPARE(Ushl(v6.D(), v7.D(), v8.D()), "ushl d6, d7, d8");
- COMPARE(Sshl(v6.D(), v7.D(), v8.D()), "sshl d6, d7, d8");
- COMPARE(Urshl(v9.D(), v10.D(), v11.D()), "urshl d9, d10, d11");
- COMPARE(Srshl(v9.D(), v10.D(), v11.D()), "srshl d9, d10, d11");
+ COMPARE_MACRO(Add(v0.D(), v1.D(), v2.D()), "add d0, d1, d2");
+ COMPARE_MACRO(Sub(v3.D(), v4.D(), v5.D()), "sub d3, d4, d5");
+ COMPARE_MACRO(Cmeq(v0.D(), v1.D(), v2.D()), "cmeq d0, d1, d2");
+ COMPARE_MACRO(Cmge(v3.D(), v4.D(), v5.D()), "cmge d3, d4, d5");
+ COMPARE_MACRO(Cmgt(v6.D(), v7.D(), v8.D()), "cmgt d6, d7, d8");
+ COMPARE_MACRO(Cmhi(v0.D(), v1.D(), v2.D()), "cmhi d0, d1, d2");
+ COMPARE_MACRO(Cmhs(v3.D(), v4.D(), v5.D()), "cmhs d3, d4, d5");
+ COMPARE_MACRO(Cmtst(v6.D(), v7.D(), v8.D()), "cmtst d6, d7, d8");
+ COMPARE_MACRO(Ushl(v6.D(), v7.D(), v8.D()), "ushl d6, d7, d8");
+ COMPARE_MACRO(Sshl(v6.D(), v7.D(), v8.D()), "sshl d6, d7, d8");
+ COMPARE_MACRO(Urshl(v9.D(), v10.D(), v11.D()), "urshl d9, d10, d11");
+ COMPARE_MACRO(Srshl(v9.D(), v10.D(), v11.D()), "srshl d9, d10, d11");
// Instructions that support S and D-sized scalar operations.
- COMPARE(Frecps(v12.S(), v13.S(), v14.S()), "frecps s12, s13, s14");
- COMPARE(Frecps(v15.D(), v16.D(), v17.D()), "frecps d15, d16, d17");
- COMPARE(Frsqrts(v18.S(), v19.S(), v20.S()), "frsqrts s18, s19, s20");
- COMPARE(Frsqrts(v21.D(), v22.D(), v23.D()), "frsqrts d21, d22, d23");
- COMPARE(Fmulx(v12.S(), v13.S(), v14.S()), "fmulx s12, s13, s14");
- COMPARE(Fmulx(v15.D(), v16.D(), v17.D()), "fmulx d15, d16, d17");
- COMPARE(Fcmeq(v12.S(), v13.S(), v14.S()), "fcmeq s12, s13, s14");
- COMPARE(Fcmeq(v15.D(), v16.D(), v17.D()), "fcmeq d15, d16, d17");
- COMPARE(Fcmge(v12.S(), v13.S(), v14.S()), "fcmge s12, s13, s14");
- COMPARE(Fcmge(v15.D(), v16.D(), v17.D()), "fcmge d15, d16, d17");
- COMPARE(Fcmgt(v12.S(), v13.S(), v14.S()), "fcmgt s12, s13, s14");
- COMPARE(Fcmgt(v15.D(), v16.D(), v17.D()), "fcmgt d15, d16, d17");
- COMPARE(Fcmge(v12.S(), v13.S(), v14.S()), "fcmge s12, s13, s14");
- COMPARE(Fcmge(v15.D(), v16.D(), v17.D()), "fcmge d15, d16, d17");
- COMPARE(Facgt(v12.S(), v13.S(), v14.S()), "facgt s12, s13, s14");
- COMPARE(Facgt(v15.D(), v16.D(), v17.D()), "facgt d15, d16, d17");
+ COMPARE_MACRO(Frecps(v12.S(), v13.S(), v14.S()), "frecps s12, s13, s14");
+ COMPARE_MACRO(Frecps(v15.D(), v16.D(), v17.D()), "frecps d15, d16, d17");
+ COMPARE_MACRO(Frsqrts(v18.S(), v19.S(), v20.S()), "frsqrts s18, s19, s20");
+ COMPARE_MACRO(Frsqrts(v21.D(), v22.D(), v23.D()), "frsqrts d21, d22, d23");
+ COMPARE_MACRO(Fmulx(v12.S(), v13.S(), v14.S()), "fmulx s12, s13, s14");
+ COMPARE_MACRO(Fmulx(v15.D(), v16.D(), v17.D()), "fmulx d15, d16, d17");
+ COMPARE_MACRO(Fcmeq(v12.S(), v13.S(), v14.S()), "fcmeq s12, s13, s14");
+ COMPARE_MACRO(Fcmeq(v15.D(), v16.D(), v17.D()), "fcmeq d15, d16, d17");
+ COMPARE_MACRO(Fcmge(v12.S(), v13.S(), v14.S()), "fcmge s12, s13, s14");
+ COMPARE_MACRO(Fcmge(v15.D(), v16.D(), v17.D()), "fcmge d15, d16, d17");
+ COMPARE_MACRO(Fcmgt(v12.S(), v13.S(), v14.S()), "fcmgt s12, s13, s14");
+ COMPARE_MACRO(Fcmgt(v15.D(), v16.D(), v17.D()), "fcmgt d15, d16, d17");
+ COMPARE_MACRO(Fcmge(v12.S(), v13.S(), v14.S()), "fcmge s12, s13, s14");
+ COMPARE_MACRO(Fcmge(v15.D(), v16.D(), v17.D()), "fcmge d15, d16, d17");
+ COMPARE_MACRO(Facgt(v12.S(), v13.S(), v14.S()), "facgt s12, s13, s14");
+ COMPARE_MACRO(Facgt(v15.D(), v16.D(), v17.D()), "facgt d15, d16, d17");
// Instructions that support H and S-sized scalar operations.
- COMPARE(Sqdmulh(v12.S(), v13.S(), v14.S()), "sqdmulh s12, s13, s14");
- COMPARE(Sqdmulh(v15.H(), v16.H(), v17.H()), "sqdmulh h15, h16, h17");
- COMPARE(Sqrdmulh(v12.S(), v13.S(), v14.S()), "sqrdmulh s12, s13, s14");
- COMPARE(Sqrdmulh(v15.H(), v16.H(), v17.H()), "sqrdmulh h15, h16, h17");
+ COMPARE_MACRO(Sqdmulh(v12.S(), v13.S(), v14.S()), "sqdmulh s12, s13, s14");
+ COMPARE_MACRO(Sqdmulh(v15.H(), v16.H(), v17.H()), "sqdmulh h15, h16, h17");
+ COMPARE_MACRO(Sqrdmulh(v12.S(), v13.S(), v14.S()), "sqrdmulh s12, s13, s14");
+ COMPARE_MACRO(Sqrdmulh(v15.H(), v16.H(), v17.H()), "sqrdmulh h15, h16, h17");
#define DISASM_INST(M, R) \
- COMPARE(Uqadd(v6.M, v7.M, v8.M), "uqadd " R "6, " R "7, " R "8");
+ COMPARE_MACRO(Uqadd(v6.M, v7.M, v8.M), "uqadd " R "6, " R "7, " R "8");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, R) \
- COMPARE(Uqsub(v9.M, v10.M, v11.M), "uqsub " R "9, " R "10, " R "11");
+ COMPARE_MACRO(Uqsub(v9.M, v10.M, v11.M), "uqsub " R "9, " R "10, " R "11");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, R) \
- COMPARE(Sqadd(v12.M, v13.M, v14.M), "sqadd " R "12, " R "13, " R "14");
+#define DISASM_INST(M, R) \
+ COMPARE_MACRO(Sqadd(v12.M, v13.M, v14.M), \
+ "sqadd " R "12, " R "13, " R \
+ "1" \
+ "4");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, R) \
- COMPARE(Sqsub(v15.M, v16.M, v17.M), "sqsub " R "15, " R "16, " R "17");
+#define DISASM_INST(M, R) \
+ COMPARE_MACRO(Sqsub(v15.M, v16.M, v17.M), \
+ "sqsub " R "15, " R "16, " R \
+ "1" \
+ "7");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, R) \
- COMPARE(Uqshl(v18.M, v19.M, v20.M), "uqshl " R "18, " R "19, " R "20");
+#define DISASM_INST(M, R) \
+ COMPARE_MACRO(Uqshl(v18.M, v19.M, v20.M), \
+ "uqshl " R "18, " R "19, " R \
+ "2" \
+ "0");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(M, R) \
- COMPARE(Sqshl(v21.M, v22.M, v23.M), "sqshl " R "21, " R "22, " R "23");
+#define DISASM_INST(M, R) \
+ COMPARE_MACRO(Sqshl(v21.M, v22.M, v23.M), \
+ "sqshl " R "21, " R "22, " R \
+ "2" \
+ "3");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, R) \
- COMPARE(Uqrshl(v30.M, v31.M, v0.M), "uqrshl " R "30, " R "31, " R "0");
+ COMPARE_MACRO(Uqrshl(v30.M, v31.M, v0.M), "uqrshl " R "30, " R "31, " R "0");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, R) \
- COMPARE(Sqrshl(v1.M, v2.M, v3.M), "sqrshl " R "1, " R "2, " R "3");
+ COMPARE_MACRO(Sqrshl(v1.M, v2.M, v3.M), "sqrshl " R "1, " R "2, " R "3");
NEON_SCALAR_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
@@ -4593,504 +4793,532 @@ TEST(neon_scalar_3same) {
TEST(neon_byelement) {
- SETUP_MACRO();
-
- COMPARE(Mul(v0.V4H(), v1.V4H(), v2.H(), 0), "mul v0.4h, v1.4h, v2.h[0]");
- COMPARE(Mul(v2.V8H(), v3.V8H(), v15.H(), 7), "mul v2.8h, v3.8h, v15.h[7]");
- COMPARE(Mul(v0.V2S(), v1.V2S(), v2.S(), 0), "mul v0.2s, v1.2s, v2.s[0]");
- COMPARE(Mul(v2.V4S(), v3.V4S(), v15.S(), 3), "mul v2.4s, v3.4s, v15.s[3]");
-
- COMPARE(Mla(v0.V4H(), v1.V4H(), v2.H(), 0), "mla v0.4h, v1.4h, v2.h[0]");
- COMPARE(Mla(v2.V8H(), v3.V8H(), v15.H(), 7), "mla v2.8h, v3.8h, v15.h[7]");
- COMPARE(Mla(v0.V2S(), v1.V2S(), v2.S(), 0), "mla v0.2s, v1.2s, v2.s[0]");
- COMPARE(Mla(v2.V4S(), v3.V4S(), v15.S(), 3), "mla v2.4s, v3.4s, v15.s[3]");
-
- COMPARE(Mls(v0.V4H(), v1.V4H(), v2.H(), 0), "mls v0.4h, v1.4h, v2.h[0]");
- COMPARE(Mls(v2.V8H(), v3.V8H(), v15.H(), 7), "mls v2.8h, v3.8h, v15.h[7]");
- COMPARE(Mls(v0.V2S(), v1.V2S(), v2.S(), 0), "mls v0.2s, v1.2s, v2.s[0]");
- COMPARE(Mls(v2.V4S(), v3.V4S(), v15.S(), 3), "mls v2.4s, v3.4s, v15.s[3]");
-
- COMPARE(Sqdmulh(v0.V4H(), v1.V4H(), v2.H(), 0),
- "sqdmulh v0.4h, v1.4h, v2.h[0]");
- COMPARE(Sqdmulh(v2.V8H(), v3.V8H(), v15.H(), 7),
- "sqdmulh v2.8h, v3.8h, v15.h[7]");
- COMPARE(Sqdmulh(v0.V2S(), v1.V2S(), v2.S(), 0),
- "sqdmulh v0.2s, v1.2s, v2.s[0]");
- COMPARE(Sqdmulh(v2.V4S(), v3.V4S(), v15.S(), 3),
- "sqdmulh v2.4s, v3.4s, v15.s[3]");
- COMPARE(Sqdmulh(h0, h1, v2.H(), 0), "sqdmulh h0, h1, v2.h[0]");
- COMPARE(Sqdmulh(s0, s1, v2.S(), 0), "sqdmulh s0, s1, v2.s[0]");
-
- COMPARE(Sqrdmulh(v0.V4H(), v1.V4H(), v2.H(), 0),
- "sqrdmulh v0.4h, v1.4h, v2.h[0]");
- COMPARE(Sqrdmulh(v2.V8H(), v3.V8H(), v15.H(), 7),
- "sqrdmulh v2.8h, v3.8h, v15.h[7]");
- COMPARE(Sqrdmulh(v0.V2S(), v1.V2S(), v2.S(), 0),
- "sqrdmulh v0.2s, v1.2s, v2.s[0]");
- COMPARE(Sqrdmulh(v2.V4S(), v3.V4S(), v15.S(), 3),
- "sqrdmulh v2.4s, v3.4s, v15.s[3]");
- COMPARE(Sqrdmulh(h0, h1, v2.H(), 0), "sqrdmulh h0, h1, v2.h[0]");
- COMPARE(Sqrdmulh(s0, s1, v2.S(), 0), "sqrdmulh s0, s1, v2.s[0]");
-
- COMPARE(Smull(v0.V4S(), v1.V4H(), v2.H(), 0), "smull v0.4s, v1.4h, v2.h[0]");
- COMPARE(Smull2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "smull2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Smull(v0.V2D(), v1.V2S(), v2.S(), 0), "smull v0.2d, v1.2s, v2.s[0]");
- COMPARE(Smull2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "smull2 v2.2d, v3.4s, v4.s[3]");
-
- COMPARE(Umull(v0.V4S(), v1.V4H(), v2.H(), 0), "umull v0.4s, v1.4h, v2.h[0]");
- COMPARE(Umull2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "umull2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Umull(v0.V2D(), v1.V2S(), v2.S(), 0), "umull v0.2d, v1.2s, v2.s[0]");
- COMPARE(Umull2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "umull2 v2.2d, v3.4s, v4.s[3]");
-
- COMPARE(Smlal(v0.V4S(), v1.V4H(), v2.H(), 0), "smlal v0.4s, v1.4h, v2.h[0]");
- COMPARE(Smlal2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "smlal2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Smlal(v0.V2D(), v1.V2S(), v2.S(), 0), "smlal v0.2d, v1.2s, v2.s[0]");
- COMPARE(Smlal2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "smlal2 v2.2d, v3.4s, v4.s[3]");
-
- COMPARE(Umlal(v0.V4S(), v1.V4H(), v2.H(), 0), "umlal v0.4s, v1.4h, v2.h[0]");
- COMPARE(Umlal2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "umlal2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Umlal(v0.V2D(), v1.V2S(), v2.S(), 0), "umlal v0.2d, v1.2s, v2.s[0]");
- COMPARE(Umlal2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "umlal2 v2.2d, v3.4s, v4.s[3]");
-
- COMPARE(Smlsl(v0.V4S(), v1.V4H(), v2.H(), 0), "smlsl v0.4s, v1.4h, v2.h[0]");
- COMPARE(Smlsl2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "smlsl2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Smlsl(v0.V2D(), v1.V2S(), v2.S(), 0), "smlsl v0.2d, v1.2s, v2.s[0]");
- COMPARE(Smlsl2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "smlsl2 v2.2d, v3.4s, v4.s[3]");
-
- COMPARE(Umlsl(v0.V4S(), v1.V4H(), v2.H(), 0), "umlsl v0.4s, v1.4h, v2.h[0]");
- COMPARE(Umlsl2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "umlsl2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Umlsl(v0.V2D(), v1.V2S(), v2.S(), 0), "umlsl v0.2d, v1.2s, v2.s[0]");
- COMPARE(Umlsl2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "umlsl2 v2.2d, v3.4s, v4.s[3]");
-
- COMPARE(Sqdmull(v0.V4S(), v1.V4H(), v2.H(), 0),
- "sqdmull v0.4s, v1.4h, v2.h[0]");
- COMPARE(Sqdmull2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "sqdmull2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Sqdmull(v0.V2D(), v1.V2S(), v2.S(), 0),
- "sqdmull v0.2d, v1.2s, v2.s[0]");
- COMPARE(Sqdmull2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "sqdmull2 v2.2d, v3.4s, v4.s[3]");
- COMPARE(Sqdmull(s0, h1, v2.H(), 0), "sqdmull s0, h1, v2.h[0]");
- COMPARE(Sqdmull(d0, s1, v2.S(), 0), "sqdmull d0, s1, v2.s[0]");
-
- COMPARE(Sqdmlal(v0.V4S(), v1.V4H(), v2.H(), 0),
- "sqdmlal v0.4s, v1.4h, v2.h[0]");
- COMPARE(Sqdmlal2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "sqdmlal2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Sqdmlal(v0.V2D(), v1.V2S(), v2.S(), 0),
- "sqdmlal v0.2d, v1.2s, v2.s[0]");
- COMPARE(Sqdmlal2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "sqdmlal2 v2.2d, v3.4s, v4.s[3]");
- COMPARE(Sqdmlal(s0, h1, v2.H(), 0), "sqdmlal s0, h1, v2.h[0]");
- COMPARE(Sqdmlal(d0, s1, v2.S(), 0), "sqdmlal d0, s1, v2.s[0]");
-
- COMPARE(Sqdmlsl(v0.V4S(), v1.V4H(), v2.H(), 0),
- "sqdmlsl v0.4s, v1.4h, v2.h[0]");
- COMPARE(Sqdmlsl2(v2.V4S(), v3.V8H(), v4.H(), 7),
- "sqdmlsl2 v2.4s, v3.8h, v4.h[7]");
- COMPARE(Sqdmlsl(v0.V2D(), v1.V2S(), v2.S(), 0),
- "sqdmlsl v0.2d, v1.2s, v2.s[0]");
- COMPARE(Sqdmlsl2(v2.V2D(), v3.V4S(), v4.S(), 3),
- "sqdmlsl2 v2.2d, v3.4s, v4.s[3]");
- COMPARE(Sqdmlsl(s0, h1, v2.H(), 0), "sqdmlsl s0, h1, v2.h[0]");
- COMPARE(Sqdmlsl(d0, s1, v2.S(), 0), "sqdmlsl d0, s1, v2.s[0]");
+ SETUP();
+
+ COMPARE_MACRO(Mul(v0.V4H(), v1.V4H(), v2.H(), 0),
+ "mul v0.4h, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Mul(v2.V8H(), v3.V8H(), v15.H(), 7),
+ "mul v2.8h, v3.8h, v15.h[7]");
+ COMPARE_MACRO(Mul(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "mul v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Mul(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "mul v2.4s, v3.4s, v15.s[3]");
+
+ COMPARE_MACRO(Mla(v0.V4H(), v1.V4H(), v2.H(), 0),
+ "mla v0.4h, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Mla(v2.V8H(), v3.V8H(), v15.H(), 7),
+ "mla v2.8h, v3.8h, v15.h[7]");
+ COMPARE_MACRO(Mla(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "mla v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Mla(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "mla v2.4s, v3.4s, v15.s[3]");
+
+ COMPARE_MACRO(Mls(v0.V4H(), v1.V4H(), v2.H(), 0),
+ "mls v0.4h, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Mls(v2.V8H(), v3.V8H(), v15.H(), 7),
+ "mls v2.8h, v3.8h, v15.h[7]");
+ COMPARE_MACRO(Mls(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "mls v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Mls(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "mls v2.4s, v3.4s, v15.s[3]");
+
+ COMPARE_MACRO(Sqdmulh(v0.V4H(), v1.V4H(), v2.H(), 0),
+ "sqdmulh v0.4h, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Sqdmulh(v2.V8H(), v3.V8H(), v15.H(), 7),
+ "sqdmulh v2.8h, v3.8h, v15.h[7]");
+ COMPARE_MACRO(Sqdmulh(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "sqdmulh v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Sqdmulh(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "sqdmulh v2.4s, v3.4s, v15.s[3]");
+ COMPARE_MACRO(Sqdmulh(h0, h1, v2.H(), 0), "sqdmulh h0, h1, v2.h[0]");
+ COMPARE_MACRO(Sqdmulh(s0, s1, v2.S(), 0), "sqdmulh s0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Sqrdmulh(v0.V4H(), v1.V4H(), v2.H(), 0),
+ "sqrdmulh v0.4h, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Sqrdmulh(v2.V8H(), v3.V8H(), v15.H(), 7),
+ "sqrdmulh v2.8h, v3.8h, v15.h[7]");
+ COMPARE_MACRO(Sqrdmulh(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "sqrdmulh v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Sqrdmulh(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "sqrdmulh v2.4s, v3.4s, v15.s[3]");
+ COMPARE_MACRO(Sqrdmulh(h0, h1, v2.H(), 0), "sqrdmulh h0, h1, v2.h[0]");
+ COMPARE_MACRO(Sqrdmulh(s0, s1, v2.S(), 0), "sqrdmulh s0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Smull(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "smull v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Smull2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "smull2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Smull(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "smull v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Smull2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "smull2 v2.2d, v3.4s, v4.s[3]");
+
+ COMPARE_MACRO(Umull(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "umull v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Umull2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "umull2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Umull(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "umull v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Umull2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "umull2 v2.2d, v3.4s, v4.s[3]");
+
+ COMPARE_MACRO(Smlal(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "smlal v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Smlal2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "smlal2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Smlal(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "smlal v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Smlal2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "smlal2 v2.2d, v3.4s, v4.s[3]");
+
+ COMPARE_MACRO(Umlal(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "umlal v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Umlal2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "umlal2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Umlal(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "umlal v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Umlal2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "umlal2 v2.2d, v3.4s, v4.s[3]");
+
+ COMPARE_MACRO(Smlsl(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "smlsl v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Smlsl2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "smlsl2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Smlsl(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "smlsl v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Smlsl2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "smlsl2 v2.2d, v3.4s, v4.s[3]");
+
+ COMPARE_MACRO(Umlsl(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "umlsl v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Umlsl2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "umlsl2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Umlsl(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "umlsl v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Umlsl2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "umlsl2 v2.2d, v3.4s, v4.s[3]");
+
+ COMPARE_MACRO(Sqdmull(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "sqdmull v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Sqdmull2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "sqdmull2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Sqdmull(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "sqdmull v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Sqdmull2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "sqdmull2 v2.2d, v3.4s, v4.s[3]");
+ COMPARE_MACRO(Sqdmull(s0, h1, v2.H(), 0), "sqdmull s0, h1, v2.h[0]");
+ COMPARE_MACRO(Sqdmull(d0, s1, v2.S(), 0), "sqdmull d0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Sqdmlal(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "sqdmlal v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Sqdmlal2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "sqdmlal2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Sqdmlal(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "sqdmlal v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Sqdmlal2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "sqdmlal2 v2.2d, v3.4s, v4.s[3]");
+ COMPARE_MACRO(Sqdmlal(s0, h1, v2.H(), 0), "sqdmlal s0, h1, v2.h[0]");
+ COMPARE_MACRO(Sqdmlal(d0, s1, v2.S(), 0), "sqdmlal d0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Sqdmlsl(v0.V4S(), v1.V4H(), v2.H(), 0),
+ "sqdmlsl v0.4s, v1.4h, v2.h[0]");
+ COMPARE_MACRO(Sqdmlsl2(v2.V4S(), v3.V8H(), v4.H(), 7),
+ "sqdmlsl2 v2.4s, v3.8h, v4.h[7]");
+ COMPARE_MACRO(Sqdmlsl(v0.V2D(), v1.V2S(), v2.S(), 0),
+ "sqdmlsl v0.2d, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Sqdmlsl2(v2.V2D(), v3.V4S(), v4.S(), 3),
+ "sqdmlsl2 v2.2d, v3.4s, v4.s[3]");
+ COMPARE_MACRO(Sqdmlsl(s0, h1, v2.H(), 0), "sqdmlsl s0, h1, v2.h[0]");
+ COMPARE_MACRO(Sqdmlsl(d0, s1, v2.S(), 0), "sqdmlsl d0, s1, v2.s[0]");
CLEANUP();
}
TEST(neon_fp_byelement) {
- SETUP_MACRO();
-
- COMPARE(Fmul(v0.V2S(), v1.V2S(), v2.S(), 0), "fmul v0.2s, v1.2s, v2.s[0]");
- COMPARE(Fmul(v2.V4S(), v3.V4S(), v15.S(), 3), "fmul v2.4s, v3.4s, v15.s[3]");
- COMPARE(Fmul(v0.V2D(), v1.V2D(), v2.D(), 0), "fmul v0.2d, v1.2d, v2.d[0]");
- COMPARE(Fmul(d0, d1, v2.D(), 0), "fmul d0, d1, v2.d[0]");
- COMPARE(Fmul(s0, s1, v2.S(), 0), "fmul s0, s1, v2.s[0]");
-
- COMPARE(Fmla(v0.V2S(), v1.V2S(), v2.S(), 0), "fmla v0.2s, v1.2s, v2.s[0]");
- COMPARE(Fmla(v2.V4S(), v3.V4S(), v15.S(), 3), "fmla v2.4s, v3.4s, v15.s[3]");
- COMPARE(Fmla(v0.V2D(), v1.V2D(), v2.D(), 0), "fmla v0.2d, v1.2d, v2.d[0]");
- COMPARE(Fmla(d0, d1, v2.D(), 0), "fmla d0, d1, v2.d[0]");
- COMPARE(Fmla(s0, s1, v2.S(), 0), "fmla s0, s1, v2.s[0]");
-
- COMPARE(Fmls(v0.V2S(), v1.V2S(), v2.S(), 0), "fmls v0.2s, v1.2s, v2.s[0]");
- COMPARE(Fmls(v2.V4S(), v3.V4S(), v15.S(), 3), "fmls v2.4s, v3.4s, v15.s[3]");
- COMPARE(Fmls(v0.V2D(), v1.V2D(), v2.D(), 0), "fmls v0.2d, v1.2d, v2.d[0]");
- COMPARE(Fmls(d0, d1, v2.D(), 0), "fmls d0, d1, v2.d[0]");
- COMPARE(Fmls(s0, s1, v2.S(), 0), "fmls s0, s1, v2.s[0]");
-
- COMPARE(Fmulx(v0.V2S(), v1.V2S(), v2.S(), 0), "fmulx v0.2s, v1.2s, v2.s[0]");
- COMPARE(Fmulx(v2.V4S(), v3.V4S(), v8.S(), 3), "fmulx v2.4s, v3.4s, v8.s[3]");
- COMPARE(Fmulx(v0.V2D(), v1.V2D(), v2.D(), 0), "fmulx v0.2d, v1.2d, v2.d[0]");
- COMPARE(Fmulx(d0, d1, v2.D(), 0), "fmulx d0, d1, v2.d[0]");
- COMPARE(Fmulx(s0, s1, v2.S(), 0), "fmulx s0, s1, v2.s[0]");
+ SETUP();
+
+ COMPARE_MACRO(Fmul(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "fmul v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Fmul(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "fmul v2.4s, v3.4s, v15.s[3]");
+ COMPARE_MACRO(Fmul(v0.V2D(), v1.V2D(), v2.D(), 0),
+ "fmul v0.2d, v1.2d, v2.d[0]");
+ COMPARE_MACRO(Fmul(d0, d1, v2.D(), 0), "fmul d0, d1, v2.d[0]");
+ COMPARE_MACRO(Fmul(s0, s1, v2.S(), 0), "fmul s0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Fmla(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "fmla v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Fmla(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "fmla v2.4s, v3.4s, v15.s[3]");
+ COMPARE_MACRO(Fmla(v0.V2D(), v1.V2D(), v2.D(), 0),
+ "fmla v0.2d, v1.2d, v2.d[0]");
+ COMPARE_MACRO(Fmla(d0, d1, v2.D(), 0), "fmla d0, d1, v2.d[0]");
+ COMPARE_MACRO(Fmla(s0, s1, v2.S(), 0), "fmla s0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Fmls(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "fmls v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Fmls(v2.V4S(), v3.V4S(), v15.S(), 3),
+ "fmls v2.4s, v3.4s, v15.s[3]");
+ COMPARE_MACRO(Fmls(v0.V2D(), v1.V2D(), v2.D(), 0),
+ "fmls v0.2d, v1.2d, v2.d[0]");
+ COMPARE_MACRO(Fmls(d0, d1, v2.D(), 0), "fmls d0, d1, v2.d[0]");
+ COMPARE_MACRO(Fmls(s0, s1, v2.S(), 0), "fmls s0, s1, v2.s[0]");
+
+ COMPARE_MACRO(Fmulx(v0.V2S(), v1.V2S(), v2.S(), 0),
+ "fmulx v0.2s, v1.2s, v2.s[0]");
+ COMPARE_MACRO(Fmulx(v2.V4S(), v3.V4S(), v8.S(), 3),
+ "fmulx v2.4s, v3.4s, v8.s[3]");
+ COMPARE_MACRO(Fmulx(v0.V2D(), v1.V2D(), v2.D(), 0),
+ "fmulx v0.2d, v1.2d, v2.d[0]");
+ COMPARE_MACRO(Fmulx(d0, d1, v2.D(), 0), "fmulx d0, d1, v2.d[0]");
+ COMPARE_MACRO(Fmulx(s0, s1, v2.S(), 0), "fmulx s0, s1, v2.s[0]");
CLEANUP();
}
TEST(neon_3different) {
- SETUP_MACRO();
+ SETUP();
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uaddl(v0.TA, v1.TB, v2.TB), \
- "uaddl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uaddl(v0.TA, v1.TB, v2.TB), \
+ "uaddl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uaddl2(v0.TA, v1.TB, v2.TB), \
- "uaddl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uaddl2(v0.TA, v1.TB, v2.TB), \
+ "uaddl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uaddw(v0.TA, v1.TA, v2.TB), \
- "uaddw v0." TAS ", v1." TAS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uaddw(v0.TA, v1.TA, v2.TB), \
+ "uaddw v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uaddw2(v0.TA, v1.TA, v2.TB), \
- "uaddw2 v0." TAS ", v1." TAS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uaddw2(v0.TA, v1.TA, v2.TB), \
+ "uaddw2 v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Saddl(v0.TA, v1.TB, v2.TB), \
- "saddl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Saddl(v0.TA, v1.TB, v2.TB), \
+ "saddl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Saddl2(v0.TA, v1.TB, v2.TB), \
- "saddl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Saddl2(v0.TA, v1.TB, v2.TB), \
+ "saddl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Saddw(v0.TA, v1.TA, v2.TB), \
- "saddw v0." TAS ", v1." TAS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Saddw(v0.TA, v1.TA, v2.TB), \
+ "saddw v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Saddw2(v0.TA, v1.TA, v2.TB), \
- "saddw2 v0." TAS ", v1." TAS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Saddw2(v0.TA, v1.TA, v2.TB), \
+ "saddw2 v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Usubl(v0.TA, v1.TB, v2.TB), \
- "usubl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Usubl(v0.TA, v1.TB, v2.TB), \
+ "usubl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Usubl2(v0.TA, v1.TB, v2.TB), \
- "usubl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Usubl2(v0.TA, v1.TB, v2.TB), \
+ "usubl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Usubw(v0.TA, v1.TA, v2.TB), \
- "usubw v0." TAS ", v1." TAS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Usubw(v0.TA, v1.TA, v2.TB), \
+ "usubw v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Usubw2(v0.TA, v1.TA, v2.TB), \
- "usubw2 v0." TAS ", v1." TAS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Usubw2(v0.TA, v1.TA, v2.TB), \
+ "usubw2 v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Ssubl(v0.TA, v1.TB, v2.TB), \
- "ssubl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Ssubl(v0.TA, v1.TB, v2.TB), \
+ "ssubl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Ssubl2(v0.TA, v1.TB, v2.TB), \
- "ssubl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Ssubl2(v0.TA, v1.TB, v2.TB), \
+ "ssubl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Ssubw(v0.TA, v1.TA, v2.TB), \
- "ssubw v0." TAS ", v1." TAS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Ssubw(v0.TA, v1.TA, v2.TB), \
+ "ssubw v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Ssubw2(v0.TA, v1.TA, v2.TB), \
- "ssubw2 v0." TAS ", v1." TAS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Ssubw2(v0.TA, v1.TA, v2.TB), \
+ "ssubw2 v0." TAS ", v1." TAS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Sabal(v0.TA, v1.TB, v2.TB), \
- "sabal v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Sabal(v0.TA, v1.TB, v2.TB), \
+ "sabal v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Sabal2(v0.TA, v1.TB, v2.TB), \
- "sabal2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Sabal2(v0.TA, v1.TB, v2.TB), \
+ "sabal2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uabal(v0.TA, v1.TB, v2.TB), \
- "uabal v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uabal(v0.TA, v1.TB, v2.TB), \
+ "uabal v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uabal2(v0.TA, v1.TB, v2.TB), \
- "uabal2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uabal2(v0.TA, v1.TB, v2.TB), \
+ "uabal2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Sabdl(v0.TA, v1.TB, v2.TB), \
- "sabdl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Sabdl(v0.TA, v1.TB, v2.TB), \
+ "sabdl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Sabdl2(v0.TA, v1.TB, v2.TB), \
- "sabdl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Sabdl2(v0.TA, v1.TB, v2.TB), \
+ "sabdl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uabdl(v0.TA, v1.TB, v2.TB), \
- "uabdl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uabdl(v0.TA, v1.TB, v2.TB), \
+ "uabdl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uabdl2(v0.TA, v1.TB, v2.TB), \
- "uabdl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Uabdl2(v0.TA, v1.TB, v2.TB), \
+ "uabdl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Smlal(v0.TA, v1.TB, v2.TB), \
- "smlal v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Smlal(v0.TA, v1.TB, v2.TB), \
+ "smlal v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Smlal2(v0.TA, v1.TB, v2.TB), \
- "smlal2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Smlal2(v0.TA, v1.TB, v2.TB), \
+ "smlal2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Umlsl(v0.TA, v1.TB, v2.TB), \
- "umlsl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Umlsl(v0.TA, v1.TB, v2.TB), \
+ "umlsl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Umlsl2(v0.TA, v1.TB, v2.TB), \
- "umlsl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Umlsl2(v0.TA, v1.TB, v2.TB), \
+ "umlsl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Smlsl(v0.TA, v1.TB, v2.TB), \
- "smlsl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Smlsl(v0.TA, v1.TB, v2.TB), \
+ "smlsl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Smlsl2(v0.TA, v1.TB, v2.TB), \
- "smlsl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Smlsl2(v0.TA, v1.TB, v2.TB), \
+ "smlsl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Umlsl(v0.TA, v1.TB, v2.TB), \
- "umlsl v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Umlsl(v0.TA, v1.TB, v2.TB), \
+ "umlsl v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Umlsl2(v0.TA, v1.TB, v2.TB), \
- "umlsl2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Umlsl2(v0.TA, v1.TB, v2.TB), \
+ "umlsl2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Smull(v0.TA, v1.TB, v2.TB), \
- "smull v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Smull(v0.TA, v1.TB, v2.TB), \
+ "smull v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Smull2(v0.TA, v1.TB, v2.TB), \
- "smull2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Smull2(v0.TA, v1.TB, v2.TB), \
+ "smull2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Umull(v0.TA, v1.TB, v2.TB), \
- "umull v0." TAS ", v1." TBS \
- ", " \
- "v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Umull(v0.TA, v1.TB, v2.TB), \
+ "umull v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW(DISASM_INST)
#undef DISASM_INST
-#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Umull2(v0.TA, v1.TB, v2.TB), \
- "umull2 v0." TAS ", v1." TBS ", v2." TBS);
+#define DISASM_INST(TA, TAS, TB, TBS) \
+ COMPARE_MACRO(Umull2(v0.TA, v1.TB, v2.TB), \
+ "umull2 v0." TAS ", v1." TBS ", v2." TBS);
NEON_FORMAT_LIST_LW2(DISASM_INST)
#undef DISASM_INST
- COMPARE(Sqdmull(v0.V4S(), v1.V4H(), v2.V4H()), "sqdmull v0.4s, v1.4h, v2.4h");
- COMPARE(Sqdmull(v1.V2D(), v2.V2S(), v3.V2S()), "sqdmull v1.2d, v2.2s, v3.2s");
- COMPARE(Sqdmull2(v2.V4S(), v3.V8H(), v4.V8H()),
- "sqdmull2 v2.4s, v3.8h, v4.8h");
- COMPARE(Sqdmull2(v3.V2D(), v4.V4S(), v5.V4S()),
- "sqdmull2 v3.2d, v4.4s, v5.4s");
- COMPARE(Sqdmull(s0, h1, h2), "sqdmull s0, h1, h2");
- COMPARE(Sqdmull(d1, s2, s3), "sqdmull d1, s2, s3");
-
- COMPARE(Sqdmlal(v0.V4S(), v1.V4H(), v2.V4H()), "sqdmlal v0.4s, v1.4h, v2.4h");
- COMPARE(Sqdmlal(v1.V2D(), v2.V2S(), v3.V2S()), "sqdmlal v1.2d, v2.2s, v3.2s");
- COMPARE(Sqdmlal2(v2.V4S(), v3.V8H(), v4.V8H()),
- "sqdmlal2 v2.4s, v3.8h, v4.8h");
- COMPARE(Sqdmlal2(v3.V2D(), v4.V4S(), v5.V4S()),
- "sqdmlal2 v3.2d, v4.4s, v5.4s");
- COMPARE(Sqdmlal(s0, h1, h2), "sqdmlal s0, h1, h2");
- COMPARE(Sqdmlal(d1, s2, s3), "sqdmlal d1, s2, s3");
-
- COMPARE(Sqdmlsl(v0.V4S(), v1.V4H(), v2.V4H()), "sqdmlsl v0.4s, v1.4h, v2.4h");
- COMPARE(Sqdmlsl(v1.V2D(), v2.V2S(), v3.V2S()), "sqdmlsl v1.2d, v2.2s, v3.2s");
- COMPARE(Sqdmlsl2(v2.V4S(), v3.V8H(), v4.V8H()),
- "sqdmlsl2 v2.4s, v3.8h, v4.8h");
- COMPARE(Sqdmlsl2(v3.V2D(), v4.V4S(), v5.V4S()),
- "sqdmlsl2 v3.2d, v4.4s, v5.4s");
- COMPARE(Sqdmlsl(s0, h1, h2), "sqdmlsl s0, h1, h2");
- COMPARE(Sqdmlsl(d1, s2, s3), "sqdmlsl d1, s2, s3");
-
- COMPARE(Addhn(v0.V8B(), v1.V8H(), v2.V8H()), "addhn v0.8b, v1.8h, v2.8h");
- COMPARE(Addhn(v1.V4H(), v2.V4S(), v3.V4S()), "addhn v1.4h, v2.4s, v3.4s");
- COMPARE(Addhn(v2.V2S(), v3.V2D(), v4.V2D()), "addhn v2.2s, v3.2d, v4.2d");
- COMPARE(Addhn2(v0.V16B(), v1.V8H(), v5.V8H()), "addhn2 v0.16b, v1.8h, v5.8h");
- COMPARE(Addhn2(v1.V8H(), v2.V4S(), v6.V4S()), "addhn2 v1.8h, v2.4s, v6.4s");
- COMPARE(Addhn2(v2.V4S(), v3.V2D(), v7.V2D()), "addhn2 v2.4s, v3.2d, v7.2d");
-
- COMPARE(Raddhn(v0.V8B(), v1.V8H(), v2.V8H()), "raddhn v0.8b, v1.8h, v2.8h");
- COMPARE(Raddhn(v1.V4H(), v2.V4S(), v3.V4S()), "raddhn v1.4h, v2.4s, v3.4s");
- COMPARE(Raddhn(v2.V2S(), v3.V2D(), v4.V2D()), "raddhn v2.2s, v3.2d, v4.2d");
- COMPARE(Raddhn2(v0.V16B(), v1.V8H(), v5.V8H()),
- "raddhn2 v0.16b, v1.8h, v5.8h");
- COMPARE(Raddhn2(v1.V8H(), v2.V4S(), v6.V4S()), "raddhn2 v1.8h, v2.4s, v6.4s");
- COMPARE(Raddhn2(v2.V4S(), v3.V2D(), v7.V2D()), "raddhn2 v2.4s, v3.2d, v7.2d");
-
- COMPARE(Subhn(v1.V4H(), v2.V4S(), v3.V4S()), "subhn v1.4h, v2.4s, v3.4s");
- COMPARE(Subhn(v2.V2S(), v3.V2D(), v4.V2D()), "subhn v2.2s, v3.2d, v4.2d");
- COMPARE(Subhn2(v0.V16B(), v1.V8H(), v5.V8H()), "subhn2 v0.16b, v1.8h, v5.8h");
- COMPARE(Subhn2(v1.V8H(), v2.V4S(), v6.V4S()), "subhn2 v1.8h, v2.4s, v6.4s");
- COMPARE(Subhn2(v2.V4S(), v3.V2D(), v7.V2D()), "subhn2 v2.4s, v3.2d, v7.2d");
-
- COMPARE(Rsubhn(v0.V8B(), v1.V8H(), v2.V8H()), "rsubhn v0.8b, v1.8h, v2.8h");
- COMPARE(Rsubhn(v1.V4H(), v2.V4S(), v3.V4S()), "rsubhn v1.4h, v2.4s, v3.4s");
- COMPARE(Rsubhn(v2.V2S(), v3.V2D(), v4.V2D()), "rsubhn v2.2s, v3.2d, v4.2d");
- COMPARE(Rsubhn2(v0.V16B(), v1.V8H(), v5.V8H()),
- "rsubhn2 v0.16b, v1.8h, v5.8h");
- COMPARE(Rsubhn2(v1.V8H(), v2.V4S(), v6.V4S()), "rsubhn2 v1.8h, v2.4s, v6.4s");
- COMPARE(Rsubhn2(v2.V4S(), v3.V2D(), v7.V2D()), "rsubhn2 v2.4s, v3.2d, v7.2d");
-
- COMPARE(Pmull(v0.V8H(), v1.V8B(), v2.V8B()), "pmull v0.8h, v1.8b, v2.8b");
- COMPARE(Pmull2(v2.V8H(), v3.V16B(), v4.V16B()),
- "pmull2 v2.8h, v3.16b, v4.16b");
+ COMPARE_MACRO(Sqdmull(v0.V4S(), v1.V4H(), v2.V4H()),
+ "sqdmull v0.4s, v1.4h, v2.4h");
+ COMPARE_MACRO(Sqdmull(v1.V2D(), v2.V2S(), v3.V2S()),
+ "sqdmull v1.2d, v2.2s, v3.2s");
+ COMPARE_MACRO(Sqdmull2(v2.V4S(), v3.V8H(), v4.V8H()),
+ "sqdmull2 v2.4s, v3.8h, v4.8h");
+ COMPARE_MACRO(Sqdmull2(v3.V2D(), v4.V4S(), v5.V4S()),
+ "sqdmull2 v3.2d, v4.4s, v5.4s");
+ COMPARE_MACRO(Sqdmull(s0, h1, h2), "sqdmull s0, h1, h2");
+ COMPARE_MACRO(Sqdmull(d1, s2, s3), "sqdmull d1, s2, s3");
+
+ COMPARE_MACRO(Sqdmlal(v0.V4S(), v1.V4H(), v2.V4H()),
+ "sqdmlal v0.4s, v1.4h, v2.4h");
+ COMPARE_MACRO(Sqdmlal(v1.V2D(), v2.V2S(), v3.V2S()),
+ "sqdmlal v1.2d, v2.2s, v3.2s");
+ COMPARE_MACRO(Sqdmlal2(v2.V4S(), v3.V8H(), v4.V8H()),
+ "sqdmlal2 v2.4s, v3.8h, v4.8h");
+ COMPARE_MACRO(Sqdmlal2(v3.V2D(), v4.V4S(), v5.V4S()),
+ "sqdmlal2 v3.2d, v4.4s, v5.4s");
+ COMPARE_MACRO(Sqdmlal(s0, h1, h2), "sqdmlal s0, h1, h2");
+ COMPARE_MACRO(Sqdmlal(d1, s2, s3), "sqdmlal d1, s2, s3");
+
+ COMPARE_MACRO(Sqdmlsl(v0.V4S(), v1.V4H(), v2.V4H()),
+ "sqdmlsl v0.4s, v1.4h, v2.4h");
+ COMPARE_MACRO(Sqdmlsl(v1.V2D(), v2.V2S(), v3.V2S()),
+ "sqdmlsl v1.2d, v2.2s, v3.2s");
+ COMPARE_MACRO(Sqdmlsl2(v2.V4S(), v3.V8H(), v4.V8H()),
+ "sqdmlsl2 v2.4s, v3.8h, v4.8h");
+ COMPARE_MACRO(Sqdmlsl2(v3.V2D(), v4.V4S(), v5.V4S()),
+ "sqdmlsl2 v3.2d, v4.4s, v5.4s");
+ COMPARE_MACRO(Sqdmlsl(s0, h1, h2), "sqdmlsl s0, h1, h2");
+ COMPARE_MACRO(Sqdmlsl(d1, s2, s3), "sqdmlsl d1, s2, s3");
+
+ COMPARE_MACRO(Addhn(v0.V8B(), v1.V8H(), v2.V8H()),
+ "addhn v0.8b, v1.8h, v2.8h");
+ COMPARE_MACRO(Addhn(v1.V4H(), v2.V4S(), v3.V4S()),
+ "addhn v1.4h, v2.4s, v3.4s");
+ COMPARE_MACRO(Addhn(v2.V2S(), v3.V2D(), v4.V2D()),
+ "addhn v2.2s, v3.2d, v4.2d");
+ COMPARE_MACRO(Addhn2(v0.V16B(), v1.V8H(), v5.V8H()),
+ "addhn2 v0.16b, v1.8h, v5.8h");
+ COMPARE_MACRO(Addhn2(v1.V8H(), v2.V4S(), v6.V4S()),
+ "addhn2 v1.8h, v2.4s, v6.4s");
+ COMPARE_MACRO(Addhn2(v2.V4S(), v3.V2D(), v7.V2D()),
+ "addhn2 v2.4s, v3.2d, v7.2d");
+
+ COMPARE_MACRO(Raddhn(v0.V8B(), v1.V8H(), v2.V8H()),
+ "raddhn v0.8b, v1.8h, v2.8h");
+ COMPARE_MACRO(Raddhn(v1.V4H(), v2.V4S(), v3.V4S()),
+ "raddhn v1.4h, v2.4s, v3.4s");
+ COMPARE_MACRO(Raddhn(v2.V2S(), v3.V2D(), v4.V2D()),
+ "raddhn v2.2s, v3.2d, v4.2d");
+ COMPARE_MACRO(Raddhn2(v0.V16B(), v1.V8H(), v5.V8H()),
+ "raddhn2 v0.16b, v1.8h, v5.8h");
+ COMPARE_MACRO(Raddhn2(v1.V8H(), v2.V4S(), v6.V4S()),
+ "raddhn2 v1.8h, v2.4s, v6.4s");
+ COMPARE_MACRO(Raddhn2(v2.V4S(), v3.V2D(), v7.V2D()),
+ "raddhn2 v2.4s, v3.2d, v7.2d");
+
+ COMPARE_MACRO(Subhn(v1.V4H(), v2.V4S(), v3.V4S()),
+ "subhn v1.4h, v2.4s, v3.4s");
+ COMPARE_MACRO(Subhn(v2.V2S(), v3.V2D(), v4.V2D()),
+ "subhn v2.2s, v3.2d, v4.2d");
+ COMPARE_MACRO(Subhn2(v0.V16B(), v1.V8H(), v5.V8H()),
+ "subhn2 v0.16b, v1.8h, v5.8h");
+ COMPARE_MACRO(Subhn2(v1.V8H(), v2.V4S(), v6.V4S()),
+ "subhn2 v1.8h, v2.4s, v6.4s");
+ COMPARE_MACRO(Subhn2(v2.V4S(), v3.V2D(), v7.V2D()),
+ "subhn2 v2.4s, v3.2d, v7.2d");
+
+ COMPARE_MACRO(Rsubhn(v0.V8B(), v1.V8H(), v2.V8H()),
+ "rsubhn v0.8b, v1.8h, v2.8h");
+ COMPARE_MACRO(Rsubhn(v1.V4H(), v2.V4S(), v3.V4S()),
+ "rsubhn v1.4h, v2.4s, v3.4s");
+ COMPARE_MACRO(Rsubhn(v2.V2S(), v3.V2D(), v4.V2D()),
+ "rsubhn v2.2s, v3.2d, v4.2d");
+ COMPARE_MACRO(Rsubhn2(v0.V16B(), v1.V8H(), v5.V8H()),
+ "rsubhn2 v0.16b, v1.8h, v5.8h");
+ COMPARE_MACRO(Rsubhn2(v1.V8H(), v2.V4S(), v6.V4S()),
+ "rsubhn2 v1.8h, v2.4s, v6.4s");
+ COMPARE_MACRO(Rsubhn2(v2.V4S(), v3.V2D(), v7.V2D()),
+ "rsubhn2 v2.4s, v3.2d, v7.2d");
+
+ COMPARE_MACRO(Pmull(v0.V8H(), v1.V8B(), v2.V8B()),
+ "pmull v0.8h, v1.8b, v2.8b");
+ COMPARE_MACRO(Pmull2(v2.V8H(), v3.V16B(), v4.V16B()),
+ "pmull2 v2.8h, v3.16b, v4.16b");
CLEANUP();
}
TEST(neon_perm) {
- SETUP_MACRO();
+ SETUP();
#define DISASM_INST(M, S) \
- COMPARE(Trn1(v0.M, v1.M, v2.M), "trn1 v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Trn1(v0.M, v1.M, v2.M), "trn1 v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Trn2(v0.M, v1.M, v2.M), "trn2 v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Trn2(v0.M, v1.M, v2.M), "trn2 v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uzp1(v0.M, v1.M, v2.M), "uzp1 v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Uzp1(v0.M, v1.M, v2.M), "uzp1 v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Uzp2(v0.M, v1.M, v2.M), "uzp2 v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Uzp2(v0.M, v1.M, v2.M), "uzp2 v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Zip1(v0.M, v1.M, v2.M), "zip1 v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Zip1(v0.M, v1.M, v2.M), "zip1 v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Zip2(v0.M, v1.M, v2.M), "zip2 v0." S ", v1." S ", v2." S);
+ COMPARE_MACRO(Zip2(v0.M, v1.M, v2.M), "zip2 v0." S ", v1." S ", v2." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
@@ -5099,256 +5327,261 @@ TEST(neon_perm) {
TEST(neon_copy) {
- SETUP_MACRO();
-
- COMPARE(Ins(v1.V16B(), 4, v5.V16B(), 0), "mov v1.b[4], v5.b[0]");
- COMPARE(Ins(v2.V8B(), 5, v6.V8B(), 1), "mov v2.b[5], v6.b[1]");
- COMPARE(Ins(v3.B(), 6, v7.B(), 2), "mov v3.b[6], v7.b[2]");
- COMPARE(Ins(v4.V8H(), 7, v8.V8H(), 3), "mov v4.h[7], v8.h[3]");
- COMPARE(Ins(v5.V4H(), 3, v9.V4H(), 0), "mov v5.h[3], v9.h[0]");
- COMPARE(Ins(v6.H(), 6, v1.H(), 1), "mov v6.h[6], v1.h[1]");
- COMPARE(Ins(v7.V4S(), 2, v2.V4S(), 2), "mov v7.s[2], v2.s[2]");
- COMPARE(Ins(v8.V2S(), 1, v3.V2S(), 0), "mov v8.s[1], v3.s[0]");
- COMPARE(Ins(v9.S(), 0, v4.S(), 1), "mov v9.s[0], v4.s[1]");
- COMPARE(Ins(v1.V2D(), 1, v5.V2D(), 0), "mov v1.d[1], v5.d[0]");
- COMPARE(Ins(v2.D(), 0, v6.D(), 1), "mov v2.d[0], v6.d[1]");
-
- COMPARE(Mov(v3.V16B(), 4, v7.V16B(), 0), "mov v3.b[4], v7.b[0]");
- COMPARE(Mov(v4.V8B(), 5, v8.V8B(), 1), "mov v4.b[5], v8.b[1]");
- COMPARE(Mov(v5.B(), 6, v9.B(), 2), "mov v5.b[6], v9.b[2]");
- COMPARE(Mov(v6.V8H(), 7, v1.V8H(), 3), "mov v6.h[7], v1.h[3]");
- COMPARE(Mov(v7.V4H(), 0, v2.V4H(), 0), "mov v7.h[0], v2.h[0]");
- COMPARE(Mov(v8.H(), 1, v3.H(), 1), "mov v8.h[1], v3.h[1]");
- COMPARE(Mov(v9.V4S(), 2, v4.V4S(), 2), "mov v9.s[2], v4.s[2]");
- COMPARE(Mov(v1.V2S(), 3, v5.V2S(), 0), "mov v1.s[3], v5.s[0]");
- COMPARE(Mov(v2.S(), 0, v6.S(), 1), "mov v2.s[0], v6.s[1]");
- COMPARE(Mov(v3.V2D(), 1, v7.V2D(), 0), "mov v3.d[1], v7.d[0]");
- COMPARE(Mov(v4.D(), 0, v8.D(), 1), "mov v4.d[0], v8.d[1]");
-
- COMPARE(Ins(v1.V16B(), 4, w0), "mov v1.b[4], w0");
- COMPARE(Ins(v2.V8B(), 5, w1), "mov v2.b[5], w1");
- COMPARE(Ins(v3.B(), 6, w2), "mov v3.b[6], w2");
- COMPARE(Ins(v4.V8H(), 7, w3), "mov v4.h[7], w3");
- COMPARE(Ins(v5.V4H(), 3, w0), "mov v5.h[3], w0");
- COMPARE(Ins(v6.H(), 6, w1), "mov v6.h[6], w1");
- COMPARE(Ins(v7.V4S(), 2, w2), "mov v7.s[2], w2");
- COMPARE(Ins(v8.V2S(), 1, w0), "mov v8.s[1], w0");
- COMPARE(Ins(v9.S(), 0, w1), "mov v9.s[0], w1");
- COMPARE(Ins(v1.V2D(), 1, x0), "mov v1.d[1], x0");
- COMPARE(Ins(v2.D(), 0, x1), "mov v2.d[0], x1");
-
- COMPARE(Mov(v1.V16B(), 4, w0), "mov v1.b[4], w0");
- COMPARE(Mov(v2.V8B(), 5, w1), "mov v2.b[5], w1");
- COMPARE(Mov(v3.B(), 6, w2), "mov v3.b[6], w2");
- COMPARE(Mov(v4.V8H(), 7, w3), "mov v4.h[7], w3");
- COMPARE(Mov(v5.V4H(), 3, w0), "mov v5.h[3], w0");
- COMPARE(Mov(v6.H(), 6, w1), "mov v6.h[6], w1");
- COMPARE(Mov(v7.V4S(), 2, w2), "mov v7.s[2], w2");
- COMPARE(Mov(v8.V2S(), 1, w0), "mov v8.s[1], w0");
- COMPARE(Mov(v9.S(), 0, w1), "mov v9.s[0], w1");
- COMPARE(Mov(v1.V2D(), 1, x0), "mov v1.d[1], x0");
- COMPARE(Mov(v2.D(), 0, x1), "mov v2.d[0], x1");
-
- COMPARE(Dup(v5.V8B(), v9.V8B(), 6), "dup v5.8b, v9.b[6]");
- COMPARE(Dup(v6.V16B(), v1.V16B(), 5), "dup v6.16b, v1.b[5]");
- COMPARE(Dup(v7.V4H(), v2.V4H(), 4), "dup v7.4h, v2.h[4]");
- COMPARE(Dup(v8.V8H(), v3.V8H(), 3), "dup v8.8h, v3.h[3]");
- COMPARE(Dup(v9.V2S(), v4.V2S(), 2), "dup v9.2s, v4.s[2]");
- COMPARE(Dup(v1.V4S(), v5.V4S(), 1), "dup v1.4s, v5.s[1]");
- COMPARE(Dup(v2.V2D(), v6.V2D(), 0), "dup v2.2d, v6.d[0]");
-
- COMPARE(Dup(v5.B(), v9.B(), 6), "mov b5, v9.b[6]");
- COMPARE(Dup(v7.H(), v2.H(), 4), "mov h7, v2.h[4]");
- COMPARE(Dup(v9.S(), v4.S(), 2), "mov s9, v4.s[2]");
- COMPARE(Dup(v2.D(), v6.D(), 0), "mov d2, v6.d[0]");
-
- COMPARE(Mov(v5.B(), v9.B(), 6), "mov b5, v9.b[6]");
- COMPARE(Mov(v7.H(), v2.H(), 4), "mov h7, v2.h[4]");
- COMPARE(Mov(v9.S(), v4.S(), 2), "mov s9, v4.s[2]");
- COMPARE(Mov(v2.D(), v6.D(), 0), "mov d2, v6.d[0]");
-
- COMPARE(Mov(v0.B(), v1.V8B(), 7), "mov b0, v1.b[7]");
- COMPARE(Mov(b2, v3.V16B(), 15), "mov b2, v3.b[15]");
- COMPARE(Mov(v4.H(), v5.V4H(), 3), "mov h4, v5.h[3]");
- COMPARE(Mov(h6, v7.V8H(), 7), "mov h6, v7.h[7]");
- COMPARE(Mov(v8.S(), v9.V2S(), 1), "mov s8, v9.s[1]");
- COMPARE(Mov(s10, v11.V4S(), 3), "mov s10, v11.s[3]");
- COMPARE(Mov(v12.D(), v13.V2D(), 1), "mov d12, v13.d[1]");
-
- COMPARE(Dup(v5.V8B(), w0), "dup v5.8b, w0");
- COMPARE(Dup(v6.V16B(), w1), "dup v6.16b, w1");
- COMPARE(Dup(v7.V4H(), w2), "dup v7.4h, w2");
- COMPARE(Dup(v8.V8H(), w3), "dup v8.8h, w3");
- COMPARE(Dup(v9.V2S(), w4), "dup v9.2s, w4");
- COMPARE(Dup(v1.V4S(), w5), "dup v1.4s, w5");
- COMPARE(Dup(v2.V2D(), x6), "dup v2.2d, x6");
-
- COMPARE(Smov(w0, v1.V16B(), 4), "smov w0, v1.b[4]");
- COMPARE(Smov(w1, v2.V8B(), 5), "smov w1, v2.b[5]");
- COMPARE(Smov(w2, v3.B(), 6), "smov w2, v3.b[6]");
- COMPARE(Smov(w3, v4.V8H(), 7), "smov w3, v4.h[7]");
- COMPARE(Smov(w0, v5.V4H(), 3), "smov w0, v5.h[3]");
- COMPARE(Smov(w1, v6.H(), 6), "smov w1, v6.h[6]");
-
- COMPARE(Smov(x0, v1.V16B(), 4), "smov x0, v1.b[4]");
- COMPARE(Smov(x1, v2.V8B(), 5), "smov x1, v2.b[5]");
- COMPARE(Smov(x2, v3.B(), 6), "smov x2, v3.b[6]");
- COMPARE(Smov(x3, v4.V8H(), 7), "smov x3, v4.h[7]");
- COMPARE(Smov(x0, v5.V4H(), 3), "smov x0, v5.h[3]");
- COMPARE(Smov(x1, v6.H(), 6), "smov x1, v6.h[6]");
- COMPARE(Smov(x2, v7.V4S(), 2), "smov x2, v7.s[2]");
- COMPARE(Smov(x0, v8.V2S(), 1), "smov x0, v8.s[1]");
- COMPARE(Smov(x1, v9.S(), 0), "smov x1, v9.s[0]");
-
- COMPARE(Umov(w0, v1.V16B(), 4), "umov w0, v1.b[4]");
- COMPARE(Umov(w1, v2.V8B(), 5), "umov w1, v2.b[5]");
- COMPARE(Umov(w2, v3.B(), 6), "umov w2, v3.b[6]");
- COMPARE(Umov(w3, v4.V8H(), 7), "umov w3, v4.h[7]");
- COMPARE(Umov(w0, v5.V4H(), 3), "umov w0, v5.h[3]");
- COMPARE(Umov(w1, v6.H(), 6), "umov w1, v6.h[6]");
- COMPARE(Umov(w2, v7.V4S(), 2), "mov w2, v7.s[2]");
- COMPARE(Umov(w0, v8.V2S(), 1), "mov w0, v8.s[1]");
- COMPARE(Umov(w1, v9.S(), 0), "mov w1, v9.s[0]");
- COMPARE(Umov(x0, v1.V2D(), 1), "mov x0, v1.d[1]");
- COMPARE(Umov(x1, v2.D(), 0), "mov x1, v2.d[0]");
-
- COMPARE(Mov(w2, v7.V4S(), 2), "mov w2, v7.s[2]");
- COMPARE(Mov(w0, v8.V2S(), 1), "mov w0, v8.s[1]");
- COMPARE(Mov(w1, v9.S(), 0), "mov w1, v9.s[0]");
- COMPARE(Mov(x0, v1.V2D(), 1), "mov x0, v1.d[1]");
- COMPARE(Mov(x1, v2.D(), 0), "mov x1, v2.d[0]");
+ SETUP();
+
+ COMPARE_MACRO(Ins(v1.V16B(), 4, v5.V16B(), 0), "mov v1.b[4], v5.b[0]");
+ COMPARE_MACRO(Ins(v2.V8B(), 5, v6.V8B(), 1), "mov v2.b[5], v6.b[1]");
+ COMPARE_MACRO(Ins(v3.B(), 6, v7.B(), 2), "mov v3.b[6], v7.b[2]");
+ COMPARE_MACRO(Ins(v4.V8H(), 7, v8.V8H(), 3), "mov v4.h[7], v8.h[3]");
+ COMPARE_MACRO(Ins(v5.V4H(), 3, v9.V4H(), 0), "mov v5.h[3], v9.h[0]");
+ COMPARE_MACRO(Ins(v6.H(), 6, v1.H(), 1), "mov v6.h[6], v1.h[1]");
+ COMPARE_MACRO(Ins(v7.V4S(), 2, v2.V4S(), 2), "mov v7.s[2], v2.s[2]");
+ COMPARE_MACRO(Ins(v8.V2S(), 1, v3.V2S(), 0), "mov v8.s[1], v3.s[0]");
+ COMPARE_MACRO(Ins(v9.S(), 0, v4.S(), 1), "mov v9.s[0], v4.s[1]");
+ COMPARE_MACRO(Ins(v1.V2D(), 1, v5.V2D(), 0), "mov v1.d[1], v5.d[0]");
+ COMPARE_MACRO(Ins(v2.D(), 0, v6.D(), 1), "mov v2.d[0], v6.d[1]");
+
+ COMPARE_MACRO(Mov(v3.V16B(), 4, v7.V16B(), 0), "mov v3.b[4], v7.b[0]");
+ COMPARE_MACRO(Mov(v4.V8B(), 5, v8.V8B(), 1), "mov v4.b[5], v8.b[1]");
+ COMPARE_MACRO(Mov(v5.B(), 6, v9.B(), 2), "mov v5.b[6], v9.b[2]");
+ COMPARE_MACRO(Mov(v6.V8H(), 7, v1.V8H(), 3), "mov v6.h[7], v1.h[3]");
+ COMPARE_MACRO(Mov(v7.V4H(), 0, v2.V4H(), 0), "mov v7.h[0], v2.h[0]");
+ COMPARE_MACRO(Mov(v8.H(), 1, v3.H(), 1), "mov v8.h[1], v3.h[1]");
+ COMPARE_MACRO(Mov(v9.V4S(), 2, v4.V4S(), 2), "mov v9.s[2], v4.s[2]");
+ COMPARE_MACRO(Mov(v1.V2S(), 3, v5.V2S(), 0), "mov v1.s[3], v5.s[0]");
+ COMPARE_MACRO(Mov(v2.S(), 0, v6.S(), 1), "mov v2.s[0], v6.s[1]");
+ COMPARE_MACRO(Mov(v3.V2D(), 1, v7.V2D(), 0), "mov v3.d[1], v7.d[0]");
+ COMPARE_MACRO(Mov(v4.D(), 0, v8.D(), 1), "mov v4.d[0], v8.d[1]");
+
+ COMPARE_MACRO(Ins(v1.V16B(), 4, w0), "mov v1.b[4], w0");
+ COMPARE_MACRO(Ins(v2.V8B(), 5, w1), "mov v2.b[5], w1");
+ COMPARE_MACRO(Ins(v3.B(), 6, w2), "mov v3.b[6], w2");
+ COMPARE_MACRO(Ins(v4.V8H(), 7, w3), "mov v4.h[7], w3");
+ COMPARE_MACRO(Ins(v5.V4H(), 3, w0), "mov v5.h[3], w0");
+ COMPARE_MACRO(Ins(v6.H(), 6, w1), "mov v6.h[6], w1");
+ COMPARE_MACRO(Ins(v7.V4S(), 2, w2), "mov v7.s[2], w2");
+ COMPARE_MACRO(Ins(v8.V2S(), 1, w0), "mov v8.s[1], w0");
+ COMPARE_MACRO(Ins(v9.S(), 0, w1), "mov v9.s[0], w1");
+ COMPARE_MACRO(Ins(v1.V2D(), 1, x0), "mov v1.d[1], x0");
+ COMPARE_MACRO(Ins(v2.D(), 0, x1), "mov v2.d[0], x1");
+
+ COMPARE_MACRO(Mov(v1.V16B(), 4, w0), "mov v1.b[4], w0");
+ COMPARE_MACRO(Mov(v2.V8B(), 5, w1), "mov v2.b[5], w1");
+ COMPARE_MACRO(Mov(v3.B(), 6, w2), "mov v3.b[6], w2");
+ COMPARE_MACRO(Mov(v4.V8H(), 7, w3), "mov v4.h[7], w3");
+ COMPARE_MACRO(Mov(v5.V4H(), 3, w0), "mov v5.h[3], w0");
+ COMPARE_MACRO(Mov(v6.H(), 6, w1), "mov v6.h[6], w1");
+ COMPARE_MACRO(Mov(v7.V4S(), 2, w2), "mov v7.s[2], w2");
+ COMPARE_MACRO(Mov(v8.V2S(), 1, w0), "mov v8.s[1], w0");
+ COMPARE_MACRO(Mov(v9.S(), 0, w1), "mov v9.s[0], w1");
+ COMPARE_MACRO(Mov(v1.V2D(), 1, x0), "mov v1.d[1], x0");
+ COMPARE_MACRO(Mov(v2.D(), 0, x1), "mov v2.d[0], x1");
+
+ COMPARE_MACRO(Dup(v5.V8B(), v9.V8B(), 6), "dup v5.8b, v9.b[6]");
+ COMPARE_MACRO(Dup(v6.V16B(), v1.V16B(), 5), "dup v6.16b, v1.b[5]");
+ COMPARE_MACRO(Dup(v7.V4H(), v2.V4H(), 4), "dup v7.4h, v2.h[4]");
+ COMPARE_MACRO(Dup(v8.V8H(), v3.V8H(), 3), "dup v8.8h, v3.h[3]");
+ COMPARE_MACRO(Dup(v9.V2S(), v4.V2S(), 2), "dup v9.2s, v4.s[2]");
+ COMPARE_MACRO(Dup(v1.V4S(), v5.V4S(), 1), "dup v1.4s, v5.s[1]");
+ COMPARE_MACRO(Dup(v2.V2D(), v6.V2D(), 0), "dup v2.2d, v6.d[0]");
+
+ COMPARE_MACRO(Dup(v5.B(), v9.B(), 6), "mov b5, v9.b[6]");
+ COMPARE_MACRO(Dup(v7.H(), v2.H(), 4), "mov h7, v2.h[4]");
+ COMPARE_MACRO(Dup(v9.S(), v4.S(), 2), "mov s9, v4.s[2]");
+ COMPARE_MACRO(Dup(v2.D(), v6.D(), 0), "mov d2, v6.d[0]");
+
+ COMPARE_MACRO(Mov(v5.B(), v9.B(), 6), "mov b5, v9.b[6]");
+ COMPARE_MACRO(Mov(v7.H(), v2.H(), 4), "mov h7, v2.h[4]");
+ COMPARE_MACRO(Mov(v9.S(), v4.S(), 2), "mov s9, v4.s[2]");
+ COMPARE_MACRO(Mov(v2.D(), v6.D(), 0), "mov d2, v6.d[0]");
+
+ COMPARE_MACRO(Mov(v0.B(), v1.V8B(), 7), "mov b0, v1.b[7]");
+ COMPARE_MACRO(Mov(b2, v3.V16B(), 15), "mov b2, v3.b[15]");
+ COMPARE_MACRO(Mov(v4.H(), v5.V4H(), 3), "mov h4, v5.h[3]");
+ COMPARE_MACRO(Mov(h6, v7.V8H(), 7), "mov h6, v7.h[7]");
+ COMPARE_MACRO(Mov(v8.S(), v9.V2S(), 1), "mov s8, v9.s[1]");
+ COMPARE_MACRO(Mov(s10, v11.V4S(), 3), "mov s10, v11.s[3]");
+ COMPARE_MACRO(Mov(v12.D(), v13.V2D(), 1), "mov d12, v13.d[1]");
+
+ COMPARE_MACRO(Dup(v5.V8B(), w0), "dup v5.8b, w0");
+ COMPARE_MACRO(Dup(v6.V16B(), w1), "dup v6.16b, w1");
+ COMPARE_MACRO(Dup(v7.V4H(), w2), "dup v7.4h, w2");
+ COMPARE_MACRO(Dup(v8.V8H(), w3), "dup v8.8h, w3");
+ COMPARE_MACRO(Dup(v9.V2S(), w4), "dup v9.2s, w4");
+ COMPARE_MACRO(Dup(v1.V4S(), w5), "dup v1.4s, w5");
+ COMPARE_MACRO(Dup(v2.V2D(), x6), "dup v2.2d, x6");
+
+ COMPARE_MACRO(Smov(w0, v1.V16B(), 4), "smov w0, v1.b[4]");
+ COMPARE_MACRO(Smov(w1, v2.V8B(), 5), "smov w1, v2.b[5]");
+ COMPARE_MACRO(Smov(w2, v3.B(), 6), "smov w2, v3.b[6]");
+ COMPARE_MACRO(Smov(w3, v4.V8H(), 7), "smov w3, v4.h[7]");
+ COMPARE_MACRO(Smov(w0, v5.V4H(), 3), "smov w0, v5.h[3]");
+ COMPARE_MACRO(Smov(w1, v6.H(), 6), "smov w1, v6.h[6]");
+
+ COMPARE_MACRO(Smov(x0, v1.V16B(), 4), "smov x0, v1.b[4]");
+ COMPARE_MACRO(Smov(x1, v2.V8B(), 5), "smov x1, v2.b[5]");
+ COMPARE_MACRO(Smov(x2, v3.B(), 6), "smov x2, v3.b[6]");
+ COMPARE_MACRO(Smov(x3, v4.V8H(), 7), "smov x3, v4.h[7]");
+ COMPARE_MACRO(Smov(x0, v5.V4H(), 3), "smov x0, v5.h[3]");
+ COMPARE_MACRO(Smov(x1, v6.H(), 6), "smov x1, v6.h[6]");
+ COMPARE_MACRO(Smov(x2, v7.V4S(), 2), "smov x2, v7.s[2]");
+ COMPARE_MACRO(Smov(x0, v8.V2S(), 1), "smov x0, v8.s[1]");
+ COMPARE_MACRO(Smov(x1, v9.S(), 0), "smov x1, v9.s[0]");
+
+ COMPARE_MACRO(Umov(w0, v1.V16B(), 4), "umov w0, v1.b[4]");
+ COMPARE_MACRO(Umov(w1, v2.V8B(), 5), "umov w1, v2.b[5]");
+ COMPARE_MACRO(Umov(w2, v3.B(), 6), "umov w2, v3.b[6]");
+ COMPARE_MACRO(Umov(w3, v4.V8H(), 7), "umov w3, v4.h[7]");
+ COMPARE_MACRO(Umov(w0, v5.V4H(), 3), "umov w0, v5.h[3]");
+ COMPARE_MACRO(Umov(w1, v6.H(), 6), "umov w1, v6.h[6]");
+ COMPARE_MACRO(Umov(w2, v7.V4S(), 2), "mov w2, v7.s[2]");
+ COMPARE_MACRO(Umov(w0, v8.V2S(), 1), "mov w0, v8.s[1]");
+ COMPARE_MACRO(Umov(w1, v9.S(), 0), "mov w1, v9.s[0]");
+ COMPARE_MACRO(Umov(x0, v1.V2D(), 1), "mov x0, v1.d[1]");
+ COMPARE_MACRO(Umov(x1, v2.D(), 0), "mov x1, v2.d[0]");
+
+ COMPARE_MACRO(Mov(w2, v7.V4S(), 2), "mov w2, v7.s[2]");
+ COMPARE_MACRO(Mov(w0, v8.V2S(), 1), "mov w0, v8.s[1]");
+ COMPARE_MACRO(Mov(w1, v9.S(), 0), "mov w1, v9.s[0]");
+ COMPARE_MACRO(Mov(x0, v1.V2D(), 1), "mov x0, v1.d[1]");
+ COMPARE_MACRO(Mov(x1, v2.D(), 0), "mov x1, v2.d[0]");
CLEANUP();
}
TEST(neon_table) {
- SETUP_MACRO();
-
- COMPARE(Tbl(v0.V8B(), v1.V16B(), v2.V8B()), "tbl v0.8b, {v1.16b}, v2.8b");
- COMPARE(Tbl(v3.V8B(), v4.V16B(), v5.V16B(), v6.V8B()),
- "tbl v3.8b, {v4.16b, v5.16b}, v6.8b");
- COMPARE(Tbl(v7.V8B(), v8.V16B(), v9.V16B(), v10.V16B(), v11.V8B()),
- "tbl v7.8b, {v8.16b, v9.16b, v10.16b}, v11.8b");
- COMPARE(Tbl(v12.V8B(),
- v13.V16B(),
- v14.V16B(),
- v15.V16B(),
- v16.V16B(),
- v17.V8B()),
- "tbl v12.8b, {v13.16b, v14.16b, v15.16b, v16.16b}, v17.8b");
- COMPARE(Tbl(v18.V16B(), v19.V16B(), v20.V16B()),
- "tbl v18.16b, {v19.16b}, v20.16b");
- COMPARE(Tbl(v21.V16B(), v22.V16B(), v23.V16B(), v24.V16B()),
- "tbl v21.16b, {v22.16b, v23.16b}, v24.16b");
- COMPARE(Tbl(v25.V16B(), v26.V16B(), v27.V16B(), v28.V16B(), v29.V16B()),
- "tbl v25.16b, {v26.16b, v27.16b, v28.16b}, v29.16b");
- COMPARE(Tbl(v30.V16B(),
- v31.V16B(),
- v0.V16B(),
- v1.V16B(),
- v2.V16B(),
- v3.V16B()),
- "tbl v30.16b, {v31.16b, v0.16b, v1.16b, v2.16b}, v3.16b");
-
- COMPARE(Tbx(v0.V8B(), v1.V16B(), v2.V8B()), "tbx v0.8b, {v1.16b}, v2.8b");
- COMPARE(Tbx(v3.V8B(), v4.V16B(), v5.V16B(), v6.V8B()),
- "tbx v3.8b, {v4.16b, v5.16b}, v6.8b");
- COMPARE(Tbx(v7.V8B(), v8.V16B(), v9.V16B(), v10.V16B(), v11.V8B()),
- "tbx v7.8b, {v8.16b, v9.16b, v10.16b}, v11.8b");
- COMPARE(Tbx(v12.V8B(),
- v13.V16B(),
- v14.V16B(),
- v15.V16B(),
- v16.V16B(),
- v17.V8B()),
- "tbx v12.8b, {v13.16b, v14.16b, v15.16b, v16.16b}, v17.8b");
- COMPARE(Tbx(v18.V16B(), v19.V16B(), v20.V16B()),
- "tbx v18.16b, {v19.16b}, v20.16b");
- COMPARE(Tbx(v21.V16B(), v22.V16B(), v23.V16B(), v24.V16B()),
- "tbx v21.16b, {v22.16b, v23.16b}, v24.16b");
- COMPARE(Tbx(v25.V16B(), v26.V16B(), v27.V16B(), v28.V16B(), v29.V16B()),
- "tbx v25.16b, {v26.16b, v27.16b, v28.16b}, v29.16b");
- COMPARE(Tbx(v30.V16B(),
- v31.V16B(),
- v0.V16B(),
- v1.V16B(),
- v2.V16B(),
- v3.V16B()),
- "tbx v30.16b, {v31.16b, v0.16b, v1.16b, v2.16b}, v3.16b");
+ SETUP();
+
+ COMPARE_MACRO(Tbl(v0.V8B(), v1.V16B(), v2.V8B()),
+ "tbl v0.8b, {v1.16b}, v2.8b");
+ COMPARE_MACRO(Tbl(v3.V8B(), v4.V16B(), v5.V16B(), v6.V8B()),
+ "tbl v3.8b, {v4.16b, v5.16b}, v6.8b");
+ COMPARE_MACRO(Tbl(v7.V8B(), v8.V16B(), v9.V16B(), v10.V16B(), v11.V8B()),
+ "tbl v7.8b, {v8.16b, v9.16b, v10.16b}, v11.8b");
+ COMPARE_MACRO(Tbl(v12.V8B(),
+ v13.V16B(),
+ v14.V16B(),
+ v15.V16B(),
+ v16.V16B(),
+ v17.V8B()),
+ "tbl v12.8b, {v13.16b, v14.16b, v15.16b, v16.16b}, v17.8b");
+ COMPARE_MACRO(Tbl(v18.V16B(), v19.V16B(), v20.V16B()),
+ "tbl v18.16b, {v19.16b}, v20.16b");
+ COMPARE_MACRO(Tbl(v21.V16B(), v22.V16B(), v23.V16B(), v24.V16B()),
+ "tbl v21.16b, {v22.16b, v23.16b}, v24.16b");
+ COMPARE_MACRO(Tbl(v25.V16B(), v26.V16B(), v27.V16B(), v28.V16B(), v29.V16B()),
+ "tbl v25.16b, {v26.16b, v27.16b, v28.16b}, v29.16b");
+ COMPARE_MACRO(Tbl(v30.V16B(),
+ v31.V16B(),
+ v0.V16B(),
+ v1.V16B(),
+ v2.V16B(),
+ v3.V16B()),
+ "tbl v30.16b, {v31.16b, v0.16b, v1.16b, v2.16b}, v3.16b");
+
+ COMPARE_MACRO(Tbx(v0.V8B(), v1.V16B(), v2.V8B()),
+ "tbx v0.8b, {v1.16b}, v2.8b");
+ COMPARE_MACRO(Tbx(v3.V8B(), v4.V16B(), v5.V16B(), v6.V8B()),
+ "tbx v3.8b, {v4.16b, v5.16b}, v6.8b");
+ COMPARE_MACRO(Tbx(v7.V8B(), v8.V16B(), v9.V16B(), v10.V16B(), v11.V8B()),
+ "tbx v7.8b, {v8.16b, v9.16b, v10.16b}, v11.8b");
+ COMPARE_MACRO(Tbx(v12.V8B(),
+ v13.V16B(),
+ v14.V16B(),
+ v15.V16B(),
+ v16.V16B(),
+ v17.V8B()),
+ "tbx v12.8b, {v13.16b, v14.16b, v15.16b, v16.16b}, v17.8b");
+ COMPARE_MACRO(Tbx(v18.V16B(), v19.V16B(), v20.V16B()),
+ "tbx v18.16b, {v19.16b}, v20.16b");
+ COMPARE_MACRO(Tbx(v21.V16B(), v22.V16B(), v23.V16B(), v24.V16B()),
+ "tbx v21.16b, {v22.16b, v23.16b}, v24.16b");
+ COMPARE_MACRO(Tbx(v25.V16B(), v26.V16B(), v27.V16B(), v28.V16B(), v29.V16B()),
+ "tbx v25.16b, {v26.16b, v27.16b, v28.16b}, v29.16b");
+ COMPARE_MACRO(Tbx(v30.V16B(),
+ v31.V16B(),
+ v0.V16B(),
+ v1.V16B(),
+ v2.V16B(),
+ v3.V16B()),
+ "tbx v30.16b, {v31.16b, v0.16b, v1.16b, v2.16b}, v3.16b");
CLEANUP();
}
TEST(neon_extract) {
- SETUP_MACRO();
+ SETUP();
- COMPARE(Ext(v4.V8B(), v5.V8B(), v6.V8B(), 0), "ext v4.8b, v5.8b, v6.8b, #0");
- COMPARE(Ext(v1.V8B(), v2.V8B(), v3.V8B(), 7), "ext v1.8b, v2.8b, v3.8b, #7");
- COMPARE(Ext(v1.V16B(), v2.V16B(), v3.V16B(), 0),
- "ext v1.16b, v2.16b, v3.16b, #0");
- COMPARE(Ext(v1.V16B(), v2.V16B(), v3.V16B(), 15),
- "ext v1.16b, v2.16b, v3.16b, #15");
+ COMPARE_MACRO(Ext(v4.V8B(), v5.V8B(), v6.V8B(), 0),
+ "ext v4.8b, v5.8b, v6.8b, #0");
+ COMPARE_MACRO(Ext(v1.V8B(), v2.V8B(), v3.V8B(), 7),
+ "ext v1.8b, v2.8b, v3.8b, #7");
+ COMPARE_MACRO(Ext(v1.V16B(), v2.V16B(), v3.V16B(), 0),
+ "ext v1.16b, v2.16b, v3.16b, #0");
+ COMPARE_MACRO(Ext(v1.V16B(), v2.V16B(), v3.V16B(), 15),
+ "ext v1.16b, v2.16b, v3.16b, #15");
CLEANUP();
}
TEST(neon_modimm) {
- SETUP_MACRO();
-
- COMPARE(Orr(v4.V4H(), 0xaa, 0), "orr v4.4h, #0xaa, lsl #0");
- COMPARE(Orr(v1.V8H(), 0xcc, 8), "orr v1.8h, #0xcc, lsl #8");
- COMPARE(Orr(v4.V2S(), 0xaa, 0), "orr v4.2s, #0xaa, lsl #0");
- COMPARE(Orr(v1.V2S(), 0xcc, 8), "orr v1.2s, #0xcc, lsl #8");
- COMPARE(Orr(v4.V4S(), 0xaa, 16), "orr v4.4s, #0xaa, lsl #16");
- COMPARE(Orr(v1.V4S(), 0xcc, 24), "orr v1.4s, #0xcc, lsl #24");
-
- COMPARE(Bic(v4.V4H(), 0xaa, 0), "bic v4.4h, #0xaa, lsl #0");
- COMPARE(Bic(v1.V8H(), 0xcc, 8), "bic v1.8h, #0xcc, lsl #8");
- COMPARE(Bic(v4.V2S(), 0xaa, 0), "bic v4.2s, #0xaa, lsl #0");
- COMPARE(Bic(v1.V2S(), 0xcc, 8), "bic v1.2s, #0xcc, lsl #8");
- COMPARE(Bic(v4.V4S(), 0xaa, 16), "bic v4.4s, #0xaa, lsl #16");
- COMPARE(Bic(v1.V4S(), 0xcc, 24), "bic v1.4s, #0xcc, lsl #24");
-
- COMPARE(Mvni(v4.V4H(), 0xaa, LSL, 0), "mvni v4.4h, #0xaa, lsl #0");
- COMPARE(Mvni(v1.V8H(), 0xcc, LSL, 8), "mvni v1.8h, #0xcc, lsl #8");
- COMPARE(Mvni(v4.V2S(), 0xaa, LSL, 0), "mvni v4.2s, #0xaa, lsl #0");
- COMPARE(Mvni(v1.V2S(), 0xcc, LSL, 8), "mvni v1.2s, #0xcc, lsl #8");
- COMPARE(Mvni(v4.V4S(), 0xaa, LSL, 16), "mvni v4.4s, #0xaa, lsl #16");
- COMPARE(Mvni(v1.V4S(), 0xcc, LSL, 24), "mvni v1.4s, #0xcc, lsl #24");
-
- COMPARE(Mvni(v4.V2S(), 0xaa, MSL, 8), "mvni v4.2s, #0xaa, msl #8");
- COMPARE(Mvni(v1.V2S(), 0xcc, MSL, 16), "mvni v1.2s, #0xcc, msl #16");
- COMPARE(Mvni(v4.V4S(), 0xaa, MSL, 8), "mvni v4.4s, #0xaa, msl #8");
- COMPARE(Mvni(v1.V4S(), 0xcc, MSL, 16), "mvni v1.4s, #0xcc, msl #16");
-
- COMPARE(Movi(v4.V8B(), 0xaa), "movi v4.8b, #0xaa");
- COMPARE(Movi(v1.V16B(), 0xcc), "movi v1.16b, #0xcc");
-
- COMPARE(Movi(v4.V4H(), 0xaa, LSL, 0), "movi v4.4h, #0xaa, lsl #0");
- COMPARE(Movi(v1.V8H(), 0xcc, LSL, 8), "movi v1.8h, #0xcc, lsl #8");
-
- COMPARE(Movi(v4.V2S(), 0xaa, LSL, 0), "movi v4.2s, #0xaa, lsl #0");
- COMPARE(Movi(v1.V2S(), 0xcc, LSL, 8), "movi v1.2s, #0xcc, lsl #8");
- COMPARE(Movi(v4.V4S(), 0xaa, LSL, 16), "movi v4.4s, #0xaa, lsl #16");
- COMPARE(Movi(v1.V4S(), 0xcc, LSL, 24), "movi v1.4s, #0xcc, lsl #24");
-
- COMPARE(Movi(v4.V2S(), 0xaa, MSL, 8), "movi v4.2s, #0xaa, msl #8");
- COMPARE(Movi(v1.V2S(), 0xcc, MSL, 16), "movi v1.2s, #0xcc, msl #16");
- COMPARE(Movi(v4.V4S(), 0xaa, MSL, 8), "movi v4.4s, #0xaa, msl #8");
- COMPARE(Movi(v1.V4S(), 0xcc, MSL, 16), "movi v1.4s, #0xcc, msl #16");
-
- COMPARE(Movi(d2, 0xffff0000ffffff), "movi d2, #0xffff0000ffffff");
- COMPARE(Movi(v1.V2D(), 0xffff0000ffffff), "movi v1.2d, #0xffff0000ffffff");
-
- COMPARE(Fmov(v0.V2S(), 1.0f), "fmov v0.2s, #0x70 (1.0000)");
- COMPARE(Fmov(v31.V2S(), -13.0f), "fmov v31.2s, #0xaa (-13.0000)");
- COMPARE(Fmov(v0.V4S(), 1.0f), "fmov v0.4s, #0x70 (1.0000)");
- COMPARE(Fmov(v31.V4S(), -13.0f), "fmov v31.4s, #0xaa (-13.0000)");
- COMPARE(Fmov(v1.V2D(), 1.0), "fmov v1.2d, #0x70 (1.0000)");
- COMPARE(Fmov(v29.V2D(), -13.0), "fmov v29.2d, #0xaa (-13.0000)");
+ SETUP();
+
+ COMPARE_MACRO(Orr(v4.V4H(), 0xaa, 0), "orr v4.4h, #0xaa, lsl #0");
+ COMPARE_MACRO(Orr(v1.V8H(), 0xcc, 8), "orr v1.8h, #0xcc, lsl #8");
+ COMPARE_MACRO(Orr(v4.V2S(), 0xaa, 0), "orr v4.2s, #0xaa, lsl #0");
+ COMPARE_MACRO(Orr(v1.V2S(), 0xcc, 8), "orr v1.2s, #0xcc, lsl #8");
+ COMPARE_MACRO(Orr(v4.V4S(), 0xaa, 16), "orr v4.4s, #0xaa, lsl #16");
+ COMPARE_MACRO(Orr(v1.V4S(), 0xcc, 24), "orr v1.4s, #0xcc, lsl #24");
+
+ COMPARE_MACRO(Bic(v4.V4H(), 0xaa, 0), "bic v4.4h, #0xaa, lsl #0");
+ COMPARE_MACRO(Bic(v1.V8H(), 0xcc, 8), "bic v1.8h, #0xcc, lsl #8");
+ COMPARE_MACRO(Bic(v4.V2S(), 0xaa, 0), "bic v4.2s, #0xaa, lsl #0");
+ COMPARE_MACRO(Bic(v1.V2S(), 0xcc, 8), "bic v1.2s, #0xcc, lsl #8");
+ COMPARE_MACRO(Bic(v4.V4S(), 0xaa, 16), "bic v4.4s, #0xaa, lsl #16");
+ COMPARE_MACRO(Bic(v1.V4S(), 0xcc, 24), "bic v1.4s, #0xcc, lsl #24");
+
+ COMPARE_MACRO(Mvni(v4.V4H(), 0xaa, LSL, 0), "mvni v4.4h, #0xaa, lsl #0");
+ COMPARE_MACRO(Mvni(v1.V8H(), 0xcc, LSL, 8), "mvni v1.8h, #0xcc, lsl #8");
+ COMPARE_MACRO(Mvni(v4.V2S(), 0xaa, LSL, 0), "mvni v4.2s, #0xaa, lsl #0");
+ COMPARE_MACRO(Mvni(v1.V2S(), 0xcc, LSL, 8), "mvni v1.2s, #0xcc, lsl #8");
+ COMPARE_MACRO(Mvni(v4.V4S(), 0xaa, LSL, 16), "mvni v4.4s, #0xaa, lsl #16");
+ COMPARE_MACRO(Mvni(v1.V4S(), 0xcc, LSL, 24), "mvni v1.4s, #0xcc, lsl #24");
+
+ COMPARE_MACRO(Mvni(v4.V2S(), 0xaa, MSL, 8), "mvni v4.2s, #0xaa, msl #8");
+ COMPARE_MACRO(Mvni(v1.V2S(), 0xcc, MSL, 16), "mvni v1.2s, #0xcc, msl #16");
+ COMPARE_MACRO(Mvni(v4.V4S(), 0xaa, MSL, 8), "mvni v4.4s, #0xaa, msl #8");
+ COMPARE_MACRO(Mvni(v1.V4S(), 0xcc, MSL, 16), "mvni v1.4s, #0xcc, msl #16");
+
+ COMPARE_MACRO(Movi(v4.V8B(), 0xaa), "movi v4.8b, #0xaa");
+ COMPARE_MACRO(Movi(v1.V16B(), 0xcc), "movi v1.16b, #0xcc");
+
+ COMPARE_MACRO(Movi(v4.V4H(), 0xaa, LSL, 0), "movi v4.4h, #0xaa, lsl #0");
+ COMPARE_MACRO(Movi(v1.V8H(), 0xcc, LSL, 8), "movi v1.8h, #0xcc, lsl #8");
+
+ COMPARE_MACRO(Movi(v4.V2S(), 0xaa, LSL, 0), "movi v4.2s, #0xaa, lsl #0");
+ COMPARE_MACRO(Movi(v1.V2S(), 0xcc, LSL, 8), "movi v1.2s, #0xcc, lsl #8");
+ COMPARE_MACRO(Movi(v4.V4S(), 0xaa, LSL, 16), "movi v4.4s, #0xaa, lsl #16");
+ COMPARE_MACRO(Movi(v1.V4S(), 0xcc, LSL, 24), "movi v1.4s, #0xcc, lsl #24");
+
+ COMPARE_MACRO(Movi(v4.V2S(), 0xaa, MSL, 8), "movi v4.2s, #0xaa, msl #8");
+ COMPARE_MACRO(Movi(v1.V2S(), 0xcc, MSL, 16), "movi v1.2s, #0xcc, msl #16");
+ COMPARE_MACRO(Movi(v4.V4S(), 0xaa, MSL, 8), "movi v4.4s, #0xaa, msl #8");
+ COMPARE_MACRO(Movi(v1.V4S(), 0xcc, MSL, 16), "movi v1.4s, #0xcc, msl #16");
+
+ COMPARE_MACRO(Movi(d2, 0xffff0000ffffff), "movi d2, #0xffff0000ffffff");
+ COMPARE_MACRO(Movi(v1.V2D(), 0xffff0000ffffff),
+ "movi v1.2d, #0xffff0000ffffff");
+
+ COMPARE_MACRO(Fmov(v0.V2S(), 1.0f), "fmov v0.2s, #0x70 (1.0000)");
+ COMPARE_MACRO(Fmov(v31.V2S(), -13.0f), "fmov v31.2s, #0xaa (-13.0000)");
+ COMPARE_MACRO(Fmov(v0.V4S(), 1.0f), "fmov v0.4s, #0x70 (1.0000)");
+ COMPARE_MACRO(Fmov(v31.V4S(), -13.0f), "fmov v31.4s, #0xaa (-13.0000)");
+ COMPARE_MACRO(Fmov(v1.V2D(), 1.0), "fmov v1.2d, #0x70 (1.0000)");
+ COMPARE_MACRO(Fmov(v29.V2D(), -13.0), "fmov v29.2d, #0xaa (-13.0000)");
// An unallocated form of fmov.
COMPARE(dci(0x2f07ffff), "unallocated (NEONModifiedImmediate)");
@@ -5358,14 +5591,14 @@ TEST(neon_modimm) {
TEST(neon_2regmisc) {
- SETUP_MACRO();
+ SETUP();
- COMPARE(Shll(v1.V8H(), v8.V8B(), 8), "shll v1.8h, v8.8b, #8");
- COMPARE(Shll(v3.V4S(), v1.V4H(), 16), "shll v3.4s, v1.4h, #16");
- COMPARE(Shll(v5.V2D(), v3.V2S(), 32), "shll v5.2d, v3.2s, #32");
- COMPARE(Shll2(v2.V8H(), v9.V16B(), 8), "shll2 v2.8h, v9.16b, #8");
- COMPARE(Shll2(v4.V4S(), v2.V8H(), 16), "shll2 v4.4s, v2.8h, #16");
- COMPARE(Shll2(v6.V2D(), v4.V4S(), 32), "shll2 v6.2d, v4.4s, #32");
+ COMPARE_MACRO(Shll(v1.V8H(), v8.V8B(), 8), "shll v1.8h, v8.8b, #8");
+ COMPARE_MACRO(Shll(v3.V4S(), v1.V4H(), 16), "shll v3.4s, v1.4h, #16");
+ COMPARE_MACRO(Shll(v5.V2D(), v3.V2S(), 32), "shll v5.2d, v3.2s, #32");
+ COMPARE_MACRO(Shll2(v2.V8H(), v9.V16B(), 8), "shll2 v2.8h, v9.16b, #8");
+ COMPARE_MACRO(Shll2(v4.V4S(), v2.V8H(), 16), "shll2 v4.4s, v2.8h, #16");
+ COMPARE_MACRO(Shll2(v6.V2D(), v4.V4S(), 32), "shll2 v6.2d, v4.4s, #32");
// An unallocated form of shll.
COMPARE(dci(0x2ee13bff), "unallocated (NEON2RegMisc)");
@@ -5373,364 +5606,672 @@ TEST(neon_2regmisc) {
COMPARE(dci(0x6ee13bff), "unallocated (NEON2RegMisc)");
#define DISASM_INST(M, S) \
- COMPARE(Cmeq(v0.M, v1.M, 0), "cmeq v0." S ", v1." S ", #0");
+ COMPARE_MACRO(Cmeq(v0.M, v1.M, 0), "cmeq v0." S ", v1." S ", #0");
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmge(v0.M, v1.M, 0), "cmge v0." S ", v1." S ", #0");
+ COMPARE_MACRO(Cmge(v0.M, v1.M, 0), "cmge v0." S ", v1." S ", #0");
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmgt(v0.M, v1.M, 0), "cmgt v0." S ", v1." S ", #0");
+ COMPARE_MACRO(Cmgt(v0.M, v1.M, 0), "cmgt v0." S ", v1." S ", #0");
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmle(v0.M, v1.M, 0), "cmle v0." S ", v1." S ", #0");
+ COMPARE_MACRO(Cmle(v0.M, v1.M, 0), "cmle v0." S ", v1." S ", #0");
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(M, S) \
- COMPARE(Cmlt(v0.M, v1.M, 0), "cmlt v0." S ", v1." S ", #0");
+ COMPARE_MACRO(Cmlt(v0.M, v1.M, 0), "cmlt v0." S ", v1." S ", #0");
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Cmeq(v0.D(), v1.D(), 0), "cmeq d0, d1, #0");
- COMPARE(Cmge(v3.D(), v4.D(), 0), "cmge d3, d4, #0");
- COMPARE(Cmgt(v6.D(), v7.D(), 0), "cmgt d6, d7, #0");
- COMPARE(Cmle(v0.D(), v1.D(), 0), "cmle d0, d1, #0");
- COMPARE(Cmlt(v3.D(), v4.D(), 0), "cmlt d3, d4, #0");
+ COMPARE_MACRO(Cmeq(v0.D(), v1.D(), 0), "cmeq d0, d1, #0");
+ COMPARE_MACRO(Cmge(v3.D(), v4.D(), 0), "cmge d3, d4, #0");
+ COMPARE_MACRO(Cmgt(v6.D(), v7.D(), 0), "cmgt d6, d7, #0");
+ COMPARE_MACRO(Cmle(v0.D(), v1.D(), 0), "cmle d0, d1, #0");
+ COMPARE_MACRO(Cmlt(v3.D(), v4.D(), 0), "cmlt d3, d4, #0");
#define DISASM_INST(M, S) \
- COMPARE(Fcmeq(v0.M, v1.M, 0), "fcmeq v0." S ", v1." S ", #0.0");
+ COMPARE_MACRO(Fcmeq(v0.M, v1.M, 0), "fcmeq v0." S ", v1." S ", #0.0");
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
- COMPARE(Fcmeq(v0.S(), v1.S(), 0), "fcmeq s0, s1, #0.0");
- COMPARE(Fcmeq(v0.D(), v1.D(), 0), "fcmeq d0, d1, #0.0");
+ COMPARE_MACRO(Fcmeq(v0.S(), v1.S(), 0),
+ "fcmeq s0, s1, "
+ "#0.0");
+ COMPARE_MACRO(Fcmeq(v0.D(), v1.D(), 0),
+ "fcmeq d0, d1, "
+ "#0.0");
#define DISASM_INST(M, S) \
- COMPARE(Fcmge(v0.M, v1.M, 0), "fcmge v0." S ", v1." S ", #0.0");
+ COMPARE_MACRO(Fcmge(v0.M, v1.M, 0), "fcmge v0." S ", v1." S ", #0.0");
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
- COMPARE(Fcmge(v0.S(), v1.S(), 0), "fcmge s0, s1, #0.0");
- COMPARE(Fcmge(v0.D(), v1.D(), 0), "fcmge d0, d1, #0.0");
+ COMPARE_MACRO(Fcmge(v0.S(), v1.S(), 0),
+ "fcmge s0, s1, "
+ "#0.0");
+ COMPARE_MACRO(Fcmge(v0.D(), v1.D(), 0),
+ "fcmge d0, d1, "
+ "#0.0");
#define DISASM_INST(M, S) \
- COMPARE(Fcmgt(v0.M, v1.M, 0), "fcmgt v0." S ", v1." S ", #0.0");
+ COMPARE_MACRO(Fcmgt(v0.M, v1.M, 0), "fcmgt v0." S ", v1." S ", #0.0");
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
- COMPARE(Fcmgt(v0.S(), v1.S(), 0), "fcmgt s0, s1, #0.0");
- COMPARE(Fcmgt(v0.D(), v1.D(), 0), "fcmgt d0, d1, #0.0");
+ COMPARE_MACRO(Fcmgt(v0.S(), v1.S(), 0),
+ "fcmgt s0, s1, "
+ "#0.0");
+ COMPARE_MACRO(Fcmgt(v0.D(), v1.D(), 0),
+ "fcmgt d0, d1, "
+ "#0.0");
#define DISASM_INST(M, S) \
- COMPARE(Fcmle(v0.M, v1.M, 0), "fcmle v0." S ", v1." S ", #0.0");
+ COMPARE_MACRO(Fcmle(v0.M, v1.M, 0), "fcmle v0." S ", v1." S ", #0.0");
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
- COMPARE(Fcmle(v0.S(), v1.S(), 0), "fcmle s0, s1, #0.0");
- COMPARE(Fcmle(v0.D(), v1.D(), 0), "fcmle d0, d1, #0.0");
+ COMPARE_MACRO(Fcmle(v0.S(), v1.S(), 0),
+ "fcmle s0, s1, "
+ "#0.0");
+ COMPARE_MACRO(Fcmle(v0.D(), v1.D(), 0),
+ "fcmle d0, d1, "
+ "#0.0");
#define DISASM_INST(M, S) \
- COMPARE(Fcmlt(v0.M, v1.M, 0), "fcmlt v0." S ", v1." S ", #0.0");
+ COMPARE_MACRO(Fcmlt(v0.M, v1.M, 0), "fcmlt v0." S ", v1." S ", #0.0");
NEON_FORMAT_LIST_FP(DISASM_INST)
#undef DISASM_INST
- COMPARE(Fcmlt(v0.S(), v1.S(), 0), "fcmlt s0, s1, #0.0");
- COMPARE(Fcmlt(v0.D(), v1.D(), 0), "fcmlt d0, d1, #0.0");
+ COMPARE_MACRO(Fcmlt(v0.S(), v1.S(), 0),
+ "fcmlt s0, s1, "
+ "#0.0");
+ COMPARE_MACRO(Fcmlt(v0.D(), v1.D(), 0),
+ "fcmlt d0, d1, "
+ "#0.0");
-#define DISASM_INST(M, S) COMPARE(Neg(v0.M, v1.M), "neg v0." S ", v1." S);
+#define DISASM_INST(M, S) COMPARE_MACRO(Neg(v0.M, v1.M), "neg v0." S ", v1." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Neg(v0.D(), v1.D()), "neg d0, d1");
+ COMPARE_MACRO(Neg(v0.D(), v1.D()), "neg d0, d1");
-#define DISASM_INST(M, S) COMPARE(Sqneg(v0.M, v1.M), "sqneg v0." S ", v1." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqneg(v0.M, v1.M), "sqneg v0." S ", v1." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Sqneg(b0, b1), "sqneg b0, b1");
- COMPARE(Sqneg(h1, h2), "sqneg h1, h2");
- COMPARE(Sqneg(s2, s3), "sqneg s2, s3");
- COMPARE(Sqneg(d3, d4), "sqneg d3, d4");
+ COMPARE_MACRO(Sqneg(b0, b1), "sqneg b0, b1");
+ COMPARE_MACRO(Sqneg(h1, h2), "sqneg h1, h2");
+ COMPARE_MACRO(Sqneg(s2, s3), "sqneg s2, s3");
+ COMPARE_MACRO(Sqneg(d3, d4), "sqneg d3, d4");
-#define DISASM_INST(M, S) COMPARE(Abs(v0.M, v1.M), "abs v0." S ", v1." S);
+#define DISASM_INST(M, S) COMPARE_MACRO(Abs(v0.M, v1.M), "abs v0." S ", v1." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Abs(v0.D(), v1.D()), "abs d0, d1");
+ COMPARE_MACRO(Abs(v0.D(), v1.D()), "abs d0, d1");
-#define DISASM_INST(M, S) COMPARE(Sqabs(v0.M, v1.M), "sqabs v0." S ", v1." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Sqabs(v0.M, v1.M), "sqabs v0." S ", v1." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Sqabs(b0, b1), "sqabs b0, b1");
- COMPARE(Sqabs(h1, h2), "sqabs h1, h2");
- COMPARE(Sqabs(s2, s3), "sqabs s2, s3");
- COMPARE(Sqabs(d3, d4), "sqabs d3, d4");
+ COMPARE_MACRO(Sqabs(b0, b1), "sqabs b0, b1");
+ COMPARE_MACRO(Sqabs(h1, h2), "sqabs h1, h2");
+ COMPARE_MACRO(Sqabs(s2, s3), "sqabs s2, s3");
+ COMPARE_MACRO(Sqabs(d3, d4), "sqabs d3, d4");
-#define DISASM_INST(M, S) COMPARE(Suqadd(v0.M, v1.M), "suqadd v0." S ", v1." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Suqadd(v0.M, v1.M), "suqadd v0." S ", v1." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Suqadd(b0, b1), "suqadd b0, b1");
- COMPARE(Suqadd(h1, h2), "suqadd h1, h2");
- COMPARE(Suqadd(s2, s3), "suqadd s2, s3");
- COMPARE(Suqadd(d3, d4), "suqadd d3, d4");
+ COMPARE_MACRO(Suqadd(b0, b1), "suqadd b0, b1");
+ COMPARE_MACRO(Suqadd(h1, h2), "suqadd h1, h2");
+ COMPARE_MACRO(Suqadd(s2, s3), "suqadd s2, s3");
+ COMPARE_MACRO(Suqadd(d3, d4), "suqadd d3, d4");
-#define DISASM_INST(M, S) COMPARE(Usqadd(v0.M, v1.M), "usqadd v0." S ", v1." S);
+#define DISASM_INST(M, S) \
+ COMPARE_MACRO(Usqadd(v0.M, v1.M), "usqadd v0." S ", v1." S);
NEON_FORMAT_LIST(DISASM_INST)
#undef DISASM_INST
- COMPARE(Usqadd(b0, b1), "usqadd b0, b1");
- COMPARE(Usqadd(h1, h2), "usqadd h1, h2");
- COMPARE(Usqadd(s2, s3), "usqadd s2, s3");
- COMPARE(Usqadd(d3, d4), "usqadd d3, d4");
-
- COMPARE(Xtn(v0.V8B(), v1.V8H()), "xtn v0.8b, v1.8h");
- COMPARE(Xtn(v1.V4H(), v2.V4S()), "xtn v1.4h, v2.4s");
- COMPARE(Xtn(v2.V2S(), v3.V2D()), "xtn v2.2s, v3.2d");
- COMPARE(Xtn2(v0.V16B(), v1.V8H()), "xtn2 v0.16b, v1.8h");
- COMPARE(Xtn2(v1.V8H(), v2.V4S()), "xtn2 v1.8h, v2.4s");
- COMPARE(Xtn2(v2.V4S(), v3.V2D()), "xtn2 v2.4s, v3.2d");
-
- COMPARE(Sqxtn(v0.V8B(), v1.V8H()), "sqxtn v0.8b, v1.8h");
- COMPARE(Sqxtn(v1.V4H(), v2.V4S()), "sqxtn v1.4h, v2.4s");
- COMPARE(Sqxtn(v2.V2S(), v3.V2D()), "sqxtn v2.2s, v3.2d");
- COMPARE(Sqxtn2(v0.V16B(), v1.V8H()), "sqxtn2 v0.16b, v1.8h");
- COMPARE(Sqxtn2(v1.V8H(), v2.V4S()), "sqxtn2 v1.8h, v2.4s");
- COMPARE(Sqxtn2(v2.V4S(), v3.V2D()), "sqxtn2 v2.4s, v3.2d");
- COMPARE(Sqxtn(b19, h0), "sqxtn b19, h0");
- COMPARE(Sqxtn(h20, s0), "sqxtn h20, s0");
- COMPARE(Sqxtn(s21, d0), "sqxtn s21, d0");
-
- COMPARE(Uqxtn(v0.V8B(), v1.V8H()), "uqxtn v0.8b, v1.8h");
- COMPARE(Uqxtn(v1.V4H(), v2.V4S()), "uqxtn v1.4h, v2.4s");
- COMPARE(Uqxtn(v2.V2S(), v3.V2D()), "uqxtn v2.2s, v3.2d");
- COMPARE(Uqxtn2(v0.V16B(), v1.V8H()), "uqxtn2 v0.16b, v1.8h");
- COMPARE(Uqxtn2(v1.V8H(), v2.V4S()), "uqxtn2 v1.8h, v2.4s");
- COMPARE(Uqxtn2(v2.V4S(), v3.V2D()), "uqxtn2 v2.4s, v3.2d");
- COMPARE(Uqxtn(b19, h0), "uqxtn b19, h0");
- COMPARE(Uqxtn(h20, s0), "uqxtn h20, s0");
- COMPARE(Uqxtn(s21, d0), "uqxtn s21, d0");
-
- COMPARE(Sqxtun(v0.V8B(), v1.V8H()), "sqxtun v0.8b, v1.8h");
- COMPARE(Sqxtun(v1.V4H(), v2.V4S()), "sqxtun v1.4h, v2.4s");
- COMPARE(Sqxtun(v2.V2S(), v3.V2D()), "sqxtun v2.2s, v3.2d");
- COMPARE(Sqxtun2(v0.V16B(), v1.V8H()), "sqxtun2 v0.16b, v1.8h");
- COMPARE(Sqxtun2(v1.V8H(), v2.V4S()), "sqxtun2 v1.8h, v2.4s");
- COMPARE(Sqxtun2(v2.V4S(), v3.V2D()), "sqxtun2 v2.4s, v3.2d");
- COMPARE(Sqxtun(b19, h0), "sqxtun b19, h0");
- COMPARE(Sqxtun(h20, s0), "sqxtun h20, s0");
- COMPARE(Sqxtun(s21, d0), "sqxtun s21, d0");
-
- COMPARE(Cls(v1.V8B(), v8.V8B()), "cls v1.8b, v8.8b");
- COMPARE(Cls(v2.V16B(), v9.V16B()), "cls v2.16b, v9.16b");
- COMPARE(Cls(v3.V4H(), v1.V4H()), "cls v3.4h, v1.4h");
- COMPARE(Cls(v4.V8H(), v2.V8H()), "cls v4.8h, v2.8h");
- COMPARE(Cls(v5.V2S(), v3.V2S()), "cls v5.2s, v3.2s");
- COMPARE(Cls(v6.V4S(), v4.V4S()), "cls v6.4s, v4.4s");
-
- COMPARE(Clz(v1.V8B(), v8.V8B()), "clz v1.8b, v8.8b");
- COMPARE(Clz(v2.V16B(), v9.V16B()), "clz v2.16b, v9.16b");
- COMPARE(Clz(v3.V4H(), v1.V4H()), "clz v3.4h, v1.4h");
- COMPARE(Clz(v4.V8H(), v2.V8H()), "clz v4.8h, v2.8h");
- COMPARE(Clz(v5.V2S(), v3.V2S()), "clz v5.2s, v3.2s");
- COMPARE(Clz(v6.V4S(), v4.V4S()), "clz v6.4s, v4.4s");
-
- COMPARE(Cnt(v1.V8B(), v8.V8B()), "cnt v1.8b, v8.8b");
- COMPARE(Cnt(v2.V16B(), v9.V16B()), "cnt v2.16b, v9.16b");
-
- COMPARE(Mvn(v4.V8B(), v5.V8B()), "mvn v4.8b, v5.8b");
- COMPARE(Mvn(v4.V16B(), v5.V16B()), "mvn v4.16b, v5.16b");
-
- COMPARE(Not(v4.V8B(), v5.V8B()), "mvn v4.8b, v5.8b");
- COMPARE(Not(v4.V16B(), v5.V16B()), "mvn v4.16b, v5.16b");
-
- COMPARE(Rev64(v1.V8B(), v8.V8B()), "rev64 v1.8b, v8.8b");
- COMPARE(Rev64(v2.V16B(), v9.V16B()), "rev64 v2.16b, v9.16b");
- COMPARE(Rev64(v3.V4H(), v1.V4H()), "rev64 v3.4h, v1.4h");
- COMPARE(Rev64(v4.V8H(), v2.V8H()), "rev64 v4.8h, v2.8h");
- COMPARE(Rev64(v5.V2S(), v3.V2S()), "rev64 v5.2s, v3.2s");
- COMPARE(Rev64(v6.V4S(), v4.V4S()), "rev64 v6.4s, v4.4s");
-
- COMPARE(Rev32(v1.V8B(), v8.V8B()), "rev32 v1.8b, v8.8b");
- COMPARE(Rev32(v2.V16B(), v9.V16B()), "rev32 v2.16b, v9.16b");
- COMPARE(Rev32(v3.V4H(), v1.V4H()), "rev32 v3.4h, v1.4h");
- COMPARE(Rev32(v4.V8H(), v2.V8H()), "rev32 v4.8h, v2.8h");
-
- COMPARE(Rev16(v1.V8B(), v8.V8B()), "rev16 v1.8b, v8.8b");
- COMPARE(Rev16(v2.V16B(), v9.V16B()), "rev16 v2.16b, v9.16b");
-
- COMPARE(Rbit(v1.V8B(), v8.V8B()), "rbit v1.8b, v8.8b");
- COMPARE(Rbit(v2.V16B(), v9.V16B()), "rbit v2.16b, v9.16b");
-
- COMPARE(Ursqrte(v2.V2S(), v9.V2S()), "ursqrte v2.2s, v9.2s");
- COMPARE(Ursqrte(v16.V4S(), v23.V4S()), "ursqrte v16.4s, v23.4s");
-
- COMPARE(Urecpe(v2.V2S(), v9.V2S()), "urecpe v2.2s, v9.2s");
- COMPARE(Urecpe(v16.V4S(), v23.V4S()), "urecpe v16.4s, v23.4s");
-
- COMPARE(Frsqrte(v2.V2S(), v9.V2S()), "frsqrte v2.2s, v9.2s");
- COMPARE(Frsqrte(v16.V4S(), v23.V4S()), "frsqrte v16.4s, v23.4s");
- COMPARE(Frsqrte(v2.V2D(), v9.V2D()), "frsqrte v2.2d, v9.2d");
- COMPARE(Frsqrte(v0.S(), v1.S()), "frsqrte s0, s1");
- COMPARE(Frsqrte(v0.D(), v1.D()), "frsqrte d0, d1");
-
- COMPARE(Frecpe(v2.V2S(), v9.V2S()), "frecpe v2.2s, v9.2s");
- COMPARE(Frecpe(v16.V4S(), v23.V4S()), "frecpe v16.4s, v23.4s");
- COMPARE(Frecpe(v2.V2D(), v9.V2D()), "frecpe v2.2d, v9.2d");
- COMPARE(Frecpe(v0.S(), v1.S()), "frecpe s0, s1");
- COMPARE(Frecpe(v0.D(), v1.D()), "frecpe d0, d1");
-
- COMPARE(Fabs(v2.V2S(), v9.V2S()), "fabs v2.2s, v9.2s");
- COMPARE(Fabs(v16.V4S(), v23.V4S()), "fabs v16.4s, v23.4s");
- COMPARE(Fabs(v31.V2D(), v30.V2D()), "fabs v31.2d, v30.2d");
-
- COMPARE(Fneg(v2.V2S(), v9.V2S()), "fneg v2.2s, v9.2s");
- COMPARE(Fneg(v16.V4S(), v23.V4S()), "fneg v16.4s, v23.4s");
- COMPARE(Fneg(v31.V2D(), v30.V2D()), "fneg v31.2d, v30.2d");
-
- COMPARE(Frintn(v2.V2S(), v9.V2S()), "frintn v2.2s, v9.2s");
- COMPARE(Frintn(v16.V4S(), v23.V4S()), "frintn v16.4s, v23.4s");
- COMPARE(Frintn(v31.V2D(), v30.V2D()), "frintn v31.2d, v30.2d");
-
- COMPARE(Frinta(v2.V2S(), v9.V2S()), "frinta v2.2s, v9.2s");
- COMPARE(Frinta(v16.V4S(), v23.V4S()), "frinta v16.4s, v23.4s");
- COMPARE(Frinta(v31.V2D(), v30.V2D()), "frinta v31.2d, v30.2d");
-
- COMPARE(Frintp(v2.V2S(), v9.V2S()), "frintp v2.2s, v9.2s");
- COMPARE(Frintp(v16.V4S(), v23.V4S()), "frintp v16.4s, v23.4s");
- COMPARE(Frintp(v31.V2D(), v30.V2D()), "frintp v31.2d, v30.2d");
-
- COMPARE(Frintm(v2.V2S(), v9.V2S()), "frintm v2.2s, v9.2s");
- COMPARE(Frintm(v16.V4S(), v23.V4S()), "frintm v16.4s, v23.4s");
- COMPARE(Frintm(v31.V2D(), v30.V2D()), "frintm v31.2d, v30.2d");
-
- COMPARE(Frintx(v2.V2S(), v9.V2S()), "frintx v2.2s, v9.2s");
- COMPARE(Frintx(v16.V4S(), v23.V4S()), "frintx v16.4s, v23.4s");
- COMPARE(Frintx(v31.V2D(), v30.V2D()), "frintx v31.2d, v30.2d");
-
- COMPARE(Frintz(v2.V2S(), v9.V2S()), "frintz v2.2s, v9.2s");
- COMPARE(Frintz(v16.V4S(), v23.V4S()), "frintz v16.4s, v23.4s");
- COMPARE(Frintz(v31.V2D(), v30.V2D()), "frintz v31.2d, v30.2d");
-
- COMPARE(Frinti(v2.V2S(), v9.V2S()), "frinti v2.2s, v9.2s");
- COMPARE(Frinti(v16.V4S(), v23.V4S()), "frinti v16.4s, v23.4s");
- COMPARE(Frinti(v31.V2D(), v30.V2D()), "frinti v31.2d, v30.2d");
-
- COMPARE(Fsqrt(v3.V2S(), v10.V2S()), "fsqrt v3.2s, v10.2s");
- COMPARE(Fsqrt(v22.V4S(), v11.V4S()), "fsqrt v22.4s, v11.4s");
- COMPARE(Fsqrt(v31.V2D(), v0.V2D()), "fsqrt v31.2d, v0.2d");
-
- COMPARE(Fcvtns(v4.V2S(), v11.V2S()), "fcvtns v4.2s, v11.2s");
- COMPARE(Fcvtns(v23.V4S(), v12.V4S()), "fcvtns v23.4s, v12.4s");
- COMPARE(Fcvtns(v30.V2D(), v1.V2D()), "fcvtns v30.2d, v1.2d");
- COMPARE(Fcvtnu(v4.V2S(), v11.V2S()), "fcvtnu v4.2s, v11.2s");
- COMPARE(Fcvtnu(v23.V4S(), v12.V4S()), "fcvtnu v23.4s, v12.4s");
- COMPARE(Fcvtnu(v30.V2D(), v1.V2D()), "fcvtnu v30.2d, v1.2d");
-
- COMPARE(Fcvtps(v4.V2S(), v11.V2S()), "fcvtps v4.2s, v11.2s");
- COMPARE(Fcvtps(v23.V4S(), v12.V4S()), "fcvtps v23.4s, v12.4s");
- COMPARE(Fcvtps(v30.V2D(), v1.V2D()), "fcvtps v30.2d, v1.2d");
- COMPARE(Fcvtpu(v4.V2S(), v11.V2S()), "fcvtpu v4.2s, v11.2s");
- COMPARE(Fcvtpu(v23.V4S(), v12.V4S()), "fcvtpu v23.4s, v12.4s");
- COMPARE(Fcvtpu(v30.V2D(), v1.V2D()), "fcvtpu v30.2d, v1.2d");
-
- COMPARE(Fcvtms(v4.V2S(), v11.V2S()), "fcvtms v4.2s, v11.2s");
- COMPARE(Fcvtms(v23.V4S(), v12.V4S()), "fcvtms v23.4s, v12.4s");
- COMPARE(Fcvtms(v30.V2D(), v1.V2D()), "fcvtms v30.2d, v1.2d");
- COMPARE(Fcvtmu(v4.V2S(), v11.V2S()), "fcvtmu v4.2s, v11.2s");
- COMPARE(Fcvtmu(v23.V4S(), v12.V4S()), "fcvtmu v23.4s, v12.4s");
- COMPARE(Fcvtmu(v30.V2D(), v1.V2D()), "fcvtmu v30.2d, v1.2d");
-
- COMPARE(Fcvtzs(v4.V2S(), v11.V2S()), "fcvtzs v4.2s, v11.2s");
- COMPARE(Fcvtzs(v23.V4S(), v12.V4S()), "fcvtzs v23.4s, v12.4s");
- COMPARE(Fcvtzs(v30.V2D(), v1.V2D()), "fcvtzs v30.2d, v1.2d");
- COMPARE(Fcvtzu(v4.V2S(), v11.V2S()), "fcvtzu v4.2s, v11.2s");
- COMPARE(Fcvtzu(v23.V4S(), v12.V4S()), "fcvtzu v23.4s, v12.4s");
- COMPARE(Fcvtzu(v30.V2D(), v1.V2D()), "fcvtzu v30.2d, v1.2d");
-
- COMPARE(Fcvtas(v4.V2S(), v11.V2S()), "fcvtas v4.2s, v11.2s");
- COMPARE(Fcvtas(v23.V4S(), v12.V4S()), "fcvtas v23.4s, v12.4s");
- COMPARE(Fcvtas(v30.V2D(), v1.V2D()), "fcvtas v30.2d, v1.2d");
- COMPARE(Fcvtau(v4.V2S(), v11.V2S()), "fcvtau v4.2s, v11.2s");
- COMPARE(Fcvtau(v23.V4S(), v12.V4S()), "fcvtau v23.4s, v12.4s");
- COMPARE(Fcvtau(v30.V2D(), v1.V2D()), "fcvtau v30.2d, v1.2d");
-
- COMPARE(Fcvtns(s0, s1), "fcvtns s0, s1");
- COMPARE(Fcvtns(d2, d3), "fcvtns d2, d3");
- COMPARE(Fcvtnu(s4, s5), "fcvtnu s4, s5");
- COMPARE(Fcvtnu(d6, d7), "fcvtnu d6, d7");
- COMPARE(Fcvtps(s8, s9), "fcvtps s8, s9");
- COMPARE(Fcvtps(d10, d11), "fcvtps d10, d11");
- COMPARE(Fcvtpu(s12, s13), "fcvtpu s12, s13");
- COMPARE(Fcvtpu(d14, d15), "fcvtpu d14, d15");
- COMPARE(Fcvtms(s16, s17), "fcvtms s16, s17");
- COMPARE(Fcvtms(d18, d19), "fcvtms d18, d19");
- COMPARE(Fcvtmu(s20, s21), "fcvtmu s20, s21");
- COMPARE(Fcvtmu(d22, d23), "fcvtmu d22, d23");
- COMPARE(Fcvtzs(s24, s25), "fcvtzs s24, s25");
- COMPARE(Fcvtzs(d26, d27), "fcvtzs d26, d27");
- COMPARE(Fcvtzu(s28, s29), "fcvtzu s28, s29");
- COMPARE(Fcvtzu(d30, d31), "fcvtzu d30, d31");
- COMPARE(Fcvtas(s0, s1), "fcvtas s0, s1");
- COMPARE(Fcvtas(d2, d3), "fcvtas d2, d3");
- COMPARE(Fcvtau(s4, s5), "fcvtau s4, s5");
- COMPARE(Fcvtau(d6, d7), "fcvtau d6, d7");
-
- COMPARE(Fcvtl(v3.V4S(), v5.V4H()), "fcvtl v3.4s, v5.4h");
- COMPARE(Fcvtl(v7.V2D(), v11.V2S()), "fcvtl v7.2d, v11.2s");
- COMPARE(Fcvtl2(v13.V4S(), v17.V8H()), "fcvtl2 v13.4s, v17.8h");
- COMPARE(Fcvtl2(v23.V2D(), v29.V4S()), "fcvtl2 v23.2d, v29.4s");
-
- COMPARE(Fcvtn(v3.V4H(), v5.V4S()), "fcvtn v3.4h, v5.4s");
- COMPARE(Fcvtn(v7.V2S(), v11.V2D()), "fcvtn v7.2s, v11.2d");
- COMPARE(Fcvtn2(v13.V8H(), v17.V4S()), "fcvtn2 v13.8h, v17.4s");
- COMPARE(Fcvtn2(v23.V4S(), v29.V2D()), "fcvtn2 v23.4s, v29.2d");
-
- COMPARE(Fcvtxn(v5.V2S(), v7.V2D()), "fcvtxn v5.2s, v7.2d");
- COMPARE(Fcvtxn2(v8.V4S(), v13.V2D()), "fcvtxn2 v8.4s, v13.2d");
- COMPARE(Fcvtxn(s17, d31), "fcvtxn s17, d31");
-
- COMPARE(Frecpx(s0, s1), "frecpx s0, s1");
- COMPARE(Frecpx(s31, s30), "frecpx s31, s30");
- COMPARE(Frecpx(d2, d3), "frecpx d2, d3");
- COMPARE(Frecpx(d31, d30), "frecpx d31, d30");
-
- COMPARE(Scvtf(v5.V2S(), v3.V2S()), "scvtf v5.2s, v3.2s");
- COMPARE(Scvtf(v6.V4S(), v4.V4S()), "scvtf v6.4s, v4.4s");
- COMPARE(Scvtf(v7.V2D(), v5.V2D()), "scvtf v7.2d, v5.2d");
- COMPARE(Scvtf(s8, s6), "scvtf s8, s6");
- COMPARE(Scvtf(d8, d6), "scvtf d8, d6");
-
- COMPARE(Ucvtf(v5.V2S(), v3.V2S()), "ucvtf v5.2s, v3.2s");
- COMPARE(Ucvtf(v6.V4S(), v4.V4S()), "ucvtf v6.4s, v4.4s");
- COMPARE(Ucvtf(v7.V2D(), v5.V2D()), "ucvtf v7.2d, v5.2d");
- COMPARE(Ucvtf(s8, s6), "ucvtf s8, s6");
- COMPARE(Ucvtf(d8, d6), "ucvtf d8, d6");
+ COMPARE_MACRO(Usqadd(b0, b1), "usqadd b0, b1");
+ COMPARE_MACRO(Usqadd(h1, h2), "usqadd h1, h2");
+ COMPARE_MACRO(Usqadd(s2, s3), "usqadd s2, s3");
+ COMPARE_MACRO(Usqadd(d3, d4), "usqadd d3, d4");
+
+ COMPARE_MACRO(Xtn(v0.V8B(), v1.V8H()),
+ "xtn v0.8b, "
+ "v1.8h");
+ COMPARE_MACRO(Xtn(v1.V4H(), v2.V4S()),
+ "xtn v1.4h, "
+ "v2.4s");
+ COMPARE_MACRO(Xtn(v2.V2S(), v3.V2D()),
+ "xtn v2.2s, "
+ "v3.2d");
+ COMPARE_MACRO(Xtn2(v0.V16B(), v1.V8H()),
+ "xtn2 v0.16b, "
+ "v1.8h");
+ COMPARE_MACRO(Xtn2(v1.V8H(), v2.V4S()),
+ "xtn2 v1.8h, "
+ "v2.4s");
+ COMPARE_MACRO(Xtn2(v2.V4S(), v3.V2D()),
+ "xtn2 v2.4s, "
+ "v3.2d");
+
+ COMPARE_MACRO(Sqxtn(v0.V8B(), v1.V8H()),
+ "sqxtn v0.8b, "
+ "v1.8h");
+ COMPARE_MACRO(Sqxtn(v1.V4H(), v2.V4S()),
+ "sqxtn v1.4h, "
+ "v2.4s");
+ COMPARE_MACRO(Sqxtn(v2.V2S(), v3.V2D()),
+ "sqxtn v2.2s, "
+ "v3.2d");
+ COMPARE_MACRO(Sqxtn2(v0.V16B(), v1.V8H()),
+ "sqxtn2 v0.16b, "
+ "v1.8h");
+ COMPARE_MACRO(Sqxtn2(v1.V8H(), v2.V4S()),
+ "sqxtn2 v1.8h, "
+ "v2.4s");
+ COMPARE_MACRO(Sqxtn2(v2.V4S(), v3.V2D()),
+ "sqxtn2 v2.4s, "
+ "v3.2d");
+ COMPARE_MACRO(Sqxtn(b19, h0), "sqxtn b19, h0");
+ COMPARE_MACRO(Sqxtn(h20, s0), "sqxtn h20, s0");
+ COMPARE_MACRO(Sqxtn(s21, d0), "sqxtn s21, d0");
+
+ COMPARE_MACRO(Uqxtn(v0.V8B(), v1.V8H()),
+ "uqxtn v0.8b, "
+ "v1.8h");
+ COMPARE_MACRO(Uqxtn(v1.V4H(), v2.V4S()),
+ "uqxtn v1.4h, "
+ "v2.4s");
+ COMPARE_MACRO(Uqxtn(v2.V2S(), v3.V2D()),
+ "uqxtn v2.2s, "
+ "v3.2d");
+ COMPARE_MACRO(Uqxtn2(v0.V16B(), v1.V8H()),
+ "uqxtn2 v0.16b, "
+ "v1.8h");
+ COMPARE_MACRO(Uqxtn2(v1.V8H(), v2.V4S()),
+ "uqxtn2 v1.8h, "
+ "v2.4s");
+ COMPARE_MACRO(Uqxtn2(v2.V4S(), v3.V2D()),
+ "uqxtn2 v2.4s, "
+ "v3.2d");
+ COMPARE_MACRO(Uqxtn(b19, h0), "uqxtn b19, h0");
+ COMPARE_MACRO(Uqxtn(h20, s0), "uqxtn h20, s0");
+ COMPARE_MACRO(Uqxtn(s21, d0), "uqxtn s21, d0");
+
+ COMPARE_MACRO(Sqxtun(v0.V8B(), v1.V8H()),
+ "sqxtun v0.8b, "
+ "v1.8h");
+ COMPARE_MACRO(Sqxtun(v1.V4H(), v2.V4S()),
+ "sqxtun v1.4h, "
+ "v2.4s");
+ COMPARE_MACRO(Sqxtun(v2.V2S(), v3.V2D()),
+ "sqxtun v2.2s, "
+ "v3.2d");
+ COMPARE_MACRO(Sqxtun2(v0.V16B(), v1.V8H()),
+ "sqxtun2 v0.16b, "
+ "v1.8h");
+ COMPARE_MACRO(Sqxtun2(v1.V8H(), v2.V4S()),
+ "sqxtun2 v1.8h, "
+ "v2.4s");
+ COMPARE_MACRO(Sqxtun2(v2.V4S(), v3.V2D()),
+ "sqxtun2 v2.4s, "
+ "v3.2d");
+ COMPARE_MACRO(Sqxtun(b19, h0), "sqxtun b19, h0");
+ COMPARE_MACRO(Sqxtun(h20, s0), "sqxtun h20, s0");
+ COMPARE_MACRO(Sqxtun(s21, d0), "sqxtun s21, d0");
+
+ COMPARE_MACRO(Cls(v1.V8B(), v8.V8B()),
+ "cls v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Cls(v2.V16B(), v9.V16B()),
+ "cls v2.16b, "
+ "v9.16b");
+ COMPARE_MACRO(Cls(v3.V4H(), v1.V4H()),
+ "cls v3.4h, "
+ "v1.4h");
+ COMPARE_MACRO(Cls(v4.V8H(), v2.V8H()),
+ "cls v4.8h, "
+ "v2.8h");
+ COMPARE_MACRO(Cls(v5.V2S(), v3.V2S()),
+ "cls v5.2s, "
+ "v3.2s");
+ COMPARE_MACRO(Cls(v6.V4S(), v4.V4S()),
+ "cls v6.4s, "
+ "v4.4s");
+
+ COMPARE_MACRO(Clz(v1.V8B(), v8.V8B()),
+ "clz v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Clz(v2.V16B(), v9.V16B()),
+ "clz v2.16b, "
+ "v9.16b");
+ COMPARE_MACRO(Clz(v3.V4H(), v1.V4H()),
+ "clz v3.4h, "
+ "v1.4h");
+ COMPARE_MACRO(Clz(v4.V8H(), v2.V8H()),
+ "clz v4.8h, "
+ "v2.8h");
+ COMPARE_MACRO(Clz(v5.V2S(), v3.V2S()),
+ "clz v5.2s, "
+ "v3.2s");
+ COMPARE_MACRO(Clz(v6.V4S(), v4.V4S()),
+ "clz v6.4s, "
+ "v4.4s");
+
+ COMPARE_MACRO(Cnt(v1.V8B(), v8.V8B()),
+ "cnt v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Cnt(v2.V16B(), v9.V16B()),
+ "cnt v2.16b, "
+ "v9.16b");
+
+ COMPARE_MACRO(Mvn(v4.V8B(), v5.V8B()),
+ "mvn v4.8b, "
+ "v5.8b");
+ COMPARE_MACRO(Mvn(v4.V16B(), v5.V16B()),
+ "mvn v4.16b, "
+ "v5.16b");
+
+ COMPARE_MACRO(Not(v4.V8B(), v5.V8B()),
+ "mvn v4.8b, "
+ "v5.8b");
+ COMPARE_MACRO(Not(v4.V16B(), v5.V16B()),
+ "mvn v4.16b, "
+ "v5.16b");
+
+ COMPARE_MACRO(Rev64(v1.V8B(), v8.V8B()),
+ "rev64 v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Rev64(v2.V16B(), v9.V16B()),
+ "rev64 v2.16b, "
+ "v9.16b");
+ COMPARE_MACRO(Rev64(v3.V4H(), v1.V4H()),
+ "rev64 v3.4h, "
+ "v1.4h");
+ COMPARE_MACRO(Rev64(v4.V8H(), v2.V8H()),
+ "rev64 v4.8h, "
+ "v2.8h");
+ COMPARE_MACRO(Rev64(v5.V2S(), v3.V2S()),
+ "rev64 v5.2s, "
+ "v3.2s");
+ COMPARE_MACRO(Rev64(v6.V4S(), v4.V4S()),
+ "rev64 v6.4s, "
+ "v4.4s");
+
+ COMPARE_MACRO(Rev32(v1.V8B(), v8.V8B()),
+ "rev32 v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Rev32(v2.V16B(), v9.V16B()),
+ "rev32 v2.16b, "
+ "v9.16b");
+ COMPARE_MACRO(Rev32(v3.V4H(), v1.V4H()),
+ "rev32 v3.4h, "
+ "v1.4h");
+ COMPARE_MACRO(Rev32(v4.V8H(), v2.V8H()),
+ "rev32 v4.8h, "
+ "v2.8h");
+
+ COMPARE_MACRO(Rev16(v1.V8B(), v8.V8B()),
+ "rev16 v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Rev16(v2.V16B(), v9.V16B()),
+ "rev16 v2.16b, "
+ "v9.16b");
+
+ COMPARE_MACRO(Rbit(v1.V8B(), v8.V8B()),
+ "rbit v1.8b, "
+ "v8.8b");
+ COMPARE_MACRO(Rbit(v2.V16B(), v9.V16B()),
+ "rbit v2.16b, "
+ "v9.16b");
+
+ COMPARE_MACRO(Ursqrte(v2.V2S(), v9.V2S()),
+ "ursqrte v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Ursqrte(v16.V4S(), v23.V4S()),
+ "ursqrte v16.4s, "
+ "v23.4s");
+
+ COMPARE_MACRO(Urecpe(v2.V2S(), v9.V2S()),
+ "urecpe v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Urecpe(v16.V4S(), v23.V4S()),
+ "urecpe v16.4s, "
+ "v23.4s");
+
+ COMPARE_MACRO(Frsqrte(v2.V2S(), v9.V2S()),
+ "frsqrte v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frsqrte(v16.V4S(), v23.V4S()),
+ "frsqrte v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frsqrte(v2.V2D(), v9.V2D()),
+ "frsqrte v2.2d, "
+ "v9.2d");
+ COMPARE_MACRO(Frsqrte(v0.S(), v1.S()), "frsqrte s0, s1");
+ COMPARE_MACRO(Frsqrte(v0.D(), v1.D()), "frsqrte d0, d1");
+
+ COMPARE_MACRO(Frecpe(v2.V2S(), v9.V2S()),
+ "frecpe v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frecpe(v16.V4S(), v23.V4S()),
+ "frecpe v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frecpe(v2.V2D(), v9.V2D()),
+ "frecpe v2.2d, "
+ "v9.2d");
+ COMPARE_MACRO(Frecpe(v0.S(), v1.S()), "frecpe s0, s1");
+ COMPARE_MACRO(Frecpe(v0.D(), v1.D()), "frecpe d0, d1");
+
+ COMPARE_MACRO(Fabs(v2.V2S(), v9.V2S()),
+ "fabs v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Fabs(v16.V4S(), v23.V4S()),
+ "fabs v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Fabs(v31.V2D(), v30.V2D()),
+ "fabs v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Fneg(v2.V2S(), v9.V2S()),
+ "fneg v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Fneg(v16.V4S(), v23.V4S()),
+ "fneg v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Fneg(v31.V2D(), v30.V2D()),
+ "fneg v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frintn(v2.V2S(), v9.V2S()),
+ "frintn v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frintn(v16.V4S(), v23.V4S()),
+ "frintn v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frintn(v31.V2D(), v30.V2D()),
+ "frintn v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frinta(v2.V2S(), v9.V2S()),
+ "frinta v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frinta(v16.V4S(), v23.V4S()),
+ "frinta v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frinta(v31.V2D(), v30.V2D()),
+ "frinta v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frintp(v2.V2S(), v9.V2S()),
+ "frintp v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frintp(v16.V4S(), v23.V4S()),
+ "frintp v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frintp(v31.V2D(), v30.V2D()),
+ "frintp v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frintm(v2.V2S(), v9.V2S()),
+ "frintm v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frintm(v16.V4S(), v23.V4S()),
+ "frintm v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frintm(v31.V2D(), v30.V2D()),
+ "frintm v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frintx(v2.V2S(), v9.V2S()),
+ "frintx v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frintx(v16.V4S(), v23.V4S()),
+ "frintx v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frintx(v31.V2D(), v30.V2D()),
+ "frintx v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frintz(v2.V2S(), v9.V2S()),
+ "frintz v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frintz(v16.V4S(), v23.V4S()),
+ "frintz v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frintz(v31.V2D(), v30.V2D()),
+ "frintz v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Frinti(v2.V2S(), v9.V2S()),
+ "frinti v2.2s, "
+ "v9.2s");
+ COMPARE_MACRO(Frinti(v16.V4S(), v23.V4S()),
+ "frinti v16.4s, "
+ "v23.4s");
+ COMPARE_MACRO(Frinti(v31.V2D(), v30.V2D()),
+ "frinti v31.2d, "
+ "v30.2d");
+
+ COMPARE_MACRO(Fsqrt(v3.V2S(), v10.V2S()),
+ "fsqrt v3.2s, "
+ "v10.2s");
+ COMPARE_MACRO(Fsqrt(v22.V4S(), v11.V4S()),
+ "fsqrt v22.4s, "
+ "v11.4s");
+ COMPARE_MACRO(Fsqrt(v31.V2D(), v0.V2D()),
+ "fsqrt v31.2d, "
+ "v0.2d");
+
+ COMPARE_MACRO(Fcvtns(v4.V2S(), v11.V2S()),
+ "fcvtns v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtns(v23.V4S(), v12.V4S()),
+ "fcvtns v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtns(v30.V2D(), v1.V2D()),
+ "fcvtns v30.2d, "
+ "v1.2d");
+ COMPARE_MACRO(Fcvtnu(v4.V2S(), v11.V2S()),
+ "fcvtnu v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtnu(v23.V4S(), v12.V4S()),
+ "fcvtnu v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtnu(v30.V2D(), v1.V2D()),
+ "fcvtnu v30.2d, "
+ "v1.2d");
+
+ COMPARE_MACRO(Fcvtps(v4.V2S(), v11.V2S()),
+ "fcvtps v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtps(v23.V4S(), v12.V4S()),
+ "fcvtps v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtps(v30.V2D(), v1.V2D()),
+ "fcvtps v30.2d, "
+ "v1.2d");
+ COMPARE_MACRO(Fcvtpu(v4.V2S(), v11.V2S()),
+ "fcvtpu v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtpu(v23.V4S(), v12.V4S()),
+ "fcvtpu v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtpu(v30.V2D(), v1.V2D()),
+ "fcvtpu v30.2d, "
+ "v1.2d");
+
+ COMPARE_MACRO(Fcvtms(v4.V2S(), v11.V2S()),
+ "fcvtms v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtms(v23.V4S(), v12.V4S()),
+ "fcvtms v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtms(v30.V2D(), v1.V2D()),
+ "fcvtms v30.2d, "
+ "v1.2d");
+ COMPARE_MACRO(Fcvtmu(v4.V2S(), v11.V2S()),
+ "fcvtmu v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtmu(v23.V4S(), v12.V4S()),
+ "fcvtmu v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtmu(v30.V2D(), v1.V2D()),
+ "fcvtmu v30.2d, "
+ "v1.2d");
+
+ COMPARE_MACRO(Fcvtzs(v4.V2S(), v11.V2S()),
+ "fcvtzs v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtzs(v23.V4S(), v12.V4S()),
+ "fcvtzs v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtzs(v30.V2D(), v1.V2D()),
+ "fcvtzs v30.2d, "
+ "v1.2d");
+ COMPARE_MACRO(Fcvtzu(v4.V2S(), v11.V2S()),
+ "fcvtzu v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtzu(v23.V4S(), v12.V4S()),
+ "fcvtzu v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtzu(v30.V2D(), v1.V2D()),
+ "fcvtzu v30.2d, "
+ "v1.2d");
+
+ COMPARE_MACRO(Fcvtas(v4.V2S(), v11.V2S()),
+ "fcvtas v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtas(v23.V4S(), v12.V4S()),
+ "fcvtas v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtas(v30.V2D(), v1.V2D()),
+ "fcvtas v30.2d, "
+ "v1.2d");
+ COMPARE_MACRO(Fcvtau(v4.V2S(), v11.V2S()),
+ "fcvtau v4.2s, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtau(v23.V4S(), v12.V4S()),
+ "fcvtau v23.4s, "
+ "v12.4s");
+ COMPARE_MACRO(Fcvtau(v30.V2D(), v1.V2D()),
+ "fcvtau v30.2d, "
+ "v1.2d");
+
+ COMPARE_MACRO(Fcvtns(s0, s1), "fcvtns s0, s1");
+ COMPARE_MACRO(Fcvtns(d2, d3), "fcvtns d2, d3");
+ COMPARE_MACRO(Fcvtnu(s4, s5), "fcvtnu s4, s5");
+ COMPARE_MACRO(Fcvtnu(d6, d7), "fcvtnu d6, d7");
+ COMPARE_MACRO(Fcvtps(s8, s9), "fcvtps s8, s9");
+ COMPARE_MACRO(Fcvtps(d10, d11), "fcvtps d10, d11");
+ COMPARE_MACRO(Fcvtpu(s12, s13), "fcvtpu s12, s13");
+ COMPARE_MACRO(Fcvtpu(d14, d15), "fcvtpu d14, d15");
+ COMPARE_MACRO(Fcvtms(s16, s17), "fcvtms s16, s17");
+ COMPARE_MACRO(Fcvtms(d18, d19), "fcvtms d18, d19");
+ COMPARE_MACRO(Fcvtmu(s20, s21), "fcvtmu s20, s21");
+ COMPARE_MACRO(Fcvtmu(d22, d23), "fcvtmu d22, d23");
+ COMPARE_MACRO(Fcvtzs(s24, s25), "fcvtzs s24, s25");
+ COMPARE_MACRO(Fcvtzs(d26, d27), "fcvtzs d26, d27");
+ COMPARE_MACRO(Fcvtzu(s28, s29), "fcvtzu s28, s29");
+ COMPARE_MACRO(Fcvtzu(d30, d31), "fcvtzu d30, d31");
+ COMPARE_MACRO(Fcvtas(s0, s1), "fcvtas s0, s1");
+ COMPARE_MACRO(Fcvtas(d2, d3), "fcvtas d2, d3");
+ COMPARE_MACRO(Fcvtau(s4, s5), "fcvtau s4, s5");
+ COMPARE_MACRO(Fcvtau(d6, d7), "fcvtau d6, d7");
+
+ COMPARE_MACRO(Fcvtl(v3.V4S(), v5.V4H()),
+ "fcvtl v3.4s, "
+ "v5.4h");
+ COMPARE_MACRO(Fcvtl(v7.V2D(), v11.V2S()),
+ "fcvtl v7.2d, "
+ "v11.2s");
+ COMPARE_MACRO(Fcvtl2(v13.V4S(), v17.V8H()),
+ "fcvtl2 v13.4s, "
+ "v17.8h");
+ COMPARE_MACRO(Fcvtl2(v23.V2D(), v29.V4S()),
+ "fcvtl2 v23.2d, "
+ "v29.4s");
+
+ COMPARE_MACRO(Fcvtn(v3.V4H(), v5.V4S()),
+ "fcvtn v3.4h, "
+ "v5.4s");
+ COMPARE_MACRO(Fcvtn(v7.V2S(), v11.V2D()),
+ "fcvtn v7.2s, "
+ "v11.2d");
+ COMPARE_MACRO(Fcvtn2(v13.V8H(), v17.V4S()),
+ "fcvtn2 v13.8h, "
+ "v17.4s");
+ COMPARE_MACRO(Fcvtn2(v23.V4S(), v29.V2D()),
+ "fcvtn2 v23.4s, "
+ "v29.2d");
+
+ COMPARE_MACRO(Fcvtxn(v5.V2S(), v7.V2D()),
+ "fcvtxn v5.2s, "
+ "v7.2d");
+ COMPARE_MACRO(Fcvtxn2(v8.V4S(), v13.V2D()),
+ "fcvtxn2 v8.4s, "
+ "v13.2d");
+ COMPARE_MACRO(Fcvtxn(s17, d31), "fcvtxn s17, d31");
+
+ COMPARE_MACRO(Frecpx(s0, s1), "frecpx s0, s1");
+ COMPARE_MACRO(Frecpx(s31, s30), "frecpx s31, s30");
+ COMPARE_MACRO(Frecpx(d2, d3), "frecpx d2, d3");
+ COMPARE_MACRO(Frecpx(d31, d30), "frecpx d31, d30");
+
+ COMPARE_MACRO(Scvtf(v5.V2S(), v3.V2S()),
+ "scvtf v5.2s, "
+ "v3.2s");
+ COMPARE_MACRO(Scvtf(v6.V4S(), v4.V4S()),
+ "scvtf v6.4s, "
+ "v4.4s");
+ COMPARE_MACRO(Scvtf(v7.V2D(), v5.V2D()),
+ "scvtf v7.2d, "
+ "v5.2d");
+ COMPARE_MACRO(Scvtf(s8, s6), "scvtf s8, s6");
+ COMPARE_MACRO(Scvtf(d8, d6), "scvtf d8, d6");
+
+ COMPARE_MACRO(Ucvtf(v5.V2S(), v3.V2S()),
+ "ucvtf v5.2s, "
+ "v3.2s");
+ COMPARE_MACRO(Ucvtf(v6.V4S(), v4.V4S()),
+ "ucvtf v6.4s, "
+ "v4.4s");
+ COMPARE_MACRO(Ucvtf(v7.V2D(), v5.V2D()),
+ "ucvtf v7.2d, "
+ "v5.2d");
+ COMPARE_MACRO(Ucvtf(s8, s6), "ucvtf s8, s6");
+ COMPARE_MACRO(Ucvtf(d8, d6), "ucvtf d8, d6");
#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Saddlp(v0.TA, v1.TB), "saddlp v0." TAS ", v1." TBS);
+ COMPARE_MACRO(Saddlp(v0.TA, v1.TB), "saddlp v0." TAS ", v1." TBS);
NEON_FORMAT_LIST_LP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uaddlp(v0.TA, v1.TB), "uaddlp v0." TAS ", v1." TBS);
+ COMPARE_MACRO(Uaddlp(v0.TA, v1.TB), "uaddlp v0." TAS ", v1." TBS);
NEON_FORMAT_LIST_LP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Sadalp(v0.TA, v1.TB), "sadalp v0." TAS ", v1." TBS);
+ COMPARE_MACRO(Sadalp(v0.TA, v1.TB), "sadalp v0." TAS ", v1." TBS);
NEON_FORMAT_LIST_LP(DISASM_INST)
#undef DISASM_INST
#define DISASM_INST(TA, TAS, TB, TBS) \
- COMPARE(Uadalp(v0.TA, v1.TB), "uadalp v0." TAS ", v1." TBS);
+ COMPARE_MACRO(Uadalp(v0.TA, v1.TB), "uadalp v0." TAS ", v1." TBS);
NEON_FORMAT_LIST_LP(DISASM_INST)
#undef DISASM_INST
@@ -5738,409 +6279,409 @@ TEST(neon_2regmisc) {
}
TEST(neon_acrosslanes) {
- SETUP_MACRO();
-
- COMPARE(Smaxv(b4, v5.V8B()), "smaxv b4, v5.8b");
- COMPARE(Smaxv(b4, v5.V16B()), "smaxv b4, v5.16b");
- COMPARE(Smaxv(h4, v5.V4H()), "smaxv h4, v5.4h");
- COMPARE(Smaxv(h4, v5.V8H()), "smaxv h4, v5.8h");
- COMPARE(Smaxv(s4, v5.V4S()), "smaxv s4, v5.4s");
-
- COMPARE(Sminv(b4, v5.V8B()), "sminv b4, v5.8b");
- COMPARE(Sminv(b4, v5.V16B()), "sminv b4, v5.16b");
- COMPARE(Sminv(h4, v5.V4H()), "sminv h4, v5.4h");
- COMPARE(Sminv(h4, v5.V8H()), "sminv h4, v5.8h");
- COMPARE(Sminv(s4, v5.V4S()), "sminv s4, v5.4s");
-
- COMPARE(Umaxv(b4, v5.V8B()), "umaxv b4, v5.8b");
- COMPARE(Umaxv(b4, v5.V16B()), "umaxv b4, v5.16b");
- COMPARE(Umaxv(h4, v5.V4H()), "umaxv h4, v5.4h");
- COMPARE(Umaxv(h4, v5.V8H()), "umaxv h4, v5.8h");
- COMPARE(Umaxv(s4, v5.V4S()), "umaxv s4, v5.4s");
-
- COMPARE(Uminv(b4, v5.V8B()), "uminv b4, v5.8b");
- COMPARE(Uminv(b4, v5.V16B()), "uminv b4, v5.16b");
- COMPARE(Uminv(h4, v5.V4H()), "uminv h4, v5.4h");
- COMPARE(Uminv(h4, v5.V8H()), "uminv h4, v5.8h");
- COMPARE(Uminv(s4, v5.V4S()), "uminv s4, v5.4s");
-
- COMPARE(Addv(b4, v5.V8B()), "addv b4, v5.8b");
- COMPARE(Addv(b4, v5.V16B()), "addv b4, v5.16b");
- COMPARE(Addv(h4, v5.V4H()), "addv h4, v5.4h");
- COMPARE(Addv(h4, v5.V8H()), "addv h4, v5.8h");
- COMPARE(Addv(s4, v5.V4S()), "addv s4, v5.4s");
-
- COMPARE(Saddlv(h4, v5.V8B()), "saddlv h4, v5.8b");
- COMPARE(Saddlv(h4, v5.V16B()), "saddlv h4, v5.16b");
- COMPARE(Saddlv(s4, v5.V4H()), "saddlv s4, v5.4h");
- COMPARE(Saddlv(s4, v5.V8H()), "saddlv s4, v5.8h");
- COMPARE(Saddlv(d4, v5.V4S()), "saddlv d4, v5.4s");
-
- COMPARE(Uaddlv(h4, v5.V8B()), "uaddlv h4, v5.8b");
- COMPARE(Uaddlv(h4, v5.V16B()), "uaddlv h4, v5.16b");
- COMPARE(Uaddlv(s4, v5.V4H()), "uaddlv s4, v5.4h");
- COMPARE(Uaddlv(s4, v5.V8H()), "uaddlv s4, v5.8h");
- COMPARE(Uaddlv(d4, v5.V4S()), "uaddlv d4, v5.4s");
-
- COMPARE(Fmaxv(s4, v5.V4S()), "fmaxv s4, v5.4s");
- COMPARE(Fminv(s4, v5.V4S()), "fminv s4, v5.4s");
- COMPARE(Fmaxnmv(s4, v5.V4S()), "fmaxnmv s4, v5.4s");
- COMPARE(Fminnmv(s4, v5.V4S()), "fminnmv s4, v5.4s");
+ SETUP();
+
+ COMPARE_MACRO(Smaxv(b4, v5.V8B()), "smaxv b4, v5.8b");
+ COMPARE_MACRO(Smaxv(b4, v5.V16B()), "smaxv b4, v5.16b");
+ COMPARE_MACRO(Smaxv(h4, v5.V4H()), "smaxv h4, v5.4h");
+ COMPARE_MACRO(Smaxv(h4, v5.V8H()), "smaxv h4, v5.8h");
+ COMPARE_MACRO(Smaxv(s4, v5.V4S()), "smaxv s4, v5.4s");
+
+ COMPARE_MACRO(Sminv(b4, v5.V8B()), "sminv b4, v5.8b");
+ COMPARE_MACRO(Sminv(b4, v5.V16B()), "sminv b4, v5.16b");
+ COMPARE_MACRO(Sminv(h4, v5.V4H()), "sminv h4, v5.4h");
+ COMPARE_MACRO(Sminv(h4, v5.V8H()), "sminv h4, v5.8h");
+ COMPARE_MACRO(Sminv(s4, v5.V4S()), "sminv s4, v5.4s");
+
+ COMPARE_MACRO(Umaxv(b4, v5.V8B()), "umaxv b4, v5.8b");
+ COMPARE_MACRO(Umaxv(b4, v5.V16B()), "umaxv b4, v5.16b");
+ COMPARE_MACRO(Umaxv(h4, v5.V4H()), "umaxv h4, v5.4h");
+ COMPARE_MACRO(Umaxv(h4, v5.V8H()), "umaxv h4, v5.8h");
+ COMPARE_MACRO(Umaxv(s4, v5.V4S()), "umaxv s4, v5.4s");
+
+ COMPARE_MACRO(Uminv(b4, v5.V8B()), "uminv b4, v5.8b");
+ COMPARE_MACRO(Uminv(b4, v5.V16B()), "uminv b4, v5.16b");
+ COMPARE_MACRO(Uminv(h4, v5.V4H()), "uminv h4, v5.4h");
+ COMPARE_MACRO(Uminv(h4, v5.V8H()), "uminv h4, v5.8h");
+ COMPARE_MACRO(Uminv(s4, v5.V4S()), "uminv s4, v5.4s");
+
+ COMPARE_MACRO(Addv(b4, v5.V8B()), "addv b4, v5.8b");
+ COMPARE_MACRO(Addv(b4, v5.V16B()), "addv b4, v5.16b");
+ COMPARE_MACRO(Addv(h4, v5.V4H()), "addv h4, v5.4h");
+ COMPARE_MACRO(Addv(h4, v5.V8H()), "addv h4, v5.8h");
+ COMPARE_MACRO(Addv(s4, v5.V4S()), "addv s4, v5.4s");
+
+ COMPARE_MACRO(Saddlv(h4, v5.V8B()), "saddlv h4, v5.8b");
+ COMPARE_MACRO(Saddlv(h4, v5.V16B()), "saddlv h4, v5.16b");
+ COMPARE_MACRO(Saddlv(s4, v5.V4H()), "saddlv s4, v5.4h");
+ COMPARE_MACRO(Saddlv(s4, v5.V8H()), "saddlv s4, v5.8h");
+ COMPARE_MACRO(Saddlv(d4, v5.V4S()), "saddlv d4, v5.4s");
+
+ COMPARE_MACRO(Uaddlv(h4, v5.V8B()), "uaddlv h4, v5.8b");
+ COMPARE_MACRO(Uaddlv(h4, v5.V16B()), "uaddlv h4, v5.16b");
+ COMPARE_MACRO(Uaddlv(s4, v5.V4H()), "uaddlv s4, v5.4h");
+ COMPARE_MACRO(Uaddlv(s4, v5.V8H()), "uaddlv s4, v5.8h");
+ COMPARE_MACRO(Uaddlv(d4, v5.V4S()), "uaddlv d4, v5.4s");
+
+ COMPARE_MACRO(Fmaxv(s4, v5.V4S()), "fmaxv s4, v5.4s");
+ COMPARE_MACRO(Fminv(s4, v5.V4S()), "fminv s4, v5.4s");
+ COMPARE_MACRO(Fmaxnmv(s4, v5.V4S()), "fmaxnmv s4, v5.4s");
+ COMPARE_MACRO(Fminnmv(s4, v5.V4S()), "fminnmv s4, v5.4s");
CLEANUP();
}
TEST(neon_scalar_pairwise) {
- SETUP_MACRO();
-
- COMPARE(Addp(d0, v1.V2D()), "addp d0, v1.2d");
- COMPARE(Faddp(s0, v1.V2S()), "faddp s0, v1.2s");
- COMPARE(Faddp(d2, v3.V2D()), "faddp d2, v3.2d");
- COMPARE(Fmaxp(s4, v5.V2S()), "fmaxp s4, v5.2s");
- COMPARE(Fmaxp(d6, v7.V2D()), "fmaxp d6, v7.2d");
- COMPARE(Fmaxnmp(s8, v9.V2S()), "fmaxnmp s8, v9.2s");
- COMPARE(Fmaxnmp(d10, v11.V2D()), "fmaxnmp d10, v11.2d");
- COMPARE(Fminp(s12, v13.V2S()), "fminp s12, v13.2s");
- COMPARE(Fminp(d14, v15.V2D()), "fminp d14, v15.2d");
- COMPARE(Fminnmp(s16, v17.V2S()), "fminnmp s16, v17.2s");
- COMPARE(Fminnmp(d18, v19.V2D()), "fminnmp d18, v19.2d");
+ SETUP();
+
+ COMPARE_MACRO(Addp(d0, v1.V2D()), "addp d0, v1.2d");
+ COMPARE_MACRO(Faddp(s0, v1.V2S()), "faddp s0, v1.2s");
+ COMPARE_MACRO(Faddp(d2, v3.V2D()), "faddp d2, v3.2d");
+ COMPARE_MACRO(Fmaxp(s4, v5.V2S()), "fmaxp s4, v5.2s");
+ COMPARE_MACRO(Fmaxp(d6, v7.V2D()), "fmaxp d6, v7.2d");
+ COMPARE_MACRO(Fmaxnmp(s8, v9.V2S()), "fmaxnmp s8, v9.2s");
+ COMPARE_MACRO(Fmaxnmp(d10, v11.V2D()), "fmaxnmp d10, v11.2d");
+ COMPARE_MACRO(Fminp(s12, v13.V2S()), "fminp s12, v13.2s");
+ COMPARE_MACRO(Fminp(d14, v15.V2D()), "fminp d14, v15.2d");
+ COMPARE_MACRO(Fminnmp(s16, v17.V2S()), "fminnmp s16, v17.2s");
+ COMPARE_MACRO(Fminnmp(d18, v19.V2D()), "fminnmp d18, v19.2d");
CLEANUP();
}
TEST(neon_shift_immediate) {
- SETUP_MACRO();
-
- COMPARE(Sshr(v0.V8B(), v1.V8B(), 1), "sshr v0.8b, v1.8b, #1");
- COMPARE(Sshr(v2.V8B(), v3.V8B(), 8), "sshr v2.8b, v3.8b, #8");
- COMPARE(Sshr(v4.V16B(), v5.V16B(), 1), "sshr v4.16b, v5.16b, #1");
- COMPARE(Sshr(v6.V16B(), v7.V16B(), 8), "sshr v6.16b, v7.16b, #8");
- COMPARE(Sshr(v8.V4H(), v9.V4H(), 1), "sshr v8.4h, v9.4h, #1");
- COMPARE(Sshr(v10.V4H(), v11.V4H(), 16), "sshr v10.4h, v11.4h, #16");
- COMPARE(Sshr(v12.V8H(), v13.V8H(), 1), "sshr v12.8h, v13.8h, #1");
- COMPARE(Sshr(v14.V8H(), v15.V8H(), 16), "sshr v14.8h, v15.8h, #16");
- COMPARE(Sshr(v16.V2S(), v17.V2S(), 1), "sshr v16.2s, v17.2s, #1");
- COMPARE(Sshr(v18.V2S(), v19.V2S(), 32), "sshr v18.2s, v19.2s, #32");
- COMPARE(Sshr(v20.V4S(), v21.V4S(), 1), "sshr v20.4s, v21.4s, #1");
- COMPARE(Sshr(v22.V4S(), v23.V4S(), 32), "sshr v22.4s, v23.4s, #32");
- COMPARE(Sshr(v28.V2D(), v29.V2D(), 1), "sshr v28.2d, v29.2d, #1");
- COMPARE(Sshr(v30.V2D(), v31.V2D(), 64), "sshr v30.2d, v31.2d, #64");
- COMPARE(Sshr(d0, d1, 7), "sshr d0, d1, #7");
-
- COMPARE(Ushr(v0.V8B(), v1.V8B(), 1), "ushr v0.8b, v1.8b, #1");
- COMPARE(Ushr(v2.V8B(), v3.V8B(), 8), "ushr v2.8b, v3.8b, #8");
- COMPARE(Ushr(v4.V16B(), v5.V16B(), 1), "ushr v4.16b, v5.16b, #1");
- COMPARE(Ushr(v6.V16B(), v7.V16B(), 8), "ushr v6.16b, v7.16b, #8");
- COMPARE(Ushr(v8.V4H(), v9.V4H(), 1), "ushr v8.4h, v9.4h, #1");
- COMPARE(Ushr(v10.V4H(), v11.V4H(), 16), "ushr v10.4h, v11.4h, #16");
- COMPARE(Ushr(v12.V8H(), v13.V8H(), 1), "ushr v12.8h, v13.8h, #1");
- COMPARE(Ushr(v14.V8H(), v15.V8H(), 16), "ushr v14.8h, v15.8h, #16");
- COMPARE(Ushr(v16.V2S(), v17.V2S(), 1), "ushr v16.2s, v17.2s, #1");
- COMPARE(Ushr(v18.V2S(), v19.V2S(), 32), "ushr v18.2s, v19.2s, #32");
- COMPARE(Ushr(v20.V4S(), v21.V4S(), 1), "ushr v20.4s, v21.4s, #1");
- COMPARE(Ushr(v22.V4S(), v23.V4S(), 32), "ushr v22.4s, v23.4s, #32");
- COMPARE(Ushr(v28.V2D(), v29.V2D(), 1), "ushr v28.2d, v29.2d, #1");
- COMPARE(Ushr(v30.V2D(), v31.V2D(), 64), "ushr v30.2d, v31.2d, #64");
- COMPARE(Ushr(d0, d1, 7), "ushr d0, d1, #7");
-
- COMPARE(Srshr(v0.V8B(), v1.V8B(), 1), "srshr v0.8b, v1.8b, #1");
- COMPARE(Srshr(v2.V8B(), v3.V8B(), 8), "srshr v2.8b, v3.8b, #8");
- COMPARE(Srshr(v4.V16B(), v5.V16B(), 1), "srshr v4.16b, v5.16b, #1");
- COMPARE(Srshr(v6.V16B(), v7.V16B(), 8), "srshr v6.16b, v7.16b, #8");
- COMPARE(Srshr(v8.V4H(), v9.V4H(), 1), "srshr v8.4h, v9.4h, #1");
- COMPARE(Srshr(v10.V4H(), v11.V4H(), 16), "srshr v10.4h, v11.4h, #16");
- COMPARE(Srshr(v12.V8H(), v13.V8H(), 1), "srshr v12.8h, v13.8h, #1");
- COMPARE(Srshr(v14.V8H(), v15.V8H(), 16), "srshr v14.8h, v15.8h, #16");
- COMPARE(Srshr(v16.V2S(), v17.V2S(), 1), "srshr v16.2s, v17.2s, #1");
- COMPARE(Srshr(v18.V2S(), v19.V2S(), 32), "srshr v18.2s, v19.2s, #32");
- COMPARE(Srshr(v20.V4S(), v21.V4S(), 1), "srshr v20.4s, v21.4s, #1");
- COMPARE(Srshr(v22.V4S(), v23.V4S(), 32), "srshr v22.4s, v23.4s, #32");
- COMPARE(Srshr(v28.V2D(), v29.V2D(), 1), "srshr v28.2d, v29.2d, #1");
- COMPARE(Srshr(v30.V2D(), v31.V2D(), 64), "srshr v30.2d, v31.2d, #64");
- COMPARE(Srshr(d0, d1, 7), "srshr d0, d1, #7");
-
- COMPARE(Urshr(v0.V8B(), v1.V8B(), 1), "urshr v0.8b, v1.8b, #1");
- COMPARE(Urshr(v2.V8B(), v3.V8B(), 8), "urshr v2.8b, v3.8b, #8");
- COMPARE(Urshr(v4.V16B(), v5.V16B(), 1), "urshr v4.16b, v5.16b, #1");
- COMPARE(Urshr(v6.V16B(), v7.V16B(), 8), "urshr v6.16b, v7.16b, #8");
- COMPARE(Urshr(v8.V4H(), v9.V4H(), 1), "urshr v8.4h, v9.4h, #1");
- COMPARE(Urshr(v10.V4H(), v11.V4H(), 16), "urshr v10.4h, v11.4h, #16");
- COMPARE(Urshr(v12.V8H(), v13.V8H(), 1), "urshr v12.8h, v13.8h, #1");
- COMPARE(Urshr(v14.V8H(), v15.V8H(), 16), "urshr v14.8h, v15.8h, #16");
- COMPARE(Urshr(v16.V2S(), v17.V2S(), 1), "urshr v16.2s, v17.2s, #1");
- COMPARE(Urshr(v18.V2S(), v19.V2S(), 32), "urshr v18.2s, v19.2s, #32");
- COMPARE(Urshr(v20.V4S(), v21.V4S(), 1), "urshr v20.4s, v21.4s, #1");
- COMPARE(Urshr(v22.V4S(), v23.V4S(), 32), "urshr v22.4s, v23.4s, #32");
- COMPARE(Urshr(v28.V2D(), v29.V2D(), 1), "urshr v28.2d, v29.2d, #1");
- COMPARE(Urshr(v30.V2D(), v31.V2D(), 64), "urshr v30.2d, v31.2d, #64");
- COMPARE(Urshr(d0, d1, 7), "urshr d0, d1, #7");
-
- COMPARE(Srsra(v0.V8B(), v1.V8B(), 1), "srsra v0.8b, v1.8b, #1");
- COMPARE(Srsra(v2.V8B(), v3.V8B(), 8), "srsra v2.8b, v3.8b, #8");
- COMPARE(Srsra(v4.V16B(), v5.V16B(), 1), "srsra v4.16b, v5.16b, #1");
- COMPARE(Srsra(v6.V16B(), v7.V16B(), 8), "srsra v6.16b, v7.16b, #8");
- COMPARE(Srsra(v8.V4H(), v9.V4H(), 1), "srsra v8.4h, v9.4h, #1");
- COMPARE(Srsra(v10.V4H(), v11.V4H(), 16), "srsra v10.4h, v11.4h, #16");
- COMPARE(Srsra(v12.V8H(), v13.V8H(), 1), "srsra v12.8h, v13.8h, #1");
- COMPARE(Srsra(v14.V8H(), v15.V8H(), 16), "srsra v14.8h, v15.8h, #16");
- COMPARE(Srsra(v16.V2S(), v17.V2S(), 1), "srsra v16.2s, v17.2s, #1");
- COMPARE(Srsra(v18.V2S(), v19.V2S(), 32), "srsra v18.2s, v19.2s, #32");
- COMPARE(Srsra(v20.V4S(), v21.V4S(), 1), "srsra v20.4s, v21.4s, #1");
- COMPARE(Srsra(v22.V4S(), v23.V4S(), 32), "srsra v22.4s, v23.4s, #32");
- COMPARE(Srsra(v28.V2D(), v29.V2D(), 1), "srsra v28.2d, v29.2d, #1");
- COMPARE(Srsra(v30.V2D(), v31.V2D(), 64), "srsra v30.2d, v31.2d, #64");
- COMPARE(Srsra(d0, d1, 7), "srsra d0, d1, #7");
-
- COMPARE(Ssra(v0.V8B(), v1.V8B(), 1), "ssra v0.8b, v1.8b, #1");
- COMPARE(Ssra(v2.V8B(), v3.V8B(), 8), "ssra v2.8b, v3.8b, #8");
- COMPARE(Ssra(v4.V16B(), v5.V16B(), 1), "ssra v4.16b, v5.16b, #1");
- COMPARE(Ssra(v6.V16B(), v7.V16B(), 8), "ssra v6.16b, v7.16b, #8");
- COMPARE(Ssra(v8.V4H(), v9.V4H(), 1), "ssra v8.4h, v9.4h, #1");
- COMPARE(Ssra(v10.V4H(), v11.V4H(), 16), "ssra v10.4h, v11.4h, #16");
- COMPARE(Ssra(v12.V8H(), v13.V8H(), 1), "ssra v12.8h, v13.8h, #1");
- COMPARE(Ssra(v14.V8H(), v15.V8H(), 16), "ssra v14.8h, v15.8h, #16");
- COMPARE(Ssra(v16.V2S(), v17.V2S(), 1), "ssra v16.2s, v17.2s, #1");
- COMPARE(Ssra(v18.V2S(), v19.V2S(), 32), "ssra v18.2s, v19.2s, #32");
- COMPARE(Ssra(v20.V4S(), v21.V4S(), 1), "ssra v20.4s, v21.4s, #1");
- COMPARE(Ssra(v22.V4S(), v23.V4S(), 32), "ssra v22.4s, v23.4s, #32");
- COMPARE(Ssra(v28.V2D(), v29.V2D(), 1), "ssra v28.2d, v29.2d, #1");
- COMPARE(Ssra(v30.V2D(), v31.V2D(), 64), "ssra v30.2d, v31.2d, #64");
- COMPARE(Ssra(d0, d1, 7), "ssra d0, d1, #7");
-
- COMPARE(Ursra(v0.V8B(), v1.V8B(), 1), "ursra v0.8b, v1.8b, #1");
- COMPARE(Ursra(v2.V8B(), v3.V8B(), 8), "ursra v2.8b, v3.8b, #8");
- COMPARE(Ursra(v4.V16B(), v5.V16B(), 1), "ursra v4.16b, v5.16b, #1");
- COMPARE(Ursra(v6.V16B(), v7.V16B(), 8), "ursra v6.16b, v7.16b, #8");
- COMPARE(Ursra(v8.V4H(), v9.V4H(), 1), "ursra v8.4h, v9.4h, #1");
- COMPARE(Ursra(v10.V4H(), v11.V4H(), 16), "ursra v10.4h, v11.4h, #16");
- COMPARE(Ursra(v12.V8H(), v13.V8H(), 1), "ursra v12.8h, v13.8h, #1");
- COMPARE(Ursra(v14.V8H(), v15.V8H(), 16), "ursra v14.8h, v15.8h, #16");
- COMPARE(Ursra(v16.V2S(), v17.V2S(), 1), "ursra v16.2s, v17.2s, #1");
- COMPARE(Ursra(v18.V2S(), v19.V2S(), 32), "ursra v18.2s, v19.2s, #32");
- COMPARE(Ursra(v20.V4S(), v21.V4S(), 1), "ursra v20.4s, v21.4s, #1");
- COMPARE(Ursra(v22.V4S(), v23.V4S(), 32), "ursra v22.4s, v23.4s, #32");
- COMPARE(Ursra(v28.V2D(), v29.V2D(), 1), "ursra v28.2d, v29.2d, #1");
- COMPARE(Ursra(v30.V2D(), v31.V2D(), 64), "ursra v30.2d, v31.2d, #64");
- COMPARE(Ursra(d0, d1, 7), "ursra d0, d1, #7");
-
- COMPARE(Usra(v0.V8B(), v1.V8B(), 1), "usra v0.8b, v1.8b, #1");
- COMPARE(Usra(v2.V8B(), v3.V8B(), 8), "usra v2.8b, v3.8b, #8");
- COMPARE(Usra(v4.V16B(), v5.V16B(), 1), "usra v4.16b, v5.16b, #1");
- COMPARE(Usra(v6.V16B(), v7.V16B(), 8), "usra v6.16b, v7.16b, #8");
- COMPARE(Usra(v8.V4H(), v9.V4H(), 1), "usra v8.4h, v9.4h, #1");
- COMPARE(Usra(v10.V4H(), v11.V4H(), 16), "usra v10.4h, v11.4h, #16");
- COMPARE(Usra(v12.V8H(), v13.V8H(), 1), "usra v12.8h, v13.8h, #1");
- COMPARE(Usra(v14.V8H(), v15.V8H(), 16), "usra v14.8h, v15.8h, #16");
- COMPARE(Usra(v16.V2S(), v17.V2S(), 1), "usra v16.2s, v17.2s, #1");
- COMPARE(Usra(v18.V2S(), v19.V2S(), 32), "usra v18.2s, v19.2s, #32");
- COMPARE(Usra(v20.V4S(), v21.V4S(), 1), "usra v20.4s, v21.4s, #1");
- COMPARE(Usra(v22.V4S(), v23.V4S(), 32), "usra v22.4s, v23.4s, #32");
- COMPARE(Usra(v28.V2D(), v29.V2D(), 1), "usra v28.2d, v29.2d, #1");
- COMPARE(Usra(v30.V2D(), v31.V2D(), 64), "usra v30.2d, v31.2d, #64");
- COMPARE(Usra(d0, d1, 7), "usra d0, d1, #7");
-
- COMPARE(Sli(v1.V8B(), v8.V8B(), 1), "sli v1.8b, v8.8b, #1");
- COMPARE(Sli(v2.V16B(), v9.V16B(), 2), "sli v2.16b, v9.16b, #2");
- COMPARE(Sli(v3.V4H(), v1.V4H(), 3), "sli v3.4h, v1.4h, #3");
- COMPARE(Sli(v4.V8H(), v2.V8H(), 4), "sli v4.8h, v2.8h, #4");
- COMPARE(Sli(v5.V2S(), v3.V2S(), 5), "sli v5.2s, v3.2s, #5");
- COMPARE(Sli(v6.V4S(), v4.V4S(), 6), "sli v6.4s, v4.4s, #6");
- COMPARE(Sli(v7.V2D(), v5.V2D(), 7), "sli v7.2d, v5.2d, #7");
- COMPARE(Sli(d8, d6, 8), "sli d8, d6, #8");
-
- COMPARE(Shl(v1.V8B(), v8.V8B(), 1), "shl v1.8b, v8.8b, #1");
- COMPARE(Shl(v2.V16B(), v9.V16B(), 2), "shl v2.16b, v9.16b, #2");
- COMPARE(Shl(v3.V4H(), v1.V4H(), 3), "shl v3.4h, v1.4h, #3");
- COMPARE(Shl(v4.V8H(), v2.V8H(), 4), "shl v4.8h, v2.8h, #4");
- COMPARE(Shl(v5.V2S(), v3.V2S(), 5), "shl v5.2s, v3.2s, #5");
- COMPARE(Shl(v6.V4S(), v4.V4S(), 6), "shl v6.4s, v4.4s, #6");
- COMPARE(Shl(v7.V2D(), v5.V2D(), 7), "shl v7.2d, v5.2d, #7");
- COMPARE(Shl(d8, d6, 8), "shl d8, d6, #8");
-
- COMPARE(Sqshl(v1.V8B(), v8.V8B(), 1), "sqshl v1.8b, v8.8b, #1");
- COMPARE(Sqshl(v2.V16B(), v9.V16B(), 2), "sqshl v2.16b, v9.16b, #2");
- COMPARE(Sqshl(v3.V4H(), v1.V4H(), 3), "sqshl v3.4h, v1.4h, #3");
- COMPARE(Sqshl(v4.V8H(), v2.V8H(), 4), "sqshl v4.8h, v2.8h, #4");
- COMPARE(Sqshl(v5.V2S(), v3.V2S(), 5), "sqshl v5.2s, v3.2s, #5");
- COMPARE(Sqshl(v6.V4S(), v4.V4S(), 6), "sqshl v6.4s, v4.4s, #6");
- COMPARE(Sqshl(v7.V2D(), v5.V2D(), 7), "sqshl v7.2d, v5.2d, #7");
- COMPARE(Sqshl(b8, b7, 1), "sqshl b8, b7, #1");
- COMPARE(Sqshl(h9, h8, 2), "sqshl h9, h8, #2");
- COMPARE(Sqshl(s10, s9, 3), "sqshl s10, s9, #3");
- COMPARE(Sqshl(d11, d10, 4), "sqshl d11, d10, #4");
-
- COMPARE(Sqshlu(v1.V8B(), v8.V8B(), 1), "sqshlu v1.8b, v8.8b, #1");
- COMPARE(Sqshlu(v2.V16B(), v9.V16B(), 2), "sqshlu v2.16b, v9.16b, #2");
- COMPARE(Sqshlu(v3.V4H(), v1.V4H(), 3), "sqshlu v3.4h, v1.4h, #3");
- COMPARE(Sqshlu(v4.V8H(), v2.V8H(), 4), "sqshlu v4.8h, v2.8h, #4");
- COMPARE(Sqshlu(v5.V2S(), v3.V2S(), 5), "sqshlu v5.2s, v3.2s, #5");
- COMPARE(Sqshlu(v6.V4S(), v4.V4S(), 6), "sqshlu v6.4s, v4.4s, #6");
- COMPARE(Sqshlu(v7.V2D(), v5.V2D(), 7), "sqshlu v7.2d, v5.2d, #7");
- COMPARE(Sqshlu(b8, b7, 1), "sqshlu b8, b7, #1");
- COMPARE(Sqshlu(h9, h8, 2), "sqshlu h9, h8, #2");
- COMPARE(Sqshlu(s10, s9, 3), "sqshlu s10, s9, #3");
- COMPARE(Sqshlu(d11, d10, 4), "sqshlu d11, d10, #4");
-
- COMPARE(Uqshl(v1.V8B(), v8.V8B(), 1), "uqshl v1.8b, v8.8b, #1");
- COMPARE(Uqshl(v2.V16B(), v9.V16B(), 2), "uqshl v2.16b, v9.16b, #2");
- COMPARE(Uqshl(v3.V4H(), v1.V4H(), 3), "uqshl v3.4h, v1.4h, #3");
- COMPARE(Uqshl(v4.V8H(), v2.V8H(), 4), "uqshl v4.8h, v2.8h, #4");
- COMPARE(Uqshl(v5.V2S(), v3.V2S(), 5), "uqshl v5.2s, v3.2s, #5");
- COMPARE(Uqshl(v6.V4S(), v4.V4S(), 6), "uqshl v6.4s, v4.4s, #6");
- COMPARE(Uqshl(v7.V2D(), v5.V2D(), 7), "uqshl v7.2d, v5.2d, #7");
- COMPARE(Uqshl(b8, b7, 1), "uqshl b8, b7, #1");
- COMPARE(Uqshl(h9, h8, 2), "uqshl h9, h8, #2");
- COMPARE(Uqshl(s10, s9, 3), "uqshl s10, s9, #3");
- COMPARE(Uqshl(d11, d10, 4), "uqshl d11, d10, #4");
-
- COMPARE(Sshll(v1.V8H(), v8.V8B(), 1), "sshll v1.8h, v8.8b, #1");
- COMPARE(Sshll(v3.V4S(), v1.V4H(), 3), "sshll v3.4s, v1.4h, #3");
- COMPARE(Sshll(v5.V2D(), v3.V2S(), 5), "sshll v5.2d, v3.2s, #5");
- COMPARE(Sshll2(v2.V8H(), v9.V16B(), 2), "sshll2 v2.8h, v9.16b, #2");
- COMPARE(Sshll2(v4.V4S(), v2.V8H(), 4), "sshll2 v4.4s, v2.8h, #4");
- COMPARE(Sshll2(v6.V2D(), v4.V4S(), 6), "sshll2 v6.2d, v4.4s, #6");
-
- COMPARE(Sshll(v1.V8H(), v8.V8B(), 0), "sxtl v1.8h, v8.8b");
- COMPARE(Sshll(v3.V4S(), v1.V4H(), 0), "sxtl v3.4s, v1.4h");
- COMPARE(Sshll(v5.V2D(), v3.V2S(), 0), "sxtl v5.2d, v3.2s");
- COMPARE(Sshll2(v2.V8H(), v9.V16B(), 0), "sxtl2 v2.8h, v9.16b");
- COMPARE(Sshll2(v4.V4S(), v2.V8H(), 0), "sxtl2 v4.4s, v2.8h");
- COMPARE(Sshll2(v6.V2D(), v4.V4S(), 0), "sxtl2 v6.2d, v4.4s");
-
- COMPARE(Sxtl(v1.V8H(), v8.V8B()), "sxtl v1.8h, v8.8b");
- COMPARE(Sxtl(v3.V4S(), v1.V4H()), "sxtl v3.4s, v1.4h");
- COMPARE(Sxtl(v5.V2D(), v3.V2S()), "sxtl v5.2d, v3.2s");
- COMPARE(Sxtl2(v2.V8H(), v9.V16B()), "sxtl2 v2.8h, v9.16b");
- COMPARE(Sxtl2(v4.V4S(), v2.V8H()), "sxtl2 v4.4s, v2.8h");
- COMPARE(Sxtl2(v6.V2D(), v4.V4S()), "sxtl2 v6.2d, v4.4s");
-
- COMPARE(Ushll(v1.V8H(), v8.V8B(), 1), "ushll v1.8h, v8.8b, #1");
- COMPARE(Ushll(v3.V4S(), v1.V4H(), 3), "ushll v3.4s, v1.4h, #3");
- COMPARE(Ushll(v5.V2D(), v3.V2S(), 5), "ushll v5.2d, v3.2s, #5");
- COMPARE(Ushll2(v2.V8H(), v9.V16B(), 2), "ushll2 v2.8h, v9.16b, #2");
- COMPARE(Ushll2(v4.V4S(), v2.V8H(), 4), "ushll2 v4.4s, v2.8h, #4");
- COMPARE(Ushll2(v6.V2D(), v4.V4S(), 6), "ushll2 v6.2d, v4.4s, #6");
-
- COMPARE(Ushll(v1.V8H(), v8.V8B(), 0), "uxtl v1.8h, v8.8b");
- COMPARE(Ushll(v3.V4S(), v1.V4H(), 0), "uxtl v3.4s, v1.4h");
- COMPARE(Ushll(v5.V2D(), v3.V2S(), 0), "uxtl v5.2d, v3.2s");
- COMPARE(Ushll2(v2.V8H(), v9.V16B(), 0), "uxtl2 v2.8h, v9.16b");
- COMPARE(Ushll2(v4.V4S(), v2.V8H(), 0), "uxtl2 v4.4s, v2.8h");
- COMPARE(Ushll2(v6.V2D(), v4.V4S(), 0), "uxtl2 v6.2d, v4.4s");
-
- COMPARE(Uxtl(v1.V8H(), v8.V8B()), "uxtl v1.8h, v8.8b");
- COMPARE(Uxtl(v3.V4S(), v1.V4H()), "uxtl v3.4s, v1.4h");
- COMPARE(Uxtl(v5.V2D(), v3.V2S()), "uxtl v5.2d, v3.2s");
- COMPARE(Uxtl2(v2.V8H(), v9.V16B()), "uxtl2 v2.8h, v9.16b");
- COMPARE(Uxtl2(v4.V4S(), v2.V8H()), "uxtl2 v4.4s, v2.8h");
- COMPARE(Uxtl2(v6.V2D(), v4.V4S()), "uxtl2 v6.2d, v4.4s");
-
- COMPARE(Sri(v1.V8B(), v8.V8B(), 1), "sri v1.8b, v8.8b, #1");
- COMPARE(Sri(v2.V16B(), v9.V16B(), 2), "sri v2.16b, v9.16b, #2");
- COMPARE(Sri(v3.V4H(), v1.V4H(), 3), "sri v3.4h, v1.4h, #3");
- COMPARE(Sri(v4.V8H(), v2.V8H(), 4), "sri v4.8h, v2.8h, #4");
- COMPARE(Sri(v5.V2S(), v3.V2S(), 5), "sri v5.2s, v3.2s, #5");
- COMPARE(Sri(v6.V4S(), v4.V4S(), 6), "sri v6.4s, v4.4s, #6");
- COMPARE(Sri(v7.V2D(), v5.V2D(), 7), "sri v7.2d, v5.2d, #7");
- COMPARE(Sri(d8, d6, 8), "sri d8, d6, #8");
-
- COMPARE(Shrn(v0.V8B(), v1.V8H(), 1), "shrn v0.8b, v1.8h, #1");
- COMPARE(Shrn(v1.V4H(), v2.V4S(), 2), "shrn v1.4h, v2.4s, #2");
- COMPARE(Shrn(v2.V2S(), v3.V2D(), 3), "shrn v2.2s, v3.2d, #3");
- COMPARE(Shrn2(v0.V16B(), v1.V8H(), 4), "shrn2 v0.16b, v1.8h, #4");
- COMPARE(Shrn2(v1.V8H(), v2.V4S(), 5), "shrn2 v1.8h, v2.4s, #5");
- COMPARE(Shrn2(v2.V4S(), v3.V2D(), 6), "shrn2 v2.4s, v3.2d, #6");
-
- COMPARE(Rshrn(v0.V8B(), v1.V8H(), 1), "rshrn v0.8b, v1.8h, #1");
- COMPARE(Rshrn(v1.V4H(), v2.V4S(), 2), "rshrn v1.4h, v2.4s, #2");
- COMPARE(Rshrn(v2.V2S(), v3.V2D(), 3), "rshrn v2.2s, v3.2d, #3");
- COMPARE(Rshrn2(v0.V16B(), v1.V8H(), 4), "rshrn2 v0.16b, v1.8h, #4");
- COMPARE(Rshrn2(v1.V8H(), v2.V4S(), 5), "rshrn2 v1.8h, v2.4s, #5");
- COMPARE(Rshrn2(v2.V4S(), v3.V2D(), 6), "rshrn2 v2.4s, v3.2d, #6");
-
- COMPARE(Uqshrn(v0.V8B(), v1.V8H(), 1), "uqshrn v0.8b, v1.8h, #1");
- COMPARE(Uqshrn(v1.V4H(), v2.V4S(), 2), "uqshrn v1.4h, v2.4s, #2");
- COMPARE(Uqshrn(v2.V2S(), v3.V2D(), 3), "uqshrn v2.2s, v3.2d, #3");
- COMPARE(Uqshrn2(v0.V16B(), v1.V8H(), 4), "uqshrn2 v0.16b, v1.8h, #4");
- COMPARE(Uqshrn2(v1.V8H(), v2.V4S(), 5), "uqshrn2 v1.8h, v2.4s, #5");
- COMPARE(Uqshrn2(v2.V4S(), v3.V2D(), 6), "uqshrn2 v2.4s, v3.2d, #6");
- COMPARE(Uqshrn(b0, h1, 1), "uqshrn b0, h1, #1");
- COMPARE(Uqshrn(h1, s2, 2), "uqshrn h1, s2, #2");
- COMPARE(Uqshrn(s2, d3, 3), "uqshrn s2, d3, #3");
-
- COMPARE(Uqrshrn(v0.V8B(), v1.V8H(), 1), "uqrshrn v0.8b, v1.8h, #1");
- COMPARE(Uqrshrn(v1.V4H(), v2.V4S(), 2), "uqrshrn v1.4h, v2.4s, #2");
- COMPARE(Uqrshrn(v2.V2S(), v3.V2D(), 3), "uqrshrn v2.2s, v3.2d, #3");
- COMPARE(Uqrshrn2(v0.V16B(), v1.V8H(), 4), "uqrshrn2 v0.16b, v1.8h, #4");
- COMPARE(Uqrshrn2(v1.V8H(), v2.V4S(), 5), "uqrshrn2 v1.8h, v2.4s, #5");
- COMPARE(Uqrshrn2(v2.V4S(), v3.V2D(), 6), "uqrshrn2 v2.4s, v3.2d, #6");
- COMPARE(Uqrshrn(b0, h1, 1), "uqrshrn b0, h1, #1");
- COMPARE(Uqrshrn(h1, s2, 2), "uqrshrn h1, s2, #2");
- COMPARE(Uqrshrn(s2, d3, 3), "uqrshrn s2, d3, #3");
-
- COMPARE(Sqshrn(v0.V8B(), v1.V8H(), 1), "sqshrn v0.8b, v1.8h, #1");
- COMPARE(Sqshrn(v1.V4H(), v2.V4S(), 2), "sqshrn v1.4h, v2.4s, #2");
- COMPARE(Sqshrn(v2.V2S(), v3.V2D(), 3), "sqshrn v2.2s, v3.2d, #3");
- COMPARE(Sqshrn2(v0.V16B(), v1.V8H(), 4), "sqshrn2 v0.16b, v1.8h, #4");
- COMPARE(Sqshrn2(v1.V8H(), v2.V4S(), 5), "sqshrn2 v1.8h, v2.4s, #5");
- COMPARE(Sqshrn2(v2.V4S(), v3.V2D(), 6), "sqshrn2 v2.4s, v3.2d, #6");
- COMPARE(Sqshrn(b0, h1, 1), "sqshrn b0, h1, #1");
- COMPARE(Sqshrn(h1, s2, 2), "sqshrn h1, s2, #2");
- COMPARE(Sqshrn(s2, d3, 3), "sqshrn s2, d3, #3");
-
- COMPARE(Sqrshrn(v0.V8B(), v1.V8H(), 1), "sqrshrn v0.8b, v1.8h, #1");
- COMPARE(Sqrshrn(v1.V4H(), v2.V4S(), 2), "sqrshrn v1.4h, v2.4s, #2");
- COMPARE(Sqrshrn(v2.V2S(), v3.V2D(), 3), "sqrshrn v2.2s, v3.2d, #3");
- COMPARE(Sqrshrn2(v0.V16B(), v1.V8H(), 4), "sqrshrn2 v0.16b, v1.8h, #4");
- COMPARE(Sqrshrn2(v1.V8H(), v2.V4S(), 5), "sqrshrn2 v1.8h, v2.4s, #5");
- COMPARE(Sqrshrn2(v2.V4S(), v3.V2D(), 6), "sqrshrn2 v2.4s, v3.2d, #6");
- COMPARE(Sqrshrn(b0, h1, 1), "sqrshrn b0, h1, #1");
- COMPARE(Sqrshrn(h1, s2, 2), "sqrshrn h1, s2, #2");
- COMPARE(Sqrshrn(s2, d3, 3), "sqrshrn s2, d3, #3");
-
- COMPARE(Sqshrun(v0.V8B(), v1.V8H(), 1), "sqshrun v0.8b, v1.8h, #1");
- COMPARE(Sqshrun(v1.V4H(), v2.V4S(), 2), "sqshrun v1.4h, v2.4s, #2");
- COMPARE(Sqshrun(v2.V2S(), v3.V2D(), 3), "sqshrun v2.2s, v3.2d, #3");
- COMPARE(Sqshrun2(v0.V16B(), v1.V8H(), 4), "sqshrun2 v0.16b, v1.8h, #4");
- COMPARE(Sqshrun2(v1.V8H(), v2.V4S(), 5), "sqshrun2 v1.8h, v2.4s, #5");
- COMPARE(Sqshrun2(v2.V4S(), v3.V2D(), 6), "sqshrun2 v2.4s, v3.2d, #6");
- COMPARE(Sqshrun(b0, h1, 1), "sqshrun b0, h1, #1");
- COMPARE(Sqshrun(h1, s2, 2), "sqshrun h1, s2, #2");
- COMPARE(Sqshrun(s2, d3, 3), "sqshrun s2, d3, #3");
-
- COMPARE(Sqrshrun(v0.V8B(), v1.V8H(), 1), "sqrshrun v0.8b, v1.8h, #1");
- COMPARE(Sqrshrun(v1.V4H(), v2.V4S(), 2), "sqrshrun v1.4h, v2.4s, #2");
- COMPARE(Sqrshrun(v2.V2S(), v3.V2D(), 3), "sqrshrun v2.2s, v3.2d, #3");
- COMPARE(Sqrshrun2(v0.V16B(), v1.V8H(), 4), "sqrshrun2 v0.16b, v1.8h, #4");
- COMPARE(Sqrshrun2(v1.V8H(), v2.V4S(), 5), "sqrshrun2 v1.8h, v2.4s, #5");
- COMPARE(Sqrshrun2(v2.V4S(), v3.V2D(), 6), "sqrshrun2 v2.4s, v3.2d, #6");
- COMPARE(Sqrshrun(b0, h1, 1), "sqrshrun b0, h1, #1");
- COMPARE(Sqrshrun(h1, s2, 2), "sqrshrun h1, s2, #2");
- COMPARE(Sqrshrun(s2, d3, 3), "sqrshrun s2, d3, #3");
-
- COMPARE(Scvtf(v5.V2S(), v3.V2S(), 11), "scvtf v5.2s, v3.2s, #11");
- COMPARE(Scvtf(v6.V4S(), v4.V4S(), 12), "scvtf v6.4s, v4.4s, #12");
- COMPARE(Scvtf(v7.V2D(), v5.V2D(), 33), "scvtf v7.2d, v5.2d, #33");
- COMPARE(Scvtf(s8, s6, 13), "scvtf s8, s6, #13");
- COMPARE(Scvtf(d8, d6, 34), "scvtf d8, d6, #34");
-
- COMPARE(Ucvtf(v5.V2S(), v3.V2S(), 11), "ucvtf v5.2s, v3.2s, #11");
- COMPARE(Ucvtf(v6.V4S(), v4.V4S(), 12), "ucvtf v6.4s, v4.4s, #12");
- COMPARE(Ucvtf(v7.V2D(), v5.V2D(), 33), "ucvtf v7.2d, v5.2d, #33");
- COMPARE(Ucvtf(s8, s6, 13), "ucvtf s8, s6, #13");
- COMPARE(Ucvtf(d8, d6, 34), "ucvtf d8, d6, #34");
-
- COMPARE(Fcvtzs(v5.V2S(), v3.V2S(), 11), "fcvtzs v5.2s, v3.2s, #11");
- COMPARE(Fcvtzs(v6.V4S(), v4.V4S(), 12), "fcvtzs v6.4s, v4.4s, #12");
- COMPARE(Fcvtzs(v7.V2D(), v5.V2D(), 33), "fcvtzs v7.2d, v5.2d, #33");
- COMPARE(Fcvtzs(s8, s6, 13), "fcvtzs s8, s6, #13");
- COMPARE(Fcvtzs(d8, d6, 34), "fcvtzs d8, d6, #34");
-
- COMPARE(Fcvtzu(v5.V2S(), v3.V2S(), 11), "fcvtzu v5.2s, v3.2s, #11");
- COMPARE(Fcvtzu(v6.V4S(), v4.V4S(), 12), "fcvtzu v6.4s, v4.4s, #12");
- COMPARE(Fcvtzu(v7.V2D(), v5.V2D(), 33), "fcvtzu v7.2d, v5.2d, #33");
- COMPARE(Fcvtzu(s8, s6, 13), "fcvtzu s8, s6, #13");
- COMPARE(Fcvtzu(d8, d6, 34), "fcvtzu d8, d6, #34");
+ SETUP();
+ COMPARE_MACRO(Sshr(v0.V8B(), v1.V8B(), 1), "sshr v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Sshr(v2.V8B(), v3.V8B(), 8), "sshr v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Sshr(v4.V16B(), v5.V16B(), 1), "sshr v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Sshr(v6.V16B(), v7.V16B(), 8), "sshr v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Sshr(v8.V4H(), v9.V4H(), 1), "sshr v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Sshr(v10.V4H(), v11.V4H(), 16), "sshr v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Sshr(v12.V8H(), v13.V8H(), 1), "sshr v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Sshr(v14.V8H(), v15.V8H(), 16), "sshr v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Sshr(v16.V2S(), v17.V2S(), 1), "sshr v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Sshr(v18.V2S(), v19.V2S(), 32), "sshr v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Sshr(v20.V4S(), v21.V4S(), 1), "sshr v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Sshr(v22.V4S(), v23.V4S(), 32), "sshr v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Sshr(v28.V2D(), v29.V2D(), 1), "sshr v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Sshr(v30.V2D(), v31.V2D(), 64), "sshr v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Sshr(d0, d1, 7), "sshr d0, d1, #7");
+
+ COMPARE_MACRO(Ushr(v0.V8B(), v1.V8B(), 1), "ushr v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Ushr(v2.V8B(), v3.V8B(), 8), "ushr v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Ushr(v4.V16B(), v5.V16B(), 1), "ushr v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Ushr(v6.V16B(), v7.V16B(), 8), "ushr v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Ushr(v8.V4H(), v9.V4H(), 1), "ushr v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Ushr(v10.V4H(), v11.V4H(), 16), "ushr v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Ushr(v12.V8H(), v13.V8H(), 1), "ushr v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Ushr(v14.V8H(), v15.V8H(), 16), "ushr v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Ushr(v16.V2S(), v17.V2S(), 1), "ushr v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Ushr(v18.V2S(), v19.V2S(), 32), "ushr v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Ushr(v20.V4S(), v21.V4S(), 1), "ushr v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Ushr(v22.V4S(), v23.V4S(), 32), "ushr v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Ushr(v28.V2D(), v29.V2D(), 1), "ushr v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Ushr(v30.V2D(), v31.V2D(), 64), "ushr v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Ushr(d0, d1, 7), "ushr d0, d1, #7");
+
+ COMPARE_MACRO(Srshr(v0.V8B(), v1.V8B(), 1), "srshr v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Srshr(v2.V8B(), v3.V8B(), 8), "srshr v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Srshr(v4.V16B(), v5.V16B(), 1), "srshr v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Srshr(v6.V16B(), v7.V16B(), 8), "srshr v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Srshr(v8.V4H(), v9.V4H(), 1), "srshr v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Srshr(v10.V4H(), v11.V4H(), 16), "srshr v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Srshr(v12.V8H(), v13.V8H(), 1), "srshr v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Srshr(v14.V8H(), v15.V8H(), 16), "srshr v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Srshr(v16.V2S(), v17.V2S(), 1), "srshr v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Srshr(v18.V2S(), v19.V2S(), 32), "srshr v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Srshr(v20.V4S(), v21.V4S(), 1), "srshr v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Srshr(v22.V4S(), v23.V4S(), 32), "srshr v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Srshr(v28.V2D(), v29.V2D(), 1), "srshr v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Srshr(v30.V2D(), v31.V2D(), 64), "srshr v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Srshr(d0, d1, 7), "srshr d0, d1, #7");
+
+ COMPARE_MACRO(Urshr(v0.V8B(), v1.V8B(), 1), "urshr v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Urshr(v2.V8B(), v3.V8B(), 8), "urshr v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Urshr(v4.V16B(), v5.V16B(), 1), "urshr v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Urshr(v6.V16B(), v7.V16B(), 8), "urshr v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Urshr(v8.V4H(), v9.V4H(), 1), "urshr v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Urshr(v10.V4H(), v11.V4H(), 16), "urshr v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Urshr(v12.V8H(), v13.V8H(), 1), "urshr v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Urshr(v14.V8H(), v15.V8H(), 16), "urshr v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Urshr(v16.V2S(), v17.V2S(), 1), "urshr v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Urshr(v18.V2S(), v19.V2S(), 32), "urshr v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Urshr(v20.V4S(), v21.V4S(), 1), "urshr v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Urshr(v22.V4S(), v23.V4S(), 32), "urshr v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Urshr(v28.V2D(), v29.V2D(), 1), "urshr v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Urshr(v30.V2D(), v31.V2D(), 64), "urshr v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Urshr(d0, d1, 7), "urshr d0, d1, #7");
+
+ COMPARE_MACRO(Srsra(v0.V8B(), v1.V8B(), 1), "srsra v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Srsra(v2.V8B(), v3.V8B(), 8), "srsra v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Srsra(v4.V16B(), v5.V16B(), 1), "srsra v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Srsra(v6.V16B(), v7.V16B(), 8), "srsra v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Srsra(v8.V4H(), v9.V4H(), 1), "srsra v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Srsra(v10.V4H(), v11.V4H(), 16), "srsra v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Srsra(v12.V8H(), v13.V8H(), 1), "srsra v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Srsra(v14.V8H(), v15.V8H(), 16), "srsra v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Srsra(v16.V2S(), v17.V2S(), 1), "srsra v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Srsra(v18.V2S(), v19.V2S(), 32), "srsra v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Srsra(v20.V4S(), v21.V4S(), 1), "srsra v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Srsra(v22.V4S(), v23.V4S(), 32), "srsra v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Srsra(v28.V2D(), v29.V2D(), 1), "srsra v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Srsra(v30.V2D(), v31.V2D(), 64), "srsra v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Srsra(d0, d1, 7), "srsra d0, d1, #7");
+
+ COMPARE_MACRO(Ssra(v0.V8B(), v1.V8B(), 1), "ssra v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Ssra(v2.V8B(), v3.V8B(), 8), "ssra v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Ssra(v4.V16B(), v5.V16B(), 1), "ssra v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Ssra(v6.V16B(), v7.V16B(), 8), "ssra v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Ssra(v8.V4H(), v9.V4H(), 1), "ssra v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Ssra(v10.V4H(), v11.V4H(), 16), "ssra v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Ssra(v12.V8H(), v13.V8H(), 1), "ssra v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Ssra(v14.V8H(), v15.V8H(), 16), "ssra v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Ssra(v16.V2S(), v17.V2S(), 1), "ssra v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Ssra(v18.V2S(), v19.V2S(), 32), "ssra v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Ssra(v20.V4S(), v21.V4S(), 1), "ssra v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Ssra(v22.V4S(), v23.V4S(), 32), "ssra v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Ssra(v28.V2D(), v29.V2D(), 1), "ssra v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Ssra(v30.V2D(), v31.V2D(), 64), "ssra v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Ssra(d0, d1, 7), "ssra d0, d1, #7");
+
+ COMPARE_MACRO(Ursra(v0.V8B(), v1.V8B(), 1), "ursra v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Ursra(v2.V8B(), v3.V8B(), 8), "ursra v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Ursra(v4.V16B(), v5.V16B(), 1), "ursra v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Ursra(v6.V16B(), v7.V16B(), 8), "ursra v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Ursra(v8.V4H(), v9.V4H(), 1), "ursra v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Ursra(v10.V4H(), v11.V4H(), 16), "ursra v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Ursra(v12.V8H(), v13.V8H(), 1), "ursra v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Ursra(v14.V8H(), v15.V8H(), 16), "ursra v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Ursra(v16.V2S(), v17.V2S(), 1), "ursra v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Ursra(v18.V2S(), v19.V2S(), 32), "ursra v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Ursra(v20.V4S(), v21.V4S(), 1), "ursra v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Ursra(v22.V4S(), v23.V4S(), 32), "ursra v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Ursra(v28.V2D(), v29.V2D(), 1), "ursra v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Ursra(v30.V2D(), v31.V2D(), 64), "ursra v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Ursra(d0, d1, 7), "ursra d0, d1, #7");
+
+ COMPARE_MACRO(Usra(v0.V8B(), v1.V8B(), 1), "usra v0.8b, v1.8b, #1");
+ COMPARE_MACRO(Usra(v2.V8B(), v3.V8B(), 8), "usra v2.8b, v3.8b, #8");
+ COMPARE_MACRO(Usra(v4.V16B(), v5.V16B(), 1), "usra v4.16b, v5.16b, #1");
+ COMPARE_MACRO(Usra(v6.V16B(), v7.V16B(), 8), "usra v6.16b, v7.16b, #8");
+ COMPARE_MACRO(Usra(v8.V4H(), v9.V4H(), 1), "usra v8.4h, v9.4h, #1");
+ COMPARE_MACRO(Usra(v10.V4H(), v11.V4H(), 16), "usra v10.4h, v11.4h, #16");
+ COMPARE_MACRO(Usra(v12.V8H(), v13.V8H(), 1), "usra v12.8h, v13.8h, #1");
+ COMPARE_MACRO(Usra(v14.V8H(), v15.V8H(), 16), "usra v14.8h, v15.8h, #16");
+ COMPARE_MACRO(Usra(v16.V2S(), v17.V2S(), 1), "usra v16.2s, v17.2s, #1");
+ COMPARE_MACRO(Usra(v18.V2S(), v19.V2S(), 32), "usra v18.2s, v19.2s, #32");
+ COMPARE_MACRO(Usra(v20.V4S(), v21.V4S(), 1), "usra v20.4s, v21.4s, #1");
+ COMPARE_MACRO(Usra(v22.V4S(), v23.V4S(), 32), "usra v22.4s, v23.4s, #32");
+ COMPARE_MACRO(Usra(v28.V2D(), v29.V2D(), 1), "usra v28.2d, v29.2d, #1");
+ COMPARE_MACRO(Usra(v30.V2D(), v31.V2D(), 64), "usra v30.2d, v31.2d, #64");
+ COMPARE_MACRO(Usra(d0, d1, 7), "usra d0, d1, #7");
+
+ COMPARE_MACRO(Sli(v1.V8B(), v8.V8B(), 1), "sli v1.8b, v8.8b, #1");
+ COMPARE_MACRO(Sli(v2.V16B(), v9.V16B(), 2), "sli v2.16b, v9.16b, #2");
+ COMPARE_MACRO(Sli(v3.V4H(), v1.V4H(), 3), "sli v3.4h, v1.4h, #3");
+ COMPARE_MACRO(Sli(v4.V8H(), v2.V8H(), 4), "sli v4.8h, v2.8h, #4");
+ COMPARE_MACRO(Sli(v5.V2S(), v3.V2S(), 5), "sli v5.2s, v3.2s, #5");
+ COMPARE_MACRO(Sli(v6.V4S(), v4.V4S(), 6), "sli v6.4s, v4.4s, #6");
+ COMPARE_MACRO(Sli(v7.V2D(), v5.V2D(), 7), "sli v7.2d, v5.2d, #7");
+ COMPARE_MACRO(Sli(d8, d6, 8), "sli d8, d6, #8");
+
+ COMPARE_MACRO(Shl(v1.V8B(), v8.V8B(), 1), "shl v1.8b, v8.8b, #1");
+ COMPARE_MACRO(Shl(v2.V16B(), v9.V16B(), 2), "shl v2.16b, v9.16b, #2");
+ COMPARE_MACRO(Shl(v3.V4H(), v1.V4H(), 3), "shl v3.4h, v1.4h, #3");
+ COMPARE_MACRO(Shl(v4.V8H(), v2.V8H(), 4), "shl v4.8h, v2.8h, #4");
+ COMPARE_MACRO(Shl(v5.V2S(), v3.V2S(), 5), "shl v5.2s, v3.2s, #5");
+ COMPARE_MACRO(Shl(v6.V4S(), v4.V4S(), 6), "shl v6.4s, v4.4s, #6");
+ COMPARE_MACRO(Shl(v7.V2D(), v5.V2D(), 7), "shl v7.2d, v5.2d, #7");
+ COMPARE_MACRO(Shl(d8, d6, 8), "shl d8, d6, #8");
+
+ COMPARE_MACRO(Sqshl(v1.V8B(), v8.V8B(), 1), "sqshl v1.8b, v8.8b, #1");
+ COMPARE_MACRO(Sqshl(v2.V16B(), v9.V16B(), 2), "sqshl v2.16b, v9.16b, #2");
+ COMPARE_MACRO(Sqshl(v3.V4H(), v1.V4H(), 3), "sqshl v3.4h, v1.4h, #3");
+ COMPARE_MACRO(Sqshl(v4.V8H(), v2.V8H(), 4), "sqshl v4.8h, v2.8h, #4");
+ COMPARE_MACRO(Sqshl(v5.V2S(), v3.V2S(), 5), "sqshl v5.2s, v3.2s, #5");
+ COMPARE_MACRO(Sqshl(v6.V4S(), v4.V4S(), 6), "sqshl v6.4s, v4.4s, #6");
+ COMPARE_MACRO(Sqshl(v7.V2D(), v5.V2D(), 7), "sqshl v7.2d, v5.2d, #7");
+ COMPARE_MACRO(Sqshl(b8, b7, 1), "sqshl b8, b7, #1");
+ COMPARE_MACRO(Sqshl(h9, h8, 2), "sqshl h9, h8, #2");
+ COMPARE_MACRO(Sqshl(s10, s9, 3), "sqshl s10, s9, #3");
+ COMPARE_MACRO(Sqshl(d11, d10, 4), "sqshl d11, d10, #4");
+
+ COMPARE_MACRO(Sqshlu(v1.V8B(), v8.V8B(), 1), "sqshlu v1.8b, v8.8b, #1");
+ COMPARE_MACRO(Sqshlu(v2.V16B(), v9.V16B(), 2), "sqshlu v2.16b, v9.16b, #2");
+ COMPARE_MACRO(Sqshlu(v3.V4H(), v1.V4H(), 3), "sqshlu v3.4h, v1.4h, #3");
+ COMPARE_MACRO(Sqshlu(v4.V8H(), v2.V8H(), 4), "sqshlu v4.8h, v2.8h, #4");
+ COMPARE_MACRO(Sqshlu(v5.V2S(), v3.V2S(), 5), "sqshlu v5.2s, v3.2s, #5");
+ COMPARE_MACRO(Sqshlu(v6.V4S(), v4.V4S(), 6), "sqshlu v6.4s, v4.4s, #6");
+ COMPARE_MACRO(Sqshlu(v7.V2D(), v5.V2D(), 7), "sqshlu v7.2d, v5.2d, #7");
+ COMPARE_MACRO(Sqshlu(b8, b7, 1), "sqshlu b8, b7, #1");
+ COMPARE_MACRO(Sqshlu(h9, h8, 2), "sqshlu h9, h8, #2");
+ COMPARE_MACRO(Sqshlu(s10, s9, 3), "sqshlu s10, s9, #3");
+ COMPARE_MACRO(Sqshlu(d11, d10, 4), "sqshlu d11, d10, #4");
+
+ COMPARE_MACRO(Uqshl(v1.V8B(), v8.V8B(), 1), "uqshl v1.8b, v8.8b, #1");
+ COMPARE_MACRO(Uqshl(v2.V16B(), v9.V16B(), 2), "uqshl v2.16b, v9.16b, #2");
+ COMPARE_MACRO(Uqshl(v3.V4H(), v1.V4H(), 3), "uqshl v3.4h, v1.4h, #3");
+ COMPARE_MACRO(Uqshl(v4.V8H(), v2.V8H(), 4), "uqshl v4.8h, v2.8h, #4");
+ COMPARE_MACRO(Uqshl(v5.V2S(), v3.V2S(), 5), "uqshl v5.2s, v3.2s, #5");
+ COMPARE_MACRO(Uqshl(v6.V4S(), v4.V4S(), 6), "uqshl v6.4s, v4.4s, #6");
+ COMPARE_MACRO(Uqshl(v7.V2D(), v5.V2D(), 7), "uqshl v7.2d, v5.2d, #7");
+ COMPARE_MACRO(Uqshl(b8, b7, 1), "uqshl b8, b7, #1");
+ COMPARE_MACRO(Uqshl(h9, h8, 2), "uqshl h9, h8, #2");
+ COMPARE_MACRO(Uqshl(s10, s9, 3), "uqshl s10, s9, #3");
+ COMPARE_MACRO(Uqshl(d11, d10, 4), "uqshl d11, d10, #4");
+
+ COMPARE_MACRO(Sshll(v1.V8H(), v8.V8B(), 1), "sshll v1.8h, v8.8b, #1");
+ COMPARE_MACRO(Sshll(v3.V4S(), v1.V4H(), 3), "sshll v3.4s, v1.4h, #3");
+ COMPARE_MACRO(Sshll(v5.V2D(), v3.V2S(), 5), "sshll v5.2d, v3.2s, #5");
+ COMPARE_MACRO(Sshll2(v2.V8H(), v9.V16B(), 2), "sshll2 v2.8h, v9.16b, #2");
+ COMPARE_MACRO(Sshll2(v4.V4S(), v2.V8H(), 4), "sshll2 v4.4s, v2.8h, #4");
+ COMPARE_MACRO(Sshll2(v6.V2D(), v4.V4S(), 6), "sshll2 v6.2d, v4.4s, #6");
+
+ COMPARE_MACRO(Sshll(v1.V8H(), v8.V8B(), 0), "sxtl v1.8h, v8.8b");
+ COMPARE_MACRO(Sshll(v3.V4S(), v1.V4H(), 0), "sxtl v3.4s, v1.4h");
+ COMPARE_MACRO(Sshll(v5.V2D(), v3.V2S(), 0), "sxtl v5.2d, v3.2s");
+ COMPARE_MACRO(Sshll2(v2.V8H(), v9.V16B(), 0), "sxtl2 v2.8h, v9.16b");
+ COMPARE_MACRO(Sshll2(v4.V4S(), v2.V8H(), 0), "sxtl2 v4.4s, v2.8h");
+ COMPARE_MACRO(Sshll2(v6.V2D(), v4.V4S(), 0), "sxtl2 v6.2d, v4.4s");
+
+ COMPARE_MACRO(Sxtl(v1.V8H(), v8.V8B()), "sxtl v1.8h, v8.8b");
+ COMPARE_MACRO(Sxtl(v3.V4S(), v1.V4H()), "sxtl v3.4s, v1.4h");
+ COMPARE_MACRO(Sxtl(v5.V2D(), v3.V2S()), "sxtl v5.2d, v3.2s");
+ COMPARE_MACRO(Sxtl2(v2.V8H(), v9.V16B()), "sxtl2 v2.8h, v9.16b");
+ COMPARE_MACRO(Sxtl2(v4.V4S(), v2.V8H()), "sxtl2 v4.4s, v2.8h");
+ COMPARE_MACRO(Sxtl2(v6.V2D(), v4.V4S()), "sxtl2 v6.2d, v4.4s");
+
+ COMPARE_MACRO(Ushll(v1.V8H(), v8.V8B(), 1), "ushll v1.8h, v8.8b, #1");
+ COMPARE_MACRO(Ushll(v3.V4S(), v1.V4H(), 3), "ushll v3.4s, v1.4h, #3");
+ COMPARE_MACRO(Ushll(v5.V2D(), v3.V2S(), 5), "ushll v5.2d, v3.2s, #5");
+ COMPARE_MACRO(Ushll2(v2.V8H(), v9.V16B(), 2), "ushll2 v2.8h, v9.16b, #2");
+ COMPARE_MACRO(Ushll2(v4.V4S(), v2.V8H(), 4), "ushll2 v4.4s, v2.8h, #4");
+ COMPARE_MACRO(Ushll2(v6.V2D(), v4.V4S(), 6), "ushll2 v6.2d, v4.4s, #6");
+
+ COMPARE_MACRO(Ushll(v1.V8H(), v8.V8B(), 0), "uxtl v1.8h, v8.8b");
+ COMPARE_MACRO(Ushll(v3.V4S(), v1.V4H(), 0), "uxtl v3.4s, v1.4h");
+ COMPARE_MACRO(Ushll(v5.V2D(), v3.V2S(), 0), "uxtl v5.2d, v3.2s");
+ COMPARE_MACRO(Ushll2(v2.V8H(), v9.V16B(), 0), "uxtl2 v2.8h, v9.16b");
+ COMPARE_MACRO(Ushll2(v4.V4S(), v2.V8H(), 0), "uxtl2 v4.4s, v2.8h");
+ COMPARE_MACRO(Ushll2(v6.V2D(), v4.V4S(), 0), "uxtl2 v6.2d, v4.4s");
+
+ COMPARE_MACRO(Uxtl(v1.V8H(), v8.V8B()), "uxtl v1.8h, v8.8b");
+ COMPARE_MACRO(Uxtl(v3.V4S(), v1.V4H()), "uxtl v3.4s, v1.4h");
+ COMPARE_MACRO(Uxtl(v5.V2D(), v3.V2S()), "uxtl v5.2d, v3.2s");
+ COMPARE_MACRO(Uxtl2(v2.V8H(), v9.V16B()), "uxtl2 v2.8h, v9.16b");
+ COMPARE_MACRO(Uxtl2(v4.V4S(), v2.V8H()), "uxtl2 v4.4s, v2.8h");
+ COMPARE_MACRO(Uxtl2(v6.V2D(), v4.V4S()), "uxtl2 v6.2d, v4.4s");
+
+ COMPARE_MACRO(Sri(v1.V8B(), v8.V8B(), 1), "sri v1.8b, v8.8b, #1");
+ COMPARE_MACRO(Sri(v2.V16B(), v9.V16B(), 2), "sri v2.16b, v9.16b, #2");
+ COMPARE_MACRO(Sri(v3.V4H(), v1.V4H(), 3), "sri v3.4h, v1.4h, #3");
+ COMPARE_MACRO(Sri(v4.V8H(), v2.V8H(), 4), "sri v4.8h, v2.8h, #4");
+ COMPARE_MACRO(Sri(v5.V2S(), v3.V2S(), 5), "sri v5.2s, v3.2s, #5");
+ COMPARE_MACRO(Sri(v6.V4S(), v4.V4S(), 6), "sri v6.4s, v4.4s, #6");
+ COMPARE_MACRO(Sri(v7.V2D(), v5.V2D(), 7), "sri v7.2d, v5.2d, #7");
+ COMPARE_MACRO(Sri(d8, d6, 8), "sri d8, d6, #8");
+
+ COMPARE_MACRO(Shrn(v0.V8B(), v1.V8H(), 1), "shrn v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Shrn(v1.V4H(), v2.V4S(), 2), "shrn v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Shrn(v2.V2S(), v3.V2D(), 3), "shrn v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Shrn2(v0.V16B(), v1.V8H(), 4), "shrn2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Shrn2(v1.V8H(), v2.V4S(), 5), "shrn2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Shrn2(v2.V4S(), v3.V2D(), 6), "shrn2 v2.4s, v3.2d, #6");
+
+ COMPARE_MACRO(Rshrn(v0.V8B(), v1.V8H(), 1), "rshrn v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Rshrn(v1.V4H(), v2.V4S(), 2), "rshrn v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Rshrn(v2.V2S(), v3.V2D(), 3), "rshrn v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Rshrn2(v0.V16B(), v1.V8H(), 4), "rshrn2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Rshrn2(v1.V8H(), v2.V4S(), 5), "rshrn2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Rshrn2(v2.V4S(), v3.V2D(), 6), "rshrn2 v2.4s, v3.2d, #6");
+
+ COMPARE_MACRO(Uqshrn(v0.V8B(), v1.V8H(), 1), "uqshrn v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Uqshrn(v1.V4H(), v2.V4S(), 2), "uqshrn v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Uqshrn(v2.V2S(), v3.V2D(), 3), "uqshrn v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Uqshrn2(v0.V16B(), v1.V8H(), 4), "uqshrn2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Uqshrn2(v1.V8H(), v2.V4S(), 5), "uqshrn2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Uqshrn2(v2.V4S(), v3.V2D(), 6), "uqshrn2 v2.4s, v3.2d, #6");
+ COMPARE_MACRO(Uqshrn(b0, h1, 1), "uqshrn b0, h1, #1");
+ COMPARE_MACRO(Uqshrn(h1, s2, 2), "uqshrn h1, s2, #2");
+ COMPARE_MACRO(Uqshrn(s2, d3, 3), "uqshrn s2, d3, #3");
+
+ COMPARE_MACRO(Uqrshrn(v0.V8B(), v1.V8H(), 1), "uqrshrn v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Uqrshrn(v1.V4H(), v2.V4S(), 2), "uqrshrn v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Uqrshrn(v2.V2S(), v3.V2D(), 3), "uqrshrn v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Uqrshrn2(v0.V16B(), v1.V8H(), 4), "uqrshrn2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Uqrshrn2(v1.V8H(), v2.V4S(), 5), "uqrshrn2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Uqrshrn2(v2.V4S(), v3.V2D(), 6), "uqrshrn2 v2.4s, v3.2d, #6");
+ COMPARE_MACRO(Uqrshrn(b0, h1, 1), "uqrshrn b0, h1, #1");
+ COMPARE_MACRO(Uqrshrn(h1, s2, 2), "uqrshrn h1, s2, #2");
+ COMPARE_MACRO(Uqrshrn(s2, d3, 3), "uqrshrn s2, d3, #3");
+
+ COMPARE_MACRO(Sqshrn(v0.V8B(), v1.V8H(), 1), "sqshrn v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Sqshrn(v1.V4H(), v2.V4S(), 2), "sqshrn v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Sqshrn(v2.V2S(), v3.V2D(), 3), "sqshrn v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Sqshrn2(v0.V16B(), v1.V8H(), 4), "sqshrn2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Sqshrn2(v1.V8H(), v2.V4S(), 5), "sqshrn2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Sqshrn2(v2.V4S(), v3.V2D(), 6), "sqshrn2 v2.4s, v3.2d, #6");
+ COMPARE_MACRO(Sqshrn(b0, h1, 1), "sqshrn b0, h1, #1");
+ COMPARE_MACRO(Sqshrn(h1, s2, 2), "sqshrn h1, s2, #2");
+ COMPARE_MACRO(Sqshrn(s2, d3, 3), "sqshrn s2, d3, #3");
+
+ COMPARE_MACRO(Sqrshrn(v0.V8B(), v1.V8H(), 1), "sqrshrn v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Sqrshrn(v1.V4H(), v2.V4S(), 2), "sqrshrn v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Sqrshrn(v2.V2S(), v3.V2D(), 3), "sqrshrn v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Sqrshrn2(v0.V16B(), v1.V8H(), 4), "sqrshrn2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Sqrshrn2(v1.V8H(), v2.V4S(), 5), "sqrshrn2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Sqrshrn2(v2.V4S(), v3.V2D(), 6), "sqrshrn2 v2.4s, v3.2d, #6");
+ COMPARE_MACRO(Sqrshrn(b0, h1, 1), "sqrshrn b0, h1, #1");
+ COMPARE_MACRO(Sqrshrn(h1, s2, 2), "sqrshrn h1, s2, #2");
+ COMPARE_MACRO(Sqrshrn(s2, d3, 3), "sqrshrn s2, d3, #3");
+
+ COMPARE_MACRO(Sqshrun(v0.V8B(), v1.V8H(), 1), "sqshrun v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Sqshrun(v1.V4H(), v2.V4S(), 2), "sqshrun v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Sqshrun(v2.V2S(), v3.V2D(), 3), "sqshrun v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Sqshrun2(v0.V16B(), v1.V8H(), 4), "sqshrun2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Sqshrun2(v1.V8H(), v2.V4S(), 5), "sqshrun2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Sqshrun2(v2.V4S(), v3.V2D(), 6), "sqshrun2 v2.4s, v3.2d, #6");
+ COMPARE_MACRO(Sqshrun(b0, h1, 1), "sqshrun b0, h1, #1");
+ COMPARE_MACRO(Sqshrun(h1, s2, 2), "sqshrun h1, s2, #2");
+ COMPARE_MACRO(Sqshrun(s2, d3, 3), "sqshrun s2, d3, #3");
+
+ COMPARE_MACRO(Sqrshrun(v0.V8B(), v1.V8H(), 1), "sqrshrun v0.8b, v1.8h, #1");
+ COMPARE_MACRO(Sqrshrun(v1.V4H(), v2.V4S(), 2), "sqrshrun v1.4h, v2.4s, #2");
+ COMPARE_MACRO(Sqrshrun(v2.V2S(), v3.V2D(), 3), "sqrshrun v2.2s, v3.2d, #3");
+ COMPARE_MACRO(Sqrshrun2(v0.V16B(), v1.V8H(), 4),
+ "sqrshrun2 v0.16b, v1.8h, #4");
+ COMPARE_MACRO(Sqrshrun2(v1.V8H(), v2.V4S(), 5), "sqrshrun2 v1.8h, v2.4s, #5");
+ COMPARE_MACRO(Sqrshrun2(v2.V4S(), v3.V2D(), 6), "sqrshrun2 v2.4s, v3.2d, #6");
+ COMPARE_MACRO(Sqrshrun(b0, h1, 1), "sqrshrun b0, h1, #1");
+ COMPARE_MACRO(Sqrshrun(h1, s2, 2), "sqrshrun h1, s2, #2");
+ COMPARE_MACRO(Sqrshrun(s2, d3, 3), "sqrshrun s2, d3, #3");
+
+ COMPARE_MACRO(Scvtf(v5.V2S(), v3.V2S(), 11), "scvtf v5.2s, v3.2s, #11");
+ COMPARE_MACRO(Scvtf(v6.V4S(), v4.V4S(), 12), "scvtf v6.4s, v4.4s, #12");
+ COMPARE_MACRO(Scvtf(v7.V2D(), v5.V2D(), 33), "scvtf v7.2d, v5.2d, #33");
+ COMPARE_MACRO(Scvtf(s8, s6, 13), "scvtf s8, s6, #13");
+ COMPARE_MACRO(Scvtf(d8, d6, 34), "scvtf d8, d6, #34");
+
+ COMPARE_MACRO(Ucvtf(v5.V2S(), v3.V2S(), 11), "ucvtf v5.2s, v3.2s, #11");
+ COMPARE_MACRO(Ucvtf(v6.V4S(), v4.V4S(), 12), "ucvtf v6.4s, v4.4s, #12");
+ COMPARE_MACRO(Ucvtf(v7.V2D(), v5.V2D(), 33), "ucvtf v7.2d, v5.2d, #33");
+ COMPARE_MACRO(Ucvtf(s8, s6, 13), "ucvtf s8, s6, #13");
+ COMPARE_MACRO(Ucvtf(d8, d6, 34), "ucvtf d8, d6, #34");
+
+ COMPARE_MACRO(Fcvtzs(v5.V2S(), v3.V2S(), 11), "fcvtzs v5.2s, v3.2s, #11");
+ COMPARE_MACRO(Fcvtzs(v6.V4S(), v4.V4S(), 12), "fcvtzs v6.4s, v4.4s, #12");
+ COMPARE_MACRO(Fcvtzs(v7.V2D(), v5.V2D(), 33), "fcvtzs v7.2d, v5.2d, #33");
+ COMPARE_MACRO(Fcvtzs(s8, s6, 13), "fcvtzs s8, s6, #13");
+ COMPARE_MACRO(Fcvtzs(d8, d6, 34), "fcvtzs d8, d6, #34");
+
+ COMPARE_MACRO(Fcvtzu(v5.V2S(), v3.V2S(), 11), "fcvtzu v5.2s, v3.2s, #11");
+ COMPARE_MACRO(Fcvtzu(v6.V4S(), v4.V4S(), 12), "fcvtzu v6.4s, v4.4s, #12");
+ COMPARE_MACRO(Fcvtzu(v7.V2D(), v5.V2D(), 33), "fcvtzu v7.2d, v5.2d, #33");
+ COMPARE_MACRO(Fcvtzu(s8, s6, 13), "fcvtzu s8, s6, #13");
+ COMPARE_MACRO(Fcvtzu(d8, d6, 34), "fcvtzu d8, d6, #34");
CLEANUP();
}
diff --git a/test/aarch64/test-trace-aarch64.cc b/test/aarch64/test-trace-aarch64.cc
index bf767b6a..673161e8 100644
--- a/test/aarch64/test-trace-aarch64.cc
+++ b/test/aarch64/test-trace-aarch64.cc
@@ -48,7 +48,9 @@ namespace aarch64 {
#define TEST(name) TEST_(TRACE_##name)
static void GenerateTestSequenceBase(MacroAssembler* masm) {
- CodeBufferCheckScope guard(masm, masm->GetBuffer()->GetRemainingBytes());
+ ExactAssemblyScope guard(masm,
+ masm->GetBuffer()->GetRemainingBytes(),
+ ExactAssemblyScope::kMaximumSize);
__ adc(w3, w4, w5);
__ adc(x6, x7, x8);
@@ -390,7 +392,9 @@ static void GenerateTestSequenceBase(MacroAssembler* masm) {
static void GenerateTestSequenceFP(MacroAssembler* masm) {
- CodeBufferCheckScope guard(masm, masm->GetBuffer()->GetRemainingBytes());
+ ExactAssemblyScope guard(masm,
+ masm->GetBuffer()->GetRemainingBytes(),
+ ExactAssemblyScope::kMaximumSize);
// Scalar floating point instructions.
__ fabd(d13, d2, d19);
@@ -602,7 +606,9 @@ static void GenerateTestSequenceFP(MacroAssembler* masm) {
static void GenerateTestSequenceNEON(MacroAssembler* masm) {
- CodeBufferCheckScope guard(masm, masm->GetBuffer()->GetRemainingBytes());
+ ExactAssemblyScope guard(masm,
+ masm->GetBuffer()->GetRemainingBytes(),
+ ExactAssemblyScope::kMaximumSize);
// NEON integer instructions.
__ abs(d19, d0);
@@ -2505,7 +2511,9 @@ static void GenerateTestSequenceNEON(MacroAssembler* masm) {
static void GenerateTestSequenceNEONFP(MacroAssembler* masm) {
- CodeBufferCheckScope guard(masm, masm->GetBuffer()->GetRemainingBytes());
+ ExactAssemblyScope guard(masm,
+ masm->GetBuffer()->GetRemainingBytes(),
+ ExactAssemblyScope::kMaximumSize);
// NEON floating point instructions.
__ fabd(v3.V2D(), v25.V2D(), v8.V2D());
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-24 02:54:54 +0000