From 594cb9e071cf17c08ff551c7df198e27075d2fc1 Mon Sep 17 00:00:00 2001 From: kobalicek Date: Sat, 29 Nov 2025 09:13:58 +0100 Subject: [PATCH] [abi] Added support for 32-bit ARM (WIP) --- CMakeLists.txt | 21 + asmjit-testing/bench/asmjit_bench_codegen.cpp | 15 + .../bench/asmjit_bench_codegen_a32.cpp | 23 + .../tests/asmjit_test_assembler.cpp | 39 +- .../tests/asmjit_test_assembler_a32.cpp | 2881 ++++ asmjit-testing/tests/asmjit_test_perf_a32.cpp | 638 + asmjit/a32.h | 55 + asmjit/arm/a32archtraits_p.h | 76 + asmjit/arm/a32assembler.cpp | 11016 ++++++++++++++++ asmjit/arm/a32assembler.h | 69 + asmjit/arm/a32builder.cpp | 58 + asmjit/arm/a32builder.h | 57 + asmjit/arm/a32emithelper.cpp | 395 + asmjit/arm/a32emithelper_p.h | 53 + asmjit/arm/a32emitter.h | 1603 +++ asmjit/arm/a32formatter.cpp | 68 + asmjit/arm/a32formatter_p.h | 42 + asmjit/arm/a32globals.h | 531 + asmjit/arm/a32instapi.cpp | 223 + asmjit/arm/a32instapi_p.h | 42 + asmjit/arm/a32instdb.cpp | 547 + asmjit/arm/a32instdb.h | 0 asmjit/arm/a32instdb_p.h | 38 + asmjit/arm/a32operand.h | 803 ++ asmjit/arm/armformatter.cpp | 10 + asmjit/core/api-config.h | 10 + asmjit/core/archcommons.h | 4 + asmjit/core/archtraits.cpp | 12 + asmjit/core/formatter.cpp | 15 +- asmjit/core/inst.cpp | 28 + asmjit/x86/x86builder.cpp | 2 +- asmjit/x86/x86compiler.cpp | 2 +- tools/tablegen-a32.js | 1622 +++ tools/tablegen-a32.sh | 3 + tools/testgen-a32.js | 417 + 35 files changed, 21406 insertions(+), 12 deletions(-) create mode 100644 asmjit-testing/bench/asmjit_bench_codegen_a32.cpp create mode 100644 asmjit-testing/tests/asmjit_test_assembler_a32.cpp create mode 100644 asmjit-testing/tests/asmjit_test_perf_a32.cpp create mode 100644 asmjit/a32.h create mode 100644 asmjit/arm/a32archtraits_p.h create mode 100644 asmjit/arm/a32assembler.cpp create mode 100644 asmjit/arm/a32assembler.h create mode 100644 asmjit/arm/a32builder.cpp create mode 100644 asmjit/arm/a32builder.h create mode 100644 asmjit/arm/a32emithelper.cpp create mode 100644 asmjit/arm/a32emithelper_p.h create mode 100644 asmjit/arm/a32emitter.h create mode 100644 asmjit/arm/a32formatter.cpp create mode 100644 asmjit/arm/a32formatter_p.h create mode 100644 asmjit/arm/a32globals.h create mode 100644 asmjit/arm/a32instapi.cpp create mode 100644 asmjit/arm/a32instapi_p.h create mode 100644 asmjit/arm/a32instdb.cpp create mode 100644 asmjit/arm/a32instdb.h create mode 100644 asmjit/arm/a32instdb_p.h create mode 100644 asmjit/arm/a32operand.h create mode 100644 tools/tablegen-a32.js create mode 100755 tools/tablegen-a32.sh create mode 100644 tools/testgen-a32.js diff --git a/CMakeLists.txt b/CMakeLists.txt index 5d74653..d0d6c91 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -70,6 +70,7 @@ option(ASMJIT_NO_CUSTOM_FLAGS "Disable extra compilation flags added by AsmJit option(ASMJIT_NO_ABI_NAMESPACE "Disable the use of inline ABI namespace {asmjit::v...}" OFF) option(ASMJIT_NO_SHM_OPEN "Disable the use of shm_open() (some platforms have better options)" OFF) option(ASMJIT_NO_X86 "Disable X86/X64 backend" OFF) +option(ASMJIT_NO_AARCH32 "Disable AArch32 backend" OFF) option(ASMJIT_NO_AARCH64 "Disable AArch64 backend" OFF) option(ASMJIT_NO_FOREIGN "Disable all foreign backends (enables only a backend that matches the target)" OFF) option(ASMJIT_NO_JIT "Disable VirtMem, JitAllocator, and JitRuntime at build time" OFF) @@ -219,12 +220,29 @@ set(ASMJIT_SRC asmjit/support/support.h asmjit/support/support_p.h + asmjit/a32.h asmjit/a64.h asmjit/arm.h asmjit/arm/armformatter.cpp asmjit/arm/armformatter_p.h asmjit/arm/armglobals.h asmjit/arm/armutils.h + asmjit/arm/a32archtraits_p.h + asmjit/arm/a32assembler.cpp + asmjit/arm/a32assembler.h + asmjit/arm/a32builder.cpp + asmjit/arm/a32builder.h + asmjit/arm/a32emithelper.cpp + asmjit/arm/a32emithelper_p.h + asmjit/arm/a32emitter.h + asmjit/arm/a32formatter.cpp + asmjit/arm/a32formatter_p.h + asmjit/arm/a32globals.h + asmjit/arm/a32instapi.cpp + asmjit/arm/a32instapi_p.h + asmjit/arm/a32instdb.cpp + asmjit/arm/a32instdb_p.h + asmjit/arm/a32operand.h asmjit/arm/a64archtraits_p.h asmjit/arm/a64assembler.cpp asmjit/arm/a64assembler.h @@ -504,6 +522,7 @@ if (ASMJIT_NO_SHM_OPEN) endif() foreach(build_option ASMJIT_NO_X86 + ASMJIT_NO_AARCH32 ASMJIT_NO_AARCH64 ASMJIT_NO_FOREIGN ASMJIT_NO_ABI_NAMESPACE @@ -613,6 +632,7 @@ else() asmjit_add_target(asmjit_test_assembler TEST SOURCES asmjit-testing/tests/asmjit_test_assembler.cpp asmjit-testing/tests/asmjit_test_assembler.h + asmjit-testing/tests/asmjit_test_assembler_a32.cpp asmjit-testing/tests/asmjit_test_assembler_a64.cpp asmjit-testing/tests/asmjit_test_assembler_x64.cpp asmjit-testing/tests/asmjit_test_assembler_x86.cpp @@ -689,6 +709,7 @@ else() asmjit_add_target(asmjit_bench_codegen EXECUTABLE SOURCES asmjit-testing/bench/asmjit_bench_codegen.cpp + asmjit-testing/bench/asmjit_bench_codegen_a32.cpp asmjit-testing/bench/asmjit_bench_codegen_a64.cpp asmjit-testing/bench/asmjit_bench_codegen_x86.cpp SOURCES asmjit-testing/bench/asmjit_bench_codegen.h diff --git a/asmjit-testing/bench/asmjit_bench_codegen.cpp b/asmjit-testing/bench/asmjit_bench_codegen.cpp index 89e71a3..82bb910 100644 --- a/asmjit-testing/bench/asmjit_bench_codegen.cpp +++ b/asmjit-testing/bench/asmjit_bench_codegen.cpp @@ -28,6 +28,10 @@ static void print_app_info() noexcept { void benchmark_x86_emitters(uint32_t num_iterations, bool test_x86, bool test_x64) noexcept; #endif +#if !defined(ASMJIT_NO_AARCH32) +void benchmark_aarch32_emitters(uint32_t num_iterations); +#endif + #if !defined(ASMJIT_NO_AARCH64) void benchmark_aarch64_emitters(uint32_t num_iterations); #endif @@ -49,6 +53,9 @@ int main(int argc, char* argv[]) { printf(" --arch=x86 32-bit X86 architecture (X86)\n"); printf(" --arch=x64 64-bit X86 architecture (X86_64)\n"); #endif +#if !defined(ASMJIT_NO_AARCH32) + printf(" --arch=aarch32 32-bit ARM architecture (AArch32)\n"); +#endif #if !defined(ASMJIT_NO_AARCH64) printf(" --arch=aarch64 64-bit ARM architecture (AArch64)\n"); #endif @@ -71,6 +78,14 @@ int main(int argc, char* argv[]) { } #endif +#if !defined(ASMJIT_NO_AARCH32) + bool test_aarch32 = strcmp(arch, "all") == 0 || strcmp(arch, "aarch32") == 0; + + if (test_aarch32) { + benchmark_aarch32_emitters(num_iterations); + } +#endif + #if !defined(ASMJIT_NO_AARCH64) bool test_aarch64 = strcmp(arch, "all") == 0 || strcmp(arch, "aarch64") == 0; diff --git a/asmjit-testing/bench/asmjit_bench_codegen_a32.cpp b/asmjit-testing/bench/asmjit_bench_codegen_a32.cpp new file mode 100644 index 0000000..e857495 --- /dev/null +++ b/asmjit-testing/bench/asmjit_bench_codegen_a32.cpp @@ -0,0 +1,23 @@ +// This file is part of AsmJit project +// +// See or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include + +#if !defined(ASMJIT_NO_AARCH32) +#include + +#include +#include +#include + +#include + +using namespace asmjit; + +void benchmark_aarch32_emitters(uint32_t num_iterations) { + Support::maybe_unused(num_iterations); +} + +#endif // !ASMJIT_NO_AARCH32 diff --git a/asmjit-testing/tests/asmjit_test_assembler.cpp b/asmjit-testing/tests/asmjit_test_assembler.cpp index 6e15697..7b285e4 100644 --- a/asmjit-testing/tests/asmjit_test_assembler.cpp +++ b/asmjit-testing/tests/asmjit_test_assembler.cpp @@ -20,6 +20,10 @@ bool test_x86_assembler(const TestSettings& settings) noexcept; bool test_x64_assembler(const TestSettings& settings) noexcept; #endif +#if !defined(ASMJIT_NO_AARCH32) +bool test_aarch32_assembler(const TestSettings& settings) noexcept; +#endif + #if !defined(ASMJIT_NO_AARCH64) bool test_aarch64_assembler(const TestSettings& settings) noexcept; #endif @@ -47,6 +51,9 @@ static void print_app_usage(const TestSettings& settings) noexcept { printf(" --arch=x86 32-bit X86 architecture (X86)\n"); printf(" --arch=x64 64-bit X86 architecture (X86_64)\n"); #endif +#if !defined(ASMJIT_NO_AARCH32) + printf(" --arch=aarch32 32-bit ARM architecture (AArch32)\n"); +#endif #if !defined(ASMJIT_NO_AARCH64) printf(" --arch=aarch64 64-bit ARM architecture (AArch64)\n"); #endif @@ -68,34 +75,52 @@ int main(int argc, char* argv[]) { } const char* arch = cmd_line.value_of("--arch", "all"); + bool x86_failed = false; bool x64_failed = false; + bool aarch32_failed = false; bool aarch64_failed = false; #if !defined(ASMJIT_NO_X86) - if ((strcmp(arch, "all") == 0 || strcmp(arch, "x86") == 0)) + if ((strcmp(arch, "all") == 0 || strcmp(arch, "x86") == 0)) { x86_failed = !test_x86_assembler(settings); + } - if ((strcmp(arch, "all") == 0 || strcmp(arch, "x64") == 0)) + if ((strcmp(arch, "all") == 0 || strcmp(arch, "x64") == 0)) { x64_failed = !test_x64_assembler(settings); + } +#endif + +#if !defined(ASMJIT_NO_AARCH32) + if ((strcmp(arch, "all") == 0 || strcmp(arch, "aarch32") == 0)) { + aarch32_failed = !test_aarch32_assembler(settings); + } #endif #if !defined(ASMJIT_NO_AARCH64) - if ((strcmp(arch, "all") == 0 || strcmp(arch, "aarch64") == 0)) + if ((strcmp(arch, "all") == 0 || strcmp(arch, "aarch64") == 0)) { aarch64_failed = !test_aarch64_assembler(settings); + } #endif - bool failed = x86_failed || x64_failed || aarch64_failed; + bool failed = x86_failed || x64_failed || aarch32_failed || aarch64_failed; if (failed) { - if (x86_failed) + if (x86_failed) { printf("** X86 test suite failed **\n"); + } - if (x64_failed) + if (x64_failed) { printf("** X64 test suite failed **\n"); + } - if (aarch64_failed) + if (aarch32_failed) { + printf("** AArch32 test suite failed **\n"); + } + + if (aarch64_failed) { printf("** AArch64 test suite failed **\n"); + } printf("** FAILURE **\n"); } diff --git a/asmjit-testing/tests/asmjit_test_assembler_a32.cpp b/asmjit-testing/tests/asmjit_test_assembler_a32.cpp new file mode 100644 index 0000000..d60b093 --- /dev/null +++ b/asmjit-testing/tests/asmjit_test_assembler_a32.cpp @@ -0,0 +1,2881 @@ +// This file is part of AsmJit project +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include +#if !defined(ASMJIT_NO_AARCH32) + +#include + +#include +#include + +#include +#include +#include + +using namespace asmjit; + +#define TEST_INSTRUCTION(OPCODE, ...) \ + tester.test_valid_instruction(#__VA_ARGS__, OPCODE, tester.assembler.__VA_ARGS__) + +static void ASMJIT_NOINLINE test_aarch32_assembler_base(AssemblerTester& tester) noexcept { + using namespace a32; + + TEST_INSTRUCTION("1314A2E0", adc(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314A2E0", adc(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314A2E0", adc(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314A2E0", adc(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314A2E0", adc(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314A2E0", adc(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314A2E0", adc(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314A2E0", adc(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("0810A2E2", adc(r1, r2, 8)); + TEST_INSTRUCTION("FF10A2E2", adc(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CA2E2", adc(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14A2E2", adc(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12A2E2", adc(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("1314B2E0", adcs(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314B2E0", adcs(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314B2E0", adcs(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314B2E0", adcs(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314B2E0", adcs(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314B2E0", adcs(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314B2E0", adcs(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314B2E0", adcs(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10B2E2", adcs(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CB2E2", adcs(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14B2E2", adcs(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12B2E2", adcs(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131482E0", add(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331482E0", add(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531482E0", add(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731482E0", add(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031482E0", add(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231482E0", add(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431482E0", add(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631482E0", add(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1082E2", add(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C82E2", add(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1482E2", add(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1282E2", add(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131492E0", adds(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331492E0", adds(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531492E0", adds(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731492E0", adds(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031492E0", adds(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231492E0", adds(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431492E0", adds(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631492E0", adds(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1092E2", adds(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C92E2", adds(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1492E2", adds(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1292E2", adds(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131402E0", and_(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331402E0", and_(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531402E0", and_(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731402E0", and_(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031402E0", and_(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231402E0", and_(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431402E0", and_(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631402E0", and_(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1002E2", and_(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C02E2", and_(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1402E2", and_(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1202E2", and_(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131412E0", ands(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331412E0", ands(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531412E0", ands(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731412E0", ands(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031412E0", ands(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231412E0", ands(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431412E0", ands(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631412E0", ands(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1012E2", ands(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C12E2", ands(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1412E2", ands(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1212E2", ands(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("5213A0E1", asr(r1, r2, r3)); + TEST_INSTRUCTION("C211A0E1", asr(r1, r2, 3)); + TEST_INSTRUCTION("5213B0E1", asrs(r1, r2, r3)); + TEST_INSTRUCTION("C211B0E1", asrs(r1, r2, 3)); + TEST_INSTRUCTION("9F11C7E7", bfc(r1, 3, 5)); + TEST_INSTRUCTION("9211C7E7", bfi(r1, r2, 3, 5)); + TEST_INSTRUCTION("1314C2E1", bic(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314C2E1", bic(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314C2E1", bic(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314C2E1", bic(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314C2E1", bic(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314C2E1", bic(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314C2E1", bic(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314C2E1", bic(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10C2E3", bic(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CC2E3", bic(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14C2E3", bic(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12C2E3", bic(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("1314D2E1", bics(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314D2E1", bics(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314D2E1", bics(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314D2E1", bics(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314D2E1", bics(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314D2E1", bics(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314D2E1", bics(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314D2E1", bics(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10D2E3", bics(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CD2E3", bics(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14D2E3", bics(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12D2E3", bics(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("710020E1", bkpt(1)); + TEST_INSTRUCTION("31FF2FE1", blx(r1)); + TEST_INSTRUCTION("11FF2FE1", bx(r1)); + TEST_INSTRUCTION("21FF2FE1", bxj(r1)); + TEST_INSTRUCTION("1FF07FF5", clrex()); + TEST_INSTRUCTION("121F6FE1", clz(r1, r2)); + TEST_INSTRUCTION("120371E1", cmn(r1, r2, lsl(r3))); + TEST_INSTRUCTION("320371E1", cmn(r1, r2, lsr(r3))); + TEST_INSTRUCTION("520371E1", cmn(r1, r2, asr(r3))); + TEST_INSTRUCTION("720371E1", cmn(r1, r2, ror(r3))); + TEST_INSTRUCTION("020471E1", cmn(r1, r2, lsl(8))); + TEST_INSTRUCTION("220471E1", cmn(r1, r2, lsr(8))); + TEST_INSTRUCTION("420471E1", cmn(r1, r2, asr(8))); + TEST_INSTRUCTION("620471E1", cmn(r1, r2, ror(8))); + TEST_INSTRUCTION("FF0071E3", cmn(r1, 0xFF)); + TEST_INSTRUCTION("FF0C71E3", cmn(r1, 0xFF00)); + TEST_INSTRUCTION("FF0471E3", cmn(r1, 0xFF000000)); + TEST_INSTRUCTION("FF0271E3", cmn(r1, 0xF000000F)); + TEST_INSTRUCTION("120351E1", cmp(r1, r2, lsl(r3))); + TEST_INSTRUCTION("320351E1", cmp(r1, r2, lsr(r3))); + TEST_INSTRUCTION("520351E1", cmp(r1, r2, asr(r3))); + TEST_INSTRUCTION("720351E1", cmp(r1, r2, ror(r3))); + TEST_INSTRUCTION("020451E1", cmp(r1, r2, lsl(8))); + TEST_INSTRUCTION("220451E1", cmp(r1, r2, lsr(8))); + TEST_INSTRUCTION("420451E1", cmp(r1, r2, asr(8))); + TEST_INSTRUCTION("620451E1", cmp(r1, r2, ror(8))); + TEST_INSTRUCTION("FF0051E3", cmp(r1, 0xFF)); + TEST_INSTRUCTION("FF0C51E3", cmp(r1, 0xFF00)); + TEST_INSTRUCTION("FF0451E3", cmp(r1, 0xFF000000)); + TEST_INSTRUCTION("FF0251E3", cmp(r1, 0xF000000F)); + TEST_INSTRUCTION("010002F1", cps(1)); + TEST_INSTRUCTION("431002E1", crc32b(r1, r2, r3)); + TEST_INSTRUCTION("431202E1", crc32cb(r1, r2, r3)); + TEST_INSTRUCTION("431222E1", crc32ch(r1, r2, r3)); + TEST_INSTRUCTION("431242E1", crc32cw(r1, r2, r3)); + TEST_INSTRUCTION("431022E1", crc32h(r1, r2, r3)); + TEST_INSTRUCTION("431042E1", crc32w(r1, r2, r3)); + TEST_INSTRUCTION("F1F020E3", dbg(1)); + TEST_INSTRUCTION("131422E0", eor(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331422E0", eor(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531422E0", eor(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731422E0", eor(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031422E0", eor(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231422E0", eor(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431422E0", eor(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631422E0", eor(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1022E2", eor(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C22E2", eor(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1422E2", eor(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1222E2", eor(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131432E0", eors(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331432E0", eors(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531432E0", eors(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731432E0", eors(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031432E0", eors(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231432E0", eors(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431432E0", eors(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631432E0", eors(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1032E2", eors(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C32E2", eors(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1432E2", eors(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1232E2", eors(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("6E0060E1", eret()); + TEST_INSTRUCTION("710000E1", hlt(1)); + TEST_INSTRUCTION("710040E1", hvc(1)); + TEST_INSTRUCTION("0F0014E8", ldmda(ptr(r4), GpList(0xF))); + TEST_INSTRUCTION("0F0014E8", ldmda(ptr(r4), GpList{r0, r1, r2, r3})); + TEST_INSTRUCTION("001C10E8", ldmda(ptr(r0), GpList{r10, r11, r12})); + TEST_INSTRUCTION("031092E7", ldr(r1, ptr(r2, r3))); + TEST_INSTRUCTION("831092E7", ldr(r1, ptr(r2, r3, lsl(1)))); + TEST_INSTRUCTION("031192E7", ldr(r1, ptr(r2, r3, lsl(2)))); + TEST_INSTRUCTION("831192E7", ldr(r1, ptr(r2, r3, lsl(3)))); + TEST_INSTRUCTION("031292E7", ldr(r1, ptr(r2, r3, lsl(4)))); + TEST_INSTRUCTION("0310B2E7", ldr(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("031092E6", ldr(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("041092E5", ldr(r1, ptr(r2, 4))); + TEST_INSTRUCTION("0410B2E5", ldr(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("041092E4", ldr(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("0C301FE5", ldr(r3, ptr(pc, -12))); + TEST_INSTRUCTION("0310D2E7", ldrb(r1, ptr(r2, r3))); + TEST_INSTRUCTION("0310F2E7", ldrb(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("0310D2E6", ldrb(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0410D2E5", ldrb(r1, ptr(r2, 4))); + TEST_INSTRUCTION("0410F2E5", ldrb(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("0410D2E4", ldrb(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("0C305FE5", ldrb(r3, ptr(pc, -12))); + TEST_INSTRUCTION("0310F2E6", ldrbt(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0410F2E4", ldrbt(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("D30082E1", ldrd(r0, r1, ptr(r2, r3))); + TEST_INSTRUCTION("D300A2E1", ldrd(r0, r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("D30082E0", ldrd(r0, r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("D400C2E1", ldrd(r0, r1, ptr(r2, 4))); + TEST_INSTRUCTION("D400E2E1", ldrd(r0, r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("DC204FE1", ldrd(r2, r3, ptr(pc, -12))); + TEST_INSTRUCTION("B31092E1", ldrh(r1, ptr(r2, r3))); + TEST_INSTRUCTION("B310B2E1", ldrh(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("B31092E0", ldrh(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("B410D2E1", ldrh(r1, ptr(r2, 4))); + TEST_INSTRUCTION("B410F2E1", ldrh(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("B410D2E0", ldrh(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("BC505FE1", ldrh(r5, ptr(pc, -12))); + TEST_INSTRUCTION("B310B2E0", ldrht(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("B410F2E0", ldrht(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("D31092E1", ldrsb(r1, ptr(r2, r3))); + TEST_INSTRUCTION("D310B2E1", ldrsb(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("D31092E0", ldrsb(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("D410D2E1", ldrsb(r1, ptr(r2, 4))); + TEST_INSTRUCTION("D410F2E1", ldrsb(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("D410D2E0", ldrsb(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("DC705FE1", ldrsb(r7, ptr(pc, -12))); + TEST_INSTRUCTION("D310B2E0", ldrsbt(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("D410F2E0", ldrsbt(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("F31092E1", ldrsh(r1, ptr(r2, r3))); + TEST_INSTRUCTION("F310B2E1", ldrsh(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("F31092E0", ldrsh(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("F410D2E1", ldrsh(r1, ptr(r2, 4))); + TEST_INSTRUCTION("F410F2E1", ldrsh(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("F410D2E0", ldrsh(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("FC405FE1", ldrsh(r4, ptr(pc, -12))); + TEST_INSTRUCTION("F410F2E0", ldrsht(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("F310B2E0", ldrsht(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0310B2E6", ldrt(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0410B2E4", ldrt(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("8211A0E1", lsl(r1, r2, 3)); + TEST_INSTRUCTION("1213A0E1", lsl(r1, r2, r3)); + TEST_INSTRUCTION("8211B0E1", lsls(r1, r2, 3)); + TEST_INSTRUCTION("1213B0E1", lsls(r1, r2, r3)); + TEST_INSTRUCTION("A211A0E1", lsr(r1, r2, 3)); + TEST_INSTRUCTION("3213A0E1", lsr(r1, r2, r3)); + TEST_INSTRUCTION("A211B0E1", lsrs(r1, r2, 3)); + TEST_INSTRUCTION("3213B0E1", lsrs(r1, r2, r3)); + TEST_INSTRUCTION("924321E0", mla(r1, r2, r3, r4)); + TEST_INSTRUCTION("924331E0", mlas(r1, r2, r3, r4)); + TEST_INSTRUCTION("924361E0", mls(r1, r2, r3, r4)); + TEST_INSTRUCTION("1213A0E1", mov(r1, r2, lsl(r3))); + TEST_INSTRUCTION("3213A0E1", mov(r1, r2, lsr(r3))); + TEST_INSTRUCTION("5213A0E1", mov(r1, r2, asr(r3))); + TEST_INSTRUCTION("7213A0E1", mov(r1, r2, ror(r3))); + TEST_INSTRUCTION("0214A0E1", mov(r1, r2, lsl(8))); + TEST_INSTRUCTION("2214A0E1", mov(r1, r2, lsr(8))); + TEST_INSTRUCTION("4214A0E1", mov(r1, r2, asr(8))); + TEST_INSTRUCTION("6214A0E1", mov(r1, r2, ror(8))); + TEST_INSTRUCTION("FF10A0E3", mov(r1, 0xFF)); + TEST_INSTRUCTION("FF1CA0E3", mov(r1, 0xFF00)); + TEST_INSTRUCTION("FF14A0E3", mov(r1, 0xFF000000)); + TEST_INSTRUCTION("FF12A0E3", mov(r1, 0xF000000F)); + TEST_INSTRUCTION("1213B0E1", movs(r1, r2, lsl(r3))); + TEST_INSTRUCTION("3213B0E1", movs(r1, r2, lsr(r3))); + TEST_INSTRUCTION("5213B0E1", movs(r1, r2, asr(r3))); + TEST_INSTRUCTION("7213B0E1", movs(r1, r2, ror(r3))); + TEST_INSTRUCTION("0214B0E1", movs(r1, r2, lsl(8))); + TEST_INSTRUCTION("2214B0E1", movs(r1, r2, lsr(8))); + TEST_INSTRUCTION("4214B0E1", movs(r1, r2, asr(8))); + TEST_INSTRUCTION("6214B0E1", movs(r1, r2, ror(8))); + TEST_INSTRUCTION("FF10B0E3", movs(r1, 0xFF)); + TEST_INSTRUCTION("FF1CB0E3", movs(r1, 0xFF00)); + TEST_INSTRUCTION("FF14B0E3", movs(r1, 0xFF000000)); + TEST_INSTRUCTION("FF12B0E3", movs(r1, 0xF000000F)); + TEST_INSTRUCTION("011040E3", movt(r1, 1)); + TEST_INSTRUCTION("011000E3", movw(r1, 1)); + TEST_INSTRUCTION("920301E0", mul(r1, r2, r3)); + TEST_INSTRUCTION("920311E0", muls(r1, r2, r3)); + TEST_INSTRUCTION("1213E0E1", mvn(r1, r2, lsl(r3))); + TEST_INSTRUCTION("3213E0E1", mvn(r1, r2, lsr(r3))); + TEST_INSTRUCTION("5213E0E1", mvn(r1, r2, asr(r3))); + TEST_INSTRUCTION("7213E0E1", mvn(r1, r2, ror(r3))); + TEST_INSTRUCTION("0214E0E1", mvn(r1, r2, lsl(8))); + TEST_INSTRUCTION("2214E0E1", mvn(r1, r2, lsr(8))); + TEST_INSTRUCTION("4214E0E1", mvn(r1, r2, asr(8))); + TEST_INSTRUCTION("6214E0E1", mvn(r1, r2, ror(8))); + TEST_INSTRUCTION("FF10E0E3", mvn(r1, 0xFF)); + TEST_INSTRUCTION("FF1CE0E3", mvn(r1, 0xFF00)); + TEST_INSTRUCTION("FF14E0E3", mvn(r1, 0xFF000000)); + TEST_INSTRUCTION("FF12E0E3", mvn(r1, 0xF000000F)); + TEST_INSTRUCTION("1213F0E1", mvns(r1, r2, lsl(r3))); + TEST_INSTRUCTION("3213F0E1", mvns(r1, r2, lsr(r3))); + TEST_INSTRUCTION("5213F0E1", mvns(r1, r2, asr(r3))); + TEST_INSTRUCTION("7213F0E1", mvns(r1, r2, ror(r3))); + TEST_INSTRUCTION("0214F0E1", mvns(r1, r2, lsl(8))); + TEST_INSTRUCTION("2214F0E1", mvns(r1, r2, lsr(8))); + TEST_INSTRUCTION("4214F0E1", mvns(r1, r2, asr(8))); + TEST_INSTRUCTION("6214F0E1", mvns(r1, r2, ror(8))); + TEST_INSTRUCTION("FF10F0E3", mvns(r1, 0xFF)); + TEST_INSTRUCTION("FF1CF0E3", mvns(r1, 0xFF00)); + TEST_INSTRUCTION("FF14F0E3", mvns(r1, 0xFF000000)); + TEST_INSTRUCTION("FF12F0E3", mvns(r1, 0xF000000F)); + TEST_INSTRUCTION("00F020E3", nop()); + TEST_INSTRUCTION("131482E1", orr(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331482E1", orr(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531482E1", orr(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731482E1", orr(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031482E1", orr(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231482E1", orr(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431482E1", orr(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631482E1", orr(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1082E3", orr(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C82E3", orr(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1482E3", orr(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1282E3", orr(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131492E1", orrs(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331492E1", orrs(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531492E1", orrs(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731492E1", orrs(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031492E1", orrs(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231492E1", orrs(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431492E1", orrs(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631492E1", orrs(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1092E3", orrs(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C92E3", orrs(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1492E3", orrs(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1292E3", orrs(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131482E6", pkhbt(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("531482E6", pkhtb(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("02F0D1F7", pld(ptr(r1, r2))); + TEST_INSTRUCTION("04F0D1F5", pld(ptr(r1, 4))); + TEST_INSTRUCTION("02F091F7", pldw(ptr(r1, r2))); + TEST_INSTRUCTION("04F091F5", pldw(ptr(r1, 4))); + TEST_INSTRUCTION("02F0D1F6", pli(ptr(r1, r2))); + TEST_INSTRUCTION("04F0D1F4", pli(ptr(r1, 4))); + TEST_INSTRUCTION("04109DE4", pop(r1)); + TEST_INSTRUCTION("3A02BDE8", pop(GpList{r1, r3, r4, r5, r9})); + TEST_INSTRUCTION("04102DE5", push(r1)); + TEST_INSTRUCTION("7A032DE9", push(GpList{r1, r3, r4, r5, r6, r8, r9})); + TEST_INSTRUCTION("521003E1", qadd(r1, r2, r3)); + TEST_INSTRUCTION("131F22E6", qadd16(r1, r2, r3)); + TEST_INSTRUCTION("931F22E6", qadd8(r1, r2, r3)); + TEST_INSTRUCTION("331F22E6", qasx(r1, r2, r3)); + TEST_INSTRUCTION("521043E1", qdadd(r1, r2, r3)); + TEST_INSTRUCTION("521063E1", qdsub(r1, r2, r3)); + TEST_INSTRUCTION("531F22E6", qsax(r1, r2, r3)); + TEST_INSTRUCTION("521023E1", qsub(r1, r2, r3)); + TEST_INSTRUCTION("731F22E6", qsub16(r1, r2, r3)); + TEST_INSTRUCTION("F31F22E6", qsub8(r1, r2, r3)); + TEST_INSTRUCTION("321FFFE6", rbit(r1, r2)); + TEST_INSTRUCTION("321FBFE6", rev(r1, r2)); + TEST_INSTRUCTION("B21FBFE6", rev16(r1, r2)); + TEST_INSTRUCTION("B21FFFE6", revsh(r1, r2)); + TEST_INSTRUCTION("000A11F8", rfeda(ptr(r1))); + TEST_INSTRUCTION("000A11F9", rfedb(ptr(r1))); + TEST_INSTRUCTION("000A91F8", rfeia(ptr(r1))); + TEST_INSTRUCTION("000A91F9", rfeib(ptr(r1))); + TEST_INSTRUCTION("E211A0E1", ror(r1, r2, 3)); + TEST_INSTRUCTION("7213A0E1", ror(r1, r2, r3)); + TEST_INSTRUCTION("E211B0E1", rors(r1, r2, 3)); + TEST_INSTRUCTION("7213B0E1", rors(r1, r2, r3)); + TEST_INSTRUCTION("6210A0E1", rrx(r1, r2)); + TEST_INSTRUCTION("6210B0E1", rrxs(r1, r2)); + TEST_INSTRUCTION("131462E0", rsb(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331462E0", rsb(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531462E0", rsb(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731462E0", rsb(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031462E0", rsb(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231462E0", rsb(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431462E0", rsb(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631462E0", rsb(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1062E2", rsb(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C62E2", rsb(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1462E2", rsb(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1262E2", rsb(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131472E0", rsbs(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331472E0", rsbs(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531472E0", rsbs(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731472E0", rsbs(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031472E0", rsbs(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231472E0", rsbs(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431472E0", rsbs(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631472E0", rsbs(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1072E2", rsbs(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C72E2", rsbs(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1472E2", rsbs(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1272E2", rsbs(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("1314E2E0", rsc(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314E2E0", rsc(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314E2E0", rsc(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314E2E0", rsc(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314E2E0", rsc(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314E2E0", rsc(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314E2E0", rsc(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314E2E0", rsc(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10E2E2", rsc(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CE2E2", rsc(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14E2E2", rsc(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12E2E2", rsc(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("1314F2E0", rscs(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314F2E0", rscs(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314F2E0", rscs(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314F2E0", rscs(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314F2E0", rscs(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314F2E0", rscs(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314F2E0", rscs(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314F2E0", rscs(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10F2E2", rscs(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CF2E2", rscs(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14F2E2", rscs(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12F2E2", rscs(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131F12E6", sadd16(r1, r2, r3)); + TEST_INSTRUCTION("931F12E6", sadd8(r1, r2, r3)); + TEST_INSTRUCTION("331F12E6", sasx(r1, r2, r3)); + TEST_INSTRUCTION("1314C2E0", sbc(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314C2E0", sbc(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314C2E0", sbc(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314C2E0", sbc(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314C2E0", sbc(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314C2E0", sbc(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314C2E0", sbc(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314C2E0", sbc(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10C2E2", sbc(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CC2E2", sbc(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14C2E2", sbc(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12C2E2", sbc(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("1314D2E0", sbcs(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("3314D2E0", sbcs(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("5314D2E0", sbcs(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("7314D2E0", sbcs(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("0314D2E0", sbcs(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("2314D2E0", sbcs(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("4314D2E0", sbcs(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("6314D2E0", sbcs(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF10D2E2", sbcs(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1CD2E2", sbcs(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF14D2E2", sbcs(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF12D2E2", sbcs(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("D211A4E7", sbfx(r1, r2, 3, 5)); + TEST_INSTRUCTION("12F311E7", sdiv(r1, r2, r3)); + TEST_INSTRUCTION("B31F82E6", sel(r1, r2, r3)); + TEST_INSTRUCTION("04F020E3", sev()); + TEST_INSTRUCTION("05F020E3", sevl()); + TEST_INSTRUCTION("131F32E6", shadd16(r1, r2, r3)); + TEST_INSTRUCTION("931F32E6", shadd8(r1, r2, r3)); + TEST_INSTRUCTION("331F32E6", shasx(r1, r2, r3)); + TEST_INSTRUCTION("531F32E6", shsax(r1, r2, r3)); + TEST_INSTRUCTION("731F32E6", shsub16(r1, r2, r3)); + TEST_INSTRUCTION("F31F32E6", shsub8(r1, r2, r3)); + TEST_INSTRUCTION("710060E1", smc(1)); + TEST_INSTRUCTION("824301E1", smlabb(r1, r2, r3, r4)); + TEST_INSTRUCTION("C24301E1", smlabt(r1, r2, r3, r4)); + TEST_INSTRUCTION("124301E7", smlad(r1, r2, r3, r4)); + TEST_INSTRUCTION("324301E7", smladx(r1, r2, r3, r4)); + TEST_INSTRUCTION("9314E2E0", smlal(r1, r2, r3, r4)); + TEST_INSTRUCTION("831442E1", smlalbb(r1, r2, r3, r4)); + TEST_INSTRUCTION("C31442E1", smlalbt(r1, r2, r3, r4)); + TEST_INSTRUCTION("131442E7", smlald(r1, r2, r3, r4)); + TEST_INSTRUCTION("331442E7", smlaldx(r1, r2, r3, r4)); + TEST_INSTRUCTION("9314F2E0", smlals(r1, r2, r3, r4)); + TEST_INSTRUCTION("A31442E1", smlaltb(r1, r2, r3, r4)); + TEST_INSTRUCTION("E31442E1", smlaltt(r1, r2, r3, r4)); + TEST_INSTRUCTION("A24301E1", smlatb(r1, r2, r3, r4)); + TEST_INSTRUCTION("E24301E1", smlatt(r1, r2, r3, r4)); + TEST_INSTRUCTION("824321E1", smlawb(r1, r2, r3, r4)); + TEST_INSTRUCTION("C24321E1", smlawt(r1, r2, r3, r4)); + TEST_INSTRUCTION("524301E7", smlsd(r1, r2, r3, r4)); + TEST_INSTRUCTION("724301E7", smlsdx(r1, r2, r3, r4)); + TEST_INSTRUCTION("531442E7", smlsld(r1, r2, r3, r4)); + TEST_INSTRUCTION("731442E7", smlsldx(r1, r2, r3, r4)); + TEST_INSTRUCTION("124351E7", smmla(r1, r2, r3, r4)); + TEST_INSTRUCTION("324351E7", smmlar(r1, r2, r3, r4)); + TEST_INSTRUCTION("D24351E7", smmls(r1, r2, r3, r4)); + TEST_INSTRUCTION("F24351E7", smmlsr(r1, r2, r3, r4)); + TEST_INSTRUCTION("12F351E7", smmul(r1, r2, r3)); + TEST_INSTRUCTION("32F351E7", smmulr(r1, r2, r3)); + TEST_INSTRUCTION("12F301E7", smuad(r1, r2, r3)); + TEST_INSTRUCTION("32F301E7", smuadx(r1, r2, r3)); + TEST_INSTRUCTION("820361E1", smulbb(r1, r2, r3)); + TEST_INSTRUCTION("C20361E1", smulbt(r1, r2, r3)); + TEST_INSTRUCTION("9314C2E0", smull(r1, r2, r3, r4)); + TEST_INSTRUCTION("9314D2E0", smulls(r1, r2, r3, r4)); + TEST_INSTRUCTION("A20361E1", smultb(r1, r2, r3)); + TEST_INSTRUCTION("E20361E1", smultt(r1, r2, r3)); + TEST_INSTRUCTION("A20321E1", smulwb(r1, r2, r3)); + TEST_INSTRUCTION("E20321E1", smulwt(r1, r2, r3)); + TEST_INSTRUCTION("52F301E7", smusd(r1, r2, r3)); + TEST_INSTRUCTION("72F301E7", smusdx(r1, r2, r3)); + TEST_INSTRUCTION("1310A7E6", ssat(r1, 8, r3)); + TEST_INSTRUCTION("1314A7E6", ssat(r1, 8, r3, lsl(8))); + TEST_INSTRUCTION("5314A7E6", ssat(r1, 8, r3, asr(8))); + TEST_INSTRUCTION("331FA7E6", ssat16(r1, 8, r3)); + TEST_INSTRUCTION("531F12E6", ssax(r1, r2, r3)); + TEST_INSTRUCTION("731F12E6", ssub16(r1, r2, r3)); + TEST_INSTRUCTION("F31F12E6", ssub8(r1, r2, r3)); + TEST_INSTRUCTION("031082E7", str(r1, ptr(r2, r3))); + TEST_INSTRUCTION("031182E7", str(r1, ptr(r2, r3, lsl(2)))); + TEST_INSTRUCTION("0310A2E7", str(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("031082E6", str(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("041082E5", str(r1, ptr(r2, 4))); + TEST_INSTRUCTION("0410A2E5", str(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("041082E4", str(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("0C408FE5", str(r4, ptr(pc, 12))); + TEST_INSTRUCTION("0310C2E7", strb(r1, ptr(r2, r3))); + TEST_INSTRUCTION("0310E2E7", strb(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("0310C2E6", strb(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0410C2E5", strb(r1, ptr(r2, 4))); + TEST_INSTRUCTION("0410E2E5", strb(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("0410C2E4", strb(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("30A0CFE5", strb(r10, ptr(pc, 48))); + TEST_INSTRUCTION("0310E2E6", strbt(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0410E2E4", strbt(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("0490EFE4", strbt(r9, ptr(pc, 4))); + TEST_INSTRUCTION("F30082E1", strd(r0, r1, ptr(r2, r3))); + TEST_INSTRUCTION("F300A2E1", strd(r0, r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("F30082E0", strd(r0, r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("F400C2E1", strd(r0, r1, ptr(r2, 4))); + TEST_INSTRUCTION("F400E2E1", strd(r0, r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("F400C2E0", strd(r0, r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("F024CFE1", strd(r2, r3, ptr(pc, 64))); + TEST_INSTRUCTION("B31082E1", strh(r1, ptr(r2, r3))); + TEST_INSTRUCTION("B310A2E1", strh(r1, ptr_pre(r2, r3))); + TEST_INSTRUCTION("B31082E0", strh(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("B410C2E1", strh(r1, ptr(r2, 4))); + TEST_INSTRUCTION("B410E2E1", strh(r1, ptr_pre(r2, 4))); + TEST_INSTRUCTION("B410C2E0", strh(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("B0344FE1", strh(r3, ptr(pc, -64))); + TEST_INSTRUCTION("B310A2E0", strht(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("B410E2E0", strht(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("0310A2E6", strt(r1, ptr_post(r2, r3))); + TEST_INSTRUCTION("0410A2E4", strt(r1, ptr_post(r2, 4))); + TEST_INSTRUCTION("131442E0", sub(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331442E0", sub(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531442E0", sub(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731442E0", sub(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031442E0", sub(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231442E0", sub(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431442E0", sub(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631442E0", sub(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1042E2", sub(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C42E2", sub(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1442E2", sub(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1242E2", sub(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("131452E0", subs(r1, r2, r3, lsl(r4))); + TEST_INSTRUCTION("331452E0", subs(r1, r2, r3, lsr(r4))); + TEST_INSTRUCTION("531452E0", subs(r1, r2, r3, asr(r4))); + TEST_INSTRUCTION("731452E0", subs(r1, r2, r3, ror(r4))); + TEST_INSTRUCTION("031452E0", subs(r1, r2, r3, lsl(8))); + TEST_INSTRUCTION("231452E0", subs(r1, r2, r3, lsr(8))); + TEST_INSTRUCTION("431452E0", subs(r1, r2, r3, asr(8))); + TEST_INSTRUCTION("631452E0", subs(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("FF1052E2", subs(r1, r2, 0xFF)); + TEST_INSTRUCTION("FF1C52E2", subs(r1, r2, 0xFF00)); + TEST_INSTRUCTION("FF1452E2", subs(r1, r2, 0xFF000000)); + TEST_INSTRUCTION("FF1252E2", subs(r1, r2, 0xF000000F)); + TEST_INSTRUCTION("010000EF", svc(1)); + TEST_INSTRUCTION("7314A2E6", sxtab(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("731482E6", sxtab16(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("7314B2E6", sxtah(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("7214AFE6", sxtb(r1, r2, ror(8))); + TEST_INSTRUCTION("72148FE6", sxtb16(r1, r2, ror(8))); + TEST_INSTRUCTION("7214BFE6", sxth(r1, r2, ror(8))); + TEST_INSTRUCTION("120331E1", teq(r1, r2, lsl(r3))); + TEST_INSTRUCTION("320331E1", teq(r1, r2, lsr(r3))); + TEST_INSTRUCTION("520331E1", teq(r1, r2, asr(r3))); + TEST_INSTRUCTION("720331E1", teq(r1, r2, ror(r3))); + TEST_INSTRUCTION("020431E1", teq(r1, r2, lsl(8))); + TEST_INSTRUCTION("220431E1", teq(r1, r2, lsr(8))); + TEST_INSTRUCTION("420431E1", teq(r1, r2, asr(8))); + TEST_INSTRUCTION("620431E1", teq(r1, r2, ror(8))); + TEST_INSTRUCTION("FF0031E3", teq(r1, 0xFF)); + TEST_INSTRUCTION("FF0C31E3", teq(r1, 0xFF00)); + TEST_INSTRUCTION("FF0431E3", teq(r1, 0xFF000000)); + TEST_INSTRUCTION("FF0231E3", teq(r1, 0xF000000F)); + TEST_INSTRUCTION("120311E1", tst(r1, r2, lsl(r3))); + TEST_INSTRUCTION("320311E1", tst(r1, r2, lsr(r3))); + TEST_INSTRUCTION("520311E1", tst(r1, r2, asr(r3))); + TEST_INSTRUCTION("720311E1", tst(r1, r2, ror(r3))); + TEST_INSTRUCTION("020411E1", tst(r1, r2, lsl(8))); + TEST_INSTRUCTION("220411E1", tst(r1, r2, lsr(8))); + TEST_INSTRUCTION("420411E1", tst(r1, r2, asr(8))); + TEST_INSTRUCTION("620411E1", tst(r1, r2, ror(8))); + TEST_INSTRUCTION("FF0011E3", tst(r1, 0xFF)); + TEST_INSTRUCTION("FF0C11E3", tst(r1, 0xFF00)); + TEST_INSTRUCTION("FF0411E3", tst(r1, 0xFF000000)); + TEST_INSTRUCTION("FF0211E3", tst(r1, 0xF000000F)); + TEST_INSTRUCTION("131F52E6", uadd16(r1, r2, r3)); + TEST_INSTRUCTION("931F52E6", uadd8(r1, r2, r3)); + TEST_INSTRUCTION("331F52E6", uasx(r1, r2, r3)); + TEST_INSTRUCTION("D211E4E7", ubfx(r1, r2, 3, 5)); + TEST_INSTRUCTION("F100F0E7", udf(1)); + TEST_INSTRUCTION("12F331E7", udiv(r1, r2, r3)); + TEST_INSTRUCTION("131F72E6", uhadd16(r1, r2, r3)); + TEST_INSTRUCTION("931F72E6", uhadd8(r1, r2, r3)); + TEST_INSTRUCTION("331F72E6", uhasx(r1, r2, r3)); + TEST_INSTRUCTION("531F72E6", uhsax(r1, r2, r3)); + TEST_INSTRUCTION("731F72E6", uhsub16(r1, r2, r3)); + TEST_INSTRUCTION("F31F72E6", uhsub8(r1, r2, r3)); + TEST_INSTRUCTION("931442E0", umaal(r1, r2, r3, r4)); + TEST_INSTRUCTION("9314A2E0", umlal(r1, r2, r3, r4)); + TEST_INSTRUCTION("9314B2E0", umlals(r1, r2, r3, r4)); + TEST_INSTRUCTION("931482E0", umull(r1, r2, r3, r4)); + TEST_INSTRUCTION("931492E0", umulls(r1, r2, r3, r4)); + TEST_INSTRUCTION("131F62E6", uqadd16(r1, r2, r3)); + TEST_INSTRUCTION("931F62E6", uqadd8(r1, r2, r3)); + TEST_INSTRUCTION("331F62E6", uqasx(r1, r2, r3)); + TEST_INSTRUCTION("531F62E6", uqsax(r1, r2, r3)); + TEST_INSTRUCTION("731F62E6", uqsub16(r1, r2, r3)); + TEST_INSTRUCTION("F31F62E6", uqsub8(r1, r2, r3)); + TEST_INSTRUCTION("12F381E7", usad8(r1, r2, r3)); + TEST_INSTRUCTION("124381E7", usada8(r1, r2, r3, r4)); + TEST_INSTRUCTION("1314E8E6", usat(r1, 8, r3, lsl(8))); + TEST_INSTRUCTION("5314E8E6", usat(r1, 8, r3, asr(8))); + TEST_INSTRUCTION("331FE8E6", usat16(r1, 8, r3)); + TEST_INSTRUCTION("531F52E6", usax(r1, r2, r3)); + TEST_INSTRUCTION("731F52E6", usub16(r1, r2, r3)); + TEST_INSTRUCTION("F31F52E6", usub8(r1, r2, r3)); + TEST_INSTRUCTION("7314E2E6", uxtab(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("7314C2E6", uxtab16(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("7314F2E6", uxtah(r1, r2, r3, ror(8))); + TEST_INSTRUCTION("7214EFE6", uxtb(r1, r2, ror(8))); + TEST_INSTRUCTION("7214CFE6", uxtb16(r1, r2, ror(8))); + TEST_INSTRUCTION("7214FFE6", uxth(r1, r2, ror(8))); + TEST_INSTRUCTION("02F020E3", wfe()); + TEST_INSTRUCTION("03F020E3", wfi()); + TEST_INSTRUCTION("01F020E3", yield()); +} + +static void ASMJIT_NOINLINE test_aarch32_assembler_vec(AssemblerTester& tester) noexcept { + using namespace a32; + + TEST_INSTRUCTION("4423B0F3", aesd_s8(q1, q2)); + TEST_INSTRUCTION("4423B0F3", aesd_u8(q1, q2)); + TEST_INSTRUCTION("0423B0F3", aese_s8(q1, q2)); + TEST_INSTRUCTION("0423B0F3", aese_u8(q1, q2)); + TEST_INSTRUCTION("C423B0F3", aesimc_s8(q1, q2)); + TEST_INSTRUCTION("C423B0F3", aesimc_u8(q1, q2)); + TEST_INSTRUCTION("8423B0F3", aesmc_s8(q1, q2)); + TEST_INSTRUCTION("8423B0F3", aesmc_u8(q1, q2)); + TEST_INSTRUCTION("462C04F2", sha1c_32(q1, q2, q3)); + TEST_INSTRUCTION("C422B9F3", sha1h_32(q1, q2)); + TEST_INSTRUCTION("462C24F2", sha1m_32(q1, q2, q3)); + TEST_INSTRUCTION("462C14F2", sha1p_32(q1, q2, q3)); + TEST_INSTRUCTION("462C34F2", sha1su0_32(q1, q2, q3)); + TEST_INSTRUCTION("8423BAF3", sha1su1_32(q1, q2)); + TEST_INSTRUCTION("462C04F3", sha256h_32(q1, q2, q3)); + TEST_INSTRUCTION("462C14F3", sha256h2_32(q1, q2, q3)); + TEST_INSTRUCTION("C423BAF3", sha256su0_32(q1, q2)); + TEST_INSTRUCTION("462C24F3", sha256su1_32(q1, q2, q3)); + TEST_INSTRUCTION("131712F2", vaba_s16(d1, d2, d3)); + TEST_INSTRUCTION("131722F2", vaba_s32(d1, d2, d3)); + TEST_INSTRUCTION("131702F2", vaba_s8(d1, d2, d3)); + TEST_INSTRUCTION("131712F3", vaba_u16(d1, d2, d3)); + TEST_INSTRUCTION("131722F3", vaba_u32(d1, d2, d3)); + TEST_INSTRUCTION("131702F3", vaba_u8(d1, d2, d3)); + TEST_INSTRUCTION("562714F2", vaba_s16(q1, q2, q3)); + TEST_INSTRUCTION("562724F2", vaba_s32(q1, q2, q3)); + TEST_INSTRUCTION("562704F2", vaba_s8(q1, q2, q3)); + TEST_INSTRUCTION("562714F3", vaba_u16(q1, q2, q3)); + TEST_INSTRUCTION("562724F3", vaba_u32(q1, q2, q3)); + TEST_INSTRUCTION("562704F3", vaba_u8(q1, q2, q3)); + TEST_INSTRUCTION("032592F2", vabal_s16(q1, d2, d3)); + TEST_INSTRUCTION("0325A2F2", vabal_s32(q1, d2, d3)); + TEST_INSTRUCTION("032582F2", vabal_s8(q1, d2, d3)); + TEST_INSTRUCTION("032592F3", vabal_u16(q1, d2, d3)); + TEST_INSTRUCTION("0325A2F3", vabal_u32(q1, d2, d3)); + TEST_INSTRUCTION("032582F3", vabal_u8(q1, d2, d3)); + TEST_INSTRUCTION("031D32F3", vabd_f16(d1, d2, d3)); + TEST_INSTRUCTION("031D22F3", vabd_f32(d1, d2, d3)); + TEST_INSTRUCTION("462D34F3", vabd_f16(q1, q2, q3)); + TEST_INSTRUCTION("462D24F3", vabd_f32(q1, q2, q3)); + TEST_INSTRUCTION("031712F2", vabd_s16(d1, d2, d3)); + TEST_INSTRUCTION("031722F2", vabd_s32(d1, d2, d3)); + TEST_INSTRUCTION("031702F2", vabd_s8(d1, d2, d3)); + TEST_INSTRUCTION("031712F3", vabd_u16(d1, d2, d3)); + TEST_INSTRUCTION("031722F3", vabd_u32(d1, d2, d3)); + TEST_INSTRUCTION("031702F3", vabd_u8(d1, d2, d3)); + TEST_INSTRUCTION("462714F2", vabd_s16(q1, q2, q3)); + TEST_INSTRUCTION("462724F2", vabd_s32(q1, q2, q3)); + TEST_INSTRUCTION("462704F2", vabd_s8(q1, q2, q3)); + TEST_INSTRUCTION("462714F3", vabd_u16(q1, q2, q3)); + TEST_INSTRUCTION("462724F3", vabd_u32(q1, q2, q3)); + TEST_INSTRUCTION("462704F3", vabd_u8(q1, q2, q3)); + TEST_INSTRUCTION("032792F2", vabdl_s16(q1, d2, d3)); + TEST_INSTRUCTION("0327A2F2", vabdl_s32(q1, d2, d3)); + TEST_INSTRUCTION("032782F2", vabdl_s8(q1, d2, d3)); + TEST_INSTRUCTION("032792F3", vabdl_u16(q1, d2, d3)); + TEST_INSTRUCTION("0327A2F3", vabdl_u32(q1, d2, d3)); + TEST_INSTRUCTION("032782F3", vabdl_u8(q1, d2, d3)); + TEST_INSTRUCTION("C109F0EE", vabs_f16(s1, s2)); + TEST_INSTRUCTION("C10AF0EE", vabs_f32(s1, s2)); + TEST_INSTRUCTION("C21BB0EE", vabs_f64(d1, d2)); + TEST_INSTRUCTION("0217B5F3", vabs_f16(d1, d2)); + TEST_INSTRUCTION("0217B9F3", vabs_f32(d1, d2)); + TEST_INSTRUCTION("4427B5F3", vabs_f16(q1, q2)); + TEST_INSTRUCTION("4427B9F3", vabs_f32(q1, q2)); + TEST_INSTRUCTION("0213B5F3", vabs_s16(d1, d2)); + TEST_INSTRUCTION("0213B9F3", vabs_s32(d1, d2)); + TEST_INSTRUCTION("0213B1F3", vabs_s8(d1, d2)); + TEST_INSTRUCTION("4423B5F3", vabs_s16(q1, q2)); + TEST_INSTRUCTION("4423B9F3", vabs_s32(q1, q2)); + TEST_INSTRUCTION("4423B1F3", vabs_s8(q1, q2)); + TEST_INSTRUCTION("131E12F3", vacge_f16(d1, d2, d3)); + TEST_INSTRUCTION("131E02F3", vacge_f32(d1, d2, d3)); + TEST_INSTRUCTION("562E14F3", vacge_f16(q1, q2, q3)); + TEST_INSTRUCTION("562E04F3", vacge_f32(q1, q2, q3)); + TEST_INSTRUCTION("131E32F3", vacgt_f16(d1, d2, d3)); + TEST_INSTRUCTION("131E22F3", vacgt_f32(d1, d2, d3)); + TEST_INSTRUCTION("562E34F3", vacgt_f16(q1, q2, q3)); + TEST_INSTRUCTION("562E24F3", vacgt_f32(q1, q2, q3)); + TEST_INSTRUCTION("121E13F3", vacle_f16(d1, d2, d3)); + TEST_INSTRUCTION("121E03F3", vacle_f32(d1, d2, d3)); + TEST_INSTRUCTION("542E16F3", vacle_f16(q1, q2, q3)); + TEST_INSTRUCTION("542E06F3", vacle_f32(q1, q2, q3)); + TEST_INSTRUCTION("121E33F3", vaclt_f16(d1, d2, d3)); + TEST_INSTRUCTION("121E23F3", vaclt_f32(d1, d2, d3)); + TEST_INSTRUCTION("542E36F3", vaclt_f16(q1, q2, q3)); + TEST_INSTRUCTION("542E26F3", vaclt_f32(q1, q2, q3)); + TEST_INSTRUCTION("210971EE", vadd_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A71EE", vadd_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B32EE", vadd_f64(d1, d2, d3)); + TEST_INSTRUCTION("031D02F2", vadd_f32(d1, d2, d3)); + TEST_INSTRUCTION("462D04F2", vadd_f32(q1, q2, q3)); + TEST_INSTRUCTION("031812F2", vadd_s16(d1, d2, d3)); + TEST_INSTRUCTION("031822F2", vadd_s32(d1, d2, d3)); + TEST_INSTRUCTION("031832F2", vadd_s64(d1, d2, d3)); + TEST_INSTRUCTION("031802F2", vadd_s8(d1, d2, d3)); + TEST_INSTRUCTION("031812F2", vadd_u16(d1, d2, d3)); + TEST_INSTRUCTION("031822F2", vadd_u32(d1, d2, d3)); + TEST_INSTRUCTION("031832F2", vadd_u64(d1, d2, d3)); + TEST_INSTRUCTION("031802F2", vadd_u8(d1, d2, d3)); + TEST_INSTRUCTION("462814F2", vadd_s16(q1, q2, q3)); + TEST_INSTRUCTION("462824F2", vadd_s32(q1, q2, q3)); + TEST_INSTRUCTION("462834F2", vadd_s64(q1, q2, q3)); + TEST_INSTRUCTION("462804F2", vadd_s8(q1, q2, q3)); + TEST_INSTRUCTION("462814F2", vadd_u16(q1, q2, q3)); + TEST_INSTRUCTION("462824F2", vadd_u32(q1, q2, q3)); + TEST_INSTRUCTION("462834F2", vadd_u64(q1, q2, q3)); + TEST_INSTRUCTION("462804F2", vadd_u8(q1, q2, q3)); + TEST_INSTRUCTION("061484F2", vaddhn_s16(d1, q2, q3)); + TEST_INSTRUCTION("061494F2", vaddhn_s32(d1, q2, q3)); + TEST_INSTRUCTION("0614A4F2", vaddhn_s64(d1, q2, q3)); + TEST_INSTRUCTION("061484F2", vaddhn_u16(d1, q2, q3)); + TEST_INSTRUCTION("061494F2", vaddhn_u32(d1, q2, q3)); + TEST_INSTRUCTION("0614A4F2", vaddhn_u64(d1, q2, q3)); + TEST_INSTRUCTION("032092F2", vaddl_s16(q1, d2, d3)); + TEST_INSTRUCTION("0320A2F2", vaddl_s32(q1, d2, d3)); + TEST_INSTRUCTION("032082F2", vaddl_s8(q1, d2, d3)); + TEST_INSTRUCTION("032092F3", vaddl_u16(q1, d2, d3)); + TEST_INSTRUCTION("0320A2F3", vaddl_u32(q1, d2, d3)); + TEST_INSTRUCTION("032082F3", vaddl_u8(q1, d2, d3)); + TEST_INSTRUCTION("032194F2", vaddw_s16(q1, q2, d3)); + TEST_INSTRUCTION("0321A4F2", vaddw_s32(q1, q2, d3)); + TEST_INSTRUCTION("032184F2", vaddw_s8(q1, q2, d3)); + TEST_INSTRUCTION("032194F3", vaddw_u16(q1, q2, d3)); + TEST_INSTRUCTION("0321A4F3", vaddw_u32(q1, q2, d3)); + TEST_INSTRUCTION("032184F3", vaddw_u8(q1, q2, d3)); + TEST_INSTRUCTION("131102F2", vand(d1, d2, d3)); + TEST_INSTRUCTION("562104F2", vand(q1, q2, q3)); + TEST_INSTRUCTION("3F1B87F3", vand_s16(d1, 0xFF)); + TEST_INSTRUCTION("3F1987F3", vand_s16(d1, 0xFF00)); + TEST_INSTRUCTION("3F1187F3", vand_s32(d1, 0xFFFFFF00)); + TEST_INSTRUCTION("3F1787F3", vand_s32(d1, 0x00FFFFFF)); + TEST_INSTRUCTION("3F1B87F3", vand_u16(d1, 0xFF)); + TEST_INSTRUCTION("3F1987F3", vand_u16(d1, 0xFF00)); + TEST_INSTRUCTION("3F1187F3", vand_u32(d1, 0xFFFFFF00)); + TEST_INSTRUCTION("3F1787F3", vand_u32(d1, 0x00FFFFFF)); + TEST_INSTRUCTION("7F2B87F3", vand_s16(q1, 0xFF)); + TEST_INSTRUCTION("7F2987F3", vand_s16(q1, 0xFF00)); + TEST_INSTRUCTION("7F2187F3", vand_s32(q1, 0xFFFFFF00)); + TEST_INSTRUCTION("7F2787F3", vand_s32(q1, 0x00FFFFFF)); + TEST_INSTRUCTION("7F2B87F3", vand_u16(q1, 0xFF)); + TEST_INSTRUCTION("7F2987F3", vand_u16(q1, 0xFF00)); + TEST_INSTRUCTION("7F2187F3", vand_u32(q1, 0xFFFFFF00)); + TEST_INSTRUCTION("7F2787F3", vand_u32(q1, 0x00FFFFFF)); + TEST_INSTRUCTION("131112F2", vbic(d1, d2, d3)); + TEST_INSTRUCTION("562114F2", vbic(q1, q2, q3)); + TEST_INSTRUCTION("3F1981F2", vbic_s16(d1, 0x1F)); + TEST_INSTRUCTION("301980F3", vbic_s16(d1, 0x80)); + TEST_INSTRUCTION("3F1987F3", vbic_s16(d1, 0xFF)); + TEST_INSTRUCTION("3F1B81F2", vbic_s16(d1, 0x1F00)); + TEST_INSTRUCTION("3F1B87F3", vbic_s16(d1, 0xFF00)); + TEST_INSTRUCTION("3F1181F2", vbic_s32(d1, 0x1F)); + TEST_INSTRUCTION("301180F3", vbic_s32(d1, 0x80)); + TEST_INSTRUCTION("3F1187F3", vbic_s32(d1, 0xFF)); + TEST_INSTRUCTION("3F1381F2", vbic_s32(d1, 0x1F00)); + TEST_INSTRUCTION("3F1387F3", vbic_s32(d1, 0xFF00)); + TEST_INSTRUCTION("3F1581F2", vbic_s32(d1, 0x1F0000)); + TEST_INSTRUCTION("3F1587F3", vbic_s32(d1, 0xFF0000)); + TEST_INSTRUCTION("3F1787F3", vbic_s32(d1, 0xFF000000)); + TEST_INSTRUCTION("3F1981F2", vbic_u16(d1, 0x1F)); + TEST_INSTRUCTION("301980F3", vbic_u16(d1, 0x80)); + TEST_INSTRUCTION("3F1987F3", vbic_u16(d1, 0xFF)); + TEST_INSTRUCTION("3F1B81F2", vbic_u16(d1, 0x1F00)); + TEST_INSTRUCTION("3F1B87F3", vbic_u16(d1, 0xFF00)); + TEST_INSTRUCTION("3F1181F2", vbic_u32(d1, 0x1F)); + TEST_INSTRUCTION("301180F3", vbic_u32(d1, 0x80)); + TEST_INSTRUCTION("3F1187F3", vbic_u32(d1, 0xFF)); + TEST_INSTRUCTION("3F1381F2", vbic_u32(d1, 0x1F00)); + TEST_INSTRUCTION("3F1387F3", vbic_u32(d1, 0xFF00)); + TEST_INSTRUCTION("3F1581F2", vbic_u32(d1, 0x1F0000)); + TEST_INSTRUCTION("3F1587F3", vbic_u32(d1, 0xFF0000)); + TEST_INSTRUCTION("3F1787F3", vbic_u32(d1, 0xFF000000)); + TEST_INSTRUCTION("7F2981F2", vbic_s16(q1, 0x1F)); + TEST_INSTRUCTION("702980F3", vbic_s16(q1, 0x80)); + TEST_INSTRUCTION("7F2987F3", vbic_s16(q1, 0xFF)); + TEST_INSTRUCTION("7F2B81F2", vbic_s16(q1, 0x1F00)); + TEST_INSTRUCTION("7F2B87F3", vbic_s16(q1, 0xFF00)); + TEST_INSTRUCTION("7F2181F2", vbic_s32(q1, 0x1F)); + TEST_INSTRUCTION("702180F3", vbic_s32(q1, 0x80)); + TEST_INSTRUCTION("7F2187F3", vbic_s32(q1, 0xFF)); + TEST_INSTRUCTION("7F2381F2", vbic_s32(q1, 0x1F00)); + TEST_INSTRUCTION("7F2387F3", vbic_s32(q1, 0xFF00)); + TEST_INSTRUCTION("7F2581F2", vbic_s32(q1, 0x1F0000)); + TEST_INSTRUCTION("7F2587F3", vbic_s32(q1, 0xFF0000)); + TEST_INSTRUCTION("7F2787F3", vbic_s32(q1, 0xFF000000)); + TEST_INSTRUCTION("7F2981F2", vbic_u16(q1, 0x1F)); + TEST_INSTRUCTION("702980F3", vbic_u16(q1, 0x80)); + TEST_INSTRUCTION("7F2987F3", vbic_u16(q1, 0xFF)); + TEST_INSTRUCTION("7F2B81F2", vbic_u16(q1, 0x1F00)); + TEST_INSTRUCTION("7F2B87F3", vbic_u16(q1, 0xFF00)); + TEST_INSTRUCTION("7F2181F2", vbic_u32(q1, 0x1F)); + TEST_INSTRUCTION("702180F3", vbic_u32(q1, 0x80)); + TEST_INSTRUCTION("7F2187F3", vbic_u32(q1, 0xFF)); + TEST_INSTRUCTION("7F2381F2", vbic_u32(q1, 0x1F00)); + TEST_INSTRUCTION("7F2387F3", vbic_u32(q1, 0xFF00)); + TEST_INSTRUCTION("7F2581F2", vbic_u32(q1, 0x1F0000)); + TEST_INSTRUCTION("7F2587F3", vbic_u32(q1, 0xFF0000)); + TEST_INSTRUCTION("7F2787F3", vbic_u32(q1, 0xFF000000)); + TEST_INSTRUCTION("131132F3", vbif(d1, d2, d3)); + TEST_INSTRUCTION("562134F3", vbif(q1, q2, q3)); + TEST_INSTRUCTION("131122F3", vbit(d1, d2, d3)); + TEST_INSTRUCTION("562124F3", vbit(q1, q2, q3)); + TEST_INSTRUCTION("131112F3", vbsl(d1, d2, d3)); + TEST_INSTRUCTION("562114F3", vbsl(q1, q2, q3)); + TEST_INSTRUCTION("031882FC", vcadd_f16(d1, d2, d3, 90)); + TEST_INSTRUCTION("031882FD", vcadd_f16(d1, d2, d3, 270)); + TEST_INSTRUCTION("031892FC", vcadd_f32(d1, d2, d3, 90)); + TEST_INSTRUCTION("031892FD", vcadd_f32(d1, d2, d3, 270)); + TEST_INSTRUCTION("462884FC", vcadd_f16(q1, q2, q3, 90)); + TEST_INSTRUCTION("462884FD", vcadd_f16(q1, q2, q3, 270)); + TEST_INSTRUCTION("462894FC", vcadd_f32(q1, q2, q3, 90)); + TEST_INSTRUCTION("462894FD", vcadd_f32(q1, q2, q3, 270)); + TEST_INSTRUCTION("0215B5F3", vceq_f16(d1, d2, 0)); + TEST_INSTRUCTION("0215B9F3", vceq_f32(d1, d2, 0)); + TEST_INSTRUCTION("4425B5F3", vceq_f16(q1, q2, 0)); + TEST_INSTRUCTION("4425B9F3", vceq_f32(q1, q2, 0)); + TEST_INSTRUCTION("0211B5F3", vceq_s16(d1, d2, 0)); + TEST_INSTRUCTION("0211B9F3", vceq_s32(d1, d2, 0)); + TEST_INSTRUCTION("0211B1F3", vceq_s8(d1, d2, 0)); + TEST_INSTRUCTION("0211B5F3", vceq_u16(d1, d2, 0)); + TEST_INSTRUCTION("0211B9F3", vceq_u32(d1, d2, 0)); + TEST_INSTRUCTION("0211B1F3", vceq_u8(d1, d2, 0)); + TEST_INSTRUCTION("4421B5F3", vceq_s16(q1, q2, 0)); + TEST_INSTRUCTION("4421B9F3", vceq_s32(q1, q2, 0)); + TEST_INSTRUCTION("4421B1F3", vceq_s8(q1, q2, 0)); + TEST_INSTRUCTION("4421B5F3", vceq_u16(q1, q2, 0)); + TEST_INSTRUCTION("4421B9F3", vceq_u32(q1, q2, 0)); + TEST_INSTRUCTION("4421B1F3", vceq_u8(q1, q2, 0)); + TEST_INSTRUCTION("031E12F2", vceq_f16(d1, d2, d3)); + TEST_INSTRUCTION("031E02F2", vceq_f32(d1, d2, d3)); + TEST_INSTRUCTION("462E14F2", vceq_f16(q1, q2, q3)); + TEST_INSTRUCTION("462E04F2", vceq_f32(q1, q2, q3)); + TEST_INSTRUCTION("131812F3", vceq_s16(d1, d2, d3)); + TEST_INSTRUCTION("131822F3", vceq_s32(d1, d2, d3)); + TEST_INSTRUCTION("131802F3", vceq_s8(d1, d2, d3)); + TEST_INSTRUCTION("131812F3", vceq_u16(d1, d2, d3)); + TEST_INSTRUCTION("131822F3", vceq_u32(d1, d2, d3)); + TEST_INSTRUCTION("131802F3", vceq_u8(d1, d2, d3)); + TEST_INSTRUCTION("562814F3", vceq_s16(q1, q2, q3)); + TEST_INSTRUCTION("562824F3", vceq_s32(q1, q2, q3)); + TEST_INSTRUCTION("562804F3", vceq_s8(q1, q2, q3)); + TEST_INSTRUCTION("562814F3", vceq_u16(q1, q2, q3)); + TEST_INSTRUCTION("562824F3", vceq_u32(q1, q2, q3)); + TEST_INSTRUCTION("562804F3", vceq_u8(q1, q2, q3)); + TEST_INSTRUCTION("8214B5F3", vcge_f16(d1, d2, 0)); + TEST_INSTRUCTION("8214B9F3", vcge_f32(d1, d2, 0)); + TEST_INSTRUCTION("C424B5F3", vcge_f16(q1, q2, 0)); + TEST_INSTRUCTION("C424B9F3", vcge_f32(q1, q2, 0)); + TEST_INSTRUCTION("8210B5F3", vcge_s16(d1, d2, 0)); + TEST_INSTRUCTION("8210B9F3", vcge_s32(d1, d2, 0)); + TEST_INSTRUCTION("8210B1F3", vcge_s8(d1, d2, 0)); + TEST_INSTRUCTION("C420B5F3", vcge_s16(q1, q2, 0)); + TEST_INSTRUCTION("C420B9F3", vcge_s32(q1, q2, 0)); + TEST_INSTRUCTION("C420B1F3", vcge_s8(q1, q2, 0)); + TEST_INSTRUCTION("031E12F3", vcge_f16(d1, d2, d3)); + TEST_INSTRUCTION("031E02F3", vcge_f32(d1, d2, d3)); + TEST_INSTRUCTION("462E14F3", vcge_f16(q1, q2, q3)); + TEST_INSTRUCTION("462E04F3", vcge_f32(q1, q2, q3)); + TEST_INSTRUCTION("131312F2", vcge_s16(d1, d2, d3)); + TEST_INSTRUCTION("131322F2", vcge_s32(d1, d2, d3)); + TEST_INSTRUCTION("131302F2", vcge_s8(d1, d2, d3)); + TEST_INSTRUCTION("131312F3", vcge_u16(d1, d2, d3)); + TEST_INSTRUCTION("131322F3", vcge_u32(d1, d2, d3)); + TEST_INSTRUCTION("131302F3", vcge_u8(d1, d2, d3)); + TEST_INSTRUCTION("562314F2", vcge_s16(q1, q2, q3)); + TEST_INSTRUCTION("562324F2", vcge_s32(q1, q2, q3)); + TEST_INSTRUCTION("562304F2", vcge_s8(q1, q2, q3)); + TEST_INSTRUCTION("562314F3", vcge_u16(q1, q2, q3)); + TEST_INSTRUCTION("562324F3", vcge_u32(q1, q2, q3)); + TEST_INSTRUCTION("562304F3", vcge_u8(q1, q2, q3)); + TEST_INSTRUCTION("0214B5F3", vcgt_f16(d1, d2, 0)); + TEST_INSTRUCTION("0214B9F3", vcgt_f32(d1, d2, 0)); + TEST_INSTRUCTION("4424B5F3", vcgt_f16(q1, q2, 0)); + TEST_INSTRUCTION("4424B9F3", vcgt_f32(q1, q2, 0)); + TEST_INSTRUCTION("0210B5F3", vcgt_s16(d1, d2, 0)); + TEST_INSTRUCTION("0210B9F3", vcgt_s32(d1, d2, 0)); + TEST_INSTRUCTION("0210B1F3", vcgt_s8(d1, d2, 0)); + TEST_INSTRUCTION("4420B5F3", vcgt_s16(q1, q2, 0)); + TEST_INSTRUCTION("4420B9F3", vcgt_s32(q1, q2, 0)); + TEST_INSTRUCTION("4420B1F3", vcgt_s8(q1, q2, 0)); + TEST_INSTRUCTION("031E32F3", vcgt_f16(d1, d2, d3)); + TEST_INSTRUCTION("031E22F3", vcgt_f32(d1, d2, d3)); + TEST_INSTRUCTION("462E34F3", vcgt_f16(q1, q2, q3)); + TEST_INSTRUCTION("462E24F3", vcgt_f32(q1, q2, q3)); + TEST_INSTRUCTION("031312F2", vcgt_s16(d1, d2, d3)); + TEST_INSTRUCTION("031322F2", vcgt_s32(d1, d2, d3)); + TEST_INSTRUCTION("031302F2", vcgt_s8(d1, d2, d3)); + TEST_INSTRUCTION("031312F3", vcgt_u16(d1, d2, d3)); + TEST_INSTRUCTION("031322F3", vcgt_u32(d1, d2, d3)); + TEST_INSTRUCTION("031302F3", vcgt_u8(d1, d2, d3)); + TEST_INSTRUCTION("462314F2", vcgt_s16(q1, q2, q3)); + TEST_INSTRUCTION("462324F2", vcgt_s32(q1, q2, q3)); + TEST_INSTRUCTION("462304F2", vcgt_s8(q1, q2, q3)); + TEST_INSTRUCTION("462314F3", vcgt_u16(q1, q2, q3)); + TEST_INSTRUCTION("462324F3", vcgt_u32(q1, q2, q3)); + TEST_INSTRUCTION("462304F3", vcgt_u8(q1, q2, q3)); + TEST_INSTRUCTION("8215B5F3", vcle_f16(d1, d2, 0)); + TEST_INSTRUCTION("8215B9F3", vcle_f32(d1, d2, 0)); + TEST_INSTRUCTION("C425B5F3", vcle_f16(q1, q2, 0)); + TEST_INSTRUCTION("C425B9F3", vcle_f32(q1, q2, 0)); + TEST_INSTRUCTION("8211B5F3", vcle_s16(d1, d2, 0)); + TEST_INSTRUCTION("8211B9F3", vcle_s32(d1, d2, 0)); + TEST_INSTRUCTION("8211B1F3", vcle_s8(d1, d2, 0)); + TEST_INSTRUCTION("C421B5F3", vcle_s16(q1, q2, 0)); + TEST_INSTRUCTION("C421B9F3", vcle_s32(q1, q2, 0)); + TEST_INSTRUCTION("C421B1F3", vcle_s8(q1, q2, 0)); + TEST_INSTRUCTION("021E13F3", vcle_f16(d1, d2, d3)); + TEST_INSTRUCTION("021E03F3", vcle_f32(d1, d2, d3)); + TEST_INSTRUCTION("442E16F3", vcle_f16(q1, q2, q3)); + TEST_INSTRUCTION("442E06F3", vcle_f32(q1, q2, q3)); + TEST_INSTRUCTION("121313F2", vcle_s16(d1, d2, d3)); + TEST_INSTRUCTION("121323F2", vcle_s32(d1, d2, d3)); + TEST_INSTRUCTION("121303F2", vcle_s8(d1, d2, d3)); + TEST_INSTRUCTION("121313F3", vcle_u16(d1, d2, d3)); + TEST_INSTRUCTION("121323F3", vcle_u32(d1, d2, d3)); + TEST_INSTRUCTION("121303F3", vcle_u8(d1, d2, d3)); + TEST_INSTRUCTION("542316F2", vcle_s16(q1, q2, q3)); + TEST_INSTRUCTION("542326F2", vcle_s32(q1, q2, q3)); + TEST_INSTRUCTION("542306F2", vcle_s8(q1, q2, q3)); + TEST_INSTRUCTION("542316F3", vcle_u16(q1, q2, q3)); + TEST_INSTRUCTION("542326F3", vcle_u32(q1, q2, q3)); + TEST_INSTRUCTION("542306F3", vcle_u8(q1, q2, q3)); + TEST_INSTRUCTION("0214B4F3", vcls_s16(d1, d2)); + TEST_INSTRUCTION("0214B8F3", vcls_s32(d1, d2)); + TEST_INSTRUCTION("0214B0F3", vcls_s8(d1, d2)); + TEST_INSTRUCTION("0214B4F3", vcls_u16(d1, d2)); + TEST_INSTRUCTION("0214B8F3", vcls_u32(d1, d2)); + TEST_INSTRUCTION("0214B0F3", vcls_u8(d1, d2)); + TEST_INSTRUCTION("4424B4F3", vcls_s16(q1, q2)); + TEST_INSTRUCTION("4424B8F3", vcls_s32(q1, q2)); + TEST_INSTRUCTION("4424B0F3", vcls_s8(q1, q2)); + TEST_INSTRUCTION("4424B4F3", vcls_u16(q1, q2)); + TEST_INSTRUCTION("4424B8F3", vcls_u32(q1, q2)); + TEST_INSTRUCTION("4424B0F3", vcls_u8(q1, q2)); + TEST_INSTRUCTION("0216B5F3", vclt_f16(d1, d2, 0)); + TEST_INSTRUCTION("0216B9F3", vclt_f32(d1, d2, 0)); + TEST_INSTRUCTION("4426B5F3", vclt_f16(q1, q2, 0)); + TEST_INSTRUCTION("4426B9F3", vclt_f32(q1, q2, 0)); + TEST_INSTRUCTION("0212B5F3", vclt_s16(d1, d2, 0)); + TEST_INSTRUCTION("0212B9F3", vclt_s32(d1, d2, 0)); + TEST_INSTRUCTION("0212B1F3", vclt_s8(d1, d2, 0)); + TEST_INSTRUCTION("4422B5F3", vclt_s16(q1, q2, 0)); + TEST_INSTRUCTION("4422B9F3", vclt_s32(q1, q2, 0)); + TEST_INSTRUCTION("4422B1F3", vclt_s8(q1, q2, 0)); + TEST_INSTRUCTION("021E33F3", vclt_f16(d1, d2, d3)); + TEST_INSTRUCTION("021E23F3", vclt_f32(d1, d2, d3)); + TEST_INSTRUCTION("442E36F3", vclt_f16(q1, q2, q3)); + TEST_INSTRUCTION("442E26F3", vclt_f32(q1, q2, q3)); + TEST_INSTRUCTION("021313F2", vclt_s16(d1, d2, d3)); + TEST_INSTRUCTION("021323F2", vclt_s32(d1, d2, d3)); + TEST_INSTRUCTION("021303F2", vclt_s8(d1, d2, d3)); + TEST_INSTRUCTION("021313F3", vclt_u16(d1, d2, d3)); + TEST_INSTRUCTION("021323F3", vclt_u32(d1, d2, d3)); + TEST_INSTRUCTION("021303F3", vclt_u8(d1, d2, d3)); + TEST_INSTRUCTION("442316F2", vclt_s16(q1, q2, q3)); + TEST_INSTRUCTION("442326F2", vclt_s32(q1, q2, q3)); + TEST_INSTRUCTION("442306F2", vclt_s8(q1, q2, q3)); + TEST_INSTRUCTION("442316F3", vclt_u16(q1, q2, q3)); + TEST_INSTRUCTION("442326F3", vclt_u32(q1, q2, q3)); + TEST_INSTRUCTION("442306F3", vclt_u8(q1, q2, q3)); + TEST_INSTRUCTION("8214B4F3", vclz_s16(d1, d2)); + TEST_INSTRUCTION("8214B8F3", vclz_s32(d1, d2)); + TEST_INSTRUCTION("8214B0F3", vclz_s8(d1, d2)); + TEST_INSTRUCTION("8214B4F3", vclz_u16(d1, d2)); + TEST_INSTRUCTION("8214B8F3", vclz_u32(d1, d2)); + TEST_INSTRUCTION("8214B0F3", vclz_u8(d1, d2)); + TEST_INSTRUCTION("C424B4F3", vclz_s16(q1, q2)); + TEST_INSTRUCTION("C424B8F3", vclz_s32(q1, q2)); + TEST_INSTRUCTION("C424B0F3", vclz_s8(q1, q2)); + TEST_INSTRUCTION("C424B4F3", vclz_u16(q1, q2)); + TEST_INSTRUCTION("C424B8F3", vclz_u32(q1, q2)); + TEST_INSTRUCTION("C424B0F3", vclz_u8(q1, q2)); + TEST_INSTRUCTION("031822FC", vcmla_f16(d1, d2, d3, 0)); + TEST_INSTRUCTION("0318A2FC", vcmla_f16(d1, d2, d3, 90)); + TEST_INSTRUCTION("031822FD", vcmla_f16(d1, d2, d3, 180)); + TEST_INSTRUCTION("0318A2FD", vcmla_f16(d1, d2, d3, 270)); + TEST_INSTRUCTION("031832FC", vcmla_f32(d1, d2, d3, 0)); + TEST_INSTRUCTION("0318B2FC", vcmla_f32(d1, d2, d3, 90)); + TEST_INSTRUCTION("031832FD", vcmla_f32(d1, d2, d3, 180)); + TEST_INSTRUCTION("0318B2FD", vcmla_f32(d1, d2, d3, 270)); + TEST_INSTRUCTION("462824FC", vcmla_f16(q1, q2, q3, 0)); + TEST_INSTRUCTION("4628A4FC", vcmla_f16(q1, q2, q3, 90)); + TEST_INSTRUCTION("462824FD", vcmla_f16(q1, q2, q3, 180)); + TEST_INSTRUCTION("4628A4FD", vcmla_f16(q1, q2, q3, 270)); + TEST_INSTRUCTION("462834FC", vcmla_f32(q1, q2, q3, 0)); + TEST_INSTRUCTION("4628B4FC", vcmla_f32(q1, q2, q3, 90)); + TEST_INSTRUCTION("462834FD", vcmla_f32(q1, q2, q3, 180)); + TEST_INSTRUCTION("4628B4FD", vcmla_f32(q1, q2, q3, 270)); + TEST_INSTRUCTION("031802FE", vcmla_f16(d1, d2, d3.at(0), 0)); + TEST_INSTRUCTION("031812FE", vcmla_f16(d1, d2, d3.at(0), 90)); + TEST_INSTRUCTION("031822FE", vcmla_f16(d1, d2, d3.at(0), 180)); + TEST_INSTRUCTION("031832FE", vcmla_f16(d1, d2, d3.at(0), 270)); + TEST_INSTRUCTION("231802FE", vcmla_f16(d1, d2, d3.at(1), 0)); + TEST_INSTRUCTION("231812FE", vcmla_f16(d1, d2, d3.at(1), 90)); + TEST_INSTRUCTION("231822FE", vcmla_f16(d1, d2, d3.at(1), 180)); + TEST_INSTRUCTION("231832FE", vcmla_f16(d1, d2, d3.at(1), 270)); + TEST_INSTRUCTION("432804FE", vcmla_f16(q1, q2, d3.at(0), 0)); + TEST_INSTRUCTION("432814FE", vcmla_f16(q1, q2, d3.at(0), 90)); + TEST_INSTRUCTION("432824FE", vcmla_f16(q1, q2, d3.at(0), 180)); + TEST_INSTRUCTION("432834FE", vcmla_f16(q1, q2, d3.at(0), 270)); + TEST_INSTRUCTION("632804FE", vcmla_f16(q1, q2, d3.at(1), 0)); + TEST_INSTRUCTION("632814FE", vcmla_f16(q1, q2, d3.at(1), 90)); + TEST_INSTRUCTION("632824FE", vcmla_f16(q1, q2, d3.at(1), 180)); + TEST_INSTRUCTION("632834FE", vcmla_f16(q1, q2, d3.at(1), 270)); + TEST_INSTRUCTION("031882FE", vcmla_f32(d1, d2, d3.at(0), 0)); + TEST_INSTRUCTION("031892FE", vcmla_f32(d1, d2, d3.at(0), 90)); + TEST_INSTRUCTION("0318A2FE", vcmla_f32(d1, d2, d3.at(0), 180)); + TEST_INSTRUCTION("0318B2FE", vcmla_f32(d1, d2, d3.at(0), 270)); + TEST_INSTRUCTION("432884FE", vcmla_f32(q1, q2, d3.at(0), 0)); + TEST_INSTRUCTION("432894FE", vcmla_f32(q1, q2, d3.at(0), 90)); + TEST_INSTRUCTION("4328A4FE", vcmla_f32(q1, q2, d3.at(0), 180)); + TEST_INSTRUCTION("4328B4FE", vcmla_f32(q1, q2, d3.at(0), 270)); + TEST_INSTRUCTION("4009F5EE", vcmp_f16(s1, 0)); + TEST_INSTRUCTION("400AF5EE", vcmp_f32(s1, 0)); + TEST_INSTRUCTION("401BB5EE", vcmp_f64(d1, 0)); + TEST_INSTRUCTION("4109F4EE", vcmp_f16(s1, s2)); + TEST_INSTRUCTION("410AF4EE", vcmp_f32(s1, s2)); + TEST_INSTRUCTION("421BB4EE", vcmp_f64(d1, d2)); + TEST_INSTRUCTION("C009F5EE", vcmpe_f16(s1, 0)); + TEST_INSTRUCTION("C00AF5EE", vcmpe_f32(s1, 0)); + TEST_INSTRUCTION("C01BB5EE", vcmpe_f64(d1, 0)); + TEST_INSTRUCTION("C109F4EE", vcmpe_f16(s1, s2)); + TEST_INSTRUCTION("C10AF4EE", vcmpe_f32(s1, s2)); + TEST_INSTRUCTION("C21BB4EE", vcmpe_f64(d1, d2)); + TEST_INSTRUCTION("0215B0F3", vcnt_s8(d1, d2)); + TEST_INSTRUCTION("0215B0F3", vcnt_u8(d1, d2)); + TEST_INSTRUCTION("4425B0F3", vcnt_s8(q1, q2)); + TEST_INSTRUCTION("4425B0F3", vcnt_u8(q1, q2)); + TEST_INSTRUCTION("C20BF7EE", vcvt_f32_f64(s1, d2)); + TEST_INSTRUCTION("C11AB7EE", vcvt_f64_f32(d1, s2)); + TEST_INSTRUCTION("C10AF8EE", vcvt_f32_s32(s1, s2)); + TEST_INSTRUCTION("410AF8EE", vcvt_f32_u32(s1, s2)); + TEST_INSTRUCTION("C11BB8EE", vcvt_f64_s32(d1, s2)); + TEST_INSTRUCTION("411BB8EE", vcvt_f64_u32(d1, s2)); + TEST_INSTRUCTION("0416B6F3", vcvt_f16_f32(d1, q2)); + TEST_INSTRUCTION("0227B6F3", vcvt_f32_f16(q1, d2)); + TEST_INSTRUCTION("0217BBF3", vcvt_s32_f32(d1, d2)); + TEST_INSTRUCTION("4427BBF3", vcvt_s32_f32(q1, q2)); + TEST_INSTRUCTION("8217BBF3", vcvt_u32_f32(d1, d2)); + TEST_INSTRUCTION("C427BBF3", vcvt_u32_f32(q1, q2)); + TEST_INSTRUCTION("0216BBF3", vcvt_f32_s32(d1, d2)); + TEST_INSTRUCTION("4426BBF3", vcvt_f32_s32(q1, q2)); + TEST_INSTRUCTION("8216BBF3", vcvt_f32_u32(d1, d2)); + TEST_INSTRUCTION("C426BBF3", vcvt_f32_u32(q1, q2)); + TEST_INSTRUCTION("C109FCFE", vcvta_s32_f16(s1, s2)); + TEST_INSTRUCTION("C10AFCFE", vcvta_s32_f32(s1, s2)); + TEST_INSTRUCTION("C20BFCFE", vcvta_s32_f64(s1, d2)); + TEST_INSTRUCTION("4109FCFE", vcvta_u32_f16(s1, s2)); + TEST_INSTRUCTION("410AFCFE", vcvta_u32_f32(s1, s2)); + TEST_INSTRUCTION("420BFCFE", vcvta_u32_f64(s1, d2)); + TEST_INSTRUCTION("410AF2EE", vcvtb_f32_f16(s1, s2)); + TEST_INSTRUCTION("410AF3EE", vcvtb_f16_f32(s1, s2)); + TEST_INSTRUCTION("411BB2EE", vcvtb_f64_f16(d1, s2)); + TEST_INSTRUCTION("420BF3EE", vcvtb_f16_f64(s1, d2)); + TEST_INSTRUCTION("0213B7F3", vcvtm_s16_f16(d1, d2)); + TEST_INSTRUCTION("4423B7F3", vcvtm_s16_f16(q1, q2)); + TEST_INSTRUCTION("8213B7F3", vcvtm_u16_f16(d1, d2)); + TEST_INSTRUCTION("C423B7F3", vcvtm_u16_f16(q1, q2)); + TEST_INSTRUCTION("0213BBF3", vcvtm_s32_f32(d1, d2)); + TEST_INSTRUCTION("4423BBF3", vcvtm_s32_f32(q1, q2)); + TEST_INSTRUCTION("8213BBF3", vcvtm_u32_f32(d1, d2)); + TEST_INSTRUCTION("C423BBF3", vcvtm_u32_f32(q1, q2)); + TEST_INSTRUCTION("C109FFFE", vcvtm_s32_f16(s1, s2)); + TEST_INSTRUCTION("C10AFFFE", vcvtm_s32_f32(s1, s2)); + TEST_INSTRUCTION("C20BFFFE", vcvtm_s32_f64(s1, d2)); + TEST_INSTRUCTION("4109FFFE", vcvtm_u32_f16(s1, s2)); + TEST_INSTRUCTION("410AFFFE", vcvtm_u32_f32(s1, s2)); + TEST_INSTRUCTION("420BFFFE", vcvtm_u32_f64(s1, d2)); + TEST_INSTRUCTION("0211B7F3", vcvtn_s16_f16(d1, d2)); + TEST_INSTRUCTION("4421B7F3", vcvtn_s16_f16(q1, q2)); + TEST_INSTRUCTION("8211B7F3", vcvtn_u16_f16(d1, d2)); + TEST_INSTRUCTION("C421B7F3", vcvtn_u16_f16(q1, q2)); + TEST_INSTRUCTION("0211BBF3", vcvtn_s32_f32(d1, d2)); + TEST_INSTRUCTION("4421BBF3", vcvtn_s32_f32(q1, q2)); + TEST_INSTRUCTION("8211BBF3", vcvtn_u32_f32(d1, d2)); + TEST_INSTRUCTION("C421BBF3", vcvtn_u32_f32(q1, q2)); + TEST_INSTRUCTION("C109FDFE", vcvtn_s32_f16(s1, s2)); + TEST_INSTRUCTION("C10AFDFE", vcvtn_s32_f32(s1, s2)); + TEST_INSTRUCTION("C20BFDFE", vcvtn_s32_f64(s1, d2)); + TEST_INSTRUCTION("4109FDFE", vcvtn_u32_f16(s1, s2)); + TEST_INSTRUCTION("410AFDFE", vcvtn_u32_f32(s1, s2)); + TEST_INSTRUCTION("420BFDFE", vcvtn_u32_f64(s1, d2)); + TEST_INSTRUCTION("0212B7F3", vcvtp_s16_f16(d1, d2)); + TEST_INSTRUCTION("4422B7F3", vcvtp_s16_f16(q1, q2)); + TEST_INSTRUCTION("8212B7F3", vcvtp_u16_f16(d1, d2)); + TEST_INSTRUCTION("C422B7F3", vcvtp_u16_f16(q1, q2)); + TEST_INSTRUCTION("0212BBF3", vcvtp_s32_f32(d1, d2)); + TEST_INSTRUCTION("4422BBF3", vcvtp_s32_f32(q1, q2)); + TEST_INSTRUCTION("8212BBF3", vcvtp_u32_f32(d1, d2)); + TEST_INSTRUCTION("C422BBF3", vcvtp_u32_f32(q1, q2)); + TEST_INSTRUCTION("C109FEFE", vcvtp_s32_f16(s1, s2)); + TEST_INSTRUCTION("C10AFEFE", vcvtp_s32_f32(s1, s2)); + TEST_INSTRUCTION("C20BFEFE", vcvtp_s32_f64(s1, d2)); + TEST_INSTRUCTION("4109FEFE", vcvtp_u32_f16(s1, s2)); + TEST_INSTRUCTION("410AFEFE", vcvtp_u32_f32(s1, s2)); + TEST_INSTRUCTION("420BFEFE", vcvtp_u32_f64(s1, d2)); + TEST_INSTRUCTION("4109FDEE", vcvtr_s32_f16(s1, s2)); + TEST_INSTRUCTION("410AFDEE", vcvtr_s32_f32(s1, s2)); + TEST_INSTRUCTION("420BFDEE", vcvtr_s32_f64(s1, d2)); + TEST_INSTRUCTION("4109FCEE", vcvtr_u32_f16(s1, s2)); + TEST_INSTRUCTION("410AFCEE", vcvtr_u32_f32(s1, s2)); + TEST_INSTRUCTION("420BFCEE", vcvtr_u32_f64(s1, d2)); + TEST_INSTRUCTION("C10AF2EE", vcvtt_f32_f16(s1, s2)); + TEST_INSTRUCTION("C10AF3EE", vcvtt_f16_f32(s1, s2)); + TEST_INSTRUCTION("C11BB2EE", vcvtt_f64_f16(d1, s2)); + TEST_INSTRUCTION("C20BF3EE", vcvtt_f16_f64(s1, d2)); + TEST_INSTRUCTION("2109C1EE", vdiv_f16(s1, s2, s3)); + TEST_INSTRUCTION("210AC1EE", vdiv_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B82EE", vdiv_f64(d1, d2, d3)); + TEST_INSTRUCTION("031D02FC", vdot_bf16(d1, d2, d3)); + TEST_INSTRUCTION("462D04FC", vdot_bf16(q1, q2, q3)); + TEST_INSTRUCTION("031D02FE", vdot_bf16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("231D02FE", vdot_bf16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432D04FE", vdot_bf16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632D04FE", vdot_bf16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("102BC1EE", vdup_8(d1, r2)); + TEST_INSTRUCTION("102BE2EE", vdup_8(q1, r2)); + TEST_INSTRUCTION("302B81EE", vdup_16(d1, r2)); + TEST_INSTRUCTION("302BA2EE", vdup_16(q1, r2)); + TEST_INSTRUCTION("102B81EE", vdup_32(d1, r2)); + TEST_INSTRUCTION("102BA2EE", vdup_32(q1, r2)); + TEST_INSTRUCTION("021CB1F3", vdup_8(d1, d2.at(0))); + TEST_INSTRUCTION("021CB3F3", vdup_8(d1, d2.at(1))); + TEST_INSTRUCTION("021CB5F3", vdup_8(d1, d2.at(2))); + TEST_INSTRUCTION("021CB7F3", vdup_8(d1, d2.at(3))); + TEST_INSTRUCTION("021CB9F3", vdup_8(d1, d2.at(4))); + TEST_INSTRUCTION("021CBBF3", vdup_8(d1, d2.at(5))); + TEST_INSTRUCTION("021CBDF3", vdup_8(d1, d2.at(6))); + TEST_INSTRUCTION("021CBFF3", vdup_8(d1, d2.at(7))); + TEST_INSTRUCTION("422CB1F3", vdup_8(q1, d2.at(0))); + TEST_INSTRUCTION("422CB3F3", vdup_8(q1, d2.at(1))); + TEST_INSTRUCTION("422CB5F3", vdup_8(q1, d2.at(2))); + TEST_INSTRUCTION("422CB7F3", vdup_8(q1, d2.at(3))); + TEST_INSTRUCTION("422CB9F3", vdup_8(q1, d2.at(4))); + TEST_INSTRUCTION("422CBBF3", vdup_8(q1, d2.at(5))); + TEST_INSTRUCTION("422CBDF3", vdup_8(q1, d2.at(6))); + TEST_INSTRUCTION("422CBFF3", vdup_8(q1, d2.at(7))); + TEST_INSTRUCTION("021CB2F3", vdup_16(d1, d2.at(0))); + TEST_INSTRUCTION("021CB6F3", vdup_16(d1, d2.at(1))); + TEST_INSTRUCTION("021CBAF3", vdup_16(d1, d2.at(2))); + TEST_INSTRUCTION("021CBEF3", vdup_16(d1, d2.at(3))); + TEST_INSTRUCTION("422CB2F3", vdup_16(q1, d2.at(0))); + TEST_INSTRUCTION("422CB6F3", vdup_16(q1, d2.at(1))); + TEST_INSTRUCTION("422CBAF3", vdup_16(q1, d2.at(2))); + TEST_INSTRUCTION("422CBEF3", vdup_16(q1, d2.at(3))); + TEST_INSTRUCTION("021CB4F3", vdup_32(d1, d2.at(0))); + TEST_INSTRUCTION("021CBCF3", vdup_32(d1, d2.at(1))); + TEST_INSTRUCTION("422CB4F3", vdup_32(q1, d2.at(0))); + TEST_INSTRUCTION("422CBCF3", vdup_32(q1, d2.at(1))); + TEST_INSTRUCTION("131102F3", veor(d1, d2, d3)); + TEST_INSTRUCTION("562104F3", veor(q1, q2, q3)); + TEST_INSTRUCTION("0311B2F2", vext_8(d1, d2, d3, 1)); + TEST_INSTRUCTION("4621B4F2", vext_8(q1, q2, q3, 1)); + TEST_INSTRUCTION("2109E1EE", vfma_f16(s1, s2, s3)); + TEST_INSTRUCTION("210AE1EE", vfma_f32(s1, s2, s3)); + TEST_INSTRUCTION("031BA2EE", vfma_f64(d1, d2, d3)); + TEST_INSTRUCTION("131C12F2", vfma_f16(d1, d2, d3)); + TEST_INSTRUCTION("131C02F2", vfma_f32(d1, d2, d3)); + TEST_INSTRUCTION("562C14F2", vfma_f16(q1, q2, q3)); + TEST_INSTRUCTION("562C04F2", vfma_f32(q1, q2, q3)); + TEST_INSTRUCTION("162834FC", vfmab_bf16(q1, q2, q3)); + TEST_INSTRUCTION("132834FE", vfmab_bf16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("1B2834FE", vfmab_bf16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("332834FE", vfmab_bf16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("3B2834FE", vfmab_bf16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("311821FC", vfmal_f16(d1, s2, s3)); + TEST_INSTRUCTION("532822FC", vfmal_f16(q1, d2, d3)); + TEST_INSTRUCTION("311801FE", vfmal_f16(d1, s2, s3.at(0))); + TEST_INSTRUCTION("391801FE", vfmal_f16(d1, s2, s3.at(1))); + TEST_INSTRUCTION("532802FE", vfmal_f16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("5B2802FE", vfmal_f16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("562834FC", vfmat_bf16(q1, q2, q3)); + TEST_INSTRUCTION("532834FE", vfmat_bf16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("5B2834FE", vfmat_bf16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("732834FE", vfmat_bf16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("7B2834FE", vfmat_bf16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("6109E1EE", vfms_f16(s1, s2, s3)); + TEST_INSTRUCTION("610AE1EE", vfms_f32(s1, s2, s3)); + TEST_INSTRUCTION("431BA2EE", vfms_f64(d1, d2, d3)); + TEST_INSTRUCTION("131C32F2", vfms_f16(d1, d2, d3)); + TEST_INSTRUCTION("131C22F2", vfms_f32(d1, d2, d3)); + TEST_INSTRUCTION("562C34F2", vfms_f16(q1, q2, q3)); + TEST_INSTRUCTION("562C24F2", vfms_f32(q1, q2, q3)); + TEST_INSTRUCTION("3118A1FC", vfmsl_f16(d1, s2, s3)); + TEST_INSTRUCTION("5328A2FC", vfmsl_f16(q1, d2, d3)); + TEST_INSTRUCTION("311811FE", vfmsl_f16(d1, s2, s3.at(0))); + TEST_INSTRUCTION("391811FE", vfmsl_f16(d1, s2, s3.at(1))); + TEST_INSTRUCTION("532812FE", vfmsl_f16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("5B2812FE", vfmsl_f16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("6109D1EE", vfnma_f16(s1, s2, s3)); + TEST_INSTRUCTION("610AD1EE", vfnma_f32(s1, s2, s3)); + TEST_INSTRUCTION("431B92EE", vfnma_f64(d1, d2, d3)); + TEST_INSTRUCTION("2109D1EE", vfnms_f16(s1, s2, s3)); + TEST_INSTRUCTION("210AD1EE", vfnms_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B92EE", vfnms_f64(d1, d2, d3)); + TEST_INSTRUCTION("031012F2", vhadd_s16(d1, d2, d3)); + TEST_INSTRUCTION("031022F2", vhadd_s32(d1, d2, d3)); + TEST_INSTRUCTION("031002F2", vhadd_s8(d1, d2, d3)); + TEST_INSTRUCTION("031012F3", vhadd_u16(d1, d2, d3)); + TEST_INSTRUCTION("031022F3", vhadd_u32(d1, d2, d3)); + TEST_INSTRUCTION("031002F3", vhadd_u8(d1, d2, d3)); + TEST_INSTRUCTION("462014F2", vhadd_s16(q1, q2, q3)); + TEST_INSTRUCTION("462024F2", vhadd_s32(q1, q2, q3)); + TEST_INSTRUCTION("462004F2", vhadd_s8(q1, q2, q3)); + TEST_INSTRUCTION("462014F3", vhadd_u16(q1, q2, q3)); + TEST_INSTRUCTION("462024F3", vhadd_u32(q1, q2, q3)); + TEST_INSTRUCTION("462004F3", vhadd_u8(q1, q2, q3)); + TEST_INSTRUCTION("031212F2", vhsub_s16(d1, d2, d3)); + TEST_INSTRUCTION("031222F2", vhsub_s32(d1, d2, d3)); + TEST_INSTRUCTION("031202F2", vhsub_s8(d1, d2, d3)); + TEST_INSTRUCTION("031212F3", vhsub_u16(d1, d2, d3)); + TEST_INSTRUCTION("031222F3", vhsub_u32(d1, d2, d3)); + TEST_INSTRUCTION("031202F3", vhsub_u8(d1, d2, d3)); + TEST_INSTRUCTION("462214F2", vhsub_s16(q1, q2, q3)); + TEST_INSTRUCTION("462224F2", vhsub_s32(q1, q2, q3)); + TEST_INSTRUCTION("462204F2", vhsub_s8(q1, q2, q3)); + TEST_INSTRUCTION("462214F3", vhsub_u16(q1, q2, q3)); + TEST_INSTRUCTION("462224F3", vhsub_u32(q1, q2, q3)); + TEST_INSTRUCTION("462204F3", vhsub_u8(q1, q2, q3)); + TEST_INSTRUCTION("C10AF0FE", vins_f16(s1, s2)); + TEST_INSTRUCTION("C20BF9EE", vjcvt_s32_f64(s1, d2)); + TEST_INSTRUCTION("431722F4", vld1_16(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("831722F4", vld1_32(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("C31722F4", vld1_64(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("031722F4", vld1_8(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("4D1722F4", vld1_16(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("8D1722F4", vld1_32(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("CD1722F4", vld1_64(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("0D1722F4", vld1_8(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("441A23F4", vld1_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841A23F4", vld1_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("C41A23F4", vld1_64(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041A23F4", vld1_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1A23F4", vld1_16(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("8D1A23F4", vld1_32(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("CD1A23F4", vld1_64(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("0D1A23F4", vld1_8(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("451624F4", vld1_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851624F4", vld1_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("C51624F4", vld1_64(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051624F4", vld1_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1624F4", vld1_16(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("8D1624F4", vld1_32(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("CD1624F4", vld1_64(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0D1624F4", vld1_8(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("461225F4", vld1_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861225F4", vld1_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("C61225F4", vld1_64(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061225F4", vld1_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1225F4", vld1_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1225F4", vld1_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("CD1225F4", vld1_64(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1225F4", vld1_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0310A2F4", vld1_8(d1.at(0), ptr_post(r2, r3))); + TEST_INSTRUCTION("2310A2F4", vld1_8(d1.at(1), ptr_post(r2, r3))); + TEST_INSTRUCTION("4310A2F4", vld1_8(d1.at(2), ptr_post(r2, r3))); + TEST_INSTRUCTION("6310A2F4", vld1_8(d1.at(3), ptr_post(r2, r3))); + TEST_INSTRUCTION("8310A2F4", vld1_8(d1.at(4), ptr_post(r2, r3))); + TEST_INSTRUCTION("A310A2F4", vld1_8(d1.at(5), ptr_post(r2, r3))); + TEST_INSTRUCTION("C310A2F4", vld1_8(d1.at(6), ptr_post(r2, r3))); + TEST_INSTRUCTION("E310A2F4", vld1_8(d1.at(7), ptr_post(r2, r3))); + TEST_INSTRUCTION("0D10A2F4", vld1_8(d1.at(0), ptr_post(r2, 1))); + TEST_INSTRUCTION("2D10A2F4", vld1_8(d1.at(1), ptr_post(r2, 1))); + TEST_INSTRUCTION("4D10A2F4", vld1_8(d1.at(2), ptr_post(r2, 1))); + TEST_INSTRUCTION("6D10A2F4", vld1_8(d1.at(3), ptr_post(r2, 1))); + TEST_INSTRUCTION("8D10A2F4", vld1_8(d1.at(4), ptr_post(r2, 1))); + TEST_INSTRUCTION("AD10A2F4", vld1_8(d1.at(5), ptr_post(r2, 1))); + TEST_INSTRUCTION("CD10A2F4", vld1_8(d1.at(6), ptr_post(r2, 1))); + TEST_INSTRUCTION("ED10A2F4", vld1_8(d1.at(7), ptr_post(r2, 1))); + TEST_INSTRUCTION("0314A2F4", vld1_16(d1.at(0), ptr_post(r2, r3))); + TEST_INSTRUCTION("4314A2F4", vld1_16(d1.at(1), ptr_post(r2, r3))); + TEST_INSTRUCTION("8314A2F4", vld1_16(d1.at(2), ptr_post(r2, r3))); + TEST_INSTRUCTION("C314A2F4", vld1_16(d1.at(3), ptr_post(r2, r3))); + TEST_INSTRUCTION("0D14A2F4", vld1_16(d1.at(0), ptr_post(r2, 2))); + TEST_INSTRUCTION("4D14A2F4", vld1_16(d1.at(1), ptr_post(r2, 2))); + TEST_INSTRUCTION("8D14A2F4", vld1_16(d1.at(2), ptr_post(r2, 2))); + TEST_INSTRUCTION("CD14A2F4", vld1_16(d1.at(3), ptr_post(r2, 2))); + TEST_INSTRUCTION("0318A2F4", vld1_32(d1.at(0), ptr_post(r2, r3))); + TEST_INSTRUCTION("8318A2F4", vld1_32(d1.at(1), ptr_post(r2, r3))); + TEST_INSTRUCTION("0D18A2F4", vld1_32(d1.at(0), ptr_post(r2, 4))); + TEST_INSTRUCTION("8D18A2F4", vld1_32(d1.at(1), ptr_post(r2, 4))); + TEST_INSTRUCTION("431CA2F4", vld1r_16(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("831CA2F4", vld1r_32(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("031CA2F4", vld1r_8(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("4D1CA2F4", vld1r_16(d1, ptr_post(r2, 2))); + TEST_INSTRUCTION("8D1CA2F4", vld1r_32(d1, ptr_post(r2, 4))); + TEST_INSTRUCTION("0D1CA2F4", vld1r_8(d1, ptr_post(r2, 1))); + TEST_INSTRUCTION("641CA3F4", vld1r_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("A41CA3F4", vld1r_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("241CA3F4", vld1r_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("6D1CA3F4", vld1r_16(d1, d2, ptr_post(r3, 2))); + TEST_INSTRUCTION("AD1CA3F4", vld1r_32(d1, d2, ptr_post(r3, 4))); + TEST_INSTRUCTION("2D1CA3F4", vld1r_8(d1, d2, ptr_post(r3, 1))); + TEST_INSTRUCTION("441823F4", vld2_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841823F4", vld2_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041823F4", vld2_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1823F4", vld2_16(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("8D1823F4", vld2_32(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("0D1823F4", vld2_8(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("441823F4", vld2_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841823F4", vld2_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041823F4", vld2_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1823F4", vld2_16(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("8D1823F4", vld2_32(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("0D1823F4", vld2_8(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("461325F4", vld2_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861325F4", vld2_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061325F4", vld2_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1325F4", vld2_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1325F4", vld2_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1325F4", vld2_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0411A3F4", vld2_8(d1.at(0), d2.at(0), ptr_post(r3, r4))); + TEST_INSTRUCTION("2411A3F4", vld2_8(d1.at(1), d2.at(1), ptr_post(r3, r4))); + TEST_INSTRUCTION("4411A3F4", vld2_8(d1.at(2), d2.at(2), ptr_post(r3, r4))); + TEST_INSTRUCTION("6411A3F4", vld2_8(d1.at(3), d2.at(3), ptr_post(r3, r4))); + TEST_INSTRUCTION("8411A3F4", vld2_8(d1.at(4), d2.at(4), ptr_post(r3, r4))); + TEST_INSTRUCTION("A411A3F4", vld2_8(d1.at(5), d2.at(5), ptr_post(r3, r4))); + TEST_INSTRUCTION("C411A3F4", vld2_8(d1.at(6), d2.at(6), ptr_post(r3, r4))); + TEST_INSTRUCTION("E411A3F4", vld2_8(d1.at(7), d2.at(7), ptr_post(r3, r4))); + TEST_INSTRUCTION("0D11A3F4", vld2_8(d1.at(0), d2.at(0), ptr_post(r3, 2))); + TEST_INSTRUCTION("2D11A3F4", vld2_8(d1.at(1), d2.at(1), ptr_post(r3, 2))); + TEST_INSTRUCTION("4D11A3F4", vld2_8(d1.at(2), d2.at(2), ptr_post(r3, 2))); + TEST_INSTRUCTION("6D11A3F4", vld2_8(d1.at(3), d2.at(3), ptr_post(r3, 2))); + TEST_INSTRUCTION("8D11A3F4", vld2_8(d1.at(4), d2.at(4), ptr_post(r3, 2))); + TEST_INSTRUCTION("AD11A3F4", vld2_8(d1.at(5), d2.at(5), ptr_post(r3, 2))); + TEST_INSTRUCTION("CD11A3F4", vld2_8(d1.at(6), d2.at(6), ptr_post(r3, 2))); + TEST_INSTRUCTION("ED11A3F4", vld2_8(d1.at(7), d2.at(7), ptr_post(r3, 2))); + TEST_INSTRUCTION("0415A3F4", vld2_16(d1.at(0), d2.at(0), ptr_post(r3, r4))); + TEST_INSTRUCTION("4415A3F4", vld2_16(d1.at(1), d2.at(1), ptr_post(r3, r4))); + TEST_INSTRUCTION("8415A3F4", vld2_16(d1.at(2), d2.at(2), ptr_post(r3, r4))); + TEST_INSTRUCTION("C415A3F4", vld2_16(d1.at(3), d2.at(3), ptr_post(r3, r4))); + TEST_INSTRUCTION("0D15A3F4", vld2_16(d1.at(0), d2.at(0), ptr_post(r3, 4))); + TEST_INSTRUCTION("4D15A3F4", vld2_16(d1.at(1), d2.at(1), ptr_post(r3, 4))); + TEST_INSTRUCTION("8D15A3F4", vld2_16(d1.at(2), d2.at(2), ptr_post(r3, 4))); + TEST_INSTRUCTION("CD15A3F4", vld2_16(d1.at(3), d2.at(3), ptr_post(r3, 4))); + TEST_INSTRUCTION("0415A3F4", vld2_16(d1.at(0), d2.at(0), ptr_post(r3, r4))); + TEST_INSTRUCTION("4415A3F4", vld2_16(d1.at(1), d2.at(1), ptr_post(r3, r4))); + TEST_INSTRUCTION("8415A3F4", vld2_16(d1.at(2), d2.at(2), ptr_post(r3, r4))); + TEST_INSTRUCTION("C415A3F4", vld2_16(d1.at(3), d2.at(3), ptr_post(r3, r4))); + TEST_INSTRUCTION("0D15A3F4", vld2_16(d1.at(0), d2.at(0), ptr_post(r3, 4))); + TEST_INSTRUCTION("4D15A3F4", vld2_16(d1.at(1), d2.at(1), ptr_post(r3, 4))); + TEST_INSTRUCTION("8D15A3F4", vld2_16(d1.at(2), d2.at(2), ptr_post(r3, 4))); + TEST_INSTRUCTION("CD15A3F4", vld2_16(d1.at(3), d2.at(3), ptr_post(r3, 4))); + TEST_INSTRUCTION("0419A3F4", vld2_32(d1.at(0), d2.at(0), ptr_post(r3, r4))); + TEST_INSTRUCTION("8419A3F4", vld2_32(d1.at(1), d2.at(1), ptr_post(r3, r4))); + TEST_INSTRUCTION("0D19A3F4", vld2_32(d1.at(0), d2.at(0), ptr_post(r3, 8))); + TEST_INSTRUCTION("8D19A3F4", vld2_32(d1.at(1), d2.at(1), ptr_post(r3, 8))); + TEST_INSTRUCTION("0419A3F4", vld2_32(d1.at(0), d2.at(0), ptr_post(r3, r4))); + TEST_INSTRUCTION("8419A3F4", vld2_32(d1.at(1), d2.at(1), ptr_post(r3, r4))); + TEST_INSTRUCTION("0D19A3F4", vld2_32(d1.at(0), d2.at(0), ptr_post(r3, 8))); + TEST_INSTRUCTION("8D19A3F4", vld2_32(d1.at(1), d2.at(1), ptr_post(r3, 8))); + TEST_INSTRUCTION("441DA3F4", vld2r_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841DA3F4", vld2r_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041DA3F4", vld2r_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1DA3F4", vld2r_16(d1, d2, ptr_post(r3, 4))); + TEST_INSTRUCTION("8D1DA3F4", vld2r_32(d1, d2, ptr_post(r3, 8))); + TEST_INSTRUCTION("0D1DA3F4", vld2r_8(d1, d2, ptr_post(r3, 2))); + TEST_INSTRUCTION("441DA3F4", vld2r_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841DA3F4", vld2r_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041DA3F4", vld2r_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1DA3F4", vld2r_16(d1, d2, ptr_post(r3, 4))); + TEST_INSTRUCTION("8D1DA3F4", vld2r_32(d1, d2, ptr_post(r3, 8))); + TEST_INSTRUCTION("0D1DA3F4", vld2r_8(d1, d2, ptr_post(r3, 2))); + TEST_INSTRUCTION("451424F4", vld3_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851424F4", vld3_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051424F4", vld3_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1424F4", vld3_16(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("8D1424F4", vld3_32(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0D1424F4", vld3_8(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("451424F4", vld3_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851424F4", vld3_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051424F4", vld3_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1424F4", vld3_16(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("8D1424F4", vld3_32(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0D1424F4", vld3_8(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0512A4F4", vld3_8(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, r5))); + TEST_INSTRUCTION("2512A4F4", vld3_8(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, r5))); + TEST_INSTRUCTION("4512A4F4", vld3_8(d1.at(2), d2.at(2), d3.at(2), ptr_post(r4, r5))); + TEST_INSTRUCTION("6512A4F4", vld3_8(d1.at(3), d2.at(3), d3.at(3), ptr_post(r4, r5))); + TEST_INSTRUCTION("8512A4F4", vld3_8(d1.at(4), d2.at(4), d3.at(4), ptr_post(r4, r5))); + TEST_INSTRUCTION("A512A4F4", vld3_8(d1.at(5), d2.at(5), d3.at(5), ptr_post(r4, r5))); + TEST_INSTRUCTION("C512A4F4", vld3_8(d1.at(6), d2.at(6), d3.at(6), ptr_post(r4, r5))); + TEST_INSTRUCTION("E512A4F4", vld3_8(d1.at(7), d2.at(7), d3.at(7), ptr_post(r4, r5))); + TEST_INSTRUCTION("0D12A4F4", vld3_8(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, 3))); + TEST_INSTRUCTION("2D12A4F4", vld3_8(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, 3))); + TEST_INSTRUCTION("4D12A4F4", vld3_8(d1.at(2), d2.at(2), d3.at(2), ptr_post(r4, 3))); + TEST_INSTRUCTION("6D12A4F4", vld3_8(d1.at(3), d2.at(3), d3.at(3), ptr_post(r4, 3))); + TEST_INSTRUCTION("8D12A4F4", vld3_8(d1.at(4), d2.at(4), d3.at(4), ptr_post(r4, 3))); + TEST_INSTRUCTION("AD12A4F4", vld3_8(d1.at(5), d2.at(5), d3.at(5), ptr_post(r4, 3))); + TEST_INSTRUCTION("CD12A4F4", vld3_8(d1.at(6), d2.at(6), d3.at(6), ptr_post(r4, 3))); + TEST_INSTRUCTION("ED12A4F4", vld3_8(d1.at(7), d2.at(7), d3.at(7), ptr_post(r4, 3))); + TEST_INSTRUCTION("0516A4F4", vld3_16(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, r5))); + TEST_INSTRUCTION("4516A4F4", vld3_16(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, r5))); + TEST_INSTRUCTION("8516A4F4", vld3_16(d1.at(2), d2.at(2), d3.at(2), ptr_post(r4, r5))); + TEST_INSTRUCTION("C516A4F4", vld3_16(d1.at(3), d2.at(3), d3.at(3), ptr_post(r4, r5))); + TEST_INSTRUCTION("0D16A4F4", vld3_16(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, 6))); + TEST_INSTRUCTION("4D16A4F4", vld3_16(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, 6))); + TEST_INSTRUCTION("8D16A4F4", vld3_16(d1.at(2), d2.at(2), d3.at(2), ptr_post(r4, 6))); + TEST_INSTRUCTION("CD16A4F4", vld3_16(d1.at(3), d2.at(3), d3.at(3), ptr_post(r4, 6))); + TEST_INSTRUCTION("0516A4F4", vld3_16(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, r5))); + TEST_INSTRUCTION("4516A4F4", vld3_16(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, r5))); + TEST_INSTRUCTION("8516A4F4", vld3_16(d1.at(2), d2.at(2), d3.at(2), ptr_post(r4, r5))); + TEST_INSTRUCTION("C516A4F4", vld3_16(d1.at(3), d2.at(3), d3.at(3), ptr_post(r4, r5))); + TEST_INSTRUCTION("0D16A4F4", vld3_16(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, 6))); + TEST_INSTRUCTION("4D16A4F4", vld3_16(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, 6))); + TEST_INSTRUCTION("8D16A4F4", vld3_16(d1.at(2), d2.at(2), d3.at(2), ptr_post(r4, 6))); + TEST_INSTRUCTION("CD16A4F4", vld3_16(d1.at(3), d2.at(3), d3.at(3), ptr_post(r4, 6))); + TEST_INSTRUCTION("051AA4F4", vld3_32(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, r5))); + TEST_INSTRUCTION("851AA4F4", vld3_32(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, r5))); + TEST_INSTRUCTION("0D1AA4F4", vld3_32(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, 12))); + TEST_INSTRUCTION("8D1AA4F4", vld3_32(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, 12))); + TEST_INSTRUCTION("051AA4F4", vld3_32(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, r5))); + TEST_INSTRUCTION("851AA4F4", vld3_32(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, r5))); + TEST_INSTRUCTION("0D1AA4F4", vld3_32(d1.at(0), d2.at(0), d3.at(0), ptr_post(r4, 12))); + TEST_INSTRUCTION("8D1AA4F4", vld3_32(d1.at(1), d2.at(1), d3.at(1), ptr_post(r4, 12))); + TEST_INSTRUCTION("451EA4F4", vld3r_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851EA4F4", vld3r_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051EA4F4", vld3r_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1EA4F4", vld3r_16(d1, d2, d3, ptr_post(r4, 6))); + TEST_INSTRUCTION("8D1EA4F4", vld3r_32(d1, d2, d3, ptr_post(r4, 12))); + TEST_INSTRUCTION("0D1EA4F4", vld3r_8(d1, d2, d3, ptr_post(r4, 3))); + TEST_INSTRUCTION("451EA4F4", vld3r_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851EA4F4", vld3r_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051EA4F4", vld3r_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1EA4F4", vld3r_16(d1, d2, d3, ptr_post(r4, 6))); + TEST_INSTRUCTION("8D1EA4F4", vld3r_32(d1, d2, d3, ptr_post(r4, 12))); + TEST_INSTRUCTION("0D1EA4F4", vld3r_8(d1, d2, d3, ptr_post(r4, 3))); + TEST_INSTRUCTION("461025F4", vld4_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861025F4", vld4_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061025F4", vld4_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1025F4", vld4_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1025F4", vld4_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1025F4", vld4_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("461025F4", vld4_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861025F4", vld4_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061025F4", vld4_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1025F4", vld4_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1025F4", vld4_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1025F4", vld4_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0613A5F4", vld4_8(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, r6))); + TEST_INSTRUCTION("2613A5F4", vld4_8(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, r6))); + TEST_INSTRUCTION("4613A5F4", vld4_8(d1.at(2), d2.at(2), d3.at(2), d4.at(2), ptr_post(r5, r6))); + TEST_INSTRUCTION("6613A5F4", vld4_8(d1.at(3), d2.at(3), d3.at(3), d4.at(3), ptr_post(r5, r6))); + TEST_INSTRUCTION("8613A5F4", vld4_8(d1.at(4), d2.at(4), d3.at(4), d4.at(4), ptr_post(r5, r6))); + TEST_INSTRUCTION("A613A5F4", vld4_8(d1.at(5), d2.at(5), d3.at(5), d4.at(5), ptr_post(r5, r6))); + TEST_INSTRUCTION("C613A5F4", vld4_8(d1.at(6), d2.at(6), d3.at(6), d4.at(6), ptr_post(r5, r6))); + TEST_INSTRUCTION("E613A5F4", vld4_8(d1.at(7), d2.at(7), d3.at(7), d4.at(7), ptr_post(r5, r6))); + TEST_INSTRUCTION("0D13A5F4", vld4_8(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, 4))); + TEST_INSTRUCTION("2D13A5F4", vld4_8(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, 4))); + TEST_INSTRUCTION("4D13A5F4", vld4_8(d1.at(2), d2.at(2), d3.at(2), d4.at(2), ptr_post(r5, 4))); + TEST_INSTRUCTION("6D13A5F4", vld4_8(d1.at(3), d2.at(3), d3.at(3), d4.at(3), ptr_post(r5, 4))); + TEST_INSTRUCTION("8D13A5F4", vld4_8(d1.at(4), d2.at(4), d3.at(4), d4.at(4), ptr_post(r5, 4))); + TEST_INSTRUCTION("AD13A5F4", vld4_8(d1.at(5), d2.at(5), d3.at(5), d4.at(5), ptr_post(r5, 4))); + TEST_INSTRUCTION("CD13A5F4", vld4_8(d1.at(6), d2.at(6), d3.at(6), d4.at(6), ptr_post(r5, 4))); + TEST_INSTRUCTION("ED13A5F4", vld4_8(d1.at(7), d2.at(7), d3.at(7), d4.at(7), ptr_post(r5, 4))); + TEST_INSTRUCTION("0617A5F4", vld4_16(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, r6))); + TEST_INSTRUCTION("4617A5F4", vld4_16(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, r6))); + TEST_INSTRUCTION("8617A5F4", vld4_16(d1.at(2), d2.at(2), d3.at(2), d4.at(2), ptr_post(r5, r6))); + TEST_INSTRUCTION("C617A5F4", vld4_16(d1.at(3), d2.at(3), d3.at(3), d4.at(3), ptr_post(r5, r6))); + TEST_INSTRUCTION("0D17A5F4", vld4_16(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, 8))); + TEST_INSTRUCTION("4D17A5F4", vld4_16(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, 8))); + TEST_INSTRUCTION("8D17A5F4", vld4_16(d1.at(2), d2.at(2), d3.at(2), d4.at(2), ptr_post(r5, 8))); + TEST_INSTRUCTION("CD17A5F4", vld4_16(d1.at(3), d2.at(3), d3.at(3), d4.at(3), ptr_post(r5, 8))); + TEST_INSTRUCTION("0617A5F4", vld4_16(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, r6))); + TEST_INSTRUCTION("4617A5F4", vld4_16(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, r6))); + TEST_INSTRUCTION("8617A5F4", vld4_16(d1.at(2), d2.at(2), d3.at(2), d4.at(2), ptr_post(r5, r6))); + TEST_INSTRUCTION("C617A5F4", vld4_16(d1.at(3), d2.at(3), d3.at(3), d4.at(3), ptr_post(r5, r6))); + TEST_INSTRUCTION("0D17A5F4", vld4_16(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, 8))); + TEST_INSTRUCTION("4D17A5F4", vld4_16(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, 8))); + TEST_INSTRUCTION("8D17A5F4", vld4_16(d1.at(2), d2.at(2), d3.at(2), d4.at(2), ptr_post(r5, 8))); + TEST_INSTRUCTION("CD17A5F4", vld4_16(d1.at(3), d2.at(3), d3.at(3), d4.at(3), ptr_post(r5, 8))); + TEST_INSTRUCTION("061BA5F4", vld4_32(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, r6))); + TEST_INSTRUCTION("861BA5F4", vld4_32(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, r6))); + TEST_INSTRUCTION("0D1BA5F4", vld4_32(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, 16))); + TEST_INSTRUCTION("8D1BA5F4", vld4_32(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, 16))); + TEST_INSTRUCTION("061BA5F4", vld4_32(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, r6))); + TEST_INSTRUCTION("861BA5F4", vld4_32(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, r6))); + TEST_INSTRUCTION("0D1BA5F4", vld4_32(d1.at(0), d2.at(0), d3.at(0), d4.at(0), ptr_post(r5, 16))); + TEST_INSTRUCTION("8D1BA5F4", vld4_32(d1.at(1), d2.at(1), d3.at(1), d4.at(1), ptr_post(r5, 16))); + TEST_INSTRUCTION("461FA5F4", vld4r_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861FA5F4", vld4r_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061FA5F4", vld4r_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1FA5F4", vld4r_16(d1, d2, d3, d4, ptr_post(r5, 8))); + TEST_INSTRUCTION("8D1FA5F4", vld4r_32(d1, d2, d3, d4, ptr_post(r5, 16))); + TEST_INSTRUCTION("0D1FA5F4", vld4r_8(d1, d2, d3, d4, ptr_post(r5, 4))); + TEST_INSTRUCTION("461FA5F4", vld4r_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861FA5F4", vld4r_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061FA5F4", vld4r_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1FA5F4", vld4r_16(d1, d2, d3, d4, ptr_post(r5, 8))); + TEST_INSTRUCTION("8D1FA5F4", vld4r_32(d1, d2, d3, d4, ptr_post(r5, 16))); + TEST_INSTRUCTION("0D1FA5F4", vld4r_8(d1, d2, d3, d4, ptr_post(r5, 4))); + TEST_INSTRUCTION("040A30ED", vldmdb_32(ptr_pre(r0), VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080B30ED", vldmdb_64(ptr_pre(r0), VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("040A91EC", vldmia_32(ptr(r1), VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080B97EC", vldmia_64(ptr(r7), VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("040AB1EC", vldmia_32(ptr_pre(r1), VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080BB7EC", vldmia_64(ptr_pre(r7), VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("0209D2ED", vldr_16(s1, ptr(r2, 4))); + TEST_INSTRUCTION("2009DFED", vldr_16(s1, ptr(pc, 64))); + TEST_INSTRUCTION("010AD2ED", vldr_32(s1, ptr(r2, 4))); + TEST_INSTRUCTION("140ADFED", vldr_32(s1, ptr(pc, 80))); + TEST_INSTRUCTION("011B92ED", vldr_64(d1, ptr(r2, 4))); + TEST_INSTRUCTION("191B9FED", vldr_64(d1, ptr(pc, 100))); + TEST_INSTRUCTION("031F12F2", vmax_f16(d1, d2, d3)); + TEST_INSTRUCTION("031F02F2", vmax_f32(d1, d2, d3)); + TEST_INSTRUCTION("462F14F2", vmax_f16(q1, q2, q3)); + TEST_INSTRUCTION("462F04F2", vmax_f32(q1, q2, q3)); + TEST_INSTRUCTION("031612F2", vmax_s16(d1, d2, d3)); + TEST_INSTRUCTION("031622F2", vmax_s32(d1, d2, d3)); + TEST_INSTRUCTION("031602F2", vmax_s8(d1, d2, d3)); + TEST_INSTRUCTION("031612F3", vmax_u16(d1, d2, d3)); + TEST_INSTRUCTION("031622F3", vmax_u32(d1, d2, d3)); + TEST_INSTRUCTION("031602F3", vmax_u8(d1, d2, d3)); + TEST_INSTRUCTION("462614F2", vmax_s16(q1, q2, q3)); + TEST_INSTRUCTION("462624F2", vmax_s32(q1, q2, q3)); + TEST_INSTRUCTION("462604F2", vmax_s8(q1, q2, q3)); + TEST_INSTRUCTION("462614F3", vmax_u16(q1, q2, q3)); + TEST_INSTRUCTION("462624F3", vmax_u32(q1, q2, q3)); + TEST_INSTRUCTION("462604F3", vmax_u8(q1, q2, q3)); + TEST_INSTRUCTION("2109C1FE", vmaxnm_f16(s1, s2, s3)); + TEST_INSTRUCTION("210AC1FE", vmaxnm_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B82FE", vmaxnm_f64(d1, d2, d3)); + TEST_INSTRUCTION("131F12F3", vmaxnm_f16(d1, d2, d3)); + TEST_INSTRUCTION("131F02F3", vmaxnm_f32(d1, d2, d3)); + TEST_INSTRUCTION("562F14F3", vmaxnm_f16(q1, q2, q3)); + TEST_INSTRUCTION("562F04F3", vmaxnm_f32(q1, q2, q3)); + TEST_INSTRUCTION("031F32F2", vmin_f16(d1, d2, d3)); + TEST_INSTRUCTION("031F22F2", vmin_f32(d1, d2, d3)); + TEST_INSTRUCTION("462F34F2", vmin_f16(q1, q2, q3)); + TEST_INSTRUCTION("462F24F2", vmin_f32(q1, q2, q3)); + TEST_INSTRUCTION("131612F2", vmin_s16(d1, d2, d3)); + TEST_INSTRUCTION("131622F2", vmin_s32(d1, d2, d3)); + TEST_INSTRUCTION("131602F2", vmin_s8(d1, d2, d3)); + TEST_INSTRUCTION("131612F3", vmin_u16(d1, d2, d3)); + TEST_INSTRUCTION("131622F3", vmin_u32(d1, d2, d3)); + TEST_INSTRUCTION("131602F3", vmin_u8(d1, d2, d3)); + TEST_INSTRUCTION("562614F2", vmin_s16(q1, q2, q3)); + TEST_INSTRUCTION("562624F2", vmin_s32(q1, q2, q3)); + TEST_INSTRUCTION("562604F2", vmin_s8(q1, q2, q3)); + TEST_INSTRUCTION("562614F3", vmin_u16(q1, q2, q3)); + TEST_INSTRUCTION("562624F3", vmin_u32(q1, q2, q3)); + TEST_INSTRUCTION("562604F3", vmin_u8(q1, q2, q3)); + TEST_INSTRUCTION("6109C1FE", vminnm_f16(s1, s2, s3)); + TEST_INSTRUCTION("610AC1FE", vminnm_f32(s1, s2, s3)); + TEST_INSTRUCTION("431B82FE", vminnm_f64(d1, d2, d3)); + TEST_INSTRUCTION("131F32F3", vminnm_f16(d1, d2, d3)); + TEST_INSTRUCTION("131F22F3", vminnm_f32(d1, d2, d3)); + TEST_INSTRUCTION("562F34F3", vminnm_f16(q1, q2, q3)); + TEST_INSTRUCTION("562F24F3", vminnm_f32(q1, q2, q3)); + TEST_INSTRUCTION("210941EE", vmla_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A41EE", vmla_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B02EE", vmla_f64(d1, d2, d3)); + TEST_INSTRUCTION("131D12F2", vmla_f16(d1, d2, d3)); + TEST_INSTRUCTION("131D02F2", vmla_f32(d1, d2, d3)); + TEST_INSTRUCTION("562D14F2", vmla_f16(q1, q2, q3)); + TEST_INSTRUCTION("562D04F2", vmla_f32(q1, q2, q3)); + TEST_INSTRUCTION("031912F2", vmla_s16(d1, d2, d3)); + TEST_INSTRUCTION("031922F2", vmla_s32(d1, d2, d3)); + TEST_INSTRUCTION("031902F2", vmla_s8(d1, d2, d3)); + TEST_INSTRUCTION("031912F2", vmla_u16(d1, d2, d3)); + TEST_INSTRUCTION("031922F2", vmla_u32(d1, d2, d3)); + TEST_INSTRUCTION("031902F2", vmla_u8(d1, d2, d3)); + TEST_INSTRUCTION("462914F2", vmla_s16(q1, q2, q3)); + TEST_INSTRUCTION("462924F2", vmla_s32(q1, q2, q3)); + TEST_INSTRUCTION("462904F2", vmla_s8(q1, q2, q3)); + TEST_INSTRUCTION("462914F2", vmla_u16(q1, q2, q3)); + TEST_INSTRUCTION("462924F2", vmla_u32(q1, q2, q3)); + TEST_INSTRUCTION("462904F2", vmla_u8(q1, q2, q3)); + TEST_INSTRUCTION("431192F2", vmla_f16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1192F2", vmla_f16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631192F2", vmla_f16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1192F2", vmla_f16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432194F3", vmla_f16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2194F3", vmla_f16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632194F3", vmla_f16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2194F3", vmla_f16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("4311A2F2", vmla_f32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6311A2F2", vmla_f32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4321A4F3", vmla_f32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6321A4F3", vmla_f32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("431092F2", vmla_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1092F2", vmla_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631092F2", vmla_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1092F2", vmla_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("431092F2", vmla_u16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1092F2", vmla_u16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631092F2", vmla_u16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1092F2", vmla_u16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432094F3", vmla_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2094F3", vmla_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632094F3", vmla_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2094F3", vmla_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("432094F3", vmla_u16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2094F3", vmla_u16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632094F3", vmla_u16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2094F3", vmla_u16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("4310A2F2", vmla_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6310A2F2", vmla_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4310A2F2", vmla_u32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6310A2F2", vmla_u32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4320A4F3", vmla_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6320A4F3", vmla_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("4320A4F3", vmla_u32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6320A4F3", vmla_u32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("032892F2", vmlal_s16(q1, d2, d3)); + TEST_INSTRUCTION("0328A2F2", vmlal_s32(q1, d2, d3)); + TEST_INSTRUCTION("032882F2", vmlal_s8(q1, d2, d3)); + TEST_INSTRUCTION("032892F3", vmlal_u16(q1, d2, d3)); + TEST_INSTRUCTION("0328A2F3", vmlal_u32(q1, d2, d3)); + TEST_INSTRUCTION("032882F3", vmlal_u8(q1, d2, d3)); + TEST_INSTRUCTION("432292F2", vmlal_s16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2292F2", vmlal_s16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632292F2", vmlal_s16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2292F2", vmlal_s16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("432292F3", vmlal_u16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2292F3", vmlal_u16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632292F3", vmlal_u16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2292F3", vmlal_u16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("4322A2F2", vmlal_s32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("6322A2F2", vmlal_s32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("4322A2F3", vmlal_u32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("6322A2F3", vmlal_u32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("610941EE", vmls_f16(s1, s2, s3)); + TEST_INSTRUCTION("610A41EE", vmls_f32(s1, s2, s3)); + TEST_INSTRUCTION("431B02EE", vmls_f64(d1, d2, d3)); + TEST_INSTRUCTION("131D32F2", vmls_f16(d1, d2, d3)); + TEST_INSTRUCTION("131D22F2", vmls_f32(d1, d2, d3)); + TEST_INSTRUCTION("562D34F2", vmls_f16(q1, q2, q3)); + TEST_INSTRUCTION("562D24F2", vmls_f32(q1, q2, q3)); + TEST_INSTRUCTION("031912F3", vmls_s16(d1, d2, d3)); + TEST_INSTRUCTION("031922F3", vmls_s32(d1, d2, d3)); + TEST_INSTRUCTION("031902F3", vmls_s8(d1, d2, d3)); + TEST_INSTRUCTION("031912F3", vmls_u16(d1, d2, d3)); + TEST_INSTRUCTION("031922F3", vmls_u32(d1, d2, d3)); + TEST_INSTRUCTION("031902F3", vmls_u8(d1, d2, d3)); + TEST_INSTRUCTION("462914F3", vmls_s16(q1, q2, q3)); + TEST_INSTRUCTION("462924F3", vmls_s32(q1, q2, q3)); + TEST_INSTRUCTION("462904F3", vmls_s8(q1, q2, q3)); + TEST_INSTRUCTION("462914F3", vmls_u16(q1, q2, q3)); + TEST_INSTRUCTION("462924F3", vmls_u32(q1, q2, q3)); + TEST_INSTRUCTION("462904F3", vmls_u8(q1, q2, q3)); + TEST_INSTRUCTION("431592F2", vmls_f16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1592F2", vmls_f16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631592F2", vmls_f16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1592F2", vmls_f16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432594F3", vmls_f16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2594F3", vmls_f16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632594F3", vmls_f16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2594F3", vmls_f16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("4315A2F2", vmls_f32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6315A2F2", vmls_f32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4325A4F3", vmls_f32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6325A4F3", vmls_f32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("431492F2", vmls_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1492F2", vmls_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631492F2", vmls_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1492F2", vmls_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("431492F2", vmls_u16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1492F2", vmls_u16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631492F2", vmls_u16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1492F2", vmls_u16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432494F3", vmls_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2494F3", vmls_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632494F3", vmls_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2494F3", vmls_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("432494F3", vmls_u16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2494F3", vmls_u16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632494F3", vmls_u16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2494F3", vmls_u16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("4314A2F2", vmls_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6314A2F2", vmls_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4314A2F2", vmls_u32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6314A2F2", vmls_u32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4324A4F3", vmls_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6324A4F3", vmls_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("4324A4F3", vmls_u32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6324A4F3", vmls_u32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("032A92F2", vmlsl_s16(q1, d2, d3)); + TEST_INSTRUCTION("032AA2F2", vmlsl_s32(q1, d2, d3)); + TEST_INSTRUCTION("032A82F2", vmlsl_s8(q1, d2, d3)); + TEST_INSTRUCTION("032A92F3", vmlsl_u16(q1, d2, d3)); + TEST_INSTRUCTION("032AA2F3", vmlsl_u32(q1, d2, d3)); + TEST_INSTRUCTION("032A82F3", vmlsl_u8(q1, d2, d3)); + TEST_INSTRUCTION("432692F2", vmlsl_s16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2692F2", vmlsl_s16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632692F2", vmlsl_s16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2692F2", vmlsl_s16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("432692F3", vmlsl_u16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2692F3", vmlsl_u16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632692F3", vmlsl_u16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2692F3", vmlsl_u16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("4326A2F2", vmlsl_s32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("6326A2F2", vmlsl_s32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("4326A2F3", vmlsl_u32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("6326A2F3", vmlsl_u32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("462C04FC", vmmla_bf16(q1, q2, q3)); + TEST_INSTRUCTION("101911EE", vmov_f16(r1, s2)); + TEST_INSTRUCTION("902900EE", vmov_f16(s1, r2)); + TEST_INSTRUCTION("101A11EE", vmov(r1, s2)); + TEST_INSTRUCTION("902A00EE", vmov(s1, r2)); + TEST_INSTRUCTION("311A52EC", vmov(r1, r2, s3, s4)); + TEST_INSTRUCTION("303A44EC", vmov(s1, s2, r3, r4)); + TEST_INSTRUCTION("131B52EC", vmov(r1, r2, d3)); + TEST_INSTRUCTION("112B43EC", vmov(d1, r2, r3)); + TEST_INSTRUCTION("410AF0EE", vmov_f32(s1, s2)); + TEST_INSTRUCTION("421BB0EE", vmov_f64(d1, d2)); + TEST_INSTRUCTION("102B41EE", vmov_s8(d1.at(0), r2)); + TEST_INSTRUCTION("302B41EE", vmov_s8(d1.at(1), r2)); + TEST_INSTRUCTION("502B41EE", vmov_s8(d1.at(2), r2)); + TEST_INSTRUCTION("702B41EE", vmov_s8(d1.at(3), r2)); + TEST_INSTRUCTION("102B61EE", vmov_s8(d1.at(4), r2)); + TEST_INSTRUCTION("302B61EE", vmov_s8(d1.at(5), r2)); + TEST_INSTRUCTION("502B61EE", vmov_s8(d1.at(6), r2)); + TEST_INSTRUCTION("702B61EE", vmov_s8(d1.at(7), r2)); + TEST_INSTRUCTION("102B41EE", vmov_u8(d1.at(0), r2)); + TEST_INSTRUCTION("302B41EE", vmov_u8(d1.at(1), r2)); + TEST_INSTRUCTION("502B41EE", vmov_u8(d1.at(2), r2)); + TEST_INSTRUCTION("702B41EE", vmov_u8(d1.at(3), r2)); + TEST_INSTRUCTION("102B61EE", vmov_u8(d1.at(4), r2)); + TEST_INSTRUCTION("302B61EE", vmov_u8(d1.at(5), r2)); + TEST_INSTRUCTION("502B61EE", vmov_u8(d1.at(6), r2)); + TEST_INSTRUCTION("702B61EE", vmov_u8(d1.at(7), r2)); + TEST_INSTRUCTION("302B01EE", vmov_s16(d1.at(0), r2)); + TEST_INSTRUCTION("702B01EE", vmov_s16(d1.at(1), r2)); + TEST_INSTRUCTION("302B21EE", vmov_s16(d1.at(2), r2)); + TEST_INSTRUCTION("702B21EE", vmov_s16(d1.at(3), r2)); + TEST_INSTRUCTION("302B01EE", vmov_u16(d1.at(0), r2)); + TEST_INSTRUCTION("702B01EE", vmov_u16(d1.at(1), r2)); + TEST_INSTRUCTION("302B21EE", vmov_u16(d1.at(2), r2)); + TEST_INSTRUCTION("702B21EE", vmov_u16(d1.at(3), r2)); + TEST_INSTRUCTION("102B01EE", vmov_s32(d1.at(0), r2)); + TEST_INSTRUCTION("102B21EE", vmov_s32(d1.at(1), r2)); + TEST_INSTRUCTION("102B01EE", vmov_u32(d1.at(0), r2)); + TEST_INSTRUCTION("102B21EE", vmov_u32(d1.at(1), r2)); + TEST_INSTRUCTION("101B52EE", vmov_s8(r1, d2.at(0))); + TEST_INSTRUCTION("301B52EE", vmov_s8(r1, d2.at(1))); + TEST_INSTRUCTION("501B52EE", vmov_s8(r1, d2.at(2))); + TEST_INSTRUCTION("701B52EE", vmov_s8(r1, d2.at(3))); + TEST_INSTRUCTION("101B72EE", vmov_s8(r1, d2.at(4))); + TEST_INSTRUCTION("301B72EE", vmov_s8(r1, d2.at(5))); + TEST_INSTRUCTION("501B72EE", vmov_s8(r1, d2.at(6))); + TEST_INSTRUCTION("701B72EE", vmov_s8(r1, d2.at(7))); + TEST_INSTRUCTION("101BD2EE", vmov_u8(r1, d2.at(0))); + TEST_INSTRUCTION("301BD2EE", vmov_u8(r1, d2.at(1))); + TEST_INSTRUCTION("501BD2EE", vmov_u8(r1, d2.at(2))); + TEST_INSTRUCTION("701BD2EE", vmov_u8(r1, d2.at(3))); + TEST_INSTRUCTION("101BF2EE", vmov_u8(r1, d2.at(4))); + TEST_INSTRUCTION("301BF2EE", vmov_u8(r1, d2.at(5))); + TEST_INSTRUCTION("501BF2EE", vmov_u8(r1, d2.at(6))); + TEST_INSTRUCTION("701BF2EE", vmov_u8(r1, d2.at(7))); + TEST_INSTRUCTION("301B12EE", vmov_s16(r1, d2.at(0))); + TEST_INSTRUCTION("701B12EE", vmov_s16(r1, d2.at(1))); + TEST_INSTRUCTION("301B32EE", vmov_s16(r1, d2.at(2))); + TEST_INSTRUCTION("701B32EE", vmov_s16(r1, d2.at(3))); + TEST_INSTRUCTION("301B92EE", vmov_u16(r1, d2.at(0))); + TEST_INSTRUCTION("701B92EE", vmov_u16(r1, d2.at(1))); + TEST_INSTRUCTION("301BB2EE", vmov_u16(r1, d2.at(2))); + TEST_INSTRUCTION("701BB2EE", vmov_u16(r1, d2.at(3))); + TEST_INSTRUCTION("101B12EE", vmov_s32(r1, d2.at(0))); + TEST_INSTRUCTION("101B32EE", vmov_s32(r1, d2.at(1))); + TEST_INSTRUCTION("101B12EE", vmov_u32(r1, d2.at(0))); + TEST_INSTRUCTION("101B32EE", vmov_u32(r1, d2.at(1))); + TEST_INSTRUCTION("121122F2", vmov(d1, d2)); + TEST_INSTRUCTION("542124F2", vmov(q1, q2)); + TEST_INSTRUCTION("1F1881F2", vmov_s16(d1, 0x1F)); + TEST_INSTRUCTION("101880F3", vmov_s16(d1, 0x80)); + TEST_INSTRUCTION("1F1887F3", vmov_s16(d1, 0xFF)); + TEST_INSTRUCTION("1F1A81F2", vmov_s16(d1, 0x1F00)); + TEST_INSTRUCTION("1F1A87F3", vmov_s16(d1, 0xFF00)); + TEST_INSTRUCTION("1F1081F2", vmov_s32(d1, 0x1F)); + TEST_INSTRUCTION("101080F3", vmov_s32(d1, 0x80)); + TEST_INSTRUCTION("1F1087F3", vmov_s32(d1, 0xFF)); + TEST_INSTRUCTION("1F1281F2", vmov_s32(d1, 0x1F00)); + TEST_INSTRUCTION("1F1287F3", vmov_s32(d1, 0xFF00)); + TEST_INSTRUCTION("1F1481F2", vmov_s32(d1, 0x1F0000)); + TEST_INSTRUCTION("1F1487F3", vmov_s32(d1, 0xFF0000)); + TEST_INSTRUCTION("1F1687F3", vmov_s32(d1, 0xFF000000)); + TEST_INSTRUCTION("1F1C87F3", vmov_s32(d1, 0x0000FFFF)); + TEST_INSTRUCTION("1F1D87F3", vmov_s32(d1, 0x00FFFFFF)); + TEST_INSTRUCTION("301E82F3", vmov_s64(d1, 0xFF00FF0000000000)); + TEST_INSTRUCTION("3F1E80F2", vmov_s64(d1, 0x00000000FFFFFFFF)); + TEST_INSTRUCTION("1F1881F2", vmov_u16(d1, 0x1F)); + TEST_INSTRUCTION("101880F3", vmov_u16(d1, 0x80)); + TEST_INSTRUCTION("1F1887F3", vmov_u16(d1, 0xFF)); + TEST_INSTRUCTION("1F1A81F2", vmov_u16(d1, 0x1F00)); + TEST_INSTRUCTION("1F1A87F3", vmov_u16(d1, 0xFF00)); + TEST_INSTRUCTION("1F1081F2", vmov_u32(d1, 0x1F)); + TEST_INSTRUCTION("101080F3", vmov_u32(d1, 0x80)); + TEST_INSTRUCTION("1F1087F3", vmov_u32(d1, 0xFF)); + TEST_INSTRUCTION("1F1281F2", vmov_u32(d1, 0x1F00)); + TEST_INSTRUCTION("1F1287F3", vmov_u32(d1, 0xFF00)); + TEST_INSTRUCTION("1F1481F2", vmov_u32(d1, 0x1F0000)); + TEST_INSTRUCTION("1F1487F3", vmov_u32(d1, 0xFF0000)); + TEST_INSTRUCTION("1F1687F3", vmov_u32(d1, 0xFF000000)); + TEST_INSTRUCTION("1F1C87F3", vmov_u32(d1, 0x0000FFFF)); + TEST_INSTRUCTION("1F1D87F3", vmov_u32(d1, 0x00FFFFFF)); + TEST_INSTRUCTION("301E82F3", vmov_u64(d1, 0xFF00FF0000000000)); + TEST_INSTRUCTION("3F1E80F2", vmov_u64(d1, 0x00000000FFFFFFFF)); + TEST_INSTRUCTION("5F2881F2", vmov_s16(q1, 0x1F)); + TEST_INSTRUCTION("502880F3", vmov_s16(q1, 0x80)); + TEST_INSTRUCTION("5F2887F3", vmov_s16(q1, 0xFF)); + TEST_INSTRUCTION("5F2A81F2", vmov_s16(q1, 0x1F00)); + TEST_INSTRUCTION("5F2A87F3", vmov_s16(q1, 0xFF00)); + TEST_INSTRUCTION("5F2081F2", vmov_s32(q1, 0x1F)); + TEST_INSTRUCTION("502080F3", vmov_s32(q1, 0x80)); + TEST_INSTRUCTION("5F2087F3", vmov_s32(q1, 0xFF)); + TEST_INSTRUCTION("5F2281F2", vmov_s32(q1, 0x1F00)); + TEST_INSTRUCTION("5F2287F3", vmov_s32(q1, 0xFF00)); + TEST_INSTRUCTION("5F2481F2", vmov_s32(q1, 0x1F0000)); + TEST_INSTRUCTION("5F2487F3", vmov_s32(q1, 0xFF0000)); + TEST_INSTRUCTION("5F2687F3", vmov_s32(q1, 0xFF000000)); + TEST_INSTRUCTION("5F2C87F3", vmov_s32(q1, 0x0000FFFF)); + TEST_INSTRUCTION("5F2D87F3", vmov_s32(q1, 0x00FFFFFF)); + TEST_INSTRUCTION("702E82F3", vmov_s64(q1, 0xFF00FF0000000000)); + TEST_INSTRUCTION("7F2E80F2", vmov_s64(q1, 0x00000000FFFFFFFF)); + TEST_INSTRUCTION("5F2881F2", vmov_u16(q1, 0x1F)); + TEST_INSTRUCTION("502880F3", vmov_u16(q1, 0x80)); + TEST_INSTRUCTION("5F2887F3", vmov_u16(q1, 0xFF)); + TEST_INSTRUCTION("5F2A81F2", vmov_u16(q1, 0x1F00)); + TEST_INSTRUCTION("5F2A87F3", vmov_u16(q1, 0xFF00)); + TEST_INSTRUCTION("5F2081F2", vmov_u32(q1, 0x1F)); + TEST_INSTRUCTION("502080F3", vmov_u32(q1, 0x80)); + TEST_INSTRUCTION("5F2087F3", vmov_u32(q1, 0xFF)); + TEST_INSTRUCTION("5F2281F2", vmov_u32(q1, 0x1F00)); + TEST_INSTRUCTION("5F2287F3", vmov_u32(q1, 0xFF00)); + TEST_INSTRUCTION("5F2481F2", vmov_u32(q1, 0x1F0000)); + TEST_INSTRUCTION("5F2487F3", vmov_u32(q1, 0xFF0000)); + TEST_INSTRUCTION("5F2687F3", vmov_u32(q1, 0xFF000000)); + TEST_INSTRUCTION("5F2C87F3", vmov_u32(q1, 0x0000FFFF)); + TEST_INSTRUCTION("5F2D87F3", vmov_u32(q1, 0x00FFFFFF)); + TEST_INSTRUCTION("702E82F3", vmov_u64(q1, 0xFF00FF0000000000)); + TEST_INSTRUCTION("7F2E80F2", vmov_u64(q1, 0x00000000FFFFFFFF)); + TEST_INSTRUCTION("122A88F2", vmovl_s8(q1, d2)); + TEST_INSTRUCTION("122A88F3", vmovl_u8(q1, d2)); + TEST_INSTRUCTION("122A90F2", vmovl_s16(q1, d2)); + TEST_INSTRUCTION("122A90F3", vmovl_u16(q1, d2)); + TEST_INSTRUCTION("122AA0F2", vmovl_s32(q1, d2)); + TEST_INSTRUCTION("122AA0F3", vmovl_u32(q1, d2)); + TEST_INSTRUCTION("0412B2F3", vmovn_s16(d1, q2)); + TEST_INSTRUCTION("0412B6F3", vmovn_s32(d1, q2)); + TEST_INSTRUCTION("0412BAF3", vmovn_s64(d1, q2)); + TEST_INSTRUCTION("0412B2F3", vmovn_u16(d1, q2)); + TEST_INSTRUCTION("0412B6F3", vmovn_u32(d1, q2)); + TEST_INSTRUCTION("0412BAF3", vmovn_u64(d1, q2)); + TEST_INSTRUCTION("410AF0FE", vmovx_f16(s1, s2)); + TEST_INSTRUCTION("210961EE", vmul_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A61EE", vmul_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B22EE", vmul_f64(d1, d2, d3)); + TEST_INSTRUCTION("131D12F3", vmul_f16(d1, d2, d3)); + TEST_INSTRUCTION("131D02F3", vmul_f32(d1, d2, d3)); + TEST_INSTRUCTION("562D14F3", vmul_f16(q1, q2, q3)); + TEST_INSTRUCTION("562D04F3", vmul_f32(q1, q2, q3)); + TEST_INSTRUCTION("131902F3", vmul_p8(d1, d2, d3)); + TEST_INSTRUCTION("131912F2", vmul_s16(d1, d2, d3)); + TEST_INSTRUCTION("131922F2", vmul_s32(d1, d2, d3)); + TEST_INSTRUCTION("131902F2", vmul_s8(d1, d2, d3)); + TEST_INSTRUCTION("131912F2", vmul_u16(d1, d2, d3)); + TEST_INSTRUCTION("131922F2", vmul_u32(d1, d2, d3)); + TEST_INSTRUCTION("131902F2", vmul_u8(d1, d2, d3)); + TEST_INSTRUCTION("562904F3", vmul_p8(q1, q2, q3)); + TEST_INSTRUCTION("562914F2", vmul_s16(q1, q2, q3)); + TEST_INSTRUCTION("562924F2", vmul_s32(q1, q2, q3)); + TEST_INSTRUCTION("562904F2", vmul_s8(q1, q2, q3)); + TEST_INSTRUCTION("562914F2", vmul_u16(q1, q2, q3)); + TEST_INSTRUCTION("562924F2", vmul_u32(q1, q2, q3)); + TEST_INSTRUCTION("562904F2", vmul_u8(q1, q2, q3)); + TEST_INSTRUCTION("431992F2", vmul_f16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1992F2", vmul_f16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631992F2", vmul_f16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1992F2", vmul_f16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432994F3", vmul_f16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2994F3", vmul_f16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632994F3", vmul_f16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2994F3", vmul_f16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("4319A2F2", vmul_f32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6319A2F2", vmul_f32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4329A4F3", vmul_f32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6329A4F3", vmul_f32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("431892F2", vmul_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1892F2", vmul_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631892F2", vmul_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1892F2", vmul_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("431892F2", vmul_u16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1892F2", vmul_u16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631892F2", vmul_u16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1892F2", vmul_u16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432894F3", vmul_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2894F3", vmul_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632894F3", vmul_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2894F3", vmul_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("432894F3", vmul_u16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2894F3", vmul_u16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632894F3", vmul_u16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2894F3", vmul_u16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("4318A2F2", vmul_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6318A2F2", vmul_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4318A2F2", vmul_u32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("6318A2F2", vmul_u32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("4328A4F3", vmul_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6328A4F3", vmul_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("4328A4F3", vmul_u32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("6328A4F3", vmul_u32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("032E82F2", vmull_p8(q1, d2, d3)); + TEST_INSTRUCTION("032C92F2", vmull_s16(q1, d2, d3)); + TEST_INSTRUCTION("032CA2F2", vmull_s32(q1, d2, d3)); + TEST_INSTRUCTION("032C82F2", vmull_s8(q1, d2, d3)); + TEST_INSTRUCTION("032C92F3", vmull_u16(q1, d2, d3)); + TEST_INSTRUCTION("032CA2F3", vmull_u32(q1, d2, d3)); + TEST_INSTRUCTION("032C82F3", vmull_u8(q1, d2, d3)); + TEST_INSTRUCTION("032EA2F2", vmull_p64(q1, d2, d3)); + TEST_INSTRUCTION("432A92F2", vmull_s16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2A92F2", vmull_s16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632A92F2", vmull_s16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2A92F2", vmull_s16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("432A92F3", vmull_u16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2A92F3", vmull_u16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632A92F3", vmull_u16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2A92F3", vmull_u16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("432AA2F2", vmull_s32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("632AA2F2", vmull_s32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("432AA2F3", vmull_u32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("632AA2F3", vmull_u32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("8215B0F3", vmvn(d1, d2)); + TEST_INSTRUCTION("C425B0F3", vmvn(q1, q2)); + TEST_INSTRUCTION("4109F1EE", vneg_f16(s1, s2)); + TEST_INSTRUCTION("410AF1EE", vneg_f32(s1, s2)); + TEST_INSTRUCTION("421BB1EE", vneg_f64(d1, d2)); + TEST_INSTRUCTION("8217B5F3", vneg_f16(d1, d2)); + TEST_INSTRUCTION("8217B9F3", vneg_f32(d1, d2)); + TEST_INSTRUCTION("C427B5F3", vneg_f16(q1, q2)); + TEST_INSTRUCTION("C427B9F3", vneg_f32(q1, q2)); + TEST_INSTRUCTION("8213B5F3", vneg_s16(d1, d2)); + TEST_INSTRUCTION("8213B9F3", vneg_s32(d1, d2)); + TEST_INSTRUCTION("8213B1F3", vneg_s8(d1, d2)); + TEST_INSTRUCTION("C423B5F3", vneg_s16(q1, q2)); + TEST_INSTRUCTION("C423B9F3", vneg_s32(q1, q2)); + TEST_INSTRUCTION("C423B1F3", vneg_s8(q1, q2)); + TEST_INSTRUCTION("610951EE", vnmla_f16(s1, s2, s3)); + TEST_INSTRUCTION("610A51EE", vnmla_f32(s1, s2, s3)); + TEST_INSTRUCTION("431B12EE", vnmla_f64(d1, d2, d3)); + TEST_INSTRUCTION("210951EE", vnmls_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A51EE", vnmls_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B12EE", vnmls_f64(d1, d2, d3)); + TEST_INSTRUCTION("610961EE", vnmul_f16(s1, s2, s3)); + TEST_INSTRUCTION("610A61EE", vnmul_f32(s1, s2, s3)); + TEST_INSTRUCTION("431B22EE", vnmul_f64(d1, d2, d3)); + TEST_INSTRUCTION("131132F2", vorn(d1, d2, d3)); + TEST_INSTRUCTION("562134F2", vorn(q1, q2, q3)); + TEST_INSTRUCTION("1F1981F2", vorr_s16(d1, 0x1F)); + TEST_INSTRUCTION("101980F3", vorr_s16(d1, 0x80)); + TEST_INSTRUCTION("1F1987F3", vorr_s16(d1, 0xFF)); + TEST_INSTRUCTION("1F1B81F2", vorr_s16(d1, 0x1F00)); + TEST_INSTRUCTION("1F1B87F3", vorr_s16(d1, 0xFF00)); + TEST_INSTRUCTION("1F1181F2", vorr_s32(d1, 0x1F)); + TEST_INSTRUCTION("101180F3", vorr_s32(d1, 0x80)); + TEST_INSTRUCTION("1F1187F3", vorr_s32(d1, 0xFF)); + TEST_INSTRUCTION("1F1381F2", vorr_s32(d1, 0x1F00)); + TEST_INSTRUCTION("1F1387F3", vorr_s32(d1, 0xFF00)); + TEST_INSTRUCTION("1F1581F2", vorr_s32(d1, 0x1F0000)); + TEST_INSTRUCTION("1F1587F3", vorr_s32(d1, 0xFF0000)); + TEST_INSTRUCTION("1F1787F3", vorr_s32(d1, 0xFF000000)); + TEST_INSTRUCTION("1F1981F2", vorr_u16(d1, 0x1F)); + TEST_INSTRUCTION("101980F3", vorr_u16(d1, 0x80)); + TEST_INSTRUCTION("1F1987F3", vorr_u16(d1, 0xFF)); + TEST_INSTRUCTION("1F1B81F2", vorr_u16(d1, 0x1F00)); + TEST_INSTRUCTION("1F1B87F3", vorr_u16(d1, 0xFF00)); + TEST_INSTRUCTION("1F1181F2", vorr_u32(d1, 0x1F)); + TEST_INSTRUCTION("101180F3", vorr_u32(d1, 0x80)); + TEST_INSTRUCTION("1F1187F3", vorr_u32(d1, 0xFF)); + TEST_INSTRUCTION("1F1381F2", vorr_u32(d1, 0x1F00)); + TEST_INSTRUCTION("1F1387F3", vorr_u32(d1, 0xFF00)); + TEST_INSTRUCTION("1F1581F2", vorr_u32(d1, 0x1F0000)); + TEST_INSTRUCTION("1F1587F3", vorr_u32(d1, 0xFF0000)); + TEST_INSTRUCTION("1F1787F3", vorr_u32(d1, 0xFF000000)); + TEST_INSTRUCTION("5F2981F2", vorr_s16(q1, 0x1F)); + TEST_INSTRUCTION("502980F3", vorr_s16(q1, 0x80)); + TEST_INSTRUCTION("5F2987F3", vorr_s16(q1, 0xFF)); + TEST_INSTRUCTION("5F2B81F2", vorr_s16(q1, 0x1F00)); + TEST_INSTRUCTION("5F2B87F3", vorr_s16(q1, 0xFF00)); + TEST_INSTRUCTION("5F2181F2", vorr_s32(q1, 0x1F)); + TEST_INSTRUCTION("502180F3", vorr_s32(q1, 0x80)); + TEST_INSTRUCTION("5F2187F3", vorr_s32(q1, 0xFF)); + TEST_INSTRUCTION("5F2381F2", vorr_s32(q1, 0x1F00)); + TEST_INSTRUCTION("5F2387F3", vorr_s32(q1, 0xFF00)); + TEST_INSTRUCTION("5F2581F2", vorr_s32(q1, 0x1F0000)); + TEST_INSTRUCTION("5F2587F3", vorr_s32(q1, 0xFF0000)); + TEST_INSTRUCTION("5F2787F3", vorr_s32(q1, 0xFF000000)); + TEST_INSTRUCTION("5F2981F2", vorr_u16(q1, 0x1F)); + TEST_INSTRUCTION("502980F3", vorr_u16(q1, 0x80)); + TEST_INSTRUCTION("5F2987F3", vorr_u16(q1, 0xFF)); + TEST_INSTRUCTION("5F2B81F2", vorr_u16(q1, 0x1F00)); + TEST_INSTRUCTION("5F2B87F3", vorr_u16(q1, 0xFF00)); + TEST_INSTRUCTION("5F2181F2", vorr_u32(q1, 0x1F)); + TEST_INSTRUCTION("502180F3", vorr_u32(q1, 0x80)); + TEST_INSTRUCTION("5F2187F3", vorr_u32(q1, 0xFF)); + TEST_INSTRUCTION("5F2381F2", vorr_u32(q1, 0x1F00)); + TEST_INSTRUCTION("5F2387F3", vorr_u32(q1, 0xFF00)); + TEST_INSTRUCTION("5F2581F2", vorr_u32(q1, 0x1F0000)); + TEST_INSTRUCTION("5F2587F3", vorr_u32(q1, 0xFF0000)); + TEST_INSTRUCTION("5F2787F3", vorr_u32(q1, 0xFF000000)); + TEST_INSTRUCTION("131122F2", vorr(d1, d2, d3)); + TEST_INSTRUCTION("562124F2", vorr(q1, q2, q3)); + TEST_INSTRUCTION("0216B4F3", vpadal_s16(d1, d2)); + TEST_INSTRUCTION("0216B8F3", vpadal_s32(d1, d2)); + TEST_INSTRUCTION("0216B0F3", vpadal_s8(d1, d2)); + TEST_INSTRUCTION("8216B4F3", vpadal_u16(d1, d2)); + TEST_INSTRUCTION("8216B8F3", vpadal_u32(d1, d2)); + TEST_INSTRUCTION("8216B0F3", vpadal_u8(d1, d2)); + TEST_INSTRUCTION("4426B4F3", vpadal_s16(q1, q2)); + TEST_INSTRUCTION("4426B8F3", vpadal_s32(q1, q2)); + TEST_INSTRUCTION("4426B0F3", vpadal_s8(q1, q2)); + TEST_INSTRUCTION("C426B4F3", vpadal_u16(q1, q2)); + TEST_INSTRUCTION("C426B8F3", vpadal_u32(q1, q2)); + TEST_INSTRUCTION("C426B0F3", vpadal_u8(q1, q2)); + TEST_INSTRUCTION("031D12F3", vpadd_f16(d1, d2, d3)); + TEST_INSTRUCTION("031D02F3", vpadd_f32(d1, d2, d3)); + TEST_INSTRUCTION("0212B4F3", vpaddl_s16(d1, d2)); + TEST_INSTRUCTION("0212B8F3", vpaddl_s32(d1, d2)); + TEST_INSTRUCTION("0212B0F3", vpaddl_s8(d1, d2)); + TEST_INSTRUCTION("8212B4F3", vpaddl_u16(d1, d2)); + TEST_INSTRUCTION("8212B8F3", vpaddl_u32(d1, d2)); + TEST_INSTRUCTION("8212B0F3", vpaddl_u8(d1, d2)); + TEST_INSTRUCTION("4422B4F3", vpaddl_s16(q1, q2)); + TEST_INSTRUCTION("4422B8F3", vpaddl_s32(q1, q2)); + TEST_INSTRUCTION("4422B0F3", vpaddl_s8(q1, q2)); + TEST_INSTRUCTION("C422B4F3", vpaddl_u16(q1, q2)); + TEST_INSTRUCTION("C422B8F3", vpaddl_u32(q1, q2)); + TEST_INSTRUCTION("C422B0F3", vpaddl_u8(q1, q2)); + TEST_INSTRUCTION("031F12F3", vpmax_f16(d1, d2, d3)); + TEST_INSTRUCTION("031F02F3", vpmax_f32(d1, d2, d3)); + TEST_INSTRUCTION("031A12F2", vpmax_s16(d1, d2, d3)); + TEST_INSTRUCTION("031A22F2", vpmax_s32(d1, d2, d3)); + TEST_INSTRUCTION("031A02F2", vpmax_s8(d1, d2, d3)); + TEST_INSTRUCTION("031A12F3", vpmax_u16(d1, d2, d3)); + TEST_INSTRUCTION("031A22F3", vpmax_u32(d1, d2, d3)); + TEST_INSTRUCTION("031A02F3", vpmax_u8(d1, d2, d3)); + TEST_INSTRUCTION("031F32F3", vpmin_f16(d1, d2, d3)); + TEST_INSTRUCTION("031F22F3", vpmin_f32(d1, d2, d3)); + TEST_INSTRUCTION("131A12F2", vpmin_s16(d1, d2, d3)); + TEST_INSTRUCTION("131A22F2", vpmin_s32(d1, d2, d3)); + TEST_INSTRUCTION("131A02F2", vpmin_s8(d1, d2, d3)); + TEST_INSTRUCTION("131A12F3", vpmin_u16(d1, d2, d3)); + TEST_INSTRUCTION("131A22F3", vpmin_u32(d1, d2, d3)); + TEST_INSTRUCTION("131A02F3", vpmin_u8(d1, d2, d3)); + TEST_INSTRUCTION("040ABDEC", vpop_32(VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080BBDEC", vpop_64(VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("040A2DED", vpush_32(VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080B2DED", vpush_64(VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("0217B4F3", vqabs_s16(d1, d2)); + TEST_INSTRUCTION("0217B8F3", vqabs_s32(d1, d2)); + TEST_INSTRUCTION("0217B0F3", vqabs_s8(d1, d2)); + TEST_INSTRUCTION("4427B4F3", vqabs_s16(q1, q2)); + TEST_INSTRUCTION("4427B8F3", vqabs_s32(q1, q2)); + TEST_INSTRUCTION("4427B0F3", vqabs_s8(q1, q2)); + TEST_INSTRUCTION("131012F2", vqadd_s16(d1, d2, d3)); + TEST_INSTRUCTION("131022F2", vqadd_s32(d1, d2, d3)); + TEST_INSTRUCTION("131032F2", vqadd_s64(d1, d2, d3)); + TEST_INSTRUCTION("131002F2", vqadd_s8(d1, d2, d3)); + TEST_INSTRUCTION("131012F3", vqadd_u16(d1, d2, d3)); + TEST_INSTRUCTION("131022F3", vqadd_u32(d1, d2, d3)); + TEST_INSTRUCTION("131032F3", vqadd_u64(d1, d2, d3)); + TEST_INSTRUCTION("131002F3", vqadd_u8(d1, d2, d3)); + TEST_INSTRUCTION("562014F2", vqadd_s16(q1, q2, q3)); + TEST_INSTRUCTION("562024F2", vqadd_s32(q1, q2, q3)); + TEST_INSTRUCTION("562034F2", vqadd_s64(q1, q2, q3)); + TEST_INSTRUCTION("562004F2", vqadd_s8(q1, q2, q3)); + TEST_INSTRUCTION("562014F3", vqadd_u16(q1, q2, q3)); + TEST_INSTRUCTION("562024F3", vqadd_u32(q1, q2, q3)); + TEST_INSTRUCTION("562034F3", vqadd_u64(q1, q2, q3)); + TEST_INSTRUCTION("562004F3", vqadd_u8(q1, q2, q3)); + TEST_INSTRUCTION("032992F2", vqdmlal_s16(q1, d2, d3)); + TEST_INSTRUCTION("0329A2F2", vqdmlal_s32(q1, d2, d3)); + TEST_INSTRUCTION("432392F2", vqdmlal_s16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2392F2", vqdmlal_s16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632392F2", vqdmlal_s16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2392F2", vqdmlal_s16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("4323A2F2", vqdmlal_s32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("6323A2F2", vqdmlal_s32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("032B92F2", vqdmlsl_s16(q1, d2, d3)); + TEST_INSTRUCTION("032BA2F2", vqdmlsl_s32(q1, d2, d3)); + TEST_INSTRUCTION("432792F2", vqdmlsl_s16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2792F2", vqdmlsl_s16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632792F2", vqdmlsl_s16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2792F2", vqdmlsl_s16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("4327A2F2", vqdmlsl_s32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("6327A2F2", vqdmlsl_s32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("031B12F2", vqdmulh_s16(d1, d2, d3)); + TEST_INSTRUCTION("031B22F2", vqdmulh_s32(d1, d2, d3)); + TEST_INSTRUCTION("462B14F2", vqdmulh_s16(q1, q2, q3)); + TEST_INSTRUCTION("462B24F2", vqdmulh_s32(q1, q2, q3)); + TEST_INSTRUCTION("431C92F2", vqdmulh_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1C92F2", vqdmulh_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631C92F2", vqdmulh_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1C92F2", vqdmulh_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432C94F3", vqdmulh_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2C94F3", vqdmulh_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632C94F3", vqdmulh_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2C94F3", vqdmulh_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("431CA2F2", vqdmulh_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("631CA2F2", vqdmulh_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432CA4F3", vqdmulh_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632CA4F3", vqdmulh_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("032D92F2", vqdmull_s16(q1, d2, d3)); + TEST_INSTRUCTION("032DA2F2", vqdmull_s32(q1, d2, d3)); + TEST_INSTRUCTION("432B92F2", vqdmull_s16(q1, d2, d3.at(0))); + TEST_INSTRUCTION("4B2B92F2", vqdmull_s16(q1, d2, d3.at(1))); + TEST_INSTRUCTION("632B92F2", vqdmull_s16(q1, d2, d3.at(2))); + TEST_INSTRUCTION("6B2B92F2", vqdmull_s16(q1, d2, d3.at(3))); + TEST_INSTRUCTION("432BA2F2", vqdmull_s32(q1, d2, d3.at(0))); + TEST_INSTRUCTION("632BA2F2", vqdmull_s32(q1, d2, d3.at(1))); + TEST_INSTRUCTION("8412B2F3", vqmovn_s16(d1, q2)); + TEST_INSTRUCTION("8412B6F3", vqmovn_s32(d1, q2)); + TEST_INSTRUCTION("8412BAF3", vqmovn_s64(d1, q2)); + TEST_INSTRUCTION("C412B2F3", vqmovn_u16(d1, q2)); + TEST_INSTRUCTION("C412B6F3", vqmovn_u32(d1, q2)); + TEST_INSTRUCTION("C412BAF3", vqmovn_u64(d1, q2)); + TEST_INSTRUCTION("4412B2F3", vqmovun_s16(d1, q2)); + TEST_INSTRUCTION("4412B6F3", vqmovun_s32(d1, q2)); + TEST_INSTRUCTION("4412BAF3", vqmovun_s64(d1, q2)); + TEST_INSTRUCTION("8217B4F3", vqneg_s16(d1, d2)); + TEST_INSTRUCTION("8217B8F3", vqneg_s32(d1, d2)); + TEST_INSTRUCTION("8217B0F3", vqneg_s8(d1, d2)); + TEST_INSTRUCTION("C427B4F3", vqneg_s16(q1, q2)); + TEST_INSTRUCTION("C427B8F3", vqneg_s32(q1, q2)); + TEST_INSTRUCTION("C427B0F3", vqneg_s8(q1, q2)); + TEST_INSTRUCTION("131B12F3", vqrdmlah_s16(d1, d2, d3)); + TEST_INSTRUCTION("131B22F3", vqrdmlah_s32(d1, d2, d3)); + TEST_INSTRUCTION("562B14F3", vqrdmlah_s16(q1, q2, q3)); + TEST_INSTRUCTION("562B24F3", vqrdmlah_s32(q1, q2, q3)); + TEST_INSTRUCTION("431E92F2", vqrdmlah_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1E92F2", vqrdmlah_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631E92F2", vqrdmlah_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1E92F2", vqrdmlah_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432E94F3", vqrdmlah_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2E94F3", vqrdmlah_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632E94F3", vqrdmlah_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2E94F3", vqrdmlah_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("431EA2F2", vqrdmlah_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("631EA2F2", vqrdmlah_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432EA4F3", vqrdmlah_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632EA4F3", vqrdmlah_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("131C12F3", vqrdmlsh_s16(d1, d2, d3)); + TEST_INSTRUCTION("131C22F3", vqrdmlsh_s32(d1, d2, d3)); + TEST_INSTRUCTION("562C14F3", vqrdmlsh_s16(q1, q2, q3)); + TEST_INSTRUCTION("562C24F3", vqrdmlsh_s32(q1, q2, q3)); + TEST_INSTRUCTION("431F92F2", vqrdmlsh_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1F92F2", vqrdmlsh_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631F92F2", vqrdmlsh_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1F92F2", vqrdmlsh_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432F94F3", vqrdmlsh_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2F94F3", vqrdmlsh_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632F94F3", vqrdmlsh_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2F94F3", vqrdmlsh_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("431FA2F2", vqrdmlsh_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("631FA2F2", vqrdmlsh_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432FA4F3", vqrdmlsh_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632FA4F3", vqrdmlsh_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("031B12F3", vqrdmulh_s16(d1, d2, d3)); + TEST_INSTRUCTION("031B22F3", vqrdmulh_s32(d1, d2, d3)); + TEST_INSTRUCTION("462B14F3", vqrdmulh_s16(q1, q2, q3)); + TEST_INSTRUCTION("462B24F3", vqrdmulh_s32(q1, q2, q3)); + TEST_INSTRUCTION("431D92F2", vqrdmulh_s16(d1, d2, d3.at(0))); + TEST_INSTRUCTION("4B1D92F2", vqrdmulh_s16(d1, d2, d3.at(1))); + TEST_INSTRUCTION("631D92F2", vqrdmulh_s16(d1, d2, d3.at(2))); + TEST_INSTRUCTION("6B1D92F2", vqrdmulh_s16(d1, d2, d3.at(3))); + TEST_INSTRUCTION("432D94F3", vqrdmulh_s16(q1, q2, d3.at(0))); + TEST_INSTRUCTION("4B2D94F3", vqrdmulh_s16(q1, q2, d3.at(1))); + TEST_INSTRUCTION("632D94F3", vqrdmulh_s16(q1, q2, d3.at(2))); + TEST_INSTRUCTION("6B2D94F3", vqrdmulh_s16(q1, q2, d3.at(3))); + TEST_INSTRUCTION("431DA2F2", vqrdmulh_s32(d1, d2, d3.at(0))); + TEST_INSTRUCTION("631DA2F2", vqrdmulh_s32(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432DA4F3", vqrdmulh_s32(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632DA4F3", vqrdmulh_s32(q1, q2, d3.at(1))); + TEST_INSTRUCTION("121513F2", vqrshl_s16(d1, d2, d3)); + TEST_INSTRUCTION("121523F2", vqrshl_s32(d1, d2, d3)); + TEST_INSTRUCTION("121533F2", vqrshl_s64(d1, d2, d3)); + TEST_INSTRUCTION("121503F2", vqrshl_s8(d1, d2, d3)); + TEST_INSTRUCTION("121513F3", vqrshl_u16(d1, d2, d3)); + TEST_INSTRUCTION("121523F3", vqrshl_u32(d1, d2, d3)); + TEST_INSTRUCTION("121533F3", vqrshl_u64(d1, d2, d3)); + TEST_INSTRUCTION("121503F3", vqrshl_u8(d1, d2, d3)); + TEST_INSTRUCTION("542516F2", vqrshl_s16(q1, q2, q3)); + TEST_INSTRUCTION("542526F2", vqrshl_s32(q1, q2, q3)); + TEST_INSTRUCTION("542536F2", vqrshl_s64(q1, q2, q3)); + TEST_INSTRUCTION("542506F2", vqrshl_s8(q1, q2, q3)); + TEST_INSTRUCTION("542516F3", vqrshl_u16(q1, q2, q3)); + TEST_INSTRUCTION("542526F3", vqrshl_u32(q1, q2, q3)); + TEST_INSTRUCTION("542536F3", vqrshl_u64(q1, q2, q3)); + TEST_INSTRUCTION("542506F3", vqrshl_u8(q1, q2, q3)); + TEST_INSTRUCTION("54198DF2", vqrshrn_s16(d1, q2, 3)); + TEST_INSTRUCTION("54199DF2", vqrshrn_s32(d1, q2, 3)); + TEST_INSTRUCTION("5419BDF2", vqrshrn_s64(d1, q2, 3)); + TEST_INSTRUCTION("54198DF3", vqrshrn_u16(d1, q2, 3)); + TEST_INSTRUCTION("54199DF3", vqrshrn_u32(d1, q2, 3)); + TEST_INSTRUCTION("5419BDF3", vqrshrn_u64(d1, q2, 3)); + TEST_INSTRUCTION("54188DF3", vqrshrun_s16(d1, q2, 3)); + TEST_INSTRUCTION("54189DF3", vqrshrun_s32(d1, q2, 3)); + TEST_INSTRUCTION("5418BDF3", vqrshrun_s64(d1, q2, 3)); + TEST_INSTRUCTION("121413F2", vqshl_s16(d1, d2, d3)); + TEST_INSTRUCTION("121423F2", vqshl_s32(d1, d2, d3)); + TEST_INSTRUCTION("121433F2", vqshl_s64(d1, d2, d3)); + TEST_INSTRUCTION("121403F2", vqshl_s8(d1, d2, d3)); + TEST_INSTRUCTION("121413F3", vqshl_u16(d1, d2, d3)); + TEST_INSTRUCTION("121423F3", vqshl_u32(d1, d2, d3)); + TEST_INSTRUCTION("121433F3", vqshl_u64(d1, d2, d3)); + TEST_INSTRUCTION("121403F3", vqshl_u8(d1, d2, d3)); + TEST_INSTRUCTION("542416F2", vqshl_s16(q1, q2, q3)); + TEST_INSTRUCTION("542426F2", vqshl_s32(q1, q2, q3)); + TEST_INSTRUCTION("542436F2", vqshl_s64(q1, q2, q3)); + TEST_INSTRUCTION("542406F2", vqshl_s8(q1, q2, q3)); + TEST_INSTRUCTION("542416F3", vqshl_u16(q1, q2, q3)); + TEST_INSTRUCTION("542426F3", vqshl_u32(q1, q2, q3)); + TEST_INSTRUCTION("542436F3", vqshl_u64(q1, q2, q3)); + TEST_INSTRUCTION("542406F3", vqshl_u8(q1, q2, q3)); + TEST_INSTRUCTION("121793F2", vqshl_s16(d1, d2, 3)); + TEST_INSTRUCTION("1217A3F2", vqshl_s32(d1, d2, 3)); + TEST_INSTRUCTION("921783F2", vqshl_s64(d1, d2, 3)); + TEST_INSTRUCTION("12178BF2", vqshl_s8(d1, d2, 3)); + TEST_INSTRUCTION("121793F3", vqshl_u16(d1, d2, 3)); + TEST_INSTRUCTION("1217A3F3", vqshl_u32(d1, d2, 3)); + TEST_INSTRUCTION("921783F3", vqshl_u64(d1, d2, 3)); + TEST_INSTRUCTION("12178BF3", vqshl_u8(d1, d2, 3)); + TEST_INSTRUCTION("542793F2", vqshl_s16(q1, q2, 3)); + TEST_INSTRUCTION("5427A3F2", vqshl_s32(q1, q2, 3)); + TEST_INSTRUCTION("D42783F2", vqshl_s64(q1, q2, 3)); + TEST_INSTRUCTION("54278BF2", vqshl_s8(q1, q2, 3)); + TEST_INSTRUCTION("542793F3", vqshl_u16(q1, q2, 3)); + TEST_INSTRUCTION("5427A3F3", vqshl_u32(q1, q2, 3)); + TEST_INSTRUCTION("D42783F3", vqshl_u64(q1, q2, 3)); + TEST_INSTRUCTION("54278BF3", vqshl_u8(q1, q2, 3)); + TEST_INSTRUCTION("121693F3", vqshlu_s16(d1, d2, 3)); + TEST_INSTRUCTION("1216A3F3", vqshlu_s32(d1, d2, 3)); + TEST_INSTRUCTION("921683F3", vqshlu_s64(d1, d2, 3)); + TEST_INSTRUCTION("12168BF3", vqshlu_s8(d1, d2, 3)); + TEST_INSTRUCTION("542693F3", vqshlu_s16(q1, q2, 3)); + TEST_INSTRUCTION("5426A3F3", vqshlu_s32(q1, q2, 3)); + TEST_INSTRUCTION("D42683F3", vqshlu_s64(q1, q2, 3)); + TEST_INSTRUCTION("54268BF3", vqshlu_s8(q1, q2, 3)); + TEST_INSTRUCTION("14198DF2", vqshrn_s16(d1, q2, 3)); + TEST_INSTRUCTION("14199DF2", vqshrn_s32(d1, q2, 3)); + TEST_INSTRUCTION("1419BDF2", vqshrn_s64(d1, q2, 3)); + TEST_INSTRUCTION("14198DF3", vqshrn_u16(d1, q2, 3)); + TEST_INSTRUCTION("14199DF3", vqshrn_u32(d1, q2, 3)); + TEST_INSTRUCTION("1419BDF3", vqshrn_u64(d1, q2, 3)); + TEST_INSTRUCTION("14188DF3", vqshrun_s16(d1, q2, 3)); + TEST_INSTRUCTION("14189DF3", vqshrun_s32(d1, q2, 3)); + TEST_INSTRUCTION("1418BDF3", vqshrun_s64(d1, q2, 3)); + TEST_INSTRUCTION("131212F2", vqsub_s16(d1, d2, d3)); + TEST_INSTRUCTION("131222F2", vqsub_s32(d1, d2, d3)); + TEST_INSTRUCTION("131232F2", vqsub_s64(d1, d2, d3)); + TEST_INSTRUCTION("131202F2", vqsub_s8(d1, d2, d3)); + TEST_INSTRUCTION("131212F3", vqsub_u16(d1, d2, d3)); + TEST_INSTRUCTION("131222F3", vqsub_u32(d1, d2, d3)); + TEST_INSTRUCTION("131232F3", vqsub_u64(d1, d2, d3)); + TEST_INSTRUCTION("131202F3", vqsub_u8(d1, d2, d3)); + TEST_INSTRUCTION("562214F2", vqsub_s16(q1, q2, q3)); + TEST_INSTRUCTION("562224F2", vqsub_s32(q1, q2, q3)); + TEST_INSTRUCTION("562234F2", vqsub_s64(q1, q2, q3)); + TEST_INSTRUCTION("562204F2", vqsub_s8(q1, q2, q3)); + TEST_INSTRUCTION("562214F3", vqsub_u16(q1, q2, q3)); + TEST_INSTRUCTION("562224F3", vqsub_u32(q1, q2, q3)); + TEST_INSTRUCTION("562234F3", vqsub_u64(q1, q2, q3)); + TEST_INSTRUCTION("562204F3", vqsub_u8(q1, q2, q3)); + TEST_INSTRUCTION("061484F3", vraddhn_s16(d1, q2, q3)); + TEST_INSTRUCTION("061494F3", vraddhn_s32(d1, q2, q3)); + TEST_INSTRUCTION("0614A4F3", vraddhn_s64(d1, q2, q3)); + TEST_INSTRUCTION("061484F3", vraddhn_u16(d1, q2, q3)); + TEST_INSTRUCTION("061494F3", vraddhn_u32(d1, q2, q3)); + TEST_INSTRUCTION("0614A4F3", vraddhn_u64(d1, q2, q3)); + TEST_INSTRUCTION("0215B7F3", vrecpe_f16(d1, d2)); + TEST_INSTRUCTION("0215BBF3", vrecpe_f32(d1, d2)); + TEST_INSTRUCTION("4425B7F3", vrecpe_f16(q1, q2)); + TEST_INSTRUCTION("4425BBF3", vrecpe_f32(q1, q2)); + TEST_INSTRUCTION("0214BBF3", vrecpe_u32(d1, d2)); + TEST_INSTRUCTION("4424BBF3", vrecpe_u32(q1, q2)); + TEST_INSTRUCTION("131F12F2", vrecps_f16(d1, d2, d3)); + TEST_INSTRUCTION("131F02F2", vrecps_f32(d1, d2, d3)); + TEST_INSTRUCTION("562F14F2", vrecps_f16(q1, q2, q3)); + TEST_INSTRUCTION("562F04F2", vrecps_f32(q1, q2, q3)); + TEST_INSTRUCTION("0211B0F3", vrev16_s8(d1, d2)); + TEST_INSTRUCTION("0211B0F3", vrev16_u8(d1, d2)); + TEST_INSTRUCTION("4421B0F3", vrev16_s8(q1, q2)); + TEST_INSTRUCTION("4421B0F3", vrev16_u8(q1, q2)); + TEST_INSTRUCTION("8210B4F3", vrev32_s16(d1, d2)); + TEST_INSTRUCTION("8210B0F3", vrev32_s8(d1, d2)); + TEST_INSTRUCTION("8210B4F3", vrev32_u16(d1, d2)); + TEST_INSTRUCTION("8210B0F3", vrev32_u8(d1, d2)); + TEST_INSTRUCTION("C420B4F3", vrev32_s16(q1, q2)); + TEST_INSTRUCTION("C420B0F3", vrev32_s8(q1, q2)); + TEST_INSTRUCTION("C420B4F3", vrev32_u16(q1, q2)); + TEST_INSTRUCTION("C420B0F3", vrev32_u8(q1, q2)); + TEST_INSTRUCTION("0210B4F3", vrev64_s16(d1, d2)); + TEST_INSTRUCTION("0210B8F3", vrev64_s32(d1, d2)); + TEST_INSTRUCTION("0210B0F3", vrev64_s8(d1, d2)); + TEST_INSTRUCTION("0210B4F3", vrev64_u16(d1, d2)); + TEST_INSTRUCTION("0210B8F3", vrev64_u32(d1, d2)); + TEST_INSTRUCTION("0210B0F3", vrev64_u8(d1, d2)); + TEST_INSTRUCTION("4420B4F3", vrev64_s16(q1, q2)); + TEST_INSTRUCTION("4420B8F3", vrev64_s32(q1, q2)); + TEST_INSTRUCTION("4420B0F3", vrev64_s8(q1, q2)); + TEST_INSTRUCTION("4420B4F3", vrev64_u16(q1, q2)); + TEST_INSTRUCTION("4420B8F3", vrev64_u32(q1, q2)); + TEST_INSTRUCTION("4420B0F3", vrev64_u8(q1, q2)); + TEST_INSTRUCTION("031112F2", vrhadd_s16(d1, d2, d3)); + TEST_INSTRUCTION("031122F2", vrhadd_s32(d1, d2, d3)); + TEST_INSTRUCTION("031102F2", vrhadd_s8(d1, d2, d3)); + TEST_INSTRUCTION("031112F3", vrhadd_u16(d1, d2, d3)); + TEST_INSTRUCTION("031122F3", vrhadd_u32(d1, d2, d3)); + TEST_INSTRUCTION("031102F3", vrhadd_u8(d1, d2, d3)); + TEST_INSTRUCTION("462114F2", vrhadd_s16(q1, q2, q3)); + TEST_INSTRUCTION("462124F2", vrhadd_s32(q1, q2, q3)); + TEST_INSTRUCTION("462104F2", vrhadd_s8(q1, q2, q3)); + TEST_INSTRUCTION("462114F3", vrhadd_u16(q1, q2, q3)); + TEST_INSTRUCTION("462124F3", vrhadd_u32(q1, q2, q3)); + TEST_INSTRUCTION("462104F3", vrhadd_u8(q1, q2, q3)); + TEST_INSTRUCTION("4109F8FE", vrinta_f16(s1, s2)); + TEST_INSTRUCTION("410AF8FE", vrinta_f32(s1, s2)); + TEST_INSTRUCTION("421BB8FE", vrinta_f64(d1, d2)); + TEST_INSTRUCTION("0215B6F3", vrinta_f16(d1, d2)); + TEST_INSTRUCTION("0215BAF3", vrinta_f32(d1, d2)); + TEST_INSTRUCTION("4425B6F3", vrinta_f16(q1, q2)); + TEST_INSTRUCTION("4425BAF3", vrinta_f32(q1, q2)); + TEST_INSTRUCTION("4109FBFE", vrintm_f16(s1, s2)); + TEST_INSTRUCTION("410AFBFE", vrintm_f32(s1, s2)); + TEST_INSTRUCTION("421BBBFE", vrintm_f64(d1, d2)); + TEST_INSTRUCTION("8216B6F3", vrintm_f16(d1, d2)); + TEST_INSTRUCTION("8216BAF3", vrintm_f32(d1, d2)); + TEST_INSTRUCTION("C426B6F3", vrintm_f16(q1, q2)); + TEST_INSTRUCTION("C426BAF3", vrintm_f32(q1, q2)); + TEST_INSTRUCTION("4109F9FE", vrintn_f16(s1, s2)); + TEST_INSTRUCTION("410AF9FE", vrintn_f32(s1, s2)); + TEST_INSTRUCTION("421BB9FE", vrintn_f64(d1, d2)); + TEST_INSTRUCTION("0214B6F3", vrintn_f16(d1, d2)); + TEST_INSTRUCTION("0214BAF3", vrintn_f32(d1, d2)); + TEST_INSTRUCTION("4424B6F3", vrintn_f16(q1, q2)); + TEST_INSTRUCTION("4424BAF3", vrintn_f32(q1, q2)); + TEST_INSTRUCTION("4109FAFE", vrintp_f16(s1, s2)); + TEST_INSTRUCTION("410AFAFE", vrintp_f32(s1, s2)); + TEST_INSTRUCTION("421BBAFE", vrintp_f64(d1, d2)); + TEST_INSTRUCTION("8217B6F3", vrintp_f16(d1, d2)); + TEST_INSTRUCTION("8217BAF3", vrintp_f32(d1, d2)); + TEST_INSTRUCTION("C427B6F3", vrintp_f16(q1, q2)); + TEST_INSTRUCTION("C427BAF3", vrintp_f32(q1, q2)); + TEST_INSTRUCTION("4109F6EE", vrintr_f16(s1, s2)); + TEST_INSTRUCTION("410AF6EE", vrintr_f32(s1, s2)); + TEST_INSTRUCTION("421BB6EE", vrintr_f64(d1, d2)); + TEST_INSTRUCTION("4109F7EE", vrintx_f16(s1, s2)); + TEST_INSTRUCTION("410AF7EE", vrintx_f32(s1, s2)); + TEST_INSTRUCTION("421BB7EE", vrintx_f64(d1, d2)); + TEST_INSTRUCTION("8214B6F3", vrintx_f16(d1, d2)); + TEST_INSTRUCTION("8214BAF3", vrintx_f32(d1, d2)); + TEST_INSTRUCTION("C424B6F3", vrintx_f16(q1, q2)); + TEST_INSTRUCTION("C424BAF3", vrintx_f32(q1, q2)); + TEST_INSTRUCTION("C109F6EE", vrintz_f16(s1, s2)); + TEST_INSTRUCTION("C10AF6EE", vrintz_f32(s1, s2)); + TEST_INSTRUCTION("C21BB6EE", vrintz_f64(d1, d2)); + TEST_INSTRUCTION("8215B6F3", vrintz_f16(d1, d2)); + TEST_INSTRUCTION("8215BAF3", vrintz_f32(d1, d2)); + TEST_INSTRUCTION("C425B6F3", vrintz_f16(q1, q2)); + TEST_INSTRUCTION("C425BAF3", vrintz_f32(q1, q2)); + TEST_INSTRUCTION("021513F2", vrshl_s16(d1, d2, d3)); + TEST_INSTRUCTION("021523F2", vrshl_s32(d1, d2, d3)); + TEST_INSTRUCTION("021533F2", vrshl_s64(d1, d2, d3)); + TEST_INSTRUCTION("021503F2", vrshl_s8(d1, d2, d3)); + TEST_INSTRUCTION("021513F3", vrshl_u16(d1, d2, d3)); + TEST_INSTRUCTION("021523F3", vrshl_u32(d1, d2, d3)); + TEST_INSTRUCTION("021533F3", vrshl_u64(d1, d2, d3)); + TEST_INSTRUCTION("021503F3", vrshl_u8(d1, d2, d3)); + TEST_INSTRUCTION("442516F2", vrshl_s16(q1, q2, q3)); + TEST_INSTRUCTION("442526F2", vrshl_s32(q1, q2, q3)); + TEST_INSTRUCTION("442536F2", vrshl_s64(q1, q2, q3)); + TEST_INSTRUCTION("442506F2", vrshl_s8(q1, q2, q3)); + TEST_INSTRUCTION("442516F3", vrshl_u16(q1, q2, q3)); + TEST_INSTRUCTION("442526F3", vrshl_u32(q1, q2, q3)); + TEST_INSTRUCTION("442536F3", vrshl_u64(q1, q2, q3)); + TEST_INSTRUCTION("442506F3", vrshl_u8(q1, q2, q3)); + TEST_INSTRUCTION("12129DF2", vrshr_s16(d1, d2, 3)); + TEST_INSTRUCTION("1212BDF2", vrshr_s32(d1, d2, 3)); + TEST_INSTRUCTION("12128DF2", vrshr_s8(d1, d2, 3)); + TEST_INSTRUCTION("12129DF3", vrshr_u16(d1, d2, 3)); + TEST_INSTRUCTION("1212BDF3", vrshr_u32(d1, d2, 3)); + TEST_INSTRUCTION("12128DF3", vrshr_u8(d1, d2, 3)); + TEST_INSTRUCTION("54229DF2", vrshr_s16(q1, q2, 3)); + TEST_INSTRUCTION("5422BDF2", vrshr_s32(q1, q2, 3)); + TEST_INSTRUCTION("54228DF2", vrshr_s8(q1, q2, 3)); + TEST_INSTRUCTION("54229DF3", vrshr_u16(q1, q2, 3)); + TEST_INSTRUCTION("5422BDF3", vrshr_u32(q1, q2, 3)); + TEST_INSTRUCTION("54228DF3", vrshr_u8(q1, q2, 3)); + TEST_INSTRUCTION("54188DF2", vrshrn_s16(d1, q2, 3)); + TEST_INSTRUCTION("54189DF2", vrshrn_s32(d1, q2, 3)); + TEST_INSTRUCTION("5418BDF2", vrshrn_s64(d1, q2, 3)); + TEST_INSTRUCTION("54188DF2", vrshrn_u16(d1, q2, 3)); + TEST_INSTRUCTION("54189DF2", vrshrn_u32(d1, q2, 3)); + TEST_INSTRUCTION("5418BDF2", vrshrn_u64(d1, q2, 3)); + TEST_INSTRUCTION("8215B7F3", vrsqrte_f16(d1, d2)); + TEST_INSTRUCTION("8215BBF3", vrsqrte_f32(d1, d2)); + TEST_INSTRUCTION("C425B7F3", vrsqrte_f16(q1, q2)); + TEST_INSTRUCTION("C425BBF3", vrsqrte_f32(q1, q2)); + TEST_INSTRUCTION("8214BBF3", vrsqrte_u32(d1, d2)); + TEST_INSTRUCTION("C424BBF3", vrsqrte_u32(q1, q2)); + TEST_INSTRUCTION("131F32F2", vrsqrts_f16(d1, d2, d3)); + TEST_INSTRUCTION("131F22F2", vrsqrts_f32(d1, d2, d3)); + TEST_INSTRUCTION("562F34F2", vrsqrts_f16(q1, q2, q3)); + TEST_INSTRUCTION("562F24F2", vrsqrts_f32(q1, q2, q3)); + TEST_INSTRUCTION("12139DF2", vrsra_s16(d1, d2, 3)); + TEST_INSTRUCTION("1213BDF2", vrsra_s32(d1, d2, 3)); + TEST_INSTRUCTION("9213BDF2", vrsra_s64(d1, d2, 3)); + TEST_INSTRUCTION("12138DF2", vrsra_s8(d1, d2, 3)); + TEST_INSTRUCTION("12139DF3", vrsra_u16(d1, d2, 3)); + TEST_INSTRUCTION("1213BDF3", vrsra_u32(d1, d2, 3)); + TEST_INSTRUCTION("9213BDF3", vrsra_u64(d1, d2, 3)); + TEST_INSTRUCTION("12138DF3", vrsra_u8(d1, d2, 3)); + TEST_INSTRUCTION("54239DF2", vrsra_s16(q1, q2, 3)); + TEST_INSTRUCTION("5423BDF2", vrsra_s32(q1, q2, 3)); + TEST_INSTRUCTION("D423BDF2", vrsra_s64(q1, q2, 3)); + TEST_INSTRUCTION("54238DF2", vrsra_s8(q1, q2, 3)); + TEST_INSTRUCTION("54239DF3", vrsra_u16(q1, q2, 3)); + TEST_INSTRUCTION("5423BDF3", vrsra_u32(q1, q2, 3)); + TEST_INSTRUCTION("D423BDF3", vrsra_u64(q1, q2, 3)); + TEST_INSTRUCTION("54238DF3", vrsra_u8(q1, q2, 3)); + TEST_INSTRUCTION("061684F3", vrsubhn_s16(d1, q2, q3)); + TEST_INSTRUCTION("061694F3", vrsubhn_s32(d1, q2, q3)); + TEST_INSTRUCTION("0616A4F3", vrsubhn_s64(d1, q2, q3)); + TEST_INSTRUCTION("061684F3", vrsubhn_u16(d1, q2, q3)); + TEST_INSTRUCTION("061694F3", vrsubhn_u32(d1, q2, q3)); + TEST_INSTRUCTION("0616A4F3", vrsubhn_u64(d1, q2, q3)); + TEST_INSTRUCTION("031D22FC", vsdot_s8(d1, d2, d3)); + TEST_INSTRUCTION("462D24FC", vsdot_s8(q1, q2, q3)); + TEST_INSTRUCTION("031D22FE", vsdot_s8(d1, d2, d3.at(0))); + TEST_INSTRUCTION("231D22FE", vsdot_s8(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432D24FE", vsdot_s8(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632D24FE", vsdot_s8(q1, q2, d3.at(1))); + TEST_INSTRUCTION("210941FE", vseleq_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A41FE", vseleq_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B02FE", vseleq_f64(d1, d2, d3)); + TEST_INSTRUCTION("210961FE", vselge_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A61FE", vselge_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B22FE", vselge_f64(d1, d2, d3)); + TEST_INSTRUCTION("210971FE", vselgt_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A71FE", vselgt_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B32FE", vselgt_f64(d1, d2, d3)); + TEST_INSTRUCTION("210951FE", vselvs_f16(s1, s2, s3)); + TEST_INSTRUCTION("210A51FE", vselvs_f32(s1, s2, s3)); + TEST_INSTRUCTION("031B12FE", vselvs_f64(d1, d2, d3)); + TEST_INSTRUCTION("121593F2", vshl_s16(d1, d2, 3)); + TEST_INSTRUCTION("1215A3F2", vshl_s32(d1, d2, 3)); + TEST_INSTRUCTION("921583F2", vshl_s64(d1, d2, 3)); + TEST_INSTRUCTION("12158BF2", vshl_s8(d1, d2, 3)); + TEST_INSTRUCTION("121593F2", vshl_u16(d1, d2, 3)); + TEST_INSTRUCTION("1215A3F2", vshl_u32(d1, d2, 3)); + TEST_INSTRUCTION("921583F2", vshl_u64(d1, d2, 3)); + TEST_INSTRUCTION("12158BF2", vshl_u8(d1, d2, 3)); + TEST_INSTRUCTION("542593F2", vshl_s16(q1, q2, 3)); + TEST_INSTRUCTION("5425A3F2", vshl_s32(q1, q2, 3)); + TEST_INSTRUCTION("D42583F2", vshl_s64(q1, q2, 3)); + TEST_INSTRUCTION("54258BF2", vshl_s8(q1, q2, 3)); + TEST_INSTRUCTION("542593F2", vshl_u16(q1, q2, 3)); + TEST_INSTRUCTION("5425A3F2", vshl_u32(q1, q2, 3)); + TEST_INSTRUCTION("D42583F2", vshl_u64(q1, q2, 3)); + TEST_INSTRUCTION("54258BF2", vshl_u8(q1, q2, 3)); + TEST_INSTRUCTION("021413F2", vshl_s16(d1, d2, d3)); + TEST_INSTRUCTION("021423F2", vshl_s32(d1, d2, d3)); + TEST_INSTRUCTION("021433F2", vshl_s64(d1, d2, d3)); + TEST_INSTRUCTION("021403F2", vshl_s8(d1, d2, d3)); + TEST_INSTRUCTION("021413F3", vshl_u16(d1, d2, d3)); + TEST_INSTRUCTION("021423F3", vshl_u32(d1, d2, d3)); + TEST_INSTRUCTION("021433F3", vshl_u64(d1, d2, d3)); + TEST_INSTRUCTION("021403F3", vshl_u8(d1, d2, d3)); + TEST_INSTRUCTION("442416F2", vshl_s16(q1, q2, q3)); + TEST_INSTRUCTION("442426F2", vshl_s32(q1, q2, q3)); + TEST_INSTRUCTION("442436F2", vshl_s64(q1, q2, q3)); + TEST_INSTRUCTION("442406F2", vshl_s8(q1, q2, q3)); + TEST_INSTRUCTION("442416F3", vshl_u16(q1, q2, q3)); + TEST_INSTRUCTION("442426F3", vshl_u32(q1, q2, q3)); + TEST_INSTRUCTION("442436F3", vshl_u64(q1, q2, q3)); + TEST_INSTRUCTION("442406F3", vshl_u8(q1, q2, q3)); + TEST_INSTRUCTION("122A93F2", vshll_s16(q1, d2, 3)); + TEST_INSTRUCTION("122AA3F2", vshll_s32(q1, d2, 3)); + TEST_INSTRUCTION("122A8BF2", vshll_s8(q1, d2, 3)); + TEST_INSTRUCTION("122A93F3", vshll_u16(q1, d2, 3)); + TEST_INSTRUCTION("122AA3F3", vshll_u32(q1, d2, 3)); + TEST_INSTRUCTION("122A8BF3", vshll_u8(q1, d2, 3)); + TEST_INSTRUCTION("12109DF2", vshr_s16(d1, d2, 3)); + TEST_INSTRUCTION("1210BDF2", vshr_s32(d1, d2, 3)); + TEST_INSTRUCTION("9210BDF2", vshr_s64(d1, d2, 3)); + TEST_INSTRUCTION("12108DF2", vshr_s8(d1, d2, 3)); + TEST_INSTRUCTION("12109DF3", vshr_u16(d1, d2, 3)); + TEST_INSTRUCTION("1210BDF3", vshr_u32(d1, d2, 3)); + TEST_INSTRUCTION("9210BDF3", vshr_u64(d1, d2, 3)); + TEST_INSTRUCTION("12108DF3", vshr_u8(d1, d2, 3)); + TEST_INSTRUCTION("54209DF2", vshr_s16(q1, q2, 3)); + TEST_INSTRUCTION("5420BDF2", vshr_s32(q1, q2, 3)); + TEST_INSTRUCTION("D420BDF2", vshr_s64(q1, q2, 3)); + TEST_INSTRUCTION("54208DF2", vshr_s8(q1, q2, 3)); + TEST_INSTRUCTION("54209DF3", vshr_u16(q1, q2, 3)); + TEST_INSTRUCTION("5420BDF3", vshr_u32(q1, q2, 3)); + TEST_INSTRUCTION("D420BDF3", vshr_u64(q1, q2, 3)); + TEST_INSTRUCTION("54208DF3", vshr_u8(q1, q2, 3)); + TEST_INSTRUCTION("14188DF2", vshrn_s16(d1, q2, 3)); + TEST_INSTRUCTION("14189DF2", vshrn_s32(d1, q2, 3)); + TEST_INSTRUCTION("1418BDF2", vshrn_s64(d1, q2, 3)); + TEST_INSTRUCTION("14188DF2", vshrn_u16(d1, q2, 3)); + TEST_INSTRUCTION("14189DF2", vshrn_u32(d1, q2, 3)); + TEST_INSTRUCTION("1418BDF2", vshrn_u64(d1, q2, 3)); + TEST_INSTRUCTION("121593F3", vsli_s16(d1, d2, 3)); + TEST_INSTRUCTION("1215A3F3", vsli_s32(d1, d2, 3)); + TEST_INSTRUCTION("921583F3", vsli_s64(d1, d2, 3)); + TEST_INSTRUCTION("12158BF3", vsli_s8(d1, d2, 3)); + TEST_INSTRUCTION("121593F3", vsli_u16(d1, d2, 3)); + TEST_INSTRUCTION("1215A3F3", vsli_u32(d1, d2, 3)); + TEST_INSTRUCTION("921583F3", vsli_u64(d1, d2, 3)); + TEST_INSTRUCTION("12158BF3", vsli_u8(d1, d2, 3)); + TEST_INSTRUCTION("542593F3", vsli_s16(q1, q2, 3)); + TEST_INSTRUCTION("5425A3F3", vsli_s32(q1, q2, 3)); + TEST_INSTRUCTION("D42583F3", vsli_s64(q1, q2, 3)); + TEST_INSTRUCTION("54258BF3", vsli_s8(q1, q2, 3)); + TEST_INSTRUCTION("542593F3", vsli_u16(q1, q2, 3)); + TEST_INSTRUCTION("5425A3F3", vsli_u32(q1, q2, 3)); + TEST_INSTRUCTION("D42583F3", vsli_u64(q1, q2, 3)); + TEST_INSTRUCTION("54258BF3", vsli_u8(q1, q2, 3)); + TEST_INSTRUCTION("462C24FC", vsmmla_s8(q1, q2, q3)); + TEST_INSTRUCTION("C109F1EE", vsqrt_f16(s1, s2)); + TEST_INSTRUCTION("C10AF1EE", vsqrt_f32(s1, s2)); + TEST_INSTRUCTION("C21BB1EE", vsqrt_f64(d1, d2)); + TEST_INSTRUCTION("12119DF2", vsra_s16(d1, d2, 3)); + TEST_INSTRUCTION("1211BDF2", vsra_s32(d1, d2, 3)); + TEST_INSTRUCTION("9211BDF2", vsra_s64(d1, d2, 3)); + TEST_INSTRUCTION("12118DF2", vsra_s8(d1, d2, 3)); + TEST_INSTRUCTION("12119DF3", vsra_u16(d1, d2, 3)); + TEST_INSTRUCTION("1211BDF3", vsra_u32(d1, d2, 3)); + TEST_INSTRUCTION("9211BDF3", vsra_u64(d1, d2, 3)); + TEST_INSTRUCTION("12118DF3", vsra_u8(d1, d2, 3)); + TEST_INSTRUCTION("54219DF2", vsra_s16(q1, q2, 3)); + TEST_INSTRUCTION("5421BDF2", vsra_s32(q1, q2, 3)); + TEST_INSTRUCTION("D421BDF2", vsra_s64(q1, q2, 3)); + TEST_INSTRUCTION("54218DF2", vsra_s8(q1, q2, 3)); + TEST_INSTRUCTION("54219DF3", vsra_u16(q1, q2, 3)); + TEST_INSTRUCTION("5421BDF3", vsra_u32(q1, q2, 3)); + TEST_INSTRUCTION("D421BDF3", vsra_u64(q1, q2, 3)); + TEST_INSTRUCTION("54218DF3", vsra_u8(q1, q2, 3)); + TEST_INSTRUCTION("12149DF3", vsri_s16(d1, d2, 3)); + TEST_INSTRUCTION("1214BDF3", vsri_s32(d1, d2, 3)); + TEST_INSTRUCTION("9214BDF3", vsri_s64(d1, d2, 3)); + TEST_INSTRUCTION("12148DF3", vsri_s8(d1, d2, 3)); + TEST_INSTRUCTION("12149DF3", vsri_u16(d1, d2, 3)); + TEST_INSTRUCTION("1214BDF3", vsri_u32(d1, d2, 3)); + TEST_INSTRUCTION("9214BDF3", vsri_u64(d1, d2, 3)); + TEST_INSTRUCTION("12148DF3", vsri_u8(d1, d2, 3)); + TEST_INSTRUCTION("54249DF3", vsri_s16(q1, q2, 3)); + TEST_INSTRUCTION("5424BDF3", vsri_s32(q1, q2, 3)); + TEST_INSTRUCTION("D424BDF3", vsri_s64(q1, q2, 3)); + TEST_INSTRUCTION("54248DF3", vsri_s8(q1, q2, 3)); + TEST_INSTRUCTION("54249DF3", vsri_u16(q1, q2, 3)); + TEST_INSTRUCTION("5424BDF3", vsri_u32(q1, q2, 3)); + TEST_INSTRUCTION("D424BDF3", vsri_u64(q1, q2, 3)); + TEST_INSTRUCTION("54248DF3", vsri_u8(q1, q2, 3)); + TEST_INSTRUCTION("431702F4", vst1_16(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("831702F4", vst1_32(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("C31702F4", vst1_64(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("031702F4", vst1_8(d1, ptr_post(r2, r3))); + TEST_INSTRUCTION("4D1702F4", vst1_16(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("8D1702F4", vst1_32(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("CD1702F4", vst1_64(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("0D1702F4", vst1_8(d1, ptr_post(r2, 8))); + TEST_INSTRUCTION("441A03F4", vst1_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841A03F4", vst1_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("C41A03F4", vst1_64(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041A03F4", vst1_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1A03F4", vst1_16(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("8D1A03F4", vst1_32(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("CD1A03F4", vst1_64(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("0D1A03F4", vst1_8(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("451604F4", vst1_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851604F4", vst1_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("C51604F4", vst1_64(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051604F4", vst1_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1604F4", vst1_16(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("8D1604F4", vst1_32(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("CD1604F4", vst1_64(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0D1604F4", vst1_8(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("461205F4", vst1_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861205F4", vst1_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("C61205F4", vst1_64(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061205F4", vst1_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1205F4", vst1_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1205F4", vst1_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("CD1205F4", vst1_64(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1205F4", vst1_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("441803F4", vst2_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841803F4", vst2_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041803F4", vst2_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1803F4", vst2_16(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("8D1803F4", vst2_32(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("0D1803F4", vst2_8(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("441803F4", vst2_16(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("841803F4", vst2_32(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("041803F4", vst2_8(d1, d2, ptr_post(r3, r4))); + TEST_INSTRUCTION("4D1803F4", vst2_16(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("8D1803F4", vst2_32(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("0D1803F4", vst2_8(d1, d2, ptr_post(r3, 16))); + TEST_INSTRUCTION("461305F4", vst2_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861305F4", vst2_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061305F4", vst2_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1305F4", vst2_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1305F4", vst2_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1305F4", vst2_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("451404F4", vst3_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851404F4", vst3_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051404F4", vst3_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1404F4", vst3_16(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("8D1404F4", vst3_32(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0D1404F4", vst3_8(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("451404F4", vst3_16(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("851404F4", vst3_32(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("051404F4", vst3_8(d1, d2, d3, ptr_post(r4, r5))); + TEST_INSTRUCTION("4D1404F4", vst3_16(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("8D1404F4", vst3_32(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("0D1404F4", vst3_8(d1, d2, d3, ptr_post(r4, 24))); + TEST_INSTRUCTION("461005F4", vst4_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861005F4", vst4_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061005F4", vst4_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1005F4", vst4_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1005F4", vst4_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1005F4", vst4_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("461005F4", vst4_16(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("861005F4", vst4_32(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("061005F4", vst4_8(d1, d2, d3, d4, ptr_post(r5, r6))); + TEST_INSTRUCTION("4D1005F4", vst4_16(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("8D1005F4", vst4_32(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("0D1005F4", vst4_8(d1, d2, d3, d4, ptr_post(r5, 32))); + TEST_INSTRUCTION("040A20ED", vstmdb_32(ptr_pre(r0), VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080B20ED", vstmdb_64(ptr_pre(r0), VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("040A81EC", vstmia_32(ptr(r1), VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080B87EC", vstmia_64(ptr(r7), VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("040AA1EC", vstmia_32(ptr_pre(r1), VecSList{s0, s1, s2, s3})); + TEST_INSTRUCTION("080BA7EC", vstmia_64(ptr_pre(r7), VecDList{d0, d1, d2, d3})); + TEST_INSTRUCTION("0209C2ED", vstr_16(s1, ptr(r2, 4))); + TEST_INSTRUCTION("010AC2ED", vstr_32(s1, ptr(r2, 4))); + TEST_INSTRUCTION("011B82ED", vstr_64(d1, ptr(r2, 4))); + TEST_INSTRUCTION("610971EE", vsub_f16(s1, s2, s3)); + TEST_INSTRUCTION("610A71EE", vsub_f32(s1, s2, s3)); + TEST_INSTRUCTION("431B32EE", vsub_f64(d1, d2, d3)); + TEST_INSTRUCTION("031D32F2", vsub_f16(d1, d2, d3)); + TEST_INSTRUCTION("031D22F2", vsub_f32(d1, d2, d3)); + TEST_INSTRUCTION("462D34F2", vsub_f16(q1, q2, q3)); + TEST_INSTRUCTION("462D24F2", vsub_f32(q1, q2, q3)); + TEST_INSTRUCTION("031812F3", vsub_s16(d1, d2, d3)); + TEST_INSTRUCTION("031822F3", vsub_s32(d1, d2, d3)); + TEST_INSTRUCTION("031832F3", vsub_s64(d1, d2, d3)); + TEST_INSTRUCTION("031802F3", vsub_s8(d1, d2, d3)); + TEST_INSTRUCTION("031812F3", vsub_u16(d1, d2, d3)); + TEST_INSTRUCTION("031822F3", vsub_u32(d1, d2, d3)); + TEST_INSTRUCTION("031832F3", vsub_u64(d1, d2, d3)); + TEST_INSTRUCTION("031802F3", vsub_u8(d1, d2, d3)); + TEST_INSTRUCTION("462814F3", vsub_s16(q1, q2, q3)); + TEST_INSTRUCTION("462824F3", vsub_s32(q1, q2, q3)); + TEST_INSTRUCTION("462834F3", vsub_s64(q1, q2, q3)); + TEST_INSTRUCTION("462804F3", vsub_s8(q1, q2, q3)); + TEST_INSTRUCTION("462814F3", vsub_u16(q1, q2, q3)); + TEST_INSTRUCTION("462824F3", vsub_u32(q1, q2, q3)); + TEST_INSTRUCTION("462834F3", vsub_u64(q1, q2, q3)); + TEST_INSTRUCTION("462804F3", vsub_u8(q1, q2, q3)); + TEST_INSTRUCTION("061684F2", vsubhn_s16(d1, q2, q3)); + TEST_INSTRUCTION("061694F2", vsubhn_s32(d1, q2, q3)); + TEST_INSTRUCTION("0616A4F2", vsubhn_s64(d1, q2, q3)); + TEST_INSTRUCTION("061684F2", vsubhn_u16(d1, q2, q3)); + TEST_INSTRUCTION("061694F2", vsubhn_u32(d1, q2, q3)); + TEST_INSTRUCTION("0616A4F2", vsubhn_u64(d1, q2, q3)); + TEST_INSTRUCTION("032292F2", vsubl_s16(q1, d2, d3)); + TEST_INSTRUCTION("0322A2F2", vsubl_s32(q1, d2, d3)); + TEST_INSTRUCTION("032282F2", vsubl_s8(q1, d2, d3)); + TEST_INSTRUCTION("032292F3", vsubl_u16(q1, d2, d3)); + TEST_INSTRUCTION("0322A2F3", vsubl_u32(q1, d2, d3)); + TEST_INSTRUCTION("032282F3", vsubl_u8(q1, d2, d3)); + TEST_INSTRUCTION("032394F2", vsubw_s16(q1, q2, d3)); + TEST_INSTRUCTION("0323A4F2", vsubw_s32(q1, q2, d3)); + TEST_INSTRUCTION("032384F2", vsubw_s8(q1, q2, d3)); + TEST_INSTRUCTION("032394F3", vsubw_u16(q1, q2, d3)); + TEST_INSTRUCTION("0323A4F3", vsubw_u32(q1, q2, d3)); + TEST_INSTRUCTION("032384F3", vsubw_u8(q1, q2, d3)); + TEST_INSTRUCTION("131D82FE", vsudot_u8(d1, d2, d3.at(0))); + TEST_INSTRUCTION("331D82FE", vsudot_u8(d1, d2, d3.at(1))); + TEST_INSTRUCTION("532D84FE", vsudot_u8(q1, q2, d3.at(0))); + TEST_INSTRUCTION("732D84FE", vsudot_u8(q1, q2, d3.at(1))); + TEST_INSTRUCTION("0210B2F3", vswp(d1, d2)); + TEST_INSTRUCTION("4420B2F3", vswp(q1, q2)); + TEST_INSTRUCTION("0318B2F3", vtbl_s8(d1, d2, d3)); + TEST_INSTRUCTION("0318B2F3", vtbl_u8(d1, d2, d3)); + TEST_INSTRUCTION("0419B2F3", vtbl_s8(d1, d2, d3, d4)); + TEST_INSTRUCTION("0419B2F3", vtbl_u8(d1, d2, d3, d4)); + TEST_INSTRUCTION("051AB2F3", vtbl_s8(d1, d2, d3, d4, d5)); + TEST_INSTRUCTION("051AB2F3", vtbl_u8(d1, d2, d3, d4, d5)); + TEST_INSTRUCTION("061BB2F3", vtbl_s8(d1, d2, d3, d4, d5, d6)); + TEST_INSTRUCTION("061BB2F3", vtbl_u8(d1, d2, d3, d4, d5, d6)); + TEST_INSTRUCTION("4318B2F3", vtbx_s8(d1, d2, d3)); + TEST_INSTRUCTION("4318B2F3", vtbx_u8(d1, d2, d3)); + TEST_INSTRUCTION("4419B2F3", vtbx_s8(d1, d2, d3, d4)); + TEST_INSTRUCTION("4419B2F3", vtbx_u8(d1, d2, d3, d4)); + TEST_INSTRUCTION("451AB2F3", vtbx_s8(d1, d2, d3, d4, d5)); + TEST_INSTRUCTION("451AB2F3", vtbx_u8(d1, d2, d3, d4, d5)); + TEST_INSTRUCTION("461BB2F3", vtbx_s8(d1, d2, d3, d4, d5, d6)); + TEST_INSTRUCTION("461BB2F3", vtbx_u8(d1, d2, d3, d4, d5, d6)); + TEST_INSTRUCTION("8210B6F3", vtrn_s16(d1, d2)); + TEST_INSTRUCTION("8210BAF3", vtrn_s32(d1, d2)); + TEST_INSTRUCTION("8210B2F3", vtrn_s8(d1, d2)); + TEST_INSTRUCTION("8210B6F3", vtrn_u16(d1, d2)); + TEST_INSTRUCTION("8210BAF3", vtrn_u32(d1, d2)); + TEST_INSTRUCTION("8210B2F3", vtrn_u8(d1, d2)); + TEST_INSTRUCTION("C420B6F3", vtrn_s16(q1, q2)); + TEST_INSTRUCTION("C420BAF3", vtrn_s32(q1, q2)); + TEST_INSTRUCTION("C420B2F3", vtrn_s8(q1, q2)); + TEST_INSTRUCTION("C420B6F3", vtrn_u16(q1, q2)); + TEST_INSTRUCTION("C420BAF3", vtrn_u32(q1, q2)); + TEST_INSTRUCTION("C420B2F3", vtrn_u8(q1, q2)); + TEST_INSTRUCTION("131812F2", vtst_s16(d1, d2, d3)); + TEST_INSTRUCTION("131822F2", vtst_s32(d1, d2, d3)); + TEST_INSTRUCTION("131802F2", vtst_s8(d1, d2, d3)); + TEST_INSTRUCTION("131812F2", vtst_u16(d1, d2, d3)); + TEST_INSTRUCTION("131822F2", vtst_u32(d1, d2, d3)); + TEST_INSTRUCTION("131802F2", vtst_u8(d1, d2, d3)); + TEST_INSTRUCTION("562814F2", vtst_s16(q1, q2, q3)); + TEST_INSTRUCTION("562824F2", vtst_s32(q1, q2, q3)); + TEST_INSTRUCTION("562804F2", vtst_s8(q1, q2, q3)); + TEST_INSTRUCTION("562814F2", vtst_u16(q1, q2, q3)); + TEST_INSTRUCTION("562824F2", vtst_u32(q1, q2, q3)); + TEST_INSTRUCTION("562804F2", vtst_u8(q1, q2, q3)); + TEST_INSTRUCTION("131D22FC", vudot_u8(d1, d2, d3)); + TEST_INSTRUCTION("562D24FC", vudot_u8(q1, q2, q3)); + TEST_INSTRUCTION("131D22FE", vudot_u8(d1, d2, d3.at(0))); + TEST_INSTRUCTION("331D22FE", vudot_u8(d1, d2, d3.at(1))); + TEST_INSTRUCTION("532D24FE", vudot_u8(q1, q2, d3.at(0))); + TEST_INSTRUCTION("732D24FE", vudot_u8(q1, q2, d3.at(1))); + TEST_INSTRUCTION("562C24FC", vummla_u8(q1, q2, q3)); + TEST_INSTRUCTION("031DA2FC", vusdot_s8(d1, d2, d3)); + TEST_INSTRUCTION("462DA4FC", vusdot_s8(q1, q2, q3)); + TEST_INSTRUCTION("031D82FE", vusdot_s8(d1, d2, d3.at(0))); + TEST_INSTRUCTION("231D82FE", vusdot_s8(d1, d2, d3.at(1))); + TEST_INSTRUCTION("432D84FE", vusdot_s8(q1, q2, d3.at(0))); + TEST_INSTRUCTION("632D84FE", vusdot_s8(q1, q2, d3.at(1))); + TEST_INSTRUCTION("462CA4FC", vusmmla_s8(q1, q2, q3)); + TEST_INSTRUCTION("0211B6F3", vuzp_s16(d1, d2)); + TEST_INSTRUCTION("0211B2F3", vuzp_s8(d1, d2)); + TEST_INSTRUCTION("0211B6F3", vuzp_u16(d1, d2)); + TEST_INSTRUCTION("0211B2F3", vuzp_u8(d1, d2)); + TEST_INSTRUCTION("8210BAF3", vuzp_s32(d1, d2)); + TEST_INSTRUCTION("8210BAF3", vuzp_u32(d1, d2)); + TEST_INSTRUCTION("4421B6F3", vuzp_s16(q1, q2)); + TEST_INSTRUCTION("4421BAF3", vuzp_s32(q1, q2)); + TEST_INSTRUCTION("4421B2F3", vuzp_s8(q1, q2)); + TEST_INSTRUCTION("4421B6F3", vuzp_u16(q1, q2)); + TEST_INSTRUCTION("4421BAF3", vuzp_u32(q1, q2)); + TEST_INSTRUCTION("4421B2F3", vuzp_u8(q1, q2)); + TEST_INSTRUCTION("8211B6F3", vzip_s16(d1, d2)); + TEST_INSTRUCTION("8211B2F3", vzip_s8(d1, d2)); + TEST_INSTRUCTION("8211B6F3", vzip_u16(d1, d2)); + TEST_INSTRUCTION("8211B2F3", vzip_u8(d1, d2)); + TEST_INSTRUCTION("8210BAF3", vzip_s32(d1, d2)); + TEST_INSTRUCTION("8210BAF3", vzip_u32(d1, d2)); + TEST_INSTRUCTION("C421B6F3", vzip_s16(q1, q2)); + TEST_INSTRUCTION("C421BAF3", vzip_s32(q1, q2)); + TEST_INSTRUCTION("C421B2F3", vzip_s8(q1, q2)); + TEST_INSTRUCTION("C421B6F3", vzip_u16(q1, q2)); + TEST_INSTRUCTION("C421BAF3", vzip_u32(q1, q2)); + TEST_INSTRUCTION("C421B2F3", vzip_u8(q1, q2)); +} + +static void ASMJIT_NOINLINE test_aarch32_assembler_rel(AssemblerTester& tester) noexcept { + using namespace a32; + + // NOTE: PC points to ` + 8` on ARM32. + a32::Assembler& a = tester.assembler; + + // Check whether the relative memory address calculation is encoded properly. + { + Label L0 = a.new_label(); + a.bind(L0); + a.adr(r1, L0); + tester.test_valid_instruction("L0: adr r1, L0", "08104FE2"); + } + + // Check whether the relative memory address calculation is encoded properly. + { + Label L0 = a.new_label(); + a.adr(r1, L0); + a.bind(L0); + tester.test_valid_instruction("adr r1, L0; L0:", "04104FE2"); + } + + // Check whether the relative memory read is encoded properly. + { + Label L0 = a.new_label(); + a.bind(L0); + a.ldr(r1, ptr(L0)); + tester.test_valid_instruction("L0: ldr r1, [L0]", "08101FE5"); + } + + // Check whether the relative memory read is encoded properly. + { + Label L0 = a.new_label(); + a.ldr(r1, ptr(L0)); + a.bind(L0); + tester.test_valid_instruction("ldr r1, [L0]; L0:", "04101FE5"); + } + + // Check whether the relative backward jump is encoded properly. + { + Label L0 = a.new_label(); + a.bind(L0); + a.b(L0); + tester.test_valid_instruction("L0: b L0", "FEFFFFEA"); + } + + // Check whether the relative forward jump is encoded properly. + { + Label L0 = a.new_label(); + a.b(L0); + a.bind(L0); + tester.test_valid_instruction("b L0; L0:", "FFFFFFEA"); + } +} + +bool test_aarch32_assembler(const TestSettings& settings) noexcept { + using namespace a32; + + AssemblerTester tester(Arch::kARM, settings); + tester.print_header("AArch32"); + + test_aarch32_assembler_base(tester); + test_aarch32_assembler_vec(tester); + test_aarch32_assembler_rel(tester); + + tester.print_summary(); + return tester.did_pass(); +} + +#undef TEST_INSTRUCTION + +#endif // !ASMJIT_NO_AARCH32 diff --git a/asmjit-testing/tests/asmjit_test_perf_a32.cpp b/asmjit-testing/tests/asmjit_test_perf_a32.cpp new file mode 100644 index 0000000..75e2006 --- /dev/null +++ b/asmjit-testing/tests/asmjit_test_perf_a32.cpp @@ -0,0 +1,638 @@ +// This file is part of AsmJit project +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include + +#if !defined(ASMJIT_NO_AARCH32) +#include + +#include +#include +#include + +using namespace asmjit; + +// Generates a long sequence of GP instructions. +template +static void generateGpSequenceInternal( + Emitter& cc, + const a32::Gp& a, const a32::Gp& b, const a32::Gp& c, const a32::Gp& d) { + + using namespace asmjit::a32; + + cc.mov(a, 0); + cc.mov(b, 1); + cc.mov(c, 2); + cc.mov(d, 3); + + cc.adc(a, b, c, lsl(d)); + cc.adc(a, b, c, lsr(d)); + cc.adc(a, b, c, asr(d)); + cc.adc(a, b, c, ror(d)); + cc.adc(a, b, c, lsl(8)); + cc.adc(a, b, c, lsr(8)); + cc.adc(a, b, c, asr(8)); + cc.adc(a, b, c, ror(8)); + cc.adc(a, b, 0xFF); + cc.adc(a, b, 0xFF00); + cc.adc(a, b, 0xFF000000); + cc.adc(a, b, 0xF000000F); + cc.adcs(a, b, c, lsl(d)); + cc.adcs(a, b, c, lsr(d)); + cc.adcs(a, b, c, asr(d)); + cc.adcs(a, b, c, ror(d)); + cc.adcs(a, b, c, lsl(8)); + cc.adcs(a, b, c, lsr(8)); + cc.adcs(a, b, c, asr(8)); + cc.adcs(a, b, c, ror(8)); + cc.adcs(a, b, 0xFF); + cc.adcs(a, b, 0xFF00); + cc.adcs(a, b, 0xFF000000); + cc.adcs(a, b, 0xF000000F); + cc.add(a, b, c, lsl(d)); + cc.add(a, b, c, lsr(d)); + cc.add(a, b, c, asr(d)); + cc.add(a, b, c, ror(d)); + cc.add(a, b, c, lsl(8)); + cc.add(a, b, c, lsr(8)); + cc.add(a, b, c, asr(8)); + cc.add(a, b, c, ror(8)); + cc.add(a, b, 0xFF); + cc.add(a, b, 0xFF00); + cc.add(a, b, 0xFF000000); + cc.add(a, b, 0xF000000F); + cc.adds(a, b, c, lsl(d)); + cc.adds(a, b, c, lsr(d)); + cc.adds(a, b, c, asr(d)); + cc.adds(a, b, c, ror(d)); + cc.adds(a, b, c, lsl(8)); + cc.adds(a, b, c, lsr(8)); + cc.adds(a, b, c, asr(8)); + cc.adds(a, b, c, ror(8)); + cc.adds(a, b, 0xFF); + cc.adds(a, b, 0xFF00); + cc.adds(a, b, 0xFF000000); + cc.adds(a, b, 0xF000000F); + cc.and_(a, b, c, lsl(d)); + cc.and_(a, b, c, lsr(d)); + cc.and_(a, b, c, asr(d)); + cc.and_(a, b, c, ror(d)); + cc.and_(a, b, c, lsl(8)); + cc.and_(a, b, c, lsr(8)); + cc.and_(a, b, c, asr(8)); + cc.and_(a, b, c, ror(8)); + cc.and_(a, b, 0xFF); + cc.and_(a, b, 0xFF00); + cc.and_(a, b, 0xFF000000); + cc.and_(a, b, 0xF000000F); + cc.ands(a, b, c, lsl(d)); + cc.ands(a, b, c, lsr(d)); + cc.ands(a, b, c, asr(d)); + cc.ands(a, b, c, ror(d)); + cc.ands(a, b, c, lsl(8)); + cc.ands(a, b, c, lsr(8)); + cc.ands(a, b, c, asr(8)); + cc.ands(a, b, c, ror(8)); + cc.ands(a, b, 0xFF); + cc.ands(a, b, 0xFF00); + cc.ands(a, b, 0xFF000000); + cc.ands(a, b, 0xF000000F); + cc.asr(a, b, c); + cc.asr(a, b, 3); + cc.asrs(a, b, c); + cc.asrs(a, b, 3); + cc.bfc(a, 3, 5); + cc.bfi(a, b, 3, 5); + cc.bic(a, b, c, lsl(d)); + cc.bic(a, b, c, lsr(d)); + cc.bic(a, b, c, asr(d)); + cc.bic(a, b, c, ror(d)); + cc.bic(a, b, c, lsl(8)); + cc.bic(a, b, c, lsr(8)); + cc.bic(a, b, c, asr(8)); + cc.bic(a, b, c, ror(8)); + cc.bic(a, b, 0xFF); + cc.bic(a, b, 0xFF00); + cc.bic(a, b, 0xFF000000); + cc.bic(a, b, 0xF000000F); + cc.bics(a, b, c, lsl(d)); + cc.bics(a, b, c, lsr(d)); + cc.bics(a, b, c, asr(d)); + cc.bics(a, b, c, ror(d)); + cc.bics(a, b, c, lsl(8)); + cc.bics(a, b, c, lsr(8)); + cc.bics(a, b, c, asr(8)); + cc.bics(a, b, c, ror(8)); + cc.bics(a, b, 0xFF); + cc.bics(a, b, 0xFF00); + cc.bics(a, b, 0xFF000000); + cc.bics(a, b, 0xF000000F); + cc.clz(a, b); + cc.cmn(a, b, lsl(c)); + cc.cmn(a, b, lsr(c)); + cc.cmn(a, b, asr(c)); + cc.cmn(a, b, ror(c)); + cc.cmn(a, b, lsl(8)); + cc.cmn(a, b, lsr(8)); + cc.cmn(a, b, asr(8)); + cc.cmn(a, b, ror(8)); + cc.cmn(a, 0xFF); + cc.cmn(a, 0xFF00); + cc.cmn(a, 0xFF000000); + cc.cmn(a, 0xF000000F); + cc.cmp(a, b, lsl(c)); + cc.cmp(a, b, lsr(c)); + cc.cmp(a, b, asr(c)); + cc.cmp(a, b, ror(c)); + cc.cmp(a, b, lsl(8)); + cc.cmp(a, b, lsr(8)); + cc.cmp(a, b, asr(8)); + cc.cmp(a, b, ror(8)); + cc.cmp(a, 0xFF); + cc.cmp(a, 0xFF00); + cc.cmp(a, 0xFF000000); + cc.cmp(a, 0xF000000F); + cc.crc32b(a, b, c); + cc.crc32cb(a, b, c); + cc.crc32ch(a, b, c); + cc.crc32cw(a, b, c); + cc.crc32h(a, b, c); + cc.crc32w(a, b, c); + cc.eor(a, b, c, lsl(d)); + cc.eor(a, b, c, lsr(d)); + cc.eor(a, b, c, asr(d)); + cc.eor(a, b, c, ror(d)); + cc.eor(a, b, c, lsl(8)); + cc.eor(a, b, c, lsr(8)); + cc.eor(a, b, c, asr(8)); + cc.eor(a, b, c, ror(8)); + cc.eor(a, b, 0xFF); + cc.eor(a, b, 0xFF00); + cc.eor(a, b, 0xFF000000); + cc.eor(a, b, 0xF000000F); + cc.eors(a, b, c, lsl(d)); + cc.eors(a, b, c, lsr(d)); + cc.eors(a, b, c, asr(d)); + cc.eors(a, b, c, ror(d)); + cc.eors(a, b, c, lsl(8)); + cc.eors(a, b, c, lsr(8)); + cc.eors(a, b, c, asr(8)); + cc.eors(a, b, c, ror(8)); + cc.eors(a, b, 0xFF); + cc.eors(a, b, 0xFF00); + cc.eors(a, b, 0xFF000000); + cc.eors(a, b, 0xF000000F); + cc.ldr(a, ptr(b, c)); + cc.ldr(a, ptr_pre(b, c)); + cc.ldr(a, ptr_post(b, c)); + cc.ldr(a, ptr(b, 4)); + cc.ldr(a, ptr_pre(b, 4)); + cc.ldr(a, ptr_post(b, 4)); + cc.ldrb(a, ptr(b, c)); + cc.ldrb(a, ptr_pre(b, c)); + cc.ldrb(a, ptr_post(b, c)); + cc.ldrb(a, ptr(b, 4)); + cc.ldrb(a, ptr_pre(b, 4)); + cc.ldrb(a, ptr_post(b, 4)); + cc.ldrbt(a, ptr_post(b, c)); + cc.ldrbt(a, ptr_post(b, 4)); + cc.ldrh(a, ptr(b, c)); + cc.ldrh(a, ptr_pre(b, c)); + cc.ldrh(a, ptr_post(b, c)); + cc.ldrh(a, ptr(b, 4)); + cc.ldrh(a, ptr_pre(b, 4)); + cc.ldrh(a, ptr_post(b, 4)); + cc.ldrht(a, ptr_post(b, c)); + cc.ldrht(a, ptr_post(b, 4)); + cc.ldrsb(a, ptr(b, c)); + cc.ldrsb(a, ptr_pre(b, c)); + cc.ldrsb(a, ptr_post(b, c)); + cc.ldrsb(a, ptr(b, 4)); + cc.ldrsb(a, ptr_pre(b, 4)); + cc.ldrsb(a, ptr_post(b, 4)); + cc.ldrsbt(a, ptr_post(b, c)); + cc.ldrsbt(a, ptr_post(b, 4)); + cc.ldrsh(a, ptr(b, c)); + cc.ldrsh(a, ptr_pre(b, c)); + cc.ldrsh(a, ptr_post(b, c)); + cc.ldrsh(a, ptr(b, 4)); + cc.ldrsh(a, ptr_pre(b, 4)); + cc.ldrsh(a, ptr_post(b, 4)); + cc.ldrsht(a, ptr_post(b, 4)); + cc.ldrsht(a, ptr_post(b, c)); + cc.ldrt(a, ptr_post(b, c)); + cc.ldrt(a, ptr_post(b, 4)); + cc.lsl(a, b, 3); + cc.lsl(a, b, c); + cc.lsls(a, b, 3); + cc.lsls(a, b, c); + cc.lsr(a, b, 3); + cc.lsr(a, b, c); + cc.lsrs(a, b, 3); + cc.lsrs(a, b, c); + cc.mla(a, b, c, d); + cc.mlas(a, b, c, d); + cc.mls(a, b, c, d); + cc.mov(a, b, lsl(c)); + cc.mov(a, b, lsr(c)); + cc.mov(a, b, asr(c)); + cc.mov(a, b, ror(c)); + cc.mov(a, b, lsl(8)); + cc.mov(a, b, lsr(8)); + cc.mov(a, b, asr(8)); + cc.mov(a, b, ror(8)); + cc.mov(a, 0xFF); + cc.mov(a, 0xFF00); + cc.mov(a, 0xFF000000); + cc.mov(a, 0xF000000F); + cc.movs(a, b, lsl(c)); + cc.movs(a, b, lsr(c)); + cc.movs(a, b, asr(c)); + cc.movs(a, b, ror(c)); + cc.movs(a, b, lsl(8)); + cc.movs(a, b, lsr(8)); + cc.movs(a, b, asr(8)); + cc.movs(a, b, ror(8)); + cc.movs(a, 0xFF); + cc.movs(a, 0xFF00); + cc.movs(a, 0xFF000000); + cc.movs(a, 0xF000000F); + cc.movt(a, 1); + cc.movw(a, 1); + cc.mul(a, b, c); + cc.muls(a, b, c); + cc.mvn(a, b, lsl(c)); + cc.mvn(a, b, lsr(c)); + cc.mvn(a, b, asr(c)); + cc.mvn(a, b, ror(c)); + cc.mvn(a, b, lsl(8)); + cc.mvn(a, b, lsr(8)); + cc.mvn(a, b, asr(8)); + cc.mvn(a, b, ror(8)); + cc.mvn(a, 0xFF); + cc.mvn(a, 0xFF00); + cc.mvn(a, 0xFF000000); + cc.mvn(a, 0xF000000F); + cc.mvns(a, b, lsl(c)); + cc.mvns(a, b, lsr(c)); + cc.mvns(a, b, asr(c)); + cc.mvns(a, b, ror(c)); + cc.mvns(a, b, lsl(8)); + cc.mvns(a, b, lsr(8)); + cc.mvns(a, b, asr(8)); + cc.mvns(a, b, ror(8)); + cc.mvns(a, 0xFF); + cc.mvns(a, 0xFF00); + cc.mvns(a, 0xFF000000); + cc.mvns(a, 0xF000000F); + cc.orr(a, b, c, lsl(d)); + cc.orr(a, b, c, lsr(d)); + cc.orr(a, b, c, asr(d)); + cc.orr(a, b, c, ror(d)); + cc.orr(a, b, c, lsl(8)); + cc.orr(a, b, c, lsr(8)); + cc.orr(a, b, c, asr(8)); + cc.orr(a, b, c, ror(8)); + cc.orr(a, b, 0xFF); + cc.orr(a, b, 0xFF00); + cc.orr(a, b, 0xFF000000); + cc.orr(a, b, 0xF000000F); + cc.orrs(a, b, c, lsl(d)); + cc.orrs(a, b, c, lsr(d)); + cc.orrs(a, b, c, asr(d)); + cc.orrs(a, b, c, ror(d)); + cc.orrs(a, b, c, lsl(8)); + cc.orrs(a, b, c, lsr(8)); + cc.orrs(a, b, c, asr(8)); + cc.orrs(a, b, c, ror(8)); + cc.orrs(a, b, 0xFF); + cc.orrs(a, b, 0xFF00); + cc.orrs(a, b, 0xFF000000); + cc.orrs(a, b, 0xF000000F); + cc.pkhbt(a, b, c, lsl(8)); + cc.pkhtb(a, b, c, asr(8)); + cc.qadd(a, b, c); + cc.qadd16(a, b, c); + cc.qadd8(a, b, c); + cc.qasx(a, b, c); + cc.qdadd(a, b, c); + cc.qdsub(a, b, c); + cc.qsax(a, b, c); + cc.qsub(a, b, c); + cc.qsub16(a, b, c); + cc.qsub8(a, b, c); + cc.rbit(a, b); + cc.rev(a, b); + cc.rev16(a, b); + cc.revsh(a, b); + cc.ror(a, b, 3); + cc.ror(a, b, c); + cc.rors(a, b, 3); + cc.rors(a, b, c); + cc.rrx(a, b); + cc.rrxs(a, b); + cc.rsb(a, b, c, lsl(d)); + cc.rsb(a, b, c, lsr(d)); + cc.rsb(a, b, c, asr(d)); + cc.rsb(a, b, c, ror(d)); + cc.rsb(a, b, c, lsl(8)); + cc.rsb(a, b, c, lsr(8)); + cc.rsb(a, b, c, asr(8)); + cc.rsb(a, b, c, ror(8)); + cc.rsb(a, b, 0xFF); + cc.rsb(a, b, 0xFF00); + cc.rsb(a, b, 0xFF000000); + cc.rsb(a, b, 0xF000000F); + cc.rsbs(a, b, c, lsl(d)); + cc.rsbs(a, b, c, lsr(d)); + cc.rsbs(a, b, c, asr(d)); + cc.rsbs(a, b, c, ror(d)); + cc.rsbs(a, b, c, lsl(8)); + cc.rsbs(a, b, c, lsr(8)); + cc.rsbs(a, b, c, asr(8)); + cc.rsbs(a, b, c, ror(8)); + cc.rsbs(a, b, 0xFF); + cc.rsbs(a, b, 0xFF00); + cc.rsbs(a, b, 0xFF000000); + cc.rsbs(a, b, 0xF000000F); + cc.rsc(a, b, c, lsl(d)); + cc.rsc(a, b, c, lsr(d)); + cc.rsc(a, b, c, asr(d)); + cc.rsc(a, b, c, ror(d)); + cc.rsc(a, b, c, lsl(8)); + cc.rsc(a, b, c, lsr(8)); + cc.rsc(a, b, c, asr(8)); + cc.rsc(a, b, c, ror(8)); + cc.rsc(a, b, 0xFF); + cc.rsc(a, b, 0xFF00); + cc.rsc(a, b, 0xFF000000); + cc.rsc(a, b, 0xF000000F); + cc.rscs(a, b, c, lsl(d)); + cc.rscs(a, b, c, lsr(d)); + cc.rscs(a, b, c, asr(d)); + cc.rscs(a, b, c, ror(d)); + cc.rscs(a, b, c, lsl(8)); + cc.rscs(a, b, c, lsr(8)); + cc.rscs(a, b, c, asr(8)); + cc.rscs(a, b, c, ror(8)); + cc.rscs(a, b, 0xFF); + cc.rscs(a, b, 0xFF00); + cc.rscs(a, b, 0xFF000000); + cc.rscs(a, b, 0xF000000F); + cc.sadd16(a, b, c); + cc.sadd8(a, b, c); + cc.sasx(a, b, c); + cc.sbc(a, b, c, lsl(d)); + cc.sbc(a, b, c, lsr(d)); + cc.sbc(a, b, c, asr(d)); + cc.sbc(a, b, c, ror(d)); + cc.sbc(a, b, c, lsl(8)); + cc.sbc(a, b, c, lsr(8)); + cc.sbc(a, b, c, asr(8)); + cc.sbc(a, b, c, ror(8)); + cc.sbc(a, b, 0xFF); + cc.sbc(a, b, 0xFF00); + cc.sbc(a, b, 0xFF000000); + cc.sbc(a, b, 0xF000000F); + cc.sbcs(a, b, c, lsl(d)); + cc.sbcs(a, b, c, lsr(d)); + cc.sbcs(a, b, c, asr(d)); + cc.sbcs(a, b, c, ror(d)); + cc.sbcs(a, b, c, lsl(8)); + cc.sbcs(a, b, c, lsr(8)); + cc.sbcs(a, b, c, asr(8)); + cc.sbcs(a, b, c, ror(8)); + cc.sbcs(a, b, 0xFF); + cc.sbcs(a, b, 0xFF00); + cc.sbcs(a, b, 0xFF000000); + cc.sbcs(a, b, 0xF000000F); + cc.sbfx(a, b, 3, 5); + cc.sdiv(a, b, c); + cc.sel(a, b, c); + cc.shadd16(a, b, c); + cc.shadd8(a, b, c); + cc.shasx(a, b, c); + cc.shsax(a, b, c); + cc.shsub16(a, b, c); + cc.shsub8(a, b, c); + cc.smlabb(a, b, c, d); + cc.smlabt(a, b, c, d); + cc.smlad(a, b, c, d); + cc.smladx(a, b, c, d); + cc.smlal(a, b, c, d); + cc.smlalbb(a, b, c, d); + cc.smlalbt(a, b, c, d); + cc.smlald(a, b, c, d); + cc.smlaldx(a, b, c, d); + cc.smlals(a, b, c, d); + cc.smlaltb(a, b, c, d); + cc.smlaltt(a, b, c, d); + cc.smlatb(a, b, c, d); + cc.smlatt(a, b, c, d); + cc.smlawb(a, b, c, d); + cc.smlawt(a, b, c, d); + cc.smlsd(a, b, c, d); + cc.smlsdx(a, b, c, d); + cc.smlsld(a, b, c, d); + cc.smlsldx(a, b, c, d); + cc.smmla(a, b, c, d); + cc.smmlar(a, b, c, d); + cc.smmls(a, b, c, d); + cc.smmlsr(a, b, c, d); + cc.smmul(a, b, c); + cc.smmulr(a, b, c); + cc.smuad(a, b, c); + cc.smuadx(a, b, c); + cc.smulbb(a, b, c); + cc.smulbt(a, b, c); + cc.smull(a, b, c, d); + cc.smulls(a, b, c, d); + cc.smultb(a, b, c); + cc.smultt(a, b, c); + cc.smulwb(a, b, c); + cc.smulwt(a, b, c); + cc.smusd(a, b, c); + cc.smusdx(a, b, c); + cc.ssat(a, 8, c); + cc.ssat(a, 8, c, lsl(8)); + cc.ssat(a, 8, c, asr(8)); + cc.ssat16(a, 8, c); + cc.ssax(a, b, c); + cc.ssub16(a, b, c); + cc.ssub8(a, b, c); + cc.str(a, ptr(b, c)); + cc.str(a, ptr_pre(b, c)); + cc.str(a, ptr_post(b, c)); + cc.str(a, ptr(b, 4)); + cc.str(a, ptr_pre(b, 4)); + cc.str(a, ptr_post(b, 4)); + cc.strb(a, ptr(b, c)); + cc.strb(a, ptr_pre(b, c)); + cc.strb(a, ptr_post(b, c)); + cc.strb(a, ptr(b, 4)); + cc.strb(a, ptr_pre(b, 4)); + cc.strb(a, ptr_post(b, 4)); + cc.strbt(a, ptr_post(b, c)); + cc.strbt(a, ptr_post(b, 4)); + cc.strh(a, ptr(b, c)); + cc.strh(a, ptr_pre(b, c)); + cc.strh(a, ptr_post(b, c)); + cc.strh(a, ptr(b, 4)); + cc.strh(a, ptr_pre(b, 4)); + cc.strh(a, ptr_post(b, 4)); + cc.strht(a, ptr_post(b, c)); + cc.strht(a, ptr_post(b, 4)); + cc.strt(a, ptr_post(b, c)); + cc.strt(a, ptr_post(b, 4)); + cc.sub(a, b, c, lsl(d)); + cc.sub(a, b, c, lsr(d)); + cc.sub(a, b, c, asr(d)); + cc.sub(a, b, c, ror(d)); + cc.sub(a, b, c, lsl(8)); + cc.sub(a, b, c, lsr(8)); + cc.sub(a, b, c, asr(8)); + cc.sub(a, b, c, ror(8)); + cc.sub(a, b, 0xFF); + cc.sub(a, b, 0xFF00); + cc.sub(a, b, 0xFF000000); + cc.sub(a, b, 0xF000000F); + cc.subs(a, b, c, lsl(d)); + cc.subs(a, b, c, lsr(d)); + cc.subs(a, b, c, asr(d)); + cc.subs(a, b, c, ror(d)); + cc.subs(a, b, c, lsl(8)); + cc.subs(a, b, c, lsr(8)); + cc.subs(a, b, c, asr(8)); + cc.subs(a, b, c, ror(8)); + cc.subs(a, b, 0xFF); + cc.subs(a, b, 0xFF00); + cc.subs(a, b, 0xFF000000); + cc.subs(a, b, 0xF000000F); + cc.sxtab(a, b, c, ror(8)); + cc.sxtab16(a, b, c, ror(8)); + cc.sxtah(a, b, c, ror(8)); + cc.sxtb(a, b, ror(8)); + cc.sxtb16(a, b, ror(8)); + cc.sxth(a, b, ror(8)); + cc.teq(a, b, lsl(c)); + cc.teq(a, b, lsr(c)); + cc.teq(a, b, asr(c)); + cc.teq(a, b, ror(c)); + cc.teq(a, b, lsl(8)); + cc.teq(a, b, lsr(8)); + cc.teq(a, b, asr(8)); + cc.teq(a, b, ror(8)); + cc.teq(a, 0xFF); + cc.teq(a, 0xFF00); + cc.teq(a, 0xFF000000); + cc.teq(a, 0xF000000F); + cc.tst(a, b, lsl(c)); + cc.tst(a, b, lsr(c)); + cc.tst(a, b, asr(c)); + cc.tst(a, b, ror(c)); + cc.tst(a, b, lsl(8)); + cc.tst(a, b, lsr(8)); + cc.tst(a, b, asr(8)); + cc.tst(a, b, ror(8)); + cc.tst(a, 0xFF); + cc.tst(a, 0xFF00); + cc.tst(a, 0xFF000000); + cc.tst(a, 0xF000000F); + cc.uadd16(a, b, c); + cc.uadd8(a, b, c); + cc.uasx(a, b, c); + cc.ubfx(a, b, 3, 5); + cc.udiv(a, b, c); + cc.uhadd16(a, b, c); + cc.uhadd8(a, b, c); + cc.uhasx(a, b, c); + cc.uhsax(a, b, c); + cc.uhsub16(a, b, c); + cc.uhsub8(a, b, c); + cc.umaal(a, b, c, d); + cc.umlal(a, b, c, d); + cc.umlals(a, b, c, d); + cc.umull(a, b, c, d); + cc.umulls(a, b, c, d); + cc.uqadd16(a, b, c); + cc.uqadd8(a, b, c); + cc.uqasx(a, b, c); + cc.uqsax(a, b, c); + cc.uqsub16(a, b, c); + cc.uqsub8(a, b, c); + cc.usad8(a, b, c); + cc.usada8(a, b, c, d); + cc.usat(a, 8, c, lsl(8)); + cc.usat(a, 8, c, asr(8)); + cc.usat16(a, 8, c); + cc.usax(a, b, c); + cc.usub16(a, b, c); + cc.usub8(a, b, c); + cc.uxtab(a, b, c, ror(8)); + cc.uxtab16(a, b, c, ror(8)); + cc.uxtah(a, b, c, ror(8)); + cc.uxtb(a, b, ror(8)); + cc.uxtb16(a, b, ror(8)); + cc.uxth(a, b, ror(8)); +} + +static void generateGpSequence(BaseEmitter& emitter, bool emitPrologEpilog) { + if (emitter.isAssembler()) { + a32::Assembler& cc = *emitter.as(); + + a32::Gp a = a32::r0; + a32::Gp b = a32::r1; + a32::Gp c = a32::r2; + a32::Gp d = a32::r3; + + if (emitPrologEpilog) { + FuncDetail func; + func.init(FuncSignature::build(), cc.environment()); + + FuncFrame frame; + frame.init(func); + frame.addDirtyRegs(a, b, c, d); + frame.finalize(); + + cc.emitProlog(frame); + generateGpSequenceInternal(cc, a, b, c, d); + cc.emitEpilog(frame); + } + else { + generateGpSequenceInternal(cc, a, b, c, d); + } + } +} + +template +static void benchmarkA32Function(Arch arch, uint32_t numIterations, const char* description, const EmitterFn& emitterFn) noexcept { + CodeHolder code; + printf("%s:\n", description); + + uint32_t instCount = 0; + +#ifndef ASMJIT_NO_BUILDER + instCount = asmjit_perf_utils::calculateInstructionCount(code, arch, [&](a32::Builder& emitter) { + emitterFn(emitter, false); + }); +#endif + + asmjit_perf_utils::bench(code, arch, numIterations, "[raw]", instCount, [&](a32::Assembler& emitter) { + emitterFn(emitter, false); + }); + + printf("\n"); +} + +void benchmarkA32Emitters(uint32_t numIterations) { + static const char description[] = "GpSequence (Sequence of GP instructions)"; + benchmarkA32Function(Arch::kARM, numIterations, description, [](BaseEmitter& emitter, bool emitPrologEpilog) { + generateGpSequence(emitter, emitPrologEpilog); + }); +} + +#endif // !ASMJIT_NO_AARCH32 diff --git a/asmjit/a32.h b/asmjit/a32.h new file mode 100644 index 0000000..cf95b70 --- /dev/null +++ b/asmjit/a32.h @@ -0,0 +1,55 @@ +// This file is part of AsmJit project +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef ASMJIT_A32_H_INCLUDED +#define ASMJIT_A32_H_INCLUDED + +//! \addtogroup asmjit_a32 +//! +//! ### Emitters +//! +//! - \ref a32::Assembler - AArch32 assembler (must read, provides examples). +//! - \ref a32::Builder - AArch32 builder. +//! - \ref a32::Compiler - AArch32 compiler. +//! - \ref a32::Emitter - AArch32 emitter (abstract). +//! +//! ### Supported Instructions +//! +//! - Emitters: +//! - \ref a32::EmitterExplicitT - Provides all instructions that use explicit operands, provides also utility +//! functions. The member functions provided are part of all AArch32 emitters. +//! +//! - Instruction representation: +//! - \ref a32::Inst::Id - instruction identifiers. +//! +//! ### Register Operands +//! +//! - \ref arm::Reg - Base class of any AArch32/AArch64 register. +//! - \ref a32::Gp - 32-bit general purpose register (AArch32) +//! - \ref arm::Vec - Vector (SIMD) register: +//! - \ref arm::VecS - 32-bit SIMD register. +//! - \ref arm::VecD - 64-bit SIMD register. +//! - \ref arm::VecV - 128-bit SIMD register. +//! +//! ### Memory Operands +//! +//! - \ref arm::Mem - AArch32/AArch64 memory operand that provides support for all ARM addressing features +//! including base, index, pre/post increment, and ARM-specific shift addressing and index extending. +//! +//! ### Other +//! +//! - \ref arm::Shift - Shift operation and value. +//! - \ref arm::DataType - Data type that is part of an instruction in AArch32 mode. +//! - \ref a32::Utils - Utilities that can help during code generation for AArch32. + +#include +#include +#include +#include +#include +#include + +#endif // ASMJIT_A32_H_INCLUDED + diff --git a/asmjit/arm/a32archtraits_p.h b/asmjit/arm/a32archtraits_p.h new file mode 100644 index 0000000..82afcac --- /dev/null +++ b/asmjit/arm/a32archtraits_p.h @@ -0,0 +1,76 @@ +// This file is part of AsmJit project +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#ifndef ASMJIT_ARM_A32ARCHTRAITS_P_H_INCLUDED +#define ASMJIT_ARM_A32ARCHTRAITS_P_H_INCLUDED + +#include +#include +#include +#include +#include + +ASMJIT_BEGIN_SUB_NAMESPACE(a32) + +//! \cond INTERNAL +//! \addtogroup asmjit_a32 +//! \{ + +static const constexpr ArchTraits a32_arch_traits = { + // SP/FP/LR/PC. + 13, 11, 14, 15, + + // Reserved. + { 0u, 0u, 0u }, + + // HW stack alignment (AArch32 requires stack aligned to 4 bytes at HW level). + 4, + + // Min/max stack offset. + 0, 0, // TODO: ARM32 + + // Supported register types. + 0u | (1u << uint32_t(RegType::kGp32 )) + | (1u << uint32_t(RegType::kVec32 )) + | (1u << uint32_t(RegType::kVec64 )) + | (1u << uint32_t(RegType::kVec128)), + + // Instruction hints [Gp, Vec, ExtraVirt2, ExtraVirt3]. + {{ + InstHints::kPushPop, + InstHints::kPushPop, + InstHints::kNoHints, + InstHints::kNoHints + }}, + + // TypeIdToRegType. + #define V(index) (index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kInt8) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kUInt8) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kInt16) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kUInt16) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kInt32) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kUInt32) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kIntPtr) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kUIntPtr) ? RegType::kGp32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kFloat32) ? RegType::kVec32 : \ + index + uint32_t(TypeId::_kBaseStart) == uint32_t(TypeId::kFloat64) ? RegType::kVec64 : RegType::kNone) + {{ ASMJIT_LOOKUP_TABLE_32(V, 0) }}, + #undef V + + // Word names of 8-bit, 16-bit, 32-bit, and 64-bit quantities. + { + ArchTypeNameId::kByte, + ArchTypeNameId::kHWord, + ArchTypeNameId::kWord, + ArchTypeNameId::kXWord + } +}; + +//! \} +//! \endcond + +ASMJIT_END_SUB_NAMESPACE + +#endif // ASMJIT_ARM_A32ARCHTRAITS_P_H_INCLUDED diff --git a/asmjit/arm/a32assembler.cpp b/asmjit/arm/a32assembler.cpp new file mode 100644 index 0000000..b46f222 --- /dev/null +++ b/asmjit/arm/a32assembler.cpp @@ -0,0 +1,11016 @@ +// This file is part of AsmJit project +// +// See asmjit.h or LICENSE.md for license and copyright information +// SPDX-License-Identifier: Zlib + +#include +#if !defined(ASMJIT_NO_AARCH32) + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +ASMJIT_BEGIN_SUB_NAMESPACE(a32) + +struct InstDispatchRecord { + uint8_t group; + uint8_t index; +}; + +// ${a32::DispatchData:Begin} +// ------------------- Automatically generated, do not edit ------------------- +static const InstDispatchRecord instDispatchTable[] = { + {0, 0}, {1, 0}, {1, 1}, {1, 2}, {1, 3}, {2, 0}, {3, 0}, {3, 1}, {3, 2}, {3, 3}, {1, 4}, {1, 5}, {4, 0}, {4, 1}, {5, 0}, + {6, 0}, {7, 0}, {1, 6}, {1, 7}, {8, 0}, {5, 1}, {9, 0}, {10, 0}, {10, 1}, {0, 1}, {0, 2}, {11, 0}, {12, 0}, {13, 0}, + {14, 0}, {14, 1}, {15, 0}, {16, 0}, {16, 1}, {17, 0}, {17, 1}, {17, 2}, {17, 3}, {17, 4}, {17, 5}, {11, 1}, {18, 0}, + {0, 3}, {0, 4}, {0, 5}, {19, 0}, {19, 1}, {1, 8}, {1, 9}, {11, 2}, {11, 3}, {20, 0}, {8, 1}, {19, 2}, {0, 6}, {0, 7}, + {0, 8}, {0, 9}, {0, 10}, {0, 11}, {0, 12}, {0, 13}, {0, 14}, {0, 15}, {0, 16}, {0, 17}, {0, 18}, {0, 19}, {0, 20}, + {21, 0}, {21, 1}, {21, 2}, {21, 3}, {22, 0}, {21, 4}, {21, 5}, {23, 0}, {23, 1}, {23, 2}, {23, 3}, {24, 0}, {24, 1}, + {25, 0}, {26, 0}, {21, 6}, {21, 7}, {22, 1}, {21, 8}, {27, 0}, {28, 0}, {27, 1}, {29, 0}, {27, 2}, {30, 0}, {25, 1}, + {31, 0}, {31, 1}, {31, 2}, {31, 3}, {32, 0}, {33, 0}, {34, 0}, {35, 0}, {36, 0}, {36, 1}, {36, 2}, {37, 0}, {37, 1}, + {38, 0}, {38, 1}, {32, 1}, {33, 1}, {34, 1}, {35, 1}, {39, 0}, {40, 0}, {41, 0}, {41, 1}, {37, 2}, {37, 3}, {11, 4}, + {0, 21}, {0, 22}, {1, 10}, {1, 11}, {42, 0}, {43, 0}, {44, 0}, {45, 0}, {46, 0}, {47, 0}, {12, 1}, {47, 1}, {48, 0}, + {17, 6}, {17, 7}, {17, 8}, {48, 1}, {48, 2}, {17, 9}, {48, 3}, {17, 10}, {17, 11}, {13, 1}, {13, 2}, {13, 3}, {13, 4}, + {49, 0}, {49, 1}, {49, 2}, {49, 3}, {31, 4}, {31, 5}, {13, 5}, {13, 6}, {1, 12}, {1, 13}, {1, 14}, {1, 15}, {17, 12}, + {17, 13}, {17, 14}, {12, 2}, {1, 16}, {1, 17}, {50, 0}, {41, 2}, {17, 15}, {51, 0}, {51, 1}, {11, 5}, {11, 6}, {52, 0}, + {53, 0}, {52, 1}, {52, 2}, {52, 3}, {53, 1}, {52, 4}, {52, 5}, {53, 2}, {52, 6}, {17, 16}, {17, 17}, {17, 18}, {17, 19}, + {17, 20}, {17, 21}, {18, 1}, {36, 3}, {36, 4}, {36, 5}, {36, 6}, {54, 0}, {54, 1}, {54, 2}, {54, 3}, {54, 4}, {54, 5}, + {54, 6}, {54, 7}, {36, 7}, {36, 8}, {36, 9}, {36, 10}, {36, 11}, {36, 12}, {54, 8}, {54, 9}, {36, 13}, {36, 14}, + {36, 15}, {36, 16}, {41, 3}, {41, 4}, {41, 5}, {41, 6}, {41, 7}, {41, 8}, {54, 10}, {54, 11}, {41, 9}, {41, 10}, + {41, 11}, {41, 12}, {41, 13}, {41, 14}, {55, 0}, {55, 1}, {55, 2}, {55, 3}, {56, 0}, {57, 0}, {17, 22}, {12, 3}, + {17, 23}, {17, 24}, {58, 0}, {58, 1}, {59, 0}, {59, 1}, {60, 0}, {59, 2}, {58, 2}, {23, 4}, {23, 5}, {23, 6}, {23, 7}, + {24, 2}, {24, 3}, {61, 0}, {62, 0}, {59, 3}, {59, 4}, {60, 1}, {59, 5}, {27, 3}, {28, 1}, {25, 2}, {1, 18}, {1, 19}, + {63, 0}, {64, 0}, {64, 1}, {64, 2}, {65, 0}, {65, 1}, {65, 2}, {0, 23}, {0, 24}, {14, 2}, {14, 3}, {17, 25}, {17, 26}, + {17, 27}, {50, 1}, {20, 1}, {41, 15}, {17, 28}, {17, 29}, {17, 30}, {17, 31}, {17, 32}, {17, 33}, {54, 12}, {54, 13}, + {54, 14}, {54, 15}, {54, 16}, {17, 34}, {17, 35}, {17, 36}, {17, 37}, {17, 38}, {17, 39}, {41, 16}, {36, 17}, {66, 0}, + {67, 0}, {17, 40}, {17, 41}, {17, 42}, {64, 3}, {64, 4}, {64, 5}, {65, 3}, {65, 4}, {65, 5}, {68, 0}, {69, 0}, {70, 0}, + {69, 1}, {71, 0}, {72, 0}, {72, 1}, {73, 0}, {73, 1}, {74, 0}, {75, 0}, {69, 2}, {76, 0}, {77, 0}, {78, 0}, {79, 0}, + {79, 1}, {79, 2}, {80, 0}, {81, 0}, {82, 0}, {82, 1}, {83, 0}, {84, 0}, {83, 1}, {84, 1}, {85, 0}, {86, 0}, {86, 1}, + {87, 0}, {88, 0}, {89, 0}, {90, 0}, {91, 0}, {91, 1}, {91, 2}, {92, 0}, {90, 1}, {93, 0}, {94, 0}, {95, 0}, {79, 3}, + {96, 0}, {97, 0}, {98, 0}, {99, 0}, {98, 1}, {97, 1}, {99, 1}, {100, 0}, {100, 1}, {68, 1}, {68, 2}, {101, 0}, {102, 0}, + {103, 0}, {104, 0}, {105, 0}, {106, 0}, {107, 0}, {108, 0}, {109, 0}, {110, 0}, {111, 0}, {112, 0}, {113, 0}, {70, 1}, + {114, 0}, {70, 2}, {114, 1}, {115, 0}, {116, 0}, {115, 1}, {116, 1}, {117, 0}, {118, 0}, {119, 0}, {120, 0}, {101, 1}, + {121, 0}, {122, 0}, {123, 0}, {71, 1}, {93, 1}, {93, 2}, {93, 3}, {124, 0}, {125, 0}, {126, 0}, {127, 0}, {126, 1}, + {128, 0}, {128, 1}, {129, 0}, {129, 1}, {130, 0}, {131, 0}, {132, 0}, {132, 1}, {133, 0}, {132, 2}, {134, 0}, {135, 0}, + {130, 1}, {136, 0}, {136, 1}, {133, 1}, {137, 0}, {138, 0}, {139, 0}, {140, 0}, {141, 0}, {138, 1}, {139, 1}, {131, 1}, + {75, 1}, {142, 0}, {72, 2}, {87, 1}, {143, 0}, {84, 2}, {68, 3}, {144, 0}, {144, 1}, {144, 2}, {144, 3}, {145, 0}, + {146, 0}, {146, 1}, {137, 1}, {147, 0}, {148, 0}, {142, 1}, {72, 3}, {149, 0}, {75, 2}, {150, 0}, {151, 0}, {151, 1}, + {151, 2}, {151, 3}, {152, 0}, {153, 0}, {154, 0}, {148, 1}, {155, 0}, {156, 0}, {157, 0}, {149, 1}, {158, 0}, {159, 0}, + {160, 0}, {161, 0}, {162, 0}, {111, 1}, {112, 1}, {113, 1}, {74, 1}, {75, 3}, {69, 3}, {76, 1}, {163, 0}, {164, 0}, + {165, 0}, {165, 1}, {84, 3}, {166, 0}, {167, 0}, {168, 0}, {150, 1}, {156, 1}, {169, 0}, {169, 1}, {11, 7}, {11, 8}, + {11, 9} +}; +// ---------------------------------------------------------------------------- +// ${a32::DispatchData:End} + +// a32::Assembler - Signature Checker +// ================================== + +// The assembler checks 8 least significant bits of each operand signature. This allows +// to check multiple signatures at a time, and to know the type of the operand and a possibly + +// Low 8-bits of an operand signatures stored in `sgn`. +static constexpr uint32_t kOpRegR = uint32_t(OperandType::kReg) | (uint32_t(RegType::kGp32) << 3); +static constexpr uint32_t kOpRegS = uint32_t(OperandType::kReg) | (uint32_t(RegType::kVec32) << 3); +static constexpr uint32_t kOpRegD = uint32_t(OperandType::kReg) | (uint32_t(RegType::kVec64) << 3); +static constexpr uint32_t kOpRegQ = uint32_t(OperandType::kReg) | (uint32_t(RegType::kVec128) << 3); + +static constexpr uint32_t kOpRegListR = uint32_t(OperandType::kRegList) | (uint32_t(RegType::kGp32) << 3); +static constexpr uint32_t kOpRegListS = uint32_t(OperandType::kRegList) | (uint32_t(RegType::kVec32) << 3); +static constexpr uint32_t kOpRegListD = uint32_t(OperandType::kRegList) | (uint32_t(RegType::kVec64) << 3); + +static constexpr uint32_t kOpMemB = uint32_t(OperandType::kMem) | (uint32_t(RegType::kGp32) << 3); +static constexpr uint32_t kOpMemAny = uint32_t(OperandType::kMem); +static constexpr uint32_t kOpImmI = uint32_t(OperandType::kImm) | (uint32_t(ImmType::kInt) << 3); +static constexpr uint32_t kOpImmF = uint32_t(OperandType::kImm) | (uint32_t(ImmType::kDouble) << 3); +static constexpr uint32_t kOpLabel = uint32_t(OperandType::kLabel); +static constexpr uint32_t kOpRegC = 0; + +// To easier calculate PC + 8 +static constexpr uint32_t kPCOffset = 8; + +namespace { + +// A mask that must be applied to 8-bit signatures. +// +// This is just to allow matching signatures where we don't care of some bits - currently only used to match kOpMemAny. +template +ASMJIT_INLINE_CONSTEXPR uint32_t op_signature_mask() noexcept { + return kValue == kOpMemAny ? 0x07u : 0xFFu; +} + +template +ASMJIT_INLINE_CONSTEXPR uint32_t op_signature_mask_0_to_3() noexcept { + return (op_signature_mask() << 0) | + (op_signature_mask() << 8) | + (op_signature_mask() << 16) | + (op_signature_mask() << 24) ; +} + +template +ASMJIT_INLINE_CONSTEXPR uint64_t op_signature_mask_0_to_5() noexcept { + return (uint64_t(op_signature_mask()) << 0) | + (uint64_t(op_signature_mask()) << 8) | + (uint64_t(op_signature_mask()) << 16) | + (uint64_t(op_signature_mask()) << 24) | + (uint64_t(op_signature_mask()) << 32) | + (uint64_t(op_signature_mask()) << 40) | (uint64_t(0xFFFFu) << 48); +} + +template +ASMJIT_INLINE_CONSTEXPR uint64_t op_signature_combine_0_to_3() noexcept { + return (o0 << 0) | + (o1 << 8) | + (o2 << 16) | + (o3 << 24) ; +} + +template +ASMJIT_INLINE_CONSTEXPR uint64_t op_signature_combine_0_to_5() noexcept { + return (uint64_t(o0) << 0) | + (uint64_t(o1) << 8) | + (uint64_t(o2) << 16) | + (uint64_t(o3) << 24) | + (uint64_t(o4) << 32) | + (uint64_t(o5) << 40) ; +} + +#if ASMJIT_ARCH_BITS >= 64 +struct SignatureChecker { + uint64_t _0to5; + + ASMJIT_INLINE void init(const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_& o3, const Operand_& o4, const Operand_& o5) noexcept { + _0to5 = (uint64_t(o0._signature._bits & 0xFFu) ) | + (uint64_t(o1._signature._bits & 0xFFu) << 8) | + (uint64_t(o2._signature._bits & 0xFFu) << 16) | + (uint64_t(o3._signature._bits & 0xFFu) << 24) | + (uint64_t(o4._signature._bits & 0xFFu) << 32) | + (uint64_t(o5._signature._bits & 0xFFu) << 40) ; + } + + ASMJIT_INLINE bool empty() const noexcept { + return _0to5 == 0u; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint64_t kMask = op_signature_mask_0_to_5(); + constexpr uint64_t kPred = op_signature_combine_0_to_5(); + + return (_0to5 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint64_t kMask = op_signature_mask_0_to_5(); + constexpr uint64_t kPred = op_signature_combine_0_to_5(); + + return (_0to5 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint64_t kMask = op_signature_mask_0_to_5(); + constexpr uint64_t kPred = op_signature_combine_0_to_5(); + + return (_0to5 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint64_t kMask = op_signature_mask_0_to_5(); + constexpr uint64_t kPred = op_signature_combine_0_to_5(); + + return (_0to5 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint64_t kMask = op_signature_mask_0_to_5(); + constexpr uint64_t kPred = op_signature_combine_0_to_5(); + + return (_0to5 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint64_t kMask = op_signature_mask_0_to_5(); + constexpr uint64_t kPred = op_signature_combine_0_to_5(); + + return (_0to5 & kMask) == kPred; + } +}; +#else +struct SignatureChecker { + uint32_t _0to3; + uint32_t _4to5; + + ASMJIT_INLINE void init(const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_& o3, const Operand_& o4, const Operand_& o5) noexcept { + _0to3 = ((o0._signature._bits & 0xFFu) ) | + ((o1._signature._bits & 0xFFu) << 8) | + ((o2._signature._bits & 0xFFu) << 16) | + ((o3._signature._bits & 0xFFu) << 24) ; + _4to5 = ((o4._signature._bits & 0xFFu) ) | + ((o5._signature._bits & 0xFFu) << 8) ; + } + + ASMJIT_INLINE bool empty() const noexcept { + return _0to3 == 0u; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint32_t kMask = op_signature_mask_0_to_3(); + constexpr uint32_t kPred = op_signature_combine_0_to_3(); + + return (_0to3 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint32_t kMask = op_signature_mask_0_to_3(); + constexpr uint32_t kPred = op_signature_combine_0_to_3(); + + return (_0to3 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint32_t kMask = op_signature_mask_0_to_3(); + constexpr uint32_t kPred = op_signature_combine_0_to_3(); + + return (_0to3 & kMask) == kPred; + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint32_t kMask = op_signature_mask_0_to_3(); + constexpr uint32_t kPred = op_signature_combine_0_to_3(); + + return bool(unsigned((_0to3 & kMask) == kPred) & + unsigned(_4to5 == 0)); + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint32_t kMask0To3 = op_signature_mask_0_to_3(); + constexpr uint32_t kPred0To3 = op_signature_combine_0_to_3(); + constexpr uint32_t kMask4To5 = op_signature_mask_0_to_3(); + constexpr uint32_t kPred4To5 = op_signature_combine_0_to_3(); + + return bool(unsigned((_0to3 & kMask0To3) == kPred0To3) & + unsigned((_4to5 & kMask4To5) == kPred4To5)); + } + + template + ASMJIT_INLINE bool test() const noexcept { + constexpr uint32_t kMask0To3 = op_signature_mask_0_to_3(); + constexpr uint32_t kPred0To3 = op_signature_combine_0_to_3(); + constexpr uint32_t kMask4To5 = op_signature_mask_0_to_3(); + constexpr uint32_t kPred4To5 = op_signature_combine_0_to_3(); + + return bool(unsigned((_0to3 & kMask0To3) == kPred0To3) & + unsigned((_4to5 & kMask4To5) == kPred4To5)); + } +}; +#endif + +} // {anonymous} + +// a32::Assembler - DT Checks +// ========================== + +namespace { + +static ASMJIT_INLINE uint32_t make_dt_bits(DataType dt) noexcept { return (1u << uint32_t(dt)); } + +template +static ASMJIT_INLINE uint32_t make_dt_bits(DataType first, Dts&&... dts) noexcept { return make_dt_bits(first) | make_dt_bits(std::forward(dts)...); } + +static ASMJIT_INLINE bool is_dt_single(uint32_t dtBits, DataType dt) noexcept { + return dtBits == uint32_t(dt); +} + +static ASMJIT_INLINE bool is_dt_multiple(uint32_t dtBits, uint32_t dtAllowedMask) noexcept { + return dtBits < 16 && ((1u << dtBits) & dtAllowedMask) != 0; +} + +static ASMJIT_INLINE bool is_dt_and_dt2_single(uint32_t dtBits, DataType dt, DataType dt2) noexcept { + uint32_t dtPredicate = uint32_t(dt) | (uint32_t(dt2) << 4); + return dtBits == dtPredicate; +} + +} // {anonymous} + +// a32::Assembler - Operand Checks +// =============================== + +namespace { + +static ASMJIT_INLINE OperandSignature combined_signature(const Operand_& op) noexcept { + return op._signature; +} + +template +static ASMJIT_INLINE OperandSignature combined_signature(const Operand_& op, Args&&... args) noexcept { + return op._signature | combined_signature(std::forward(args)...); +} + +static ASMJIT_INLINE bool is_pure_vec_signature(OperandSignature signature) noexcept { + return (signature._bits & (Vec::kSignatureRegElementFlagMask)) == 0u; +}; + +static ASMJIT_INLINE bool is_element_vec_signature(OperandSignature signature) noexcept { + return (signature._bits & (Vec::kSignatureRegElementFlagMask)) == Vec::kSignatureRegElementFlagMask; +}; + +template +static ASMJIT_INLINE bool is_pure_vec(Args&&... args) noexcept { + return is_pure_vec_signature(combined_signature(std::forward(args)...)); +} + +template +static ASMJIT_INLINE bool is_element_vec(Args&&... args) noexcept { + return is_element_vec_signature(combined_signature(std::forward(args)...)); +} + +static ASMJIT_INLINE bool is_consecutive(uint32_t inc, const Reg& o0, const Reg& o1) noexcept { + return o0.id() + inc == o1.id(); +} +static ASMJIT_INLINE bool is_consecutive(uint32_t inc, const Reg& o0, const Reg& o1, const Reg& o2) noexcept { + return bool(unsigned(o0.id() + inc == o1.id()) & unsigned(o1.id() + inc == o2.id())); +} + +static ASMJIT_INLINE bool is_consecutive(uint32_t inc, const Reg& o0, const Reg& o1, const Reg& o2, const Reg& o3) noexcept { + return bool(unsigned(o0.id() + inc == o1.id()) & unsigned(o1.id() + inc == o2.id()) & unsigned(o2.id() + inc == o3.id())); +} + +[[maybe_unused]] +static ASMJIT_INLINE bool check_uoffset(int32_t offset, uint32_t nBits, uint32_t lsbCut) noexcept { + uint32_t uoff = uint32_t(offset); + uint32_t mask = Support::lsb_mask(nBits) << lsbCut; + return (uoff & ~mask) == 0; +} + +static ASMJIT_INLINE bool check_soffset(int32_t offset, uint32_t nBits, uint32_t lsbCut) noexcept { + uint32_t uoff = offset >= 0 ? uint32_t(offset) : Support::neg(uint32_t(offset)); + uint32_t mask = Support::lsb_mask(nBits) << lsbCut; + return (uoff & ~mask) == 0; +} + +static ASMJIT_INLINE bool is_mem_pc_rel(const Mem& mem) noexcept { + static constexpr uint32_t kAllowedTypeMask = (1u << uint32_t(RegType::kNone )) | + (1u << uint32_t(RegType::kLabelTag)) | + (1u << uint32_t(RegType::kGp32 )) ; + + uint32_t type_bit = 1u << uint32_t(mem.base_type()); + uint32_t base_id = mem.base_id(); + + return (kAllowedTypeMask & type_bit) && (base_id == 15u || mem.base_type() != RegType::kGp32) && !mem.has_index() && mem.is_fixed_offset(); +} + +} // {anonymous} + +// a32::Assembler - Immediate Encoders - GP +// ======================================== + +namespace { + +static ASMJIT_INLINE uint32_t encodeCond(uint32_t cc) noexcept { return (cc - 2u) & 0xFu; } +static ASMJIT_INLINE uint32_t szFromDt(uint32_t dtBits) noexcept { return (dtBits - 1) & 0x3; } +static ASMJIT_INLINE uint32_t uBitFromDt(uint32_t dtBits) noexcept { return uint32_t(dtBits >= uint32_t(DataType::kU8) && dtBits <= uint32_t(DataType::kU64)); } +static ASMJIT_INLINE uint32_t pBitFromDt(uint32_t dtBits) noexcept { return uint32_t(dtBits >= uint32_t(DataType::kP8) && dtBits <= uint32_t(DataType::kP64)); } + +struct ImmEncode { + uint32_t _imm; + ASMJIT_INLINE uint32_t imm() const noexcept { return _imm; } +}; + +struct ImmAEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& immA) noexcept { + return Utils::encode_aarch32_imm(immA.value_as(), Out(_imm)); + } +}; + +struct SsatImmEncode : public ImmEncode { + uint32_t _n; + ASMJIT_INLINE uint32_t n() const noexcept { return _n; } + + ASMJIT_INLINE bool init(const Imm& sat) noexcept { + uint64_t sat_64 = sat.value_as() - 1u; + + if (sat_64 >= 32u) + return false; + + _imm = uint32_t(sat_64); + _n = 0u; + return true; + } + + ASMJIT_INLINE bool init(const Imm& sat, const Imm& n) noexcept { + uint64_t sat_64 = sat.value_as() - 1u; + uint64_t n_64 = n.value_as(); + + if ((sat_64 | n_64) >= 32u) + return false; + + _imm = uint32_t(sat_64); + _n = uint32_t(n_64); + return true; + } +}; + +struct Ssat16ImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& ror) noexcept { + uint64_t value = ror.value_as() - 1u; + + if (value >= 16u) + return false; + + _imm = uint32_t(value); + return true; + } +}; + +struct Ror8ImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& ror) noexcept { + uint64_t value = ror.value_as(); + uint64_t mask = ~uint64_t(Support::lsb_mask(2) << 3); + + _imm = uint32_t((value >> 3) & 0x3u); + return (value & mask) == 0; + } +}; + +struct BfcBfiImmEncode { + uint32_t _lsb; + uint32_t _msb; + + ASMJIT_INLINE uint32_t lsb() const noexcept { return _lsb; } + ASMJIT_INLINE uint32_t msb() const noexcept { return _msb; } + + ASMJIT_INLINE bool init(const Imm& lsb, const Imm& width) noexcept { + uint64_t lsb_64 = lsb.value_as(); + uint64_t width_64 = width.value_as(); + + if (lsb_64 >= 32 || width_64 == 0 || width_64 > 32u - lsb_64) + return false; + + _lsb = uint32_t(lsb_64); + _msb = _lsb + uint32_t(width_64) - 1u; + return true; + } +}; + +struct SbfxUbfxImmEncode { + uint32_t _lsb; + uint32_t _widthM1; + + ASMJIT_INLINE uint32_t lsb() const noexcept { return _lsb; } + ASMJIT_INLINE uint32_t widthM1() const noexcept { return _widthM1; } + + ASMJIT_INLINE bool init(const Imm& lsb, const Imm& width) noexcept { + uint64_t lsb_64 = lsb.value_as(); + uint64_t widthM1_64 = width.value_as() - 1u; + + if ((lsb_64 | widthM1_64) >= 32u) + return false; + + _lsb = uint32_t(lsb_64); + _widthM1 = uint32_t(widthM1_64); + return true; + } +}; + +} // {anonymous} + +// a32::Assembler - Immediate Encoders - VFP/ASIMD +// =============================================== + +namespace { + +// Encodes immediate value for VAND, VBIC, VORN, VORR instructions. +// +// These only operate on 16-bit and 32-bit vectors - the immediate is an 8-bit value with a possible shift. +struct VecBicOrrImmEncode : public ImmEncode { + uint32_t _cmode; + ASMJIT_INLINE uint32_t cmode() const noexcept { return _cmode; } + + ASMJIT_INLINE bool initBicOrr(uint32_t sz, uint32_t cmodeBase, uint32_t imm) noexcept { + ASMJIT_ASSERT(sz >= 1u); + + uint32_t shift = 0; + uint32_t maxShift = (8u << sz) - 8u; + + if (imm) { + shift = Support::ctz(imm) & ~0x7u; + imm >>= shift; + + if (imm > 0xFFu || shift > maxShift) + return false; + } + + _imm = imm; + _cmode = cmodeBase | (sz == 1u ? 0x8u : 0x0u) | ((shift >> 3u) << 1u); + + return true; + } + + ASMJIT_INLINE bool init(uint32_t sz, uint32_t inv, const Imm& immV) noexcept { + static const uint64_t maskTable[4] = { 0xFFu, 0xFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu }; + + uint64_t imm_64 = immV.value_as(); + uint64_t mask_64 = maskTable[sz]; + + imm_64 ^= mask_64 & Support::bool_as_mask(inv); + if (imm_64 & ~mask_64) + return false; + + uint32_t immLo = uint32_t(imm_64 & 0xFFFFFFFFu); + uint32_t immHi = uint32_t(imm_64 >> 32); + + // Change the operation to 32-bit if the pattern repeats two 32-bit values. + if (sz == 3) { + if (immLo != immHi) + return false; + sz = 2; + } + else { + if (immHi) + return false; + } + + // Change the operation to 16-bit if the pattern repeats two 16-bit values. + if (sz == 2 && (immLo >> 16) == (immLo & 0xFFFFu)) { + sz = 1; + immLo >>= 16; + } + + return initBicOrr(sz, 0x1u, immLo); + } +}; + +// Encodes immediate value for VMOV instruction. +struct VecMovImmEncode : public VecBicOrrImmEncode { + uint32_t _op; + ASMJIT_INLINE uint32_t op() const noexcept { return _op; } + + bool init(uint32_t sz, uint32_t inv, const Imm& immV) noexcept { + static const uint64_t maskTable[4] = { 0xFFu, 0xFFFFu, 0xFFFFFFFFu, 0xFFFFFFFFFFFFFFFFu }; + + uint64_t imm_64 = immV.value_as(); + uint64_t mask_64 = maskTable[sz]; + + imm_64 ^= mask_64 & Support::bool_as_mask(inv); + if (imm_64 & ~mask_64) + return false; + + // First try the same cmode|op combinations as used by VBIC/VORR. + uint32_t immLo = uint32_t(imm_64 & 0xFFFFFFFFu); + uint32_t immHi = uint32_t(imm_64 >> 32); + + // Change the operation to 32-bit if a 64-bit pattern repeats two 32-bit values. + if (sz == 3) { + if (immLo == immHi) { + immHi = 0; + sz = 2; + } + } + else { + if (immHi) + return false; + } + + // Change the operation to 16-bit if a 32-bit pattern repeats two 16-bit values. + if (sz == 2 && (immLo >> 16) == (immLo & 0xFFFFu)) { + sz = 1; + immLo >>= 16; + } + + // VBIC/VORR specific encodings. + _op = 0; + if ((sz == 1u || sz == 2u) && initBicOrr(sz, 0x0u, immLo)) + return true; + + // VMOV specific encoding {cmode=110x op=0} - either 0x0000xxFF or 0x00xxFFFF. + if (sz == 2u) { + if ((immLo & 0xFFFF00FFu) == 0x000000FF) { + _imm = immLo >> 8u; + _cmode = 0xCu; + return true; + } + + if ((immLo & 0xFF00FFFFu) == 0x0000FFFF) { + _imm = immLo >> 16u; + _cmode = 0xDu; + return true; + } + } + + // Change the operation to 8-bit if a 16-bit pattern repeats two 8-bit values. + if (sz == 1u && (immLo >> 8u) == (immLo & 0xFFu)) { + sz = 0; + immLo >>= 8; + } + + // VMOV specific encoding {cmode=1110 op=0} - 8-bit pattern replicated to all bytes. + if (sz == 0u) { + _imm = immLo; + _cmode = 0xEu; + return true; + } + + // [ _____ ] + // VMOV specific encoding {cmode=1111 op=0} - 32-bit pattern [abbbbbbcdefgh0000000000000000000]. + if (sz == 2u) { + uint32_t b30 = (immLo >> 30u) & 0x1u; + + if (immLo == ((immLo & 0xC1F80000u) | (((b30 ^ 1u) * 0x1Fu) << 25u))) { + _imm = (((immLo >> 24u) & 0xC0u) ^ 0x40u) | ((immLo >> 25) & 0x3Fu); + return true; + } + } + + // VMOV specific encoding {cmode=1110 op=1} - 64-bit pattern where each byte is either 0x00 or 0xFF. + { + uint64_t byte_mask = imm_64; + + if (sz == 1u) { + byte_mask |= byte_mask << 16; + byte_mask |= byte_mask << 32; + } + else if (sz == 2u) { + byte_mask |= byte_mask << 32; + } + + if (Utils::is_byte_mask_imm(byte_mask)) { + _op = 1u; + _imm = Utils::encode_imm64_byte_mask_to_imm8(byte_mask); + _cmode = 0xEu; + return true; + } + } + + return false; + } +}; + +struct VecVFPImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& immVFP) noexcept { + double d = immVFP.type() == ImmType::kInt ? double(immVFP.value()) : immVFP.value_as(); + + if (!Utils::is_fp64_imm8(d)) + return false; + + _imm = Utils::encode_fp64_to_imm8(d); + return true; + } +}; + +struct VecRot1ImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& rot1) noexcept { + uint64_t value = rot1.value_as(); + _imm = value == 90u ? 0u : value == 270u ? 1u : 0xFFFFFFFFu; + return _imm != 0xFFFFFFFFu; + } +}; + +struct VecRot2ImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& rot2) noexcept { + uint64_t value = rot2.value_as(); + _imm = value == 0u ? 0u : + value == 90u ? 1u : + value == 180u ? 2u : + value == 270u ? 3u : 0xFFFFFFFFu; + return _imm != 0xFFFFFFFFu; + } +}; + +struct VecFBitsVFPEncode : public ImmEncode { + ASMJIT_INLINE bool init(uint32_t szInBits, const Imm& fbits) noexcept { + uint64_t value = fbits.value_as(); + if (value >= szInBits) + return false; + + _imm = szInBits - uint32_t(value); + return true; + } +}; + +struct VecFBitsASIMDEncode : public ImmEncode { + ASMJIT_INLINE bool init(const Imm& fbits) noexcept { + uint64_t value = fbits.value_as(); + if (value >= 64u) + return false; + + _imm = 64u - uint32_t(value); + return true; + } +}; + +struct VecShiftPImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(uint32_t szField, const Imm& n) noexcept { + uint64_t value = n.value_as(); + if (value >= (8u << szField)) + return false; + + _imm = (8u << szField) + uint32_t(value); + return true; + } +}; + +struct VecShiftNImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(uint32_t szField, const Imm& n) noexcept { + uint64_t value = n.value_as(); + if (value - 1u >= (8u << szField)) + return false; + + _imm = (16u << szField) - uint32_t(value); + return true; + } +}; + +struct VecShiftNarrowImmEncode : public ImmEncode { + ASMJIT_INLINE bool init(uint32_t szField, const Imm& n) noexcept { + uint64_t value = n.value_as(); + if (value - 1u >= (4u << szField)) + return false; + + _imm = (8u << szField) - uint32_t(value); + return true; + } +}; + +} // {anonymous} + +// a32::Assembler - RegList Encoders +// ======================================= + +namespace { + +struct GpListImmEncode { + uint32_t _mask; + + ASMJIT_INLINE bool init(const BaseRegList& op, RegMask allowedMask = 0xFFFFu) noexcept { + _mask = op.list(); + if (!_mask) + return false; + + if (_mask & ~allowedMask) + return false; + + return true; + } + + ASMJIT_INLINE uint32_t immMask() const noexcept { return _mask; } +}; + +struct VecSListImmEncode { + uint32_t _index; + uint32_t _count; + + ASMJIT_INLINE bool init(const BaseRegList& op) noexcept { + RegMask mask = op.list(); + if (!mask) + return false; + + // The registers must be consecutive, so find index and count. + _index = Support::ctz(mask); + mask = mask >> _index; + + _count = Support::ctz(~mask); + mask = mask >> _count; + + return mask == 0u && _index + _count <= 32u; + } + + ASMJIT_INLINE uint32_t immVd() const noexcept { return _index; } + ASMJIT_INLINE uint32_t immCount() const noexcept { return _count; } +}; + +struct VecDListImmEncode { + uint32_t _index; + uint32_t _count; + + ASMJIT_INLINE bool init(const BaseRegList& op) noexcept { + RegMask mask = op.list(); + if (!mask) + return false; + + // The registers must be consecutive, so find index and count. + _index = Support::ctz(mask); + mask = mask >> _index; + + _count = Support::ctz(~mask); + mask = mask >> _count; + + return mask == 0u && _index + _count <= 32u; + } + + ASMJIT_INLINE uint32_t immVd() const noexcept { return _index; } + ASMJIT_INLINE uint32_t immCount() const noexcept { return _count * 2u; } +}; + +} // {anonymous} + +// a32::Assembler - Offset Encoders +// ================================ + +namespace { + +struct SOffsetEncode { + uint32_t _imm; + uint32_t _u; + + ASMJIT_INLINE SOffsetEncode(const Mem& m) noexcept { + // Memory operand with base register always represents index as 32-bit signed integer. This means + // it's safe to use `m.offset_lo32()` instead of `m.offset()` to avoid working with 64-bit offset. + uint32_t offset = uint32_t(m.offset_lo32()); + uint32_t negMsk = uint32_t(int32_t(offset) >> 31); + + _imm = (offset ^ negMsk) - negMsk; + _u = negMsk + 1u; + } + + ASMJIT_INLINE uint32_t imm() const noexcept { return _imm; } + ASMJIT_INLINE uint32_t u() const noexcept { return _u; } +}; + +} // {anonymous} + +static ASMJIT_INLINE InstId recombine_inst_id(InstId inst_id, uint32_t cc, uint32_t dt) noexcept { + return inst_id | (cc << Support::ctz_const) + | (dt << Support::ctz_const); +} + +// a32::Assembler - Construction & Destruction +// =========================================== + +Assembler::Assembler(CodeHolder* code) noexcept : BaseAssembler() { + _arch_mask = (uint64_t(1) << uint32_t(Arch::kARM )) | + (uint64_t(1) << uint32_t(Arch::kThumb)) ; + + if (code) { + code->attach(this); + } +} + +Assembler::~Assembler() noexcept {} + +// a32::Assembler - Emit +// ===================== + +Error Assembler::_emit(InstId inst_id, const Operand_& o0, const Operand_& o1, const Operand_& o2, const Operand_* opExt) { + using DT = DataType; + + // Logging/Validation/Error. + constexpr InstOptions kRequiresSpecialHandling = InstOptions::kReserved; + + // Instruction payload extraction. + constexpr uint32_t kCondMask = uint32_t(InstIdParts::kARM_Cond); + constexpr uint32_t kDtMask = uint32_t(InstIdParts::kA32_DT) | uint32_t(InstIdParts::kA32_DT2); + + // Operand #index in `opExt[]`. + constexpr uint32_t kOp3 = EmitterUtils::kOp3; + constexpr uint32_t kOp4 = EmitterUtils::kOp4; + constexpr uint32_t kOp5 = EmitterUtils::kOp5; + + Error err; + CodeWriter writer(this); + + uint32_t cc = (inst_id & kCondMask) >> Support::ctz_const; + uint32_t dtBits = (inst_id & kDtMask) >> Support::ctz_const; + + inst_id &= ~(kCondMask | kDtMask); + if (inst_id >= Inst::_kIdCount) + inst_id = 0u; + + uint32_t opcode; + + const Operand_& o3 = opExt[kOp3]; + const Operand_& o4 = opExt[kOp4]; + const Operand_& o5 = opExt[kOp5]; + + const Mem* mem = nullptr; + const Operand_* rel = nullptr; + + // uint32_t multipleOpData[4]; + // uint32_t multipleOpCount; + + // These are only used when instruction uses a relative displacement. + OffsetFormat offset_format; + uint64_t offsetValue; + + // Combine all instruction options and also check whether the instruction + // is valid. All options that require special handling (including invalid + // instruction) are handled by the next branch. + InstOptions options = InstOptions(inst_id == 0) | InstOptions((size_t)(_buffer_end - writer.cursor()) < 4) | inst_options() | forced_inst_options(); + InstDispatchRecord idr; + + // Combined signatures of input operands for quick checks. + SignatureChecker sgn; + sgn.init(o0, o1, o2, o3, o4, o5); + + if (Support::test(options, kRequiresSpecialHandling)) { + if (ASMJIT_UNLIKELY(!_code)) + return report_error(make_error(Error::kNotInitialized)); + + // Unknown instruction. + if (ASMJIT_UNLIKELY(inst_id == 0)) + goto InvalidInstruction; + + // Grow request, happens rarely. + err = writer.ensure_space(this, 4); + if (ASMJIT_UNLIKELY(err != Error::kOk)) + goto Emit_Failed; + } + + // ${a32::Assembler::Impl:Begin} + // ------------------- Automatically generated, do not edit ------------------- + idr = instDispatchTable[inst_id]; + switch (idr.group) { + case 0: { + break; + } + + case 1: { + static const uint32_t opcode_table[] = { + 0x00A00010u, 0x00A00000u, 0x00A00000u, 0x02A00000u, // Instruction 'adc'. + 0x00B00010u, 0x00B00000u, 0x00B00000u, 0x02B00000u, // Instruction 'adcs'. + 0x00800010u, 0x00800000u, 0x00800000u, 0x02800000u, // Instruction 'add'. + 0x00900010u, 0x00900000u, 0x00900000u, 0x02900000u, // Instruction 'adds'. + 0x00000010u, 0x00000000u, 0x00000000u, 0x02000000u, // Instruction 'and'. + 0x00100010u, 0x00100000u, 0x00100000u, 0x02100000u, // Instruction 'ands'. + 0x01C00010u, 0x01C00000u, 0x01C00000u, 0x03C00000u, // Instruction 'bic'. + 0x01D00010u, 0x01D00000u, 0x01D00000u, 0x03D00000u, // Instruction 'bics'. + 0x00200010u, 0x00200000u, 0x00200000u, 0x02200000u, // Instruction 'eor'. + 0x00300010u, 0x00300000u, 0x00300000u, 0x02300000u, // Instruction 'eors'. + 0x01800010u, 0x01800000u, 0x01800000u, 0x03800000u, // Instruction 'orr'. + 0x01900010u, 0x01900000u, 0x01900000u, 0x03900000u, // Instruction 'orrs'. + 0x00600010u, 0x00600000u, 0x00600000u, 0x02600000u, // Instruction 'rsb'. + 0x00700010u, 0x00700000u, 0x00700000u, 0x02700000u, // Instruction 'rsbs'. + 0x00E00010u, 0x00E00000u, 0x00E00000u, 0x02E00000u, // Instruction 'rsc'. + 0x00F00010u, 0x00F00000u, 0x00F00000u, 0x02F00000u, // Instruction 'rscs'. + 0x00C00010u, 0x00C00000u, 0x00C00000u, 0x02C00000u, // Instruction 'sbc'. + 0x00D00010u, 0x00D00000u, 0x00D00000u, 0x02D00000u, // Instruction 'sbcs'. + 0x00400010u, 0x00400000u, 0x00400000u, 0x02400000u, // Instruction 'sub'. + 0x00500010u, 0x00500000u, 0x00500000u, 0x02500000u // Instruction 'subs'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + uint32_t shift_op = o3.as().predicate(); + if (shift_op <= 3u) { + opcode = opcode_table_ptr[0]; + opcode |= shift_op << 5u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_R3At8Of4_Cond; + } + } + + if (sgn.test()) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + + if (sgn.test()) { + uint32_t shift_op = o3.as().predicate(); + uint64_t shiftImm = o3.as().value_as(); + if (shift_op <= 3 && shiftImm <= 31u) { + opcode = opcode_table_ptr[2]; + opcode |= shift_op << 5u; + opcode |= uint32_t(shiftImm) << 7u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + } + + if (sgn.test()) { + ImmAEncode enc0; + if (enc0.init(o2.as())) { + opcode = opcode_table_ptr[3]; + opcode |= enc0.imm() << 0u; + goto Emit_R0At12Of4_R1At16Of4_Cond; + } + } + + break; + } + + case 2: { + // Instruction 'adr'. + if (sgn.test() || sgn.test()) { + rel = &o1; + offset_format.reset_to_imm_value(OffsetType::kAArch32_ADR, 4, 0, 12, 0); + opcode = 0x020F0000u; + goto Emit_R0At12Of4_Rel_Cond; + } + + break; + } + + case 3: { + static const uint32_t opcode_table[] = { + 0xF3B00340u, // Instruction 'aesd'. + 0xF3B00300u, // Instruction 'aese'. + 0xF3B003C0u, // Instruction 'aesimc'. + 0xF3B00380u // Instruction 'aesmc'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[0]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 4: { + static const uint32_t opcode_table[] = { + 0x01A00050u, 0x01A00040u, // Instruction 'asr'. + 0x01B00050u, 0x01B00040u // Instruction 'asrs'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At0Of4_R2At8Of4_Cond; + } + + if (sgn.test()) { + if (o2.as().value_as() <= 0x1Fu) { + opcode = opcode_table_ptr[1]; + opcode |= o2.as().value_as() << 7u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + + break; + } + + case 5: { + static const uint32_t opcode_table[] = { + 0x0A000000u, // Instruction 'b'. + 0x0B000000u // Instruction 'bl'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test() || sgn.test()) { + rel = &o0; + offset_format.reset_to_imm_value(OffsetType::kSignedOffset, 4, 0, 24, 2); + opcode = opcode_table_ptr[0]; + goto Emit_Rel_Cond; + } + + break; + } + + case 6: { + // Instruction 'bfc'. + if (sgn.test()) { + BfcBfiImmEncode enc0; + if (enc0.init(o1.as(), o2.as())) { + opcode = 0x07C0001Fu; + opcode |= enc0.lsb() << 7u; + opcode |= enc0.msb() << 16u; + goto Emit_R0At12Of4_Cond; + } + } + + break; + } + + case 7: { + // Instruction 'bfi'. + if (sgn.test()) { + BfcBfiImmEncode enc0; + if (enc0.init(o2.as(), o3.as())) { + opcode = 0x07C00010u; + opcode |= enc0.lsb() << 7u; + opcode |= enc0.msb() << 16u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + + break; + } + + case 8: { + static const uint32_t opcode_table[] = { + 0x01200070u, // Instruction 'bkpt'. + 0x01400070u // Instruction 'hvc'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFFFFu) { + opcode = opcode_table_ptr[0]; + opcode |= (o0.as().value_as() & 0xFu) << 0u; + opcode |= (o0.as().value_as() & 0xFFF0u) << 4u; + goto Emit_Cond; + } + } + + break; + } + + case 9: { + // Instruction 'blx'. + if (sgn.test()) { + opcode = 0x012FFF30u; + goto Emit_R0At0Of4_Cond; + } + + if (sgn.test() || sgn.test()) { + rel = &o0; + offset_format.reset_to_imm_value(OffsetType::kAArch32_1To24At0_0At24, 4, 0, 25, 1); + opcode = 0xFA000000u; + goto Emit_Rel_NoCond; + } + + break; + } + + case 10: { + static const uint32_t opcode_table[] = { + 0x012FFF10u, // Instruction 'bx'. + 0x012FFF20u // Instruction 'bxj'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At0Of4_Cond; + } + + break; + } + + case 11: { + static const uint32_t opcode_table[] = { + 0x0320F016u, // Instruction 'clrbhb'. + 0x0320F014u, // Instruction 'csdb'. + 0x0160006Eu, // Instruction 'eret'. + 0x0320F010u, // Instruction 'esb'. + 0x0320F000u, // Instruction 'nop'. + 0x0320F004u, // Instruction 'sev'. + 0x0320F005u, // Instruction 'sevl'. + 0x0320F002u, // Instruction 'wfe'. + 0x0320F003u, // Instruction 'wfi'. + 0x0320F001u // Instruction 'yield'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.empty()) { + opcode = opcode_table_ptr[0]; + goto Emit_Cond; + } + + break; + } + + case 12: { + static const uint32_t opcode_table[] = { + 0xF57FF01Fu, // Instruction 'clrex'. + 0xF57FF044u, // Instruction 'pssbb'. + 0xF57FF070u, // Instruction 'sb'. + 0xF57FF040u // Instruction 'ssbb'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.empty()) { + opcode = opcode_table_ptr[0]; + goto Emit_NoCond; + } + + break; + } + + case 13: { + static const uint32_t opcode_table[] = { + 0x016F0F10u, // Instruction 'clz'. + 0x06FF0F30u, // Instruction 'rbit'. + 0x06BF0F30u, // Instruction 'rev'. + 0x06BF0FB0u, // Instruction 'rev16'. + 0x06FF0FB0u, // Instruction 'revsh'. + 0x01A00060u, // Instruction 'rrx'. + 0x01B00060u // Instruction 'rrxs'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + + break; + } + + case 14: { + static const uint32_t opcode_table[] = { + 0x01700010u, 0x01700000u, 0x01700000u, 0x03700000u, // Instruction 'cmn'. + 0x01500010u, 0x01500000u, 0x01500000u, 0x03500000u, // Instruction 'cmp'. + 0x01300010u, 0x01300000u, 0x01300000u, 0x03300000u, // Instruction 'teq'. + 0x01100010u, 0x01100000u, 0x01100000u, 0x03100000u // Instruction 'tst'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + uint32_t shift_op = o2.as().predicate(); + if (shift_op <= 3u) { + opcode = opcode_table_ptr[0]; + opcode |= shift_op << 5u; + goto Emit_R0At16Of4_R1At0Of4_R2At8Of4_Cond; + } + } + + if (sgn.test()) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At16Of4_R1At0Of4_Cond; + } + + if (sgn.test()) { + uint32_t shift_op = o2.as().predicate(); + uint64_t shiftImm = o2.as().value_as(); + if (shift_op <= 3 && shiftImm <= 31u) { + opcode = opcode_table_ptr[2]; + opcode |= shift_op << 5u; + opcode |= uint32_t(shiftImm) << 7u; + goto Emit_R0At16Of4_R1At0Of4_Cond; + } + } + + if (sgn.test()) { + ImmAEncode enc0; + if (enc0.init(o1.as())) { + opcode = opcode_table_ptr[3]; + opcode |= enc0.imm() << 0u; + goto Emit_R0At16Of4_Cond; + } + } + + break; + } + + case 15: { + // Instruction 'cps'. + if (sgn.test()) { + if (o0.as().value_as() <= 0x1Fu) { + opcode = 0xF1020000u; + opcode |= o0.as().value_as() << 0u; + goto Emit_NoCond; + } + } + + break; + } + + case 16: { + static const uint32_t opcode_table[] = { + 0xF10C0000u, 0xF10E0000u, // Instruction 'cpsid'. + 0xF1080000u, 0xF10A0000u // Instruction 'cpsie'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0x7u) { + opcode = opcode_table_ptr[0]; + opcode |= o0.as().value_as() << 6u; + goto Emit_NoCond; + } + } + + if (sgn.test()) { + if (o0.as().value_as() <= 0x7u && o1.as().value_as() <= 0x1Fu) { + opcode = opcode_table_ptr[1]; + opcode |= o1.as().value_as() << 0u; + opcode |= o0.as().value_as() << 6u; + goto Emit_NoCond; + } + } + + break; + } + + case 17: { + static const uint32_t opcode_table[] = { + 0x01000040u, // Instruction 'crc32b'. + 0x01000240u, // Instruction 'crc32cb'. + 0x01200240u, // Instruction 'crc32ch'. + 0x01400240u, // Instruction 'crc32cw'. + 0x01200040u, // Instruction 'crc32h'. + 0x01400040u, // Instruction 'crc32w'. + 0x06200F10u, // Instruction 'qadd16'. + 0x06200F90u, // Instruction 'qadd8'. + 0x06200F30u, // Instruction 'qasx'. + 0x06200F50u, // Instruction 'qsax'. + 0x06200F70u, // Instruction 'qsub16'. + 0x06200FF0u, // Instruction 'qsub8'. + 0x06100F10u, // Instruction 'sadd16'. + 0x06100F90u, // Instruction 'sadd8'. + 0x06100F30u, // Instruction 'sasx'. + 0x06800FB0u, // Instruction 'sel'. + 0x06300F10u, // Instruction 'shadd16'. + 0x06300F90u, // Instruction 'shadd8'. + 0x06300F30u, // Instruction 'shasx'. + 0x06300F50u, // Instruction 'shsax'. + 0x06300F70u, // Instruction 'shsub16'. + 0x06300FF0u, // Instruction 'shsub8'. + 0x06100F50u, // Instruction 'ssax'. + 0x06100F70u, // Instruction 'ssub16'. + 0x06100FF0u, // Instruction 'ssub8'. + 0x06500F10u, // Instruction 'uadd16'. + 0x06500F90u, // Instruction 'uadd8'. + 0x06500F30u, // Instruction 'uasx'. + 0x06700F10u, // Instruction 'uhadd16'. + 0x06700F90u, // Instruction 'uhadd8'. + 0x06700F30u, // Instruction 'uhasx'. + 0x06700F50u, // Instruction 'uhsax'. + 0x06700F70u, // Instruction 'uhsub16'. + 0x06700FF0u, // Instruction 'uhsub8'. + 0x06600F10u, // Instruction 'uqadd16'. + 0x06600F90u, // Instruction 'uqadd8'. + 0x06600F30u, // Instruction 'uqasx'. + 0x06600F50u, // Instruction 'uqsax'. + 0x06600F70u, // Instruction 'uqsub16'. + 0x06600FF0u, // Instruction 'uqsub8'. + 0x06500F50u, // Instruction 'usax'. + 0x06500F70u, // Instruction 'usub16'. + 0x06500FF0u // Instruction 'usub8'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + + break; + } + + case 18: { + static const uint32_t opcode_table[] = { + 0x0320F0F0u, // Instruction 'dbg'. + 0x01600070u // Instruction 'smc'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu) { + opcode = opcode_table_ptr[0]; + opcode |= o0.as().value_as() << 0u; + goto Emit_Cond; + } + } + + break; + } + + case 19: { + static const uint32_t opcode_table[] = { + 0xF57FF050u, // Instruction 'dmb'. + 0xF57FF040u, // Instruction 'dsb'. + 0xF57FF060u // Instruction 'isb'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu) { + opcode = opcode_table_ptr[0]; + opcode |= o0.as().value_as() << 0u; + goto Emit_NoCond; + } + } + + break; + } + + case 20: { + static const uint32_t opcode_table[] = { + 0xE1000070u, // Instruction 'hlt'. + 0xE7F000F0u // Instruction 'udf'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFFFFu) { + opcode = opcode_table_ptr[0]; + opcode |= (o0.as().value_as() & 0xFu) << 0u; + opcode |= (o0.as().value_as() & 0xFFF0u) << 4u; + goto Emit_NoCond; + } + } + + break; + } + + case 21: { + static const uint32_t opcode_table[] = { + 0x01900C9Fu, // Instruction 'lda'. + 0x01D00C9Fu, // Instruction 'ldab'. + 0x01900E9Fu, // Instruction 'ldaex'. + 0x01D00E9Fu, // Instruction 'ldaexb'. + 0x01F00E9Fu, // Instruction 'ldaexh'. + 0x01F00C9Fu, // Instruction 'ldah'. + 0x01900F9Fu, // Instruction 'ldrex'. + 0x01D00F9Fu, // Instruction 'ldrexb'. + 0x01F00F9Fu // Instruction 'ldrexh'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_MemBaseAt16_Cond; + } + } + } + } + } + + break; + } + + case 22: { + static const uint32_t opcode_table[] = { + 0x01B00E9Fu, // Instruction 'ldaexd'. + 0x01B00F9Fu // Instruction 'ldrexd'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_MemBaseAt16_Cond; + } + } + } + } + } + } + + break; + } + + case 23: { + static const uint32_t opcode_table[] = { + 0x08100000u, 0x08500000u, // Instruction 'ldmda'. + 0x09100000u, 0x09500000u, // Instruction 'ldmdb'. + 0x08900000u, 0x08D00000u, // Instruction 'ldmia'. + 0x09900000u, 0x09D00000u, // Instruction 'ldmib'. + 0x08000000u, 0x08400000u, // Instruction 'stmda'. + 0x09000000u, 0x09400000u, // Instruction 'stmdb'. + 0x08800000u, 0x08C00000u, // Instruction 'stmia'. + 0x09800000u, 0x09C00000u // Instruction 'stmib'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + mem = &o0.as(); + const GpList& reg_list = o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (!mem->is_post_index()) { + GpListImmEncode enc0; + if (enc0.init(reg_list)) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.immMask() << 0u; + goto Emit_MemBaseAt16W21_Cond; + } + } + + if (mem->is_fixed_offset()) { + GpListImmEncode enc1; + if (enc1.init(reg_list)) { + opcode = opcode_table_ptr[1]; + opcode |= enc1.immMask() << 0u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + } + + break; + } + + case 24: { + static const uint32_t opcode_table[] = { + 0x06100000u, 0x04100000u, 0x05100000u, // Instruction 'ldr'. + 0x06500000u, 0x04500000u, 0x05500000u, // Instruction 'ldrb'. + 0x06000000u, 0x04000000u, 0x05000000u, // Instruction 'str'. + 0x06400000u, 0x04400000u, 0x05400000u // Instruction 'strb'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_P24W21_Cond; + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 12, 0)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of12_P24W21_Cond; + } + } + } + } + + if (sgn.test()) { + mem = &o1.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + opcode = opcode_table_ptr[2]; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 12, 0); + goto Emit_R0At12Of4_MemPCRel_Cond; + } + } + } + + break; + } + + case 25: { + static const uint32_t opcode_table[] = { + 0x06700000u, 0x04700000u, // Instruction 'ldrbt'. + 0x06300000u, 0x04300000u, // Instruction 'ldrt'. + 0x06200000u, 0x04200000u // Instruction 'strt'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_post_index()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_Cond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 12, 0)) { + if (mem->is_post_index()) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of12_Cond; + } + } + } + } + } + + break; + } + + case 26: { + // Instruction 'ldrd'. + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() <= 15u) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x000000D0u; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_P24W21_Cond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 0)) { + if (!mem->is_post_index()) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x004000D0u; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_P24W21_Cond; + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o2.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x014000D0u; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_0To3At0_4To7At8, 4, 0, 8, 0); + goto Emit_R0At12Of4_MemPCRel_Cond; + } + } + } + } + + break; + } + + case 27: { + static const uint32_t opcode_table[] = { + 0x001000B0u, 0x005000B0u, 0x015000B0u, // Instruction 'ldrh'. + 0x001000D0u, 0x005000D0u, 0x015000D0u, // Instruction 'ldrsb'. + 0x001000F0u, 0x005000F0u, 0x015000F0u, // Instruction 'ldrsh'. + 0x000000B0u, 0x004000B0u, 0x014000B0u // Instruction 'strh'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_P24W21_Cond; + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 0)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_P24W21_Cond; + } + } + } + } + + if (sgn.test()) { + mem = &o1.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + opcode = opcode_table_ptr[2]; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_0To3At0_4To7At8, 4, 0, 8, 0); + goto Emit_R0At12Of4_MemPCRel_Cond; + } + } + } + + break; + } + + case 28: { + static const uint32_t opcode_table[] = { + 0x003000B0u, 0x007000B0u, // Instruction 'ldrht'. + 0x002000B0u, 0x006000B0u // Instruction 'strht'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_post_index()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_Cond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 0)) { + if (mem->is_post_index()) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_Cond; + } + } + } + } + } + + break; + } + + case 29: { + // Instruction 'ldrsbt'. + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() <= 15u) { + if (mem->is_post_index()) { + opcode = 0x003000D0u; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_Cond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 0)) { + if (mem->is_post_index()) { + opcode = 0x007000D0u; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_Cond; + } + } + } + } + } + + break; + } + + case 30: { + // Instruction 'ldrsht'. + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 0)) { + if (mem->is_post_index()) { + opcode = 0x007000F0u; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_Cond; + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_post_index()) { + opcode = 0x003000F0u; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_Cond; + } + } + } + } + } + } + + break; + } + + case 31: { + static const uint32_t opcode_table[] = { + 0x01A00000u, 0x01A00010u, // Instruction 'lsl'. + 0x01B00000u, 0x01B00010u, // Instruction 'lsls'. + 0x01A00020u, 0x01A00030u, // Instruction 'lsr'. + 0x01B00020u, 0x01B00030u, // Instruction 'lsrs'. + 0x01A00060u, 0x01A00070u, // Instruction 'ror'. + 0x01B00060u, 0x01B00070u // Instruction 'rors'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (o2.as().value_as() <= 0x1Fu) { + opcode = opcode_table_ptr[0]; + opcode |= o2.as().value_as() << 7u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + + if (sgn.test()) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_R1At0Of4_R2At8Of4_Cond; + } + + break; + } + + case 32: { + static const uint32_t opcode_table[] = { + 0x0E000010u, 0x0E000010u, // Instruction 'mcr'. + 0x0E100010u, 0x0E100010u // Instruction 'mrc'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu && o1.as().value_as() <= 0x7u) { + opcode = opcode_table_ptr[0]; + opcode |= o0.as().value_as() << 8u; + opcode |= o1.as().value_as() << 21u; + goto Emit_R2At12Of4_R3At16Of4_R4At0Of4_Cond; + } + } + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu && o1.as().value_as() <= 0x7u && o5.as().value_as() <= 0x7u) { + opcode = opcode_table_ptr[1]; + opcode |= o5.as().value_as() << 5u; + opcode |= o0.as().value_as() << 8u; + opcode |= o1.as().value_as() << 21u; + goto Emit_R2At12Of4_R3At16Of4_R4At0Of4_Cond; + } + } + + break; + } + + case 33: { + static const uint32_t opcode_table[] = { + 0xFE000010u, 0xFE000010u, // Instruction 'mcr2'. + 0xFE100010u, 0xFE100010u // Instruction 'mrc2'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu && o1.as().value_as() <= 0x7u) { + opcode = opcode_table_ptr[0]; + opcode |= o0.as().value_as() << 8u; + opcode |= o1.as().value_as() << 21u; + goto Emit_R2At12Of4_R3At16Of4_R4At0Of4_NoCond; + } + } + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu && o1.as().value_as() <= 0x7u && o5.as().value_as() <= 0x7u) { + opcode = opcode_table_ptr[1]; + opcode |= o5.as().value_as() << 5u; + opcode |= o0.as().value_as() << 8u; + opcode |= o1.as().value_as() << 21u; + goto Emit_R2At12Of4_R3At16Of4_R4At0Of4_NoCond; + } + } + + break; + } + + case 34: { + static const uint32_t opcode_table[] = { + 0x0C400000u, // Instruction 'mcrr'. + 0x0C500000u // Instruction 'mrrc'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu && o1.as().value_as() <= 0xFu) { + opcode = opcode_table_ptr[0]; + opcode |= o1.as().value_as() << 4u; + opcode |= o0.as().value_as() << 8u; + goto Emit_R2At12Of4_R3At16Of4_R4At0Of4_Cond; + } + } + + break; + } + + case 35: { + static const uint32_t opcode_table[] = { + 0xFC400000u, // Instruction 'mcrr2'. + 0xFC500000u // Instruction 'mrrc2'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0xFu && o1.as().value_as() <= 0xFu) { + opcode = opcode_table_ptr[0]; + opcode |= o1.as().value_as() << 4u; + opcode |= o0.as().value_as() << 8u; + goto Emit_R2At12Of4_R3At16Of4_R4At0Of4_NoCond; + } + } + + break; + } + + case 36: { + static const uint32_t opcode_table[] = { + 0x00200090u, // Instruction 'mla'. + 0x00300090u, // Instruction 'mlas'. + 0x00600090u, // Instruction 'mls'. + 0x01000080u, // Instruction 'smlabb'. + 0x010000C0u, // Instruction 'smlabt'. + 0x07000010u, // Instruction 'smlad'. + 0x07000030u, // Instruction 'smladx'. + 0x010000A0u, // Instruction 'smlatb'. + 0x010000E0u, // Instruction 'smlatt'. + 0x01200080u, // Instruction 'smlawb'. + 0x012000C0u, // Instruction 'smlawt'. + 0x07000050u, // Instruction 'smlsd'. + 0x07000070u, // Instruction 'smlsdx'. + 0x07500010u, // Instruction 'smmla'. + 0x07500030u, // Instruction 'smmlar'. + 0x075000D0u, // Instruction 'smmls'. + 0x075000F0u, // Instruction 'smmlsr'. + 0x07800010u // Instruction 'usada8'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At16Of4_R1At0Of4_R2At8Of4_R3At12Of4_Cond; + } + + break; + } + + case 37: { + static const uint32_t opcode_table[] = { + 0x01A00010u, 0x01A00000u, 0x01A00000u, 0x03A00000u, // Instruction 'mov'. + 0x01B00010u, 0x01B00000u, 0x01B00000u, 0x03B00000u, // Instruction 'movs'. + 0x01E00010u, 0x01E00000u, 0x01E00000u, 0x03E00000u, // Instruction 'mvn'. + 0x01F00010u, 0x01F00000u, 0x01F00000u, 0x03F00000u // Instruction 'mvns'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + uint32_t shift_op = o2.as().predicate(); + if (shift_op <= 3u) { + opcode = opcode_table_ptr[0]; + opcode |= shift_op << 5u; + goto Emit_R0At12Of4_R1At0Of4_R2At8Of4_Cond; + } + } + + if (sgn.test()) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + + if (sgn.test()) { + uint32_t shift_op = o2.as().predicate(); + uint64_t shiftImm = o2.as().value_as(); + if (shift_op <= 3 && shiftImm <= 31u) { + opcode = opcode_table_ptr[2]; + opcode |= shift_op << 5u; + opcode |= uint32_t(shiftImm) << 7u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + + if (sgn.test()) { + ImmAEncode enc0; + if (enc0.init(o1.as())) { + opcode = opcode_table_ptr[3]; + opcode |= enc0.imm() << 0u; + goto Emit_R0At12Of4_Cond; + } + } + + break; + } + + case 38: { + static const uint32_t opcode_table[] = { + 0x03400000u, // Instruction 'movt'. + 0x03000000u // Instruction 'movw'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o1.as().value_as() <= 0xFFFFu) { + opcode = opcode_table_ptr[0]; + opcode |= (o1.as().value_as() & 0xFFFu) << 0u; + opcode |= (o1.as().value_as() & 0xF000u) << 4u; + goto Emit_R0At12Of4_Cond; + } + } + + break; + } + + case 39: { + // Instruction 'mrs'. + if (sgn.test()) { + if (o1.as().value_as() <= 0x1u) { + opcode = 0x010F0000u; + opcode |= o1.as().value_as() << 22u; + goto Emit_R0At12Of4_Cond; + } + } + + break; + } + + case 40: { + // Instruction 'msr'. + if (sgn.test()) { + if (o0.as().value_as() <= 0x3u) { + opcode = 0x0120F000u; + opcode |= o0.as().value_as() << 18u; + goto Emit_R1At0Of4_Cond; + } + } + + if (sgn.test()) { + if (o0.as().value_as() <= 0x3u) { + ImmAEncode enc0; + if (enc0.init(o1.as())) { + opcode = 0x0320F000u; + opcode |= enc0.imm() << 0u; + opcode |= o0.as().value_as() << 18u; + goto Emit_Cond; + } + } + } + + break; + } + + case 41: { + static const uint32_t opcode_table[] = { + 0x00000090u, // Instruction 'mul'. + 0x00100090u, // Instruction 'muls'. + 0x0710F010u, // Instruction 'sdiv'. + 0x0750F010u, // Instruction 'smmul'. + 0x0750F030u, // Instruction 'smmulr'. + 0x0700F010u, // Instruction 'smuad'. + 0x0700F030u, // Instruction 'smuadx'. + 0x01600080u, // Instruction 'smulbb'. + 0x016000C0u, // Instruction 'smulbt'. + 0x016000A0u, // Instruction 'smultb'. + 0x016000E0u, // Instruction 'smultt'. + 0x012000A0u, // Instruction 'smulwb'. + 0x012000E0u, // Instruction 'smulwt'. + 0x0700F050u, // Instruction 'smusd'. + 0x0700F070u, // Instruction 'smusdx'. + 0x0730F010u, // Instruction 'udiv'. + 0x0780F010u // Instruction 'usad8'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At16Of4_R1At0Of4_R2At8Of4_Cond; + } + + break; + } + + case 42: { + // Instruction 'pkhbt'. + if (sgn.test()) { + opcode = 0x06800010u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + + if (sgn.test()) { + uint64_t shiftImm = o3.as().value_as(); + if (o3.as().predicate() == uint32_t(ShiftOp::kLSL) && shiftImm <= 31u) { + opcode = 0x06800010u; + opcode |= uint32_t(shiftImm) << 7u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + } + + break; + } + + case 43: { + // Instruction 'pkhtb'. + if (sgn.test()) { + opcode = 0x06800050u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + + if (sgn.test()) { + uint64_t shiftImm = o3.as().value_as(); + if (o3.as().predicate() == uint32_t(ShiftOp::kASR) && shiftImm <= 31u) { + opcode = 0x06800050u; + opcode |= uint32_t(shiftImm) << 7u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + } + + break; + } + + case 44: { + // Instruction 'pld'. + if (sgn.test()) { + mem = &o0.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_fixed_offset()) { + opcode = 0xF750F000u; + goto Emit_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_NoCond; + } + } + } + } + } + + if (mem->base_id() <= 15u) { + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 12, 0)) { + if (mem->is_fixed_offset()) { + opcode = 0xF550F000u; + goto Emit_MemBaseAt16_SOffAt0Of12_NoCond; + } + } + } + } + } + + if (sgn.test()) { + mem = &o0.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + opcode = 0xF550F000u; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 12, 0); + goto Emit_MemPCRel_NoCond; + } + } + } + + break; + } + + case 45: { + // Instruction 'pldw'. + if (sgn.test()) { + mem = &o0.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_fixed_offset()) { + opcode = 0xF710F000u; + goto Emit_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_NoCond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 12, 0)) { + if (mem->is_fixed_offset()) { + opcode = 0xF510F000u; + goto Emit_MemBaseAt16_SOffAt0Of12_NoCond; + } + } + } + } + } + + break; + } + + case 46: { + // Instruction 'pli'. + if (sgn.test()) { + mem = &o0.as(); + + if (mem->base_id() <= 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_fixed_offset()) { + opcode = 0xF650F000u; + goto Emit_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_NoCond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 12, 0)) { + if (mem->is_fixed_offset()) { + opcode = 0xF450F000u; + goto Emit_MemBaseAt16_SOffAt0Of12_NoCond; + } + } + } + } + + if (mem->base_id() == 15u && !mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + opcode = 0xF650F000u; + goto Emit_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_NoCond; + } + } + } + + if (sgn.test()) { + mem = &o0.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + opcode = 0xF450F000u; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 12, 0); + goto Emit_MemPCRel_NoCond; + } + } + } + + break; + } + + case 47: { + static const uint32_t opcode_table[] = { + 0x049D0004u, 0x08BD0000u, // Instruction 'pop'. + 0x052D0004u, 0x092D0000u // Instruction 'push'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_Cond; + } + + if (sgn.test()) { + GpListImmEncode enc0; + const GpList& reg_list = o0.as(); + if (enc0.init(reg_list)) { + opcode = opcode_table_ptr[1]; + opcode |= enc0.immMask() << 0u; + goto Emit_Cond; + } + } + + break; + } + + case 48: { + static const uint32_t opcode_table[] = { + 0x01000050u, // Instruction 'qadd'. + 0x01400050u, // Instruction 'qdadd'. + 0x01600050u, // Instruction 'qdsub'. + 0x01200050u // Instruction 'qsub'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At0Of4_R2At16Of4_Cond; + } + + break; + } + + case 49: { + static const uint32_t opcode_table[] = { + 0xF8100A00u, // Instruction 'rfeda'. + 0xF9100A00u, // Instruction 'rfedb'. + 0xF8900A00u, // Instruction 'rfeia'. + 0xF9900A00u // Instruction 'rfeib'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o0.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (!mem->is_post_index()) { + opcode = opcode_table_ptr[0]; + goto Emit_MemBaseAt16W21_NoCond; + } + } + } + } + } + + break; + } + + case 50: { + static const uint32_t opcode_table[] = { + 0x07A00050u, // Instruction 'sbfx'. + 0x07E00050u // Instruction 'ubfx'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + SbfxUbfxImmEncode enc0; + if (enc0.init(o2.as(), o3.as())) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.lsb() << 7u; + opcode |= enc0.widthM1() << 16u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + + break; + } + + case 51: { + static const uint32_t opcode_table[] = { + 0xF1010000u, // Instruction 'setend'. + 0xF1100000u // Instruction 'setpan'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (o0.as().value_as() <= 0x1u) { + opcode = opcode_table_ptr[0]; + opcode |= o0.as().value_as() << 9u; + goto Emit_NoCond; + } + } + + break; + } + + case 52: { + static const uint32_t opcode_table[] = { + 0xF2000C40u, // Instruction 'sha1c'. + 0xF2200C40u, // Instruction 'sha1m'. + 0xF2100C40u, // Instruction 'sha1p'. + 0xF2300C40u, // Instruction 'sha1su0'. + 0xF3000C40u, // Instruction 'sha256h'. + 0xF3100C40u, // Instruction 'sha256h2'. + 0xF3200C40u // Instruction 'sha256su1'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + opcode = opcode_table_ptr[0]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 53: { + static const uint32_t opcode_table[] = { + 0xF3B902C0u, // Instruction 'sha1h'. + 0xF3BA0380u, // Instruction 'sha1su1'. + 0xF3BA03C0u // Instruction 'sha256su0'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + opcode = opcode_table_ptr[0]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 54: { + static const uint32_t opcode_table[] = { + 0x00E00090u, // Instruction 'smlal'. + 0x01400080u, // Instruction 'smlalbb'. + 0x014000C0u, // Instruction 'smlalbt'. + 0x07400010u, // Instruction 'smlald'. + 0x07400030u, // Instruction 'smlaldx'. + 0x00F00090u, // Instruction 'smlals'. + 0x014000A0u, // Instruction 'smlaltb'. + 0x014000E0u, // Instruction 'smlaltt'. + 0x07400050u, // Instruction 'smlsld'. + 0x07400070u, // Instruction 'smlsldx'. + 0x00C00090u, // Instruction 'smull'. + 0x00D00090u, // Instruction 'smulls'. + 0x00400090u, // Instruction 'umaal'. + 0x00A00090u, // Instruction 'umlal'. + 0x00B00090u, // Instruction 'umlals'. + 0x00800090u, // Instruction 'umull'. + 0x00900090u // Instruction 'umulls'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_R3At8Of4_Cond; + } + + break; + } + + case 55: { + static const uint32_t opcode_table[] = { + 0xF84D0500u, // Instruction 'srsda'. + 0xF94D0500u, // Instruction 'srsdb'. + 0xF8CD0500u, // Instruction 'srsia'. + 0xF9CD0500u // Instruction 'srsib'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o0.as(); + + if (mem->base_id() == 13u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (!mem->is_post_index()) { + if (o1.as().value_as() <= 0x1Fu) { + opcode = opcode_table_ptr[0]; + opcode |= o1.as().value_as() << 0u; + goto EmitW21_NoCond; + } + } + } + } + } + } + + break; + } + + case 56: { + // Instruction 'ssat'. + if (sgn.test()) { + SsatImmEncode enc0; + if (enc0.init(o1.as())) { + opcode = 0x06A00010u; + opcode |= enc0.imm() << 16u; + goto Emit_R0At12Of4_R2At0Of4_Cond; + } + } + + if (sgn.test()) { + uint32_t shift_op = o3.as().predicate(); + if ((shift_op == uint32_t(ShiftOp::kLSL) || shift_op == uint32_t(ShiftOp::kASR))) { + SsatImmEncode enc1; + if (enc1.init(o1.as(), o3.as())) { + opcode = 0x06A00010u; + opcode |= shift_op << 5u; + opcode |= enc1.n() << 7u; + opcode |= enc1.imm() << 16u; + goto Emit_R0At12Of4_R2At0Of4_Cond; + } + } + } + + break; + } + + case 57: { + // Instruction 'ssat16'. + if (sgn.test()) { + Ssat16ImmEncode enc0; + if (enc0.init(o1.as())) { + opcode = 0x06A00F30u; + opcode |= enc0.imm() << 16u; + goto Emit_R0At12Of4_R2At0Of4_Cond; + } + } + + break; + } + + case 58: { + static const uint32_t opcode_table[] = { + 0x0180FC90u, // Instruction 'stl'. + 0x01C0FC90u, // Instruction 'stlb'. + 0x01E0FC90u // Instruction 'stlh'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At0Of4_MemBaseAt16_Cond; + } + } + } + } + } + + break; + } + + case 59: { + static const uint32_t opcode_table[] = { + 0x01800E90u, // Instruction 'stlex'. + 0x01C00E90u, // Instruction 'stlexb'. + 0x01E00E90u, // Instruction 'stlexh'. + 0x01800F90u, // Instruction 'strex'. + 0x01C00F90u, // Instruction 'strexb'. + 0x01E00F90u // Instruction 'strexh'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At0Of4_MemBaseAt16_Cond; + } + } + } + } + } + + break; + } + + case 60: { + static const uint32_t opcode_table[] = { + 0x01A00E90u, // Instruction 'stlexd'. + 0x01A00F90u // Instruction 'strexd'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + mem = &o3.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_consecutive(1, o1.as(), o2.as())) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4_R1At0Of4_MemBaseAt16_Cond; + } + } + } + } + } + } + + break; + } + + case 61: { + // Instruction 'strbt'. + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (mem->is_post_index()) { + opcode = 0x06600000u; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_Cond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 12, 0)) { + if (mem->is_post_index()) { + opcode = 0x04600000u; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of12_Cond; + } + } + } + } + } + + if (sgn.test()) { + mem = &o1.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + opcode = 0x04600000u; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 12, 0); + goto Emit_R0At12Of4_MemPCRel_Cond; + } + } + } + + break; + } + + case 62: { + // Instruction 'strd'. + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if (mem->index_id() < 15u) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x000000F0u; + goto Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_P24W21_Cond; + } + } + } + } + + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 0)) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x004000F0u; + goto Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_P24W21_Cond; + } + } + } + } + } + + if (sgn.test()) { + mem = &o2.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x014000F0u; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_0To3At0_4To7At8, 4, 0, 8, 0); + goto Emit_R0At12Of4_MemPCRel_Cond; + } + } + } + } + + break; + } + + case 63: { + // Instruction 'svc'. + if (sgn.test()) { + if (o0.as().value_as() <= 0xFFFFFFu) { + opcode = 0x0F000000u; + opcode |= o0.as().value_as() << 0u; + goto Emit_Cond; + } + } + + break; + } + + case 64: { + static const uint32_t opcode_table[] = { + 0x06A00070u, 0x06A00070u, // Instruction 'sxtab'. + 0x06800070u, 0x06800070u, // Instruction 'sxtab16'. + 0x06B00070u, 0x06B00070u, // Instruction 'sxtah'. + 0x06E00070u, 0x06E00070u, // Instruction 'uxtab'. + 0x06C00070u, 0x06C00070u, // Instruction 'uxtab16'. + 0x06F00070u, 0x06F00070u // Instruction 'uxtah'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + Ror8ImmEncode enc0; + if (enc0.init(0u)) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.imm() << 10u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + } + + if (sgn.test()) { + if (o3.as().predicate() == uint32_t(ShiftOp::kROR)) { + Ror8ImmEncode enc1; + if (enc1.init(o3.as())) { + opcode = opcode_table_ptr[1]; + opcode |= enc1.imm() << 10u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond; + } + } + } + + break; + } + + case 65: { + static const uint32_t opcode_table[] = { + 0x06AF0070u, 0x06AF0070u, // Instruction 'sxtb'. + 0x068F0070u, 0x068F0070u, // Instruction 'sxtb16'. + 0x06BF0070u, 0x06BF0070u, // Instruction 'sxth'. + 0x06EF0070u, 0x06EF0070u, // Instruction 'uxtb'. + 0x06CF0070u, 0x06CF0070u, // Instruction 'uxtb16'. + 0x06FF0070u, 0x06FF0070u // Instruction 'uxth'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + Ror8ImmEncode enc0; + if (enc0.init(0u)) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.imm() << 10u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + + if (sgn.test()) { + if (o2.as().predicate() == uint32_t(ShiftOp::kROR)) { + Ror8ImmEncode enc1; + if (enc1.init(o2.as())) { + opcode = opcode_table_ptr[1]; + opcode |= enc1.imm() << 10u; + goto Emit_R0At12Of4_R1At0Of4_Cond; + } + } + } + + break; + } + + case 66: { + // Instruction 'usat'. + if (sgn.test()) { + if (o1.as().value_as() <= 0x1Fu) { + opcode = 0x06E00010u; + opcode |= o1.as().value_as() << 16u; + goto Emit_R0At12Of4_R2At0Of4_Cond; + } + } + + if (sgn.test()) { + uint32_t shift_op = o3.as().predicate(); + uint64_t shiftImm = o3.as().value_as(); + if (o1.as().value_as() <= 0x1Fu && (shift_op == uint32_t(ShiftOp::kLSL) || shift_op == uint32_t(ShiftOp::kASR)) && shiftImm <= 31u) { + opcode = 0x06E00010u; + opcode |= shift_op << 5u; + opcode |= uint32_t(shiftImm) << 7u; + opcode |= o1.as().value_as() << 16u; + goto Emit_R0At12Of4_R2At0Of4_Cond; + } + } + + break; + } + + case 67: { + // Instruction 'usat16'. + if (sgn.test()) { + if (o1.as().value_as() <= 0xFu) { + opcode = 0x06E00F30u; + opcode |= o1.as().value_as() << 16u; + goto Emit_R0At12Of4_R2At0Of4_Cond; + } + } + + break; + } + + case 68: { + static const uint32_t opcode_table[] = { + 0xF2000710u, 0xF2000750u, // Instruction 'vaba'. + 0xF2000000u, 0xF2000040u, // Instruction 'vhadd'. + 0xF2000200u, 0xF2000240u, // Instruction 'vhsub'. + 0xF2000100u, 0xF2000140u // Instruction 'vrhadd'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[1]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 69: { + static const uint32_t opcode_table[] = { + 0xF2800500u, // Instruction 'vabal'. + 0xF2800700u, // Instruction 'vabdl'. + 0xF2800000u, // Instruction 'vaddl'. + 0xF2800200u // Instruction 'vsubl'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 70: { + static const uint32_t opcode_table[] = { + 0xF3300D00u, 0xF3200D00u, 0xF2000700u, 0xF3300D40u, 0xF3200D40u, 0xF2000740u, // Instruction 'vabd'. + 0xF2100F00u, 0xF2000F00u, 0xF2000600u, 0xF2100F40u, 0xF2000F40u, 0xF2000640u, // Instruction 'vmax'. + 0xF2300F00u, 0xF2200F00u, 0xF2000610u, 0xF2300F40u, 0xF2200F40u, 0xF2000650u // Instruction 'vmin'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 6u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[2]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[5]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 71: { + static const uint32_t opcode_table[] = { + 0x0EB00AC0u, 0xEEB009C0u, 0x0EB00BC0u, 0xF3B50700u, 0xF3B90700u, 0xF3B10300u, 0xF3B50740u, 0xF3B90740u, 0xF3B10340u, // Instruction 'vabs'. + 0x0EB10A40u, 0xEEB10940u, 0x0EB10B40u, 0xF3B50780u, 0xF3B90780u, 0xF3B10380u, 0xF3B507C0u, 0xF3B907C0u, 0xF3B103C0u // Instruction 'vneg'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 9u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + opcode = opcode_table_ptr[5]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[7]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + opcode = opcode_table_ptr[8]; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 72: { + static const uint32_t opcode_table[] = { + 0xF3100E10u, 0xF3000E10u, 0xF3100E50u, 0xF3000E50u, // Instruction 'vacge'. + 0xF3300E10u, 0xF3200E10u, 0xF3300E50u, 0xF3200E50u, // Instruction 'vacgt'. + 0xF2100F10u, 0xF2000F10u, 0xF2100F50u, 0xF2000F50u, // Instruction 'vrecps'. + 0xF2300F10u, 0xF2200F10u, 0xF2300F50u, 0xF2200F50u // Instruction 'vrsqrts'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[2]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[3]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 73: { + static const uint32_t opcode_table[] = { + 0xF3100E10u, 0xF3000E10u, 0xF3100E50u, 0xF3000E50u, // Instruction 'vacle'. + 0xF3300E10u, 0xF3200E10u, 0xF3300E50u, 0xF3200E50u // Instruction 'vaclt'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[2]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[3]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + } + } + + break; + } + + case 74: { + static const uint32_t opcode_table[] = { + 0x0E300A00u, 0xEE300900u, 0x0E300B00u, 0xF2100D00u, 0xF2000D00u, 0xF2000800u, 0xF2100D40u, 0xF2000D40u, 0xF2000840u, // Instruction 'vadd'. + 0x0E300A40u, 0xEE300940u, 0x0E300B40u, 0xF2300D00u, 0xF2200D00u, 0xF3000800u, 0xF2300D40u, 0xF2200D40u, 0xF3000840u // Instruction 'vsub'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 9u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = opcode_table_ptr[5]; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[7]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = opcode_table_ptr[8]; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 75: { + static const uint32_t opcode_table[] = { + 0xF2800400u, // Instruction 'vaddhn'. + 0xF3800400u, // Instruction 'vraddhn'. + 0xF3800600u, // Instruction 'vrsubhn'. + 0xF2800600u // Instruction 'vsubhn'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + opcode = opcode_table_ptr[0]; + opcode |= (sz - 1) << 20u; + goto Emit_R0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 76: { + static const uint32_t opcode_table[] = { + 0xF2800100u, // Instruction 'vaddw'. + 0xF2800300u // Instruction 'vsubw'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 77: { + // Instruction 'vand'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2000110u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2000150u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc0; + if (enc0.init(sz, 1u, o1.as())) { + opcode = 0xF2800030u; + opcode |= (enc0.imm() & 0xFu) << 0u; + opcode |= (enc0.imm() & 0x70u) << 12u; + opcode |= (enc0.imm() & 0x80u) << 17u; + opcode |= enc0.cmode() << 8u; + goto Emit_R0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc1; + if (enc1.init(sz, 1u, o1.as())) { + opcode = 0xF2800070u; + opcode |= (enc1.imm() & 0xFu) << 0u; + opcode |= (enc1.imm() & 0x70u) << 12u; + opcode |= (enc1.imm() & 0x80u) << 17u; + opcode |= enc1.cmode() << 8u; + goto Emit_Q0At12Of4Hi22_NoCond; + } + } + } + } + + break; + } + + case 78: { + // Instruction 'vbic'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2100110u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2100150u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc0; + if (enc0.init(sz, 0u, o1.as())) { + opcode = 0xF2800030u; + opcode |= (enc0.imm() & 0xFu) << 0u; + opcode |= (enc0.imm() & 0x70u) << 12u; + opcode |= (enc0.imm() & 0x80u) << 17u; + opcode |= enc0.cmode() << 8u; + goto Emit_R0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc1; + if (enc1.init(sz, 0u, o1.as())) { + opcode = 0xF2800070u; + opcode |= (enc1.imm() & 0xFu) << 0u; + opcode |= (enc1.imm() & 0x70u) << 12u; + opcode |= (enc1.imm() & 0x80u) << 17u; + opcode |= enc1.cmode() << 8u; + goto Emit_Q0At12Of4Hi22_NoCond; + } + } + } + } + + break; + } + + case 79: { + static const uint32_t opcode_table[] = { + 0xF3300110u, 0xF3300150u, // Instruction 'vbif'. + 0xF3200110u, 0xF3200150u, // Instruction 'vbit'. + 0xF3100110u, 0xF3100150u, // Instruction 'vbsl'. + 0xF3000110u, 0xF3000150u // Instruction 'veor'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = opcode_table_ptr[1]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + break; + } + + case 80: { + // Instruction 'vcadd'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + VecRot1ImmEncode enc0; + if (enc0.init(o3.as())) { + opcode = 0xFC900800u; + opcode |= enc0.imm() << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + VecRot1ImmEncode enc2; + if (enc2.init(o3.as())) { + opcode = 0xFC800800u; + opcode |= enc2.imm() << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + VecRot1ImmEncode enc1; + if (enc1.init(o3.as())) { + opcode = 0xFC900840u; + opcode |= enc1.imm() << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + VecRot1ImmEncode enc3; + if (enc3.init(o3.as())) { + opcode = 0xFC800840u; + opcode |= enc3.imm() << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 81: { + // Instruction 'vceq'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xF2100E00u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0xF2000E00u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF3000810u; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xF2100E40u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0xF2000E40u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF3000850u; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + if (o2.as().value() == 0u) { + opcode = 0xF3B50500u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + if (o2.as().value() == 0u) { + opcode = 0xF3B90500u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + if (o2.as().value() == 0u) { + opcode = 0xF3B10100u; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + if (o2.as().value() == 0u) { + opcode = 0xF3B50540u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + if (o2.as().value() == 0u) { + opcode = 0xF3B90540u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + if (o2.as().value() == 0u) { + opcode = 0xF3B10140u; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 82: { + static const uint32_t opcode_table[] = { + 0xF3100E00u, 0xF3000E00u, 0xF2000310u, 0xF3100E40u, 0xF3000E40u, 0xF2000350u, 0xF3B50480u, 0xF3B90480u, 0xF3B10080u, 0xF3B504C0u, 0xF3B904C0u, 0xF3B100C0u, // Instruction 'vcge'. + 0xF3300E00u, 0xF3200E00u, 0xF2000300u, 0xF3300E40u, 0xF3200E40u, 0xF2000340u, 0xF3B50400u, 0xF3B90400u, 0xF3B10000u, 0xF3B50440u, 0xF3B90440u, 0xF3B10040u // Instruction 'vcgt'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 12u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[2]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[5]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[6]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[7]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[8]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[9]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[10]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[11]; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 83: { + static const uint32_t opcode_table[] = { + 0xF3100E00u, 0xF3000E00u, 0xF2000310u, 0xF3100E40u, 0xF3000E40u, 0xF2000350u, 0xF3B50580u, 0xF3B90580u, 0xF3B10180u, 0xF3B505C0u, 0xF3B905C0u, 0xF3B101C0u, // Instruction 'vcle'. + 0xF3300E00u, 0xF3200E00u, 0xF2000300u, 0xF3300E40u, 0xF3200E40u, 0xF2000340u, 0xF3B50600u, 0xF3B90600u, 0xF3B10200u, 0xF3B50640u, 0xF3B90640u, 0xF3B10240u // Instruction 'vclt'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 12u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[2]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[5]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[6]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[7]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[8]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[9]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[10]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[11]; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 84: { + static const uint32_t opcode_table[] = { + 0xF3B00400u, 0xF3B00440u, // Instruction 'vcls'. + 0xF3B00480u, 0xF3B004C0u, // Instruction 'vclz'. + 0xF3B00000u, 0xF3B00040u, // Instruction 'vrev64'. + 0xF3B20080u, 0xF3B200C0u // Instruction 'vtrn'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[1]; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 85: { + // Instruction 'vcmla'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + VecRot2ImmEncode enc0; + if (enc0.init(o3.as())) { + opcode = 0xFC300800u; + opcode |= enc0.imm() << 23u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + VecRot2ImmEncode enc4; + if (enc4.init(o3.as())) { + opcode = 0xFC200800u; + opcode |= enc4.imm() << 23u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + uint32_t i = o2.as().as().element_index(); + if (i == 0u) { + VecRot2ImmEncode enc2; + if (enc2.init(o3.as())) { + opcode = 0xFE800800u; + opcode |= enc2.imm() << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + VecRot2ImmEncode enc6; + if (enc6.init(o3.as())) { + opcode = 0xFE000800u; + opcode |= i << 5u; + opcode |= enc6.imm() << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + VecRot2ImmEncode enc1; + if (enc1.init(o3.as())) { + opcode = 0xFC300840u; + opcode |= enc1.imm() << 23u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + VecRot2ImmEncode enc5; + if (enc5.init(o3.as())) { + opcode = 0xFC200840u; + opcode |= enc5.imm() << 23u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + uint32_t i = o2.as().as().element_index(); + if (i == 0u) { + VecRot2ImmEncode enc3; + if (enc3.init(o3.as())) { + opcode = 0xFE800840u; + opcode |= enc3.imm() << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + VecRot2ImmEncode enc7; + if (enc7.init(o3.as())) { + opcode = 0xFE000840u; + opcode |= i << 5u; + opcode |= enc7.imm() << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + } + + break; + } + + case 86: { + static const uint32_t opcode_table[] = { + 0x0EB40A40u, 0xEEB40940u, 0x0EB50A40u, 0xEEB50940u, 0x0EB40B40u, 0x0EB50B40u, // Instruction 'vcmp'. + 0x0EB40AC0u, 0xEEB409C0u, 0x0EB50AC0u, 0xEEB509C0u, 0x0EB40BC0u, 0x0EB50BC0u // Instruction 'vcmpe'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 6u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + if (o1.as().value() == 0u) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Lo22_Cond; + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + if (o1.as().value() == 0u) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Lo22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + if (o1.as().value() == 0u) { + opcode = opcode_table_ptr[5]; + goto Emit_R0At12Of4Hi22_Cond; + } + } + } + } + + break; + } + + case 87: { + static const uint32_t opcode_table[] = { + 0xF3B00500u, 0xF3B00540u, // Instruction 'vcnt'. + 0xF3B00100u, 0xF3B00140u // Instruction 'vrev16'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[1]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 88: { + // Instruction 'vcvt'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kF64)) { + opcode = 0x0EB70BC0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kF32)) { + opcode = 0x0EB70AC0u; + goto Emit_R0At12Of4Hi22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kS32)) { + opcode = 0x0EB80BC0u; + goto Emit_R0At12Of4Hi22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kU32)) { + opcode = 0x0EB80B40u; + goto Emit_R0At12Of4Hi22_R1At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS32)) { + opcode = 0x0EB80AC0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU32)) { + opcode = 0x0EB80A40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS16)) { + VecFBitsVFPEncode enc0; + if (enc0.init(16u, o2.as())) { + opcode = 0x0EBA0A40u; + opcode |= (enc0.imm() & 0x1Eu) >> 1u; + opcode |= (enc0.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS16, DT::kF32)) { + VecFBitsVFPEncode enc1; + if (enc1.init(16u, o2.as())) { + opcode = 0x0EBE0A40u; + opcode |= (enc1.imm() & 0x1Eu) >> 1u; + opcode |= (enc1.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU16)) { + VecFBitsVFPEncode enc2; + if (enc2.init(16u, o2.as())) { + opcode = 0x0EBB0A40u; + opcode |= (enc2.imm() & 0x1Eu) >> 1u; + opcode |= (enc2.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU16, DT::kF32)) { + VecFBitsVFPEncode enc3; + if (enc3.init(16u, o2.as())) { + opcode = 0x0EBF0A40u; + opcode |= (enc3.imm() & 0x1Eu) >> 1u; + opcode |= (enc3.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS32)) { + VecFBitsVFPEncode enc4; + if (enc4.init(32u, o2.as())) { + opcode = 0x0EBA0AC0u; + opcode |= (enc4.imm() & 0x1Eu) >> 1u; + opcode |= (enc4.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + VecFBitsVFPEncode enc5; + if (enc5.init(32u, o2.as())) { + opcode = 0x0EBE0AC0u; + opcode |= (enc5.imm() & 0x1Eu) >> 1u; + opcode |= (enc5.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU32)) { + VecFBitsVFPEncode enc6; + if (enc6.init(32u, o2.as())) { + opcode = 0x0EBB0AC0u; + opcode |= (enc6.imm() & 0x1Eu) >> 1u; + opcode |= (enc6.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + VecFBitsVFPEncode enc7; + if (enc7.init(32u, o2.as())) { + opcode = 0x0EBF0AC0u; + opcode |= (enc7.imm() & 0x1Eu) >> 1u; + opcode |= (enc7.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kS16)) { + VecFBitsVFPEncode enc8; + if (enc8.init(16u, o2.as())) { + opcode = 0x0EBA0B40u; + opcode |= (enc8.imm() & 0x1Eu) >> 1u; + opcode |= (enc8.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS16, DT::kF64)) { + VecFBitsVFPEncode enc9; + if (enc9.init(16u, o2.as())) { + opcode = 0x0EBE0B40u; + opcode |= (enc9.imm() & 0x1Eu) >> 1u; + opcode |= (enc9.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kU16)) { + VecFBitsVFPEncode enc10; + if (enc10.init(16u, o2.as())) { + opcode = 0x0EBB0B40u; + opcode |= (enc10.imm() & 0x1Eu) >> 1u; + opcode |= (enc10.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU16, DT::kF64)) { + VecFBitsVFPEncode enc11; + if (enc11.init(16u, o2.as())) { + opcode = 0x0EBF0B40u; + opcode |= (enc11.imm() & 0x1Eu) >> 1u; + opcode |= (enc11.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kS32)) { + VecFBitsVFPEncode enc12; + if (enc12.init(32u, o2.as())) { + opcode = 0x0EBA0BC0u; + opcode |= (enc12.imm() & 0x1Eu) >> 1u; + opcode |= (enc12.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF64)) { + VecFBitsVFPEncode enc13; + if (enc13.init(32u, o2.as())) { + opcode = 0x0EBE0BC0u; + opcode |= (enc13.imm() & 0x1Eu) >> 1u; + opcode |= (enc13.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kU32)) { + VecFBitsVFPEncode enc14; + if (enc14.init(32u, o2.as())) { + opcode = 0x0EBB0BC0u; + opcode |= (enc14.imm() & 0x1Eu) >> 1u; + opcode |= (enc14.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF64)) { + VecFBitsVFPEncode enc15; + if (enc15.init(32u, o2.as())) { + opcode = 0x0EBF0BC0u; + opcode |= (enc15.imm() & 0x1Eu) >> 1u; + opcode |= (enc15.imm() & 0x1u) << 5u; + goto Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS32)) { + VecFBitsASIMDEncode enc16; + if (enc16.init(o2.as())) { + opcode = 0xF2800E10u; + opcode |= enc16.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + VecFBitsASIMDEncode enc18; + if (enc18.init(o2.as())) { + opcode = 0xF2800F10u; + opcode |= enc18.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU32)) { + VecFBitsASIMDEncode enc20; + if (enc20.init(o2.as())) { + opcode = 0xF3800E10u; + opcode |= enc20.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + VecFBitsASIMDEncode enc22; + if (enc22.init(o2.as())) { + opcode = 0xF3800F10u; + opcode |= enc22.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kS16)) { + VecFBitsASIMDEncode enc24; + if (enc24.init(o2.as())) { + opcode = 0xF2800C10u; + opcode |= enc24.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS16, DT::kF16)) { + VecFBitsASIMDEncode enc26; + if (enc26.init(o2.as())) { + opcode = 0xF2800D10u; + opcode |= enc26.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kU16)) { + VecFBitsASIMDEncode enc28; + if (enc28.init(o2.as())) { + opcode = 0xF3800C10u; + opcode |= enc28.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU16, DT::kF16)) { + VecFBitsASIMDEncode enc30; + if (enc30.init(o2.as())) { + opcode = 0xF3800D10u; + opcode |= enc30.imm() << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = 0xF3BB0700u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = 0xF3BB0780u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS32)) { + opcode = 0xF3BB0600u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU32)) { + opcode = 0xF3BB0680u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = 0xF3BB0740u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = 0xF3BB07C0u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS32)) { + opcode = 0xF3BB0640u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU32)) { + opcode = 0xF3BB06C0u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kS32)) { + VecFBitsASIMDEncode enc17; + if (enc17.init(o2.as())) { + opcode = 0xF2800E50u; + opcode |= enc17.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + VecFBitsASIMDEncode enc19; + if (enc19.init(o2.as())) { + opcode = 0xF2800F50u; + opcode |= enc19.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kU32)) { + VecFBitsASIMDEncode enc21; + if (enc21.init(o2.as())) { + opcode = 0xF3800E50u; + opcode |= enc21.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + VecFBitsASIMDEncode enc23; + if (enc23.init(o2.as())) { + opcode = 0xF3800F50u; + opcode |= enc23.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kS16)) { + VecFBitsASIMDEncode enc25; + if (enc25.init(o2.as())) { + opcode = 0xF2800C50u; + opcode |= enc25.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kS16, DT::kF16)) { + VecFBitsASIMDEncode enc27; + if (enc27.init(o2.as())) { + opcode = 0xF2800D50u; + opcode |= enc27.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kU16)) { + VecFBitsASIMDEncode enc29; + if (enc29.init(o2.as())) { + opcode = 0xF3800C50u; + opcode |= enc29.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + if (is_dt_and_dt2_single(dtBits, DT::kU16, DT::kF16)) { + VecFBitsASIMDEncode enc31; + if (enc31.init(o2.as())) { + opcode = 0xF3800D50u; + opcode |= enc31.imm() << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kF32)) { + opcode = 0xF3B60600u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kF16)) { + opcode = 0xF3B60700u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 89: { + // Instruction 'vcvta'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = 0xFEBC0AC0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = 0xFEBC0A40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF16)) { + opcode = 0xFEBC09C0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF16)) { + opcode = 0xFEBC0940u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF64)) { + opcode = 0xFEBC0BC0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF64)) { + opcode = 0xFEBC0B40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 90: { + static const uint32_t opcode_table[] = { + 0x0EB30940u, 0x0EB30B40u, 0x0EB20A40u, 0x0EB30A40u, 0x0EB20B40u, // Instruction 'vcvtb'. + 0x0EB309C0u, 0x0EB30BC0u, 0x0EB20AC0u, 0x0EB30AC0u, 0x0EB20BC0u // Instruction 'vcvtt'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 5u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kBF16, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kF64)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF32, DT::kF16)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kF16, DT::kF32)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kF64, DT::kF16)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At0Of4Lo5_Cond; + } + } + } + + break; + } + + case 91: { + static const uint32_t opcode_table[] = { + 0xF3BB0300u, 0xF3BB0380u, 0xF3B70300u, 0xF3B70380u, 0xF3BB0340u, 0xF3BB03C0u, 0xF3B70340u, 0xF3B703C0u, 0xFEBF0AC0u, 0xFEBF0A40u, 0xFEBF09C0u, 0xFEBF0940u, 0xFEBF0BC0u, 0xFEBF0B40u, // Instruction 'vcvtm'. + 0xF3BB0100u, 0xF3BB0180u, 0xF3B70100u, 0xF3B70180u, 0xF3BB0140u, 0xF3BB01C0u, 0xF3B70140u, 0xF3B701C0u, 0xFEBD0AC0u, 0xFEBD0A40u, 0xFEBD09C0u, 0xFEBD0940u, 0xFEBD0BC0u, 0xFEBD0B40u, // Instruction 'vcvtn'. + 0xF3BB0200u, 0xF3BB0280u, 0xF3B70200u, 0xF3B70280u, 0xF3BB0240u, 0xF3BB02C0u, 0xF3B70240u, 0xF3B702C0u, 0xFEBE0AC0u, 0xFEBE0A40u, 0xFEBE09C0u, 0xFEBE0940u, 0xFEBE0BC0u, 0xFEBE0B40u // Instruction 'vcvtp'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 14u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kS16, DT::kF16)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU16, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = opcode_table_ptr[5]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kS16, DT::kF16)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU16, DT::kF16)) { + opcode = opcode_table_ptr[7]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = opcode_table_ptr[8]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = opcode_table_ptr[9]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF16)) { + opcode = opcode_table_ptr[10]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF16)) { + opcode = opcode_table_ptr[11]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF64)) { + opcode = opcode_table_ptr[12]; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF64)) { + opcode = opcode_table_ptr[13]; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 92: { + // Instruction 'vcvtr'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF32)) { + opcode = 0x0EBD0A40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF32)) { + opcode = 0x0EBC0A40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF16)) { + opcode = 0xEEBD0940u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF16)) { + opcode = 0xEEBC0940u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF64)) { + opcode = 0x0EBD0B40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_Cond; + } + + if (is_dt_and_dt2_single(dtBits, DT::kU32, DT::kF64)) { + opcode = 0x0EBC0B40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_Cond; + } + } + } + + break; + } + + case 93: { + static const uint32_t opcode_table[] = { + 0x0E800A00u, 0xEE800900u, 0x0E800B00u, // Instruction 'vdiv'. + 0x0E100A40u, 0xEE100940u, 0x0E100B40u, // Instruction 'vnmla'. + 0x0E100A00u, 0xEE100900u, 0x0E100B00u, // Instruction 'vnmls'. + 0x0E200A40u, 0xEE200940u, 0x0E200B40u // Instruction 'vnmul'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond; + } + } + } + + break; + } + + case 94: { + // Instruction 'vdot'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + opcode = 0xFC000D00u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xFE000D00u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + opcode = 0xFC000D40u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xFE000D40u; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 95: { + // Instruction 'vdup'. + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = 0x0EC00B10u; + goto Emit_R0At16Of4Hi7_R1At12Of4_Cond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + opcode = 0x0E800B30u; + goto Emit_R0At16Of4Hi7_R1At12Of4_Cond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + opcode = 0x0E800B10u; + goto Emit_R0At16Of4Hi7_R1At12Of4_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = 0x0EE00B10u; + goto Emit_Q0At16Of4Hi7_R1At12Of4_Cond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + opcode = 0x0EA00B30u; + goto Emit_Q0At16Of4Hi7_R1At12Of4_Cond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + opcode = 0x0EA00B10u; + goto Emit_Q0At16Of4Hi7_R1At12Of4_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as()) && is_element_vec(o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF3B10C00u; + opcode |= i << 17u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF3B20C00u; + opcode |= i << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF3B40C00u; + opcode |= i << 19u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as()) && is_element_vec(o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF3B10C40u; + opcode |= i << 17u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF3B20C40u; + opcode |= i << 18u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF3B40C40u; + opcode |= i << 19u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 96: { + // Instruction 'vext'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + if (o3.as().value_as() <= 0xFu) { + opcode = 0xF2B00000u; + opcode |= o3.as().value_as() << 8u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + if (o3.as().value_as() <= 0xFu) { + opcode = 0xF2B00040u; + opcode |= o3.as().value_as() << 8u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 97: { + static const uint32_t opcode_table[] = { + 0xEEA00900u, 0x0EA00A00u, 0x0EA00B00u, 0xF2100C10u, 0xF2000C10u, 0xF2100C50u, 0xF2000C50u, // Instruction 'vfma'. + 0xEEA00940u, 0x0EA00A40u, 0x0EA00B40u, 0xF2300C10u, 0xF2200C10u, 0xF2300C50u, 0xF2200C50u // Instruction 'vfms'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 7u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[5]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 98: { + static const uint32_t opcode_table[] = { + 0xFC300810u, 0xFE300810u, // Instruction 'vfmab'. + 0xFC300850u, 0xFE300850u // Instruction 'vfmat'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[1]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + } + } + + break; + } + + case 99: { + static const uint32_t opcode_table[] = { + 0xFC200810u, 0xFE000810u, 0xFC200850u, 0xFE000850u, // Instruction 'vfmal'. + 0xFCA00810u, 0xFE100810u, 0xFCA00850u, 0xFE100850u // Instruction 'vfmsl'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[1]; + opcode |= i << 3u; + goto Emit_R0At12Of4Hi22_R1At16Of4Lo7_R2At0Of3Lo5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[2]; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[3]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + } + } + + break; + } + + case 100: { + static const uint32_t opcode_table[] = { + 0xEE900940u, 0x0E900A40u, 0x0E900B40u, // Instruction 'vfnma'. + 0xEE900900u, 0x0E900A00u, 0x0E900B00u // Instruction 'vfnms'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond; + } + } + } + + break; + } + + case 101: { + static const uint32_t opcode_table[] = { + 0xFEB00AC0u, // Instruction 'vins'. + 0xFEB00A40u // Instruction 'vmovx'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + break; + } + + case 102: { + // Instruction 'vjcvt'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_and_dt2_single(dtBits, DT::kS32, DT::kF64)) { + opcode = 0xEEB90BC0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 103: { + // Instruction 'vld1'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF420070Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_element_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0000Fu; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0040Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A0080Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 8u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF420070Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 1u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0000Du; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 2u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0040Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 4u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A0080Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4200700u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_element_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A00000u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00400u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00800u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4200A0Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 16u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4200A0Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4200A00u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o3.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF420060Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 24u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF420060Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4200600u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF420020Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 32u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF420020Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4200200u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 104: { + // Instruction 'vld1r'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00C0Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == (1u << sz)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00C0Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00C00u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00C2Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == (1u << sz)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00C2Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00C20u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 105: { + // Instruction 'vld2'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420080Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420090Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_element_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0010Fu; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0050Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A0090Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0052Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A0094Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 16u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420080Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420090Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 2u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0010Du; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 4u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0050Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0052Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 8u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A0090Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A0094Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200800u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200900u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + + if (is_element_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A00100u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00500u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00900u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00520u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00940u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420030Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 32u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420030Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200300u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 106: { + // Instruction 'vld2r'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00D0Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00D2Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == (2u << sz)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00D0Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00D2Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00D00u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00D20u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 107: { + // Instruction 'vld3'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o3.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420040Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420052Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_element_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0020Fu; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0060Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00A0Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0062Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00A4Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 24u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420040Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420052Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 3u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0020Du; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 6u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0060Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0062Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 12u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00A0Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00A4Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200400u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200520u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + + if (is_element_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A00200u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00600u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00A00u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00620u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00A40u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + } + + break; + } + + case 108: { + // Instruction 'vld3r'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o3.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00E0Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00E2Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == (3u << sz)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00E0Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00E2Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00E00u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00E20u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 109: { + // Instruction 'vld4'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420000Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420010Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_element_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0030Fu; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0070Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00B0Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0072Fu; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00B4Fu; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 32u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420000Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF420010Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 4u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A0030Du; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 8u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0070Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A0072Du; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 16u) { + if (mem->is_post_index()) { + if (is_element_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00B0Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00B4Du; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200000u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4200100u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + + if (is_element_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0xF4A00300u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00700u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00B00u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF4A00720u; + opcode |= i << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF4A00B40u; + opcode |= i << 7u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + } + + break; + } + + case 110: { + // Instruction 'vld4r'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00F0Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00F2Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == (4u << sz)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00F0Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00F2Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00F00u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4A00F20u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 111: { + static const uint32_t opcode_table[] = { + 0x0D300A00u, 0x0D300A00u, 0x0D300B00u, 0x0D300B00u, // Instruction 'vldmdb'. + 0x0D200A00u, 0x0D200A00u, 0x0D200B00u, 0x0D200B00u // Instruction 'vstmdb'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + mem = &o0.as(); + const GpList& reg_list = o1.as(); + + if (mem->base_id() <= 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_pre_index()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + VecSListImmEncode enc0; + if (enc0.init(reg_list)) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.immCount() << 0u; + opcode |= (enc0.immVd() & 0x1Eu) << 11u; + opcode |= (enc0.immVd() & 0x1u) << 22u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + } + + if (mem->base_id() == 15u && !mem->offset_lo32()) { + if (mem->is_pre_index()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + VecSListImmEncode enc1; + if (enc1.init(reg_list)) { + opcode = opcode_table_ptr[1]; + opcode |= enc1.immCount() << 0u; + opcode |= (enc1.immVd() & 0x1Eu) << 11u; + opcode |= (enc1.immVd() & 0x1u) << 22u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + + if (sgn.test()) { + mem = &o0.as(); + const GpList& reg_list = o1.as(); + + if (mem->base_id() <= 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_pre_index()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + VecDListImmEncode enc2; + if (enc2.init(reg_list)) { + opcode = opcode_table_ptr[2]; + opcode |= enc2.immCount() << 0u; + opcode |= (enc2.immVd() & 0xFu) << 12u; + opcode |= (enc2.immVd() & 0x10u) << 18u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + } + + if (mem->base_id() == 15u && !mem->offset_lo32()) { + if (mem->is_pre_index()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + VecDListImmEncode enc3; + if (enc3.init(reg_list)) { + opcode = opcode_table_ptr[3]; + opcode |= enc3.immCount() << 0u; + opcode |= (enc3.immVd() & 0xFu) << 12u; + opcode |= (enc3.immVd() & 0x10u) << 18u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + + break; + } + + case 112: { + static const uint32_t opcode_table[] = { + 0x0C900A00u, 0x0C900A00u, 0x0C900B00u, 0x0C900B00u, // Instruction 'vldmia'. + 0x0C800A00u, 0x0C800A00u, 0x0C800B00u, 0x0C800B00u // Instruction 'vstmia'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + mem = &o0.as(); + const GpList& reg_list = o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (!mem->is_post_index()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + VecSListImmEncode enc0; + if (enc0.init(reg_list)) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.immCount() << 0u; + opcode |= (enc0.immVd() & 0x1Eu) << 11u; + opcode |= (enc0.immVd() & 0x1u) << 22u; + goto Emit_MemBaseAt16W21_Cond; + } + } + } + } + } + } + + if (mem->base_id() == 15u && !mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + VecSListImmEncode enc2; + if (enc2.init(reg_list)) { + opcode = opcode_table_ptr[1]; + opcode |= enc2.immCount() << 0u; + opcode |= (enc2.immVd() & 0x1Eu) << 11u; + opcode |= (enc2.immVd() & 0x1u) << 22u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + + if (sgn.test()) { + mem = &o0.as(); + const GpList& reg_list = o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (!mem->is_post_index()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + VecDListImmEncode enc1; + if (enc1.init(reg_list)) { + opcode = opcode_table_ptr[2]; + opcode |= enc1.immCount() << 0u; + opcode |= (enc1.immVd() & 0xFu) << 12u; + opcode |= (enc1.immVd() & 0x10u) << 18u; + goto Emit_MemBaseAt16W21_Cond; + } + } + } + } + } + } + + if (mem->base_id() == 15u && !mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + VecDListImmEncode enc3; + if (enc3.init(reg_list)) { + opcode = opcode_table_ptr[3]; + opcode |= enc3.immCount() << 0u; + opcode |= (enc3.immVd() & 0xFu) << 12u; + opcode |= (enc3.immVd() & 0x10u) << 18u; + goto Emit_MemBaseAt16_Cond; + } + } + } + } + } + + break; + } + + case 113: { + static const uint32_t opcode_table[] = { + 0x0D100A00u, 0xED100900u, 0x0D100A00u, 0xED100900u, 0x0D100B00u, 0x0D100B00u, // Instruction 'vldr'. + 0x0D000A00u, 0xED000900u, 0x0D000A00u, 0xED000900u, 0x0D000B00u, 0x0D000B00u // Instruction 'vstr'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 6u; + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() <= 15u) { + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 2)) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + opcode = opcode_table_ptr[0]; + opcode |= uBitFromDt(dtBits) << 23u; + goto Emit_R0At12Of4Lo22_MemBaseAt16_SOffAt0Of8Mul4_Cond; + } + } + } + } + + if (check_soffset(mem->offset_lo32(), 8, 1)) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + opcode = opcode_table_ptr[1]; + opcode |= uBitFromDt(dtBits) << 23u; + goto Emit_R0At12Of4Lo22_MemBaseAt16_SOffAt0Of8Mul2_NoCond; + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o1.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + opcode = opcode_table_ptr[2]; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 8, 0); + goto Emit_R0At12Of4Lo22_MemPCRel_Cond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16))) { + opcode = opcode_table_ptr[3]; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 8, 0); + goto Emit_R0At12Of4Lo22_MemPCRel_NoCond; + } + } + } + } + } + + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() <= 15u) { + if (!mem->has_index()) { + if (check_soffset(mem->offset_lo32(), 8, 2)) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + opcode = opcode_table_ptr[4]; + opcode |= uBitFromDt(dtBits) << 23u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_SOffAt0Of8Mul4_Cond; + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o1.as(); + + if (is_mem_pc_rel(*mem)) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + opcode = opcode_table_ptr[5]; + opcode |= 0xFu << 16; + offset_format.reset_to_imm_value(OffsetType::kAArch32_U23_SignedOffset, 4, 0, 8, 0); + goto Emit_R0At12Of4Hi22_MemPCRel_Cond; + } + } + } + } + } + + break; + } + + case 114: { + static const uint32_t opcode_table[] = { + 0xFE800900u, 0xFE800A00u, 0xFE800B00u, 0xF3100F10u, 0xF3000F10u, 0xF3100F50u, 0xF3000F50u, // Instruction 'vmaxnm'. + 0xFE800940u, 0xFE800A40u, 0xFE800B40u, 0xF3300F10u, 0xF3200F10u, 0xF3300F50u, 0xF3200F50u // Instruction 'vminnm'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 7u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[5]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 115: { + static const uint32_t opcode_table[] = { + 0x0E000A00u, 0xEE000900u, 0x0E000B00u, 0xF2100D10u, 0xF2000D10u, 0xF2000900u, 0xF2900140u, 0xF2A00140u, 0xF2900040u, 0xF2A00040u, 0xF2100D50u, 0xF2000D50u, 0xF2000940u, 0xF3900140u, 0xF3A00140u, 0xF3900040u, 0xF3A00040u, // Instruction 'vmla'. + 0x0E000A40u, 0xEE000940u, 0x0E000B40u, 0xF2300D10u, 0xF2200D10u, 0xF3000900u, 0xF2900540u, 0xF2A00540u, 0xF2900440u, 0xF2A00440u, 0xF2300D50u, 0xF2200D50u, 0xF3000940u, 0xF3900540u, 0xF3A00540u, 0xF3900440u, 0xF3A00440u // Instruction 'vmls'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 17u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[5]; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[6]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[7]; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[8]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[9]; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[10]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[11]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[12]; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[13]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[14]; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[15]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[16]; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 116: { + static const uint32_t opcode_table[] = { + 0xF2800800u, 0xF2900240u, 0xF2A00240u, // Instruction 'vmlal'. + 0xF2800A00u, 0xF2900640u, 0xF2A00640u // Instruction 'vmlsl'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[1]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[2]; + opcode |= i << 5u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 117: { + // Instruction 'vmmla'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kBF16)) { + opcode = 0xFC000C40u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 118: { + // Instruction 'vmov'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0x0EB00A40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = 0x0EB00B40u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond; + } + opcode = 0xF2200110u; + goto Emit_R0At12Of4Hi22_R1At0Of4At16Of4Hi5Hi7_NoCond; + } + } + + if (sgn.test() || sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + VecVFPImmEncode enc0; + if (enc0.init(o1.as())) { + opcode = 0x0EB00A00u; + opcode |= (enc0.imm() & 0xFu) << 0u; + opcode |= (enc0.imm() & 0xF0u) << 12u; + goto Emit_R0At12Of4Lo22_Cond; + } + } + + if (is_dt_single(dtBits, DT::kF16)) { + VecVFPImmEncode enc2; + if (enc2.init(o1.as())) { + opcode = 0xEEB00900u; + opcode |= (enc2.imm() & 0xFu) << 0u; + opcode |= (enc2.imm() & 0xF0u) << 12u; + goto Emit_R0At12Of4Lo22_NoCond; + } + } + } + } + + if (sgn.test() || sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + VecVFPImmEncode enc1; + if (enc1.init(o1.as())) { + opcode = 0x0EB00B00u; + opcode |= (enc1.imm() & 0xFu) << 0u; + opcode |= (enc1.imm() & 0xF0u) << 12u; + goto Emit_R0At12Of4Hi22_Cond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xEE100910u; + goto Emit_R0At12Of4_R1At16Of4Lo7_NoCond; + } + opcode = 0x0E100A10u; + goto Emit_R0At12Of4_R1At16Of4Lo7_Cond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xEE000910u; + goto Emit_R0At16Of4Lo7_R1At12Of4_NoCond; + } + opcode = 0x0E000A10u; + goto Emit_R0At16Of4Lo7_R1At12Of4_Cond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o2.as(), o3.as())) { + if (is_consecutive(1, o2.as(), o3.as())) { + opcode = 0x0C500A10u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + opcode = 0x0C400A10u; + goto Emit_R0At0Of4Lo5_R2At12Of4_R3At16Of4_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o2.as())) { + opcode = 0x0C500B10u; + goto Emit_R0At12Of4_R1At16Of4_R2At0Of4Hi5_Cond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + opcode = 0x0C400B10u; + goto Emit_R0At0Of4Hi5_R1At12Of4_R2At16Of4_Cond; + } + } + + if (sgn.test()) { + if (is_element_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x7) { + opcode = 0x0E400B10u; + opcode |= (i & 0x3u) << 5u; + opcode |= (i & 0x4u) << 19u; + goto Emit_R0At16Of4Hi7_R1At12Of4_Cond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x3) { + opcode = 0x0E000B30u; + opcode |= (i & 0x1u) << 6u; + opcode |= (i & 0x2u) << 20u; + goto Emit_R0At16Of4Hi7_R1At12Of4_Cond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o0.as().as().element_index(); + if (i <= 0x1) { + opcode = 0x0E000B10u; + opcode |= i << 21u; + goto Emit_R0At16Of4Hi7_R1At12Of4_Cond; + } + } + } + } + + if (sgn.test()) { + if (is_element_vec(o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x7) { + opcode = 0x0E500B10u; + opcode |= (i & 0x3u) << 5u; + opcode |= (i & 0x4u) << 19u; + opcode |= uBitFromDt(dtBits) << 23u; + goto Emit_R0At12Of4_R1At16Of4Hi7_Cond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x3) { + opcode = 0x0E100B30u; + opcode |= (i & 0x1u) << 6u; + opcode |= (i & 0x2u) << 20u; + opcode |= uBitFromDt(dtBits) << 23u; + goto Emit_R0At12Of4_R1At16Of4Hi7_Cond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o1.as().as().element_index(); + if (i <= 0x1) { + opcode = 0x0E100B10u; + opcode |= i << 21u; + goto Emit_R0At12Of4_R1At16Of4Hi7_Cond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + opcode = 0xF2200150u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4At16Of4Hi5Hi7_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecMovImmEncode enc3; + if (enc3.init(sz, 0u, o1.as())) { + opcode = 0xF2800010u; + opcode |= (enc3.imm() & 0xFu) << 0u; + opcode |= (enc3.imm() & 0x70u) << 12u; + opcode |= (enc3.imm() & 0x80u) << 17u; + opcode |= enc3.op() << 5u; + opcode |= enc3.cmode() << 8u; + goto Emit_R0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecMovImmEncode enc4; + if (enc4.init(sz, 0u, o1.as())) { + opcode = 0xF2800050u; + opcode |= (enc4.imm() & 0xFu) << 0u; + opcode |= (enc4.imm() & 0x70u) << 12u; + opcode |= (enc4.imm() & 0x80u) << 17u; + opcode |= enc4.op() << 5u; + opcode |= enc4.cmode() << 8u; + goto Emit_Q0At12Of4Hi22_NoCond; + } + } + } + } + + break; + } + + case 119: { + // Instruction 'vmovl'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = 0xF2880A10u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + opcode = 0xF2900A10u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + opcode = 0xF2A00A10u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 120: { + // Instruction 'vmovn'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + opcode = 0xF3B20200u; + opcode |= (sz - 1) << 18u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 121: { + // Instruction 'vmul'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0x0E200A00u; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xEE200900u; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = 0x0E200B00u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xF3100D10u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0xF3000D10u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kP8, DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF2000910u; + opcode |= sz << 20u; + opcode |= pBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF2900940u; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF2A00940u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF2900840u; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF2A00840u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF3900940u; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kF32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF3A00940u; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF3900840u; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF3A00840u; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xF3100D50u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0xF3000D50u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kP8, DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF2000950u; + opcode |= sz << 20u; + opcode |= pBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 122: { + // Instruction 'vmull'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kP8, DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF2800C00u; + opcode |= pBitFromDt(dtBits) << 9u; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kP64)) { + opcode = 0xF2A00C00u; + opcode |= pBitFromDt(dtBits) << 9u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = 0xF2900A40u; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xF2A00A40u; + opcode |= i << 5u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 123: { + // Instruction 'vmvn'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + VecMovImmEncode enc0; + if (enc0.init(sz, 1u, o1.as())) { + opcode = 0xF2800010u; + opcode |= (enc0.imm() & 0xFu) << 0u; + opcode |= (enc0.imm() & 0x70u) << 12u; + opcode |= (enc0.imm() & 0x80u) << 17u; + opcode |= enc0.op() << 5u; + opcode |= enc0.cmode() << 8u; + goto Emit_R0At12Of4Hi22_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + VecMovImmEncode enc1; + if (enc1.init(sz, 1u, o1.as())) { + opcode = 0xF2800050u; + opcode |= (enc1.imm() & 0xFu) << 0u; + opcode |= (enc1.imm() & 0x70u) << 12u; + opcode |= (enc1.imm() & 0x80u) << 17u; + opcode |= enc1.op() << 5u; + opcode |= enc1.cmode() << 8u; + goto Emit_Q0At12Of4Hi22_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + opcode = 0xF3B00580u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + opcode = 0xF3B005C0u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + break; + } + + case 124: { + // Instruction 'vorn'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc0; + if (enc0.init(sz, 1u, o1.as())) { + opcode = 0xF2800010u; + opcode |= (enc0.imm() & 0xFu) << 0u; + opcode |= (enc0.imm() & 0x70u) << 12u; + opcode |= (enc0.imm() & 0x80u) << 17u; + opcode |= enc0.cmode() << 8u; + goto Emit_R0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc1; + if (enc1.init(sz, 1u, o1.as())) { + opcode = 0xF2800050u; + opcode |= (enc1.imm() & 0xFu) << 0u; + opcode |= (enc1.imm() & 0x70u) << 12u; + opcode |= (enc1.imm() & 0x80u) << 17u; + opcode |= enc1.cmode() << 8u; + goto Emit_Q0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2300110u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2300150u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + break; + } + + case 125: { + // Instruction 'vorr'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc0; + if (enc0.init(sz, 0u, o1.as())) { + opcode = 0xF2800010u; + opcode |= (enc0.imm() & 0xFu) << 0u; + opcode |= (enc0.imm() & 0x70u) << 12u; + opcode |= (enc0.imm() & 0x80u) << 17u; + opcode |= enc0.cmode() << 8u; + goto Emit_R0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecBicOrrImmEncode enc1; + if (enc1.init(sz, 0u, o1.as())) { + opcode = 0xF2800050u; + opcode |= (enc1.imm() & 0xFu) << 0u; + opcode |= (enc1.imm() & 0x70u) << 12u; + opcode |= (enc1.imm() & 0x80u) << 17u; + opcode |= enc1.cmode() << 8u; + goto Emit_Q0At12Of4Hi22_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2200110u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + opcode = 0xF2200150u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + + break; + } + + case 126: { + static const uint32_t opcode_table[] = { + 0xF3B00600u, 0xF3B00640u, // Instruction 'vpadal'. + 0xF3B00200u, 0xF3B00240u // Instruction 'vpaddl'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= uBitFromDt(dtBits) << 7u; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[1]; + opcode |= uBitFromDt(dtBits) << 7u; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 127: { + // Instruction 'vpadd'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xF3100D00u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0xF3000D00u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 128: { + static const uint32_t opcode_table[] = { + 0xF3100F00u, 0xF3000F00u, 0xF2000A00u, // Instruction 'vpmax'. + 0xF3300F00u, 0xF3200F00u, 0xF2000A10u // Instruction 'vpmin'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[2]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 129: { + static const uint32_t opcode_table[] = { + 0x0CBD0A00u, 0x0CBD0B00u, // Instruction 'vpop'. + 0x0D2D0A00u, 0x0D2D0B00u // Instruction 'vpush'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + if (sgn.test()) { + const GpList& reg_list = o0.as(); + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32, DT::kF32))) { + VecSListImmEncode enc0; + if (enc0.init(reg_list)) { + opcode = opcode_table_ptr[0]; + opcode |= enc0.immCount() << 0u; + opcode |= (enc0.immVd() & 0x1Eu) << 11u; + opcode |= (enc0.immVd() & 0x1u) << 22u; + goto Emit_Cond; + } + } + } + + if (sgn.test()) { + const GpList& reg_list = o0.as(); + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS64, DT::kU64, DT::kF64))) { + VecDListImmEncode enc1; + if (enc1.init(reg_list)) { + opcode = opcode_table_ptr[1]; + opcode |= enc1.immCount() << 0u; + opcode |= (enc1.immVd() & 0xFu) << 12u; + opcode |= (enc1.immVd() & 0x10u) << 18u; + goto Emit_Cond; + } + } + } + + break; + } + + case 130: { + static const uint32_t opcode_table[] = { + 0xF3B00700u, 0xF3B00740u, // Instruction 'vqabs'. + 0xF3B00780u, 0xF3B007C0u // Instruction 'vqneg'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8))) { + opcode = opcode_table_ptr[1]; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 131: { + static const uint32_t opcode_table[] = { + 0xF2000010u, 0xF2000050u, // Instruction 'vqadd'. + 0xF2000210u, 0xF2000250u // Instruction 'vqsub'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = opcode_table_ptr[1]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 132: { + static const uint32_t opcode_table[] = { + 0xF2800900u, 0xF2900340u, 0xF2A00340u, // Instruction 'vqdmlal'. + 0xF2800B00u, 0xF2900740u, 0xF2A00740u, // Instruction 'vqdmlsl'. + 0xF2800D00u, 0xF2900B40u, 0xF2A00B40u // Instruction 'vqdmull'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[1]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kS32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[2]; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 133: { + static const uint32_t opcode_table[] = { + 0xF2000B00u, 0xF2900C40u, 0xF2A00C40u, 0xF2000B40u, 0xF3900C40u, 0xF3A00C40u, // Instruction 'vqdmulh'. + 0xF3000B00u, 0xF2900D40u, 0xF2A00D40u, 0xF3000B40u, 0xF3900D40u, 0xF3A00D40u // Instruction 'vqrdmulh'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 6u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[1]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kS32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[2]; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32))) { + opcode = opcode_table_ptr[3]; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[4]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kS32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[5]; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 134: { + // Instruction 'vqmovn'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + opcode = 0xF3B20280u; + opcode |= uBitFromDt(dtBits) << 6u; + opcode |= (sz - 1) << 18u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 135: { + // Instruction 'vqmovun'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64))) { + opcode = 0xF3B20240u; + opcode |= (sz - 1) << 18u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 136: { + static const uint32_t opcode_table[] = { + 0xF3000B10u, 0xF2800E40u, 0xF2800E40u, 0xF3000B50u, 0xF3800E40u, 0xF3800E40u, // Instruction 'vqrdmlah'. + 0xF3000C10u, 0xF2800F40u, 0xF2800F40u, 0xF3000C50u, 0xF3800F40u, 0xF3800F40u // Instruction 'vqrdmlsh'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 6u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[1]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kS32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[2]; + opcode |= i << 5u; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32))) { + opcode = opcode_table_ptr[3]; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS16)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x3) { + opcode = opcode_table_ptr[4]; + opcode |= (i & 0x1u) << 3u; + opcode |= (i & 0x2u) << 4u; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond; + } + } + + if (is_dt_single(dtBits, DT::kS32)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[5]; + opcode |= i << 5u; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 137: { + static const uint32_t opcode_table[] = { + 0xF2000510u, 0xF2000550u, // Instruction 'vqrshl'. + 0xF2000500u, 0xF2000540u // Instruction 'vrshl'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = opcode_table_ptr[1]; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + } + } + + break; + } + + case 138: { + static const uint32_t opcode_table[] = { + 0xF3B20280u, 0xF2800950u, // Instruction 'vqrshrn'. + 0xF3B20280u, 0xF2800910u // Instruction 'vqshrn'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecShiftNarrowImmEncode enc0; + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[0]; + opcode |= uBitFromDt(dtBits) << 6u; + opcode |= (sz - 1) << 18u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + if (enc0.init(sz, o2.as())) { + opcode = opcode_table_ptr[1]; + opcode |= enc0.imm() << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 139: { + static const uint32_t opcode_table[] = { + 0xF3B20240u, 0xF3800850u, // Instruction 'vqrshrun'. + 0xF3B20240u, 0xF3800810u // Instruction 'vqshrun'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64))) { + VecShiftNarrowImmEncode enc0; + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[0]; + opcode |= (sz - 1) << 18u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + if (enc0.init(sz, o2.as())) { + opcode = opcode_table_ptr[1]; + opcode |= enc0.imm() << 16u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 140: { + // Instruction 'vqshl'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = 0xF2000410u; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = 0xF2000450u; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftPImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = 0xF2800710u; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftPImmEncode enc1; + if (enc1.init(sz, o2.as())) { + opcode = 0xF2800750u; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 141: { + // Instruction 'vqshlu'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8))) { + VecShiftPImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = 0xF3800610u; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8))) { + VecShiftPImmEncode enc1; + if (enc1.init(sz, o2.as())) { + opcode = 0xF3800650u; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 142: { + static const uint32_t opcode_table[] = { + 0xF3B70500u, 0xF3BB0500u, 0xF3BB0400u, 0xF3B70540u, 0xF3BB0540u, 0xF3BB0440u, // Instruction 'vrecpe'. + 0xF3B70580u, 0xF3BB0580u, 0xF3BB0480u, 0xF3B705C0u, 0xF3BB05C0u, 0xF3BB04C0u // Instruction 'vrsqrte'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 6u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kU32)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kU32)) { + opcode = opcode_table_ptr[5]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 143: { + // Instruction 'vrev32'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS8, DT::kU16, DT::kU8))) { + opcode = 0xF3B00080u; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS8, DT::kU16, DT::kU8))) { + opcode = 0xF3B000C0u; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 144: { + static const uint32_t opcode_table[] = { + 0xFEB80940u, 0xFEB80A40u, 0xFEB80B40u, 0xF3B60500u, 0xF3BA0500u, 0xF3B60540u, 0xF3BA0540u, // Instruction 'vrinta'. + 0xFEBB0940u, 0xFEBB0A40u, 0xFEBB0B40u, 0xF3B60680u, 0xF3BA0680u, 0xF3B606C0u, 0xF3BA06C0u, // Instruction 'vrintm'. + 0xFEB90940u, 0xFEB90A40u, 0xFEB90B40u, 0xF3B60400u, 0xF3BA0400u, 0xF3B60440u, 0xF3BA0440u, // Instruction 'vrintn'. + 0xFEBA0940u, 0xFEBA0A40u, 0xFEBA0B40u, 0xF3B60780u, 0xF3BA0780u, 0xF3B607C0u, 0xF3BA07C0u // Instruction 'vrintp'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 7u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[5]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 145: { + // Instruction 'vrintr'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xEEB60940u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0x0EB60A40u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = 0x0EB60B40u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond; + } + } + } + + break; + } + + case 146: { + static const uint32_t opcode_table[] = { + 0xEEB70940u, 0x0EB70A40u, 0x0EB70B40u, 0xF3B60480u, 0xF3BA0480u, 0xF3B604C0u, 0xF3BA04C0u, // Instruction 'vrintx'. + 0xEEB609C0u, 0x0EB60AC0u, 0x0EB60BC0u, 0xF3B60580u, 0xF3BA0580u, 0xF3B605C0u, 0xF3BA05C0u // Instruction 'vrintz'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 7u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[4]; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[5]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[6]; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 147: { + // Instruction 'vrshr'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + VecShiftNImmEncode enc0; + if (o2.as().value() == 0u) { + opcode = 0xF2200110u; + goto Emit_R0At12Of4Hi22_R1At0Of4At16Of4Hi5Hi7_NoCond; + } + if (enc0.init(sz, o2.as())) { + opcode = 0xF2800210u; + opcode |= enc0.imm() << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + VecShiftNImmEncode enc1; + if (o2.as().value() == 0u) { + opcode = 0xF2200150u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4At16Of4Hi5Hi7_NoCond; + } + if (enc1.init(sz, o2.as())) { + opcode = 0xF2800250u; + opcode |= enc1.imm() << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 148: { + static const uint32_t opcode_table[] = { + 0xF3B20210u, 0xF2800850u, // Instruction 'vrshrn'. + 0xFFB20210u, 0xF2800810u // Instruction 'vshrn'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kU16, DT::kU32, DT::kU64))) { + VecShiftNarrowImmEncode enc0; + if (o2.as().value() == 0u) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + if (enc0.init(sz, o2.as())) { + opcode = opcode_table_ptr[1]; + opcode |= enc0.imm() << 16u; + goto Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 149: { + static const uint32_t opcode_table[] = { + 0xF2800310u, 0xF2800350u, // Instruction 'vrsra'. + 0xF2800110u, 0xF2800150u // Instruction 'vsra'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 2u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftNImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = opcode_table_ptr[0]; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftNImmEncode enc1; + if (enc1.init(sz, o2.as())) { + opcode = opcode_table_ptr[1]; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 150: { + static const uint32_t opcode_table[] = { + 0xFC200D00u, 0xFE200D00u, 0xFC200D40u, 0xFE200D40u, // Instruction 'vsdot'. + 0xFCA00D00u, 0xFE800D00u, 0xFCA00D40u, 0xFE800D40u // Instruction 'vusdot'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kS8)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS8)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[1]; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kS8)) { + opcode = opcode_table_ptr[2]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kS8)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = opcode_table_ptr[3]; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 151: { + static const uint32_t opcode_table[] = { + 0xFE000900u, 0xFE000A00u, 0xFE000B00u, // Instruction 'vseleq'. + 0xFE200900u, 0xFE200A00u, 0xFE200B00u, // Instruction 'vselge'. + 0xFE300900u, 0xFE300A00u, 0xFE300B00u, // Instruction 'vselgt'. + 0xFE100900u, 0xFE100A00u, 0xFE100B00u // Instruction 'vselvs'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF16)) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + + if (is_dt_single(dtBits, DT::kF32)) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 152: { + // Instruction 'vshl'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = 0xF2000400u; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + opcode = 0xF2000440u; + opcode |= sz << 20u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftPImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = 0xF2800510u; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftPImmEncode enc1; + if (enc1.init(sz, o2.as())) { + opcode = 0xF2800550u; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 153: { + // Instruction 'vshll'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + VecShiftPImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = 0xF2800A10u; + opcode |= enc0.imm() << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 154: { + // Instruction 'vshr'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftNImmEncode enc0; + if (o2.as().value() == 0u) { + opcode = 0xF2200110u; + goto Emit_R0At12Of4Hi22_R1At0Of4At16Of4Hi5Hi7_NoCond; + } + if (enc0.init(sz, o2.as())) { + opcode = 0xF2800010u; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftNImmEncode enc1; + if (o2.as().value() == 0u) { + opcode = 0xF2200150u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4At16Of4Hi5Hi7_NoCond; + } + if (enc1.init(sz, o2.as())) { + opcode = 0xF2800050u; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + opcode |= uBitFromDt(dtBits) << 24u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 155: { + // Instruction 'vsli'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftPImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = 0xF3800510u; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftPImmEncode enc1; + if (enc1.init(sz, o2.as())) { + opcode = 0xF3800550u; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 156: { + static const uint32_t opcode_table[] = { + 0xFC200C40u, // Instruction 'vsmmla'. + 0xFCA00C40u // Instruction 'vusmmla'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 1u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kS8)) { + opcode = opcode_table_ptr[0]; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 157: { + // Instruction 'vsqrt'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF32)) { + opcode = 0x0EB10AC0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond; + } + + if (is_dt_single(dtBits, DT::kF16)) { + opcode = 0xEEB109C0u; + goto Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_single(dtBits, DT::kF64)) { + opcode = 0x0EB10BC0u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond; + } + } + } + + break; + } + + case 158: { + // Instruction 'vsri'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftNImmEncode enc0; + if (enc0.init(sz, o2.as())) { + opcode = 0xF3800410u; + opcode |= (enc0.imm() & 0x40u) << 1u; + opcode |= (enc0.imm() & 0x3Fu) << 16u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS64, DT::kS8, DT::kU16, DT::kU32, DT::kU64, DT::kU8))) { + VecShiftNImmEncode enc1; + if (enc1.init(sz, o2.as())) { + opcode = 0xF3800450u; + opcode |= (enc1.imm() & 0x40u) << 1u; + opcode |= (enc1.imm() & 0x3Fu) << 16u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 159: { + // Instruction 'vst1'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o1.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF400070Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 8u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF400070Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4000700u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4000A0Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 16u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4000A0Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4000A00u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o3.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF400060Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 24u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF400060Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4000600u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF400020Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 32u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF400020Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS64, DT::kU64, DT::kF64, DT::kS8, DT::kU8))) { + opcode = 0xF4000200u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 160: { + // Instruction 'vst2'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o2.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400080Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400090Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 16u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400080Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400090Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_consecutive(1, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000800u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000900u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400030Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 32u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400030Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000300u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 161: { + // Instruction 'vst3'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o3.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400040Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400052Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 24u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400040Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400052Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000400u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000520u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 162: { + // Instruction 'vst4'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + mem = &o4.as(); + + if (mem->base_id() < 15u) { + if (!mem->has_index()) { + if (!mem->offset_lo32()) { + if (mem->is_fixed_offset()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400000Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400010Fu; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + + if (uint32_t(mem->offset_lo32()) == 32u) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400000Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF400010Du; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_NoCond; + } + } + } + } + } + } + + if (mem->index_type() == RegType::kGp32) { + if (!mem->offset_lo32()) { + if ((mem->index_id() < 13u) || (mem->index_id() == 14u)) { + if (mem->is_post_index()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000000u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + + if (is_consecutive(2, o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kU16, DT::kF16, DT::kBF16, DT::kS32, DT::kU32, DT::kF32, DT::kS8, DT::kU8))) { + opcode = 0xF4000100u; + opcode |= sz << 6u; + goto Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond; + } + } + } + } + } + } + } + } + } + + break; + } + + case 163: { + // Instruction 'vsudot'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xFE800D10u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xFE800D50u; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 164: { + // Instruction 'vswp'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + opcode = 0xF3B20000u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + opcode = 0xF3B20040u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + + break; + } + + case 165: { + static const uint32_t opcode_table[] = { + 0xF3B00800u, 0xF3B00900u, 0xF3B00A00u, 0xF3B00B00u, // Instruction 'vtbl'. + 0xF3B00840u, 0xF3B00940u, 0xF3B00A40u, 0xF3B00B40u // Instruction 'vtbx'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 4u; + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[0]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as())) { + if (is_consecutive(1, o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[1]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R3At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as(), o4.as())) { + if (is_consecutive(1, o1.as(), o2.as(), o3.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[2]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R4At0Of4Hi5_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as(), o3.as(), o4.as(), o5.as())) { + if (is_consecutive(1, o1.as(), o2.as(), o3.as(), o4.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS8, DT::kU8))) { + opcode = opcode_table_ptr[3]; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R5At0Of4Hi5_NoCond; + } + } + } + } + + break; + } + + case 166: { + // Instruction 'vtst'. + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF2000810u; + opcode |= sz << 20u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = 0xF2000850u; + opcode |= sz << 20u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 167: { + // Instruction 'vudot'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + opcode = 0xFC200D10u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond; + } + } + + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xFE200D10u; + opcode |= i << 5u; + goto Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + opcode = 0xFC200D50u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as()) && is_element_vec(o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + uint32_t i = o2.as().as().element_index(); + if (i <= 0x1) { + opcode = 0xFE200D50u; + opcode |= i << 5u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond; + } + } + } + } + + break; + } + + case 168: { + // Instruction 'vummla'. + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as(), o2.as())) { + if (is_dt_single(dtBits, DT::kU8)) { + opcode = 0xFC200C50u; + goto Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond; + } + } + } + + break; + } + + case 169: { + static const uint32_t opcode_table[] = { + 0xF3B20100u, 0xF3B20080u, 0xF3B20140u, // Instruction 'vuzp'. + 0xF3B20180u, 0xF3B20080u, 0xF3B201C0u // Instruction 'vzip'. + }; + + const uint32_t* opcode_table_ptr = opcode_table + uint32_t(idr.index) * 3u; + + uint32_t sz = szFromDt(dtBits); + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS8, DT::kU16, DT::kU8))) { + opcode = opcode_table_ptr[0]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS32, DT::kU32))) { + opcode = opcode_table_ptr[1]; + opcode |= sz << 18u; + goto Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond; + } + } + } + + if (sgn.test()) { + if (is_pure_vec(o0.as(), o1.as())) { + if (is_dt_multiple(dtBits, make_dt_bits(DT::kS16, DT::kS32, DT::kS8, DT::kU16, DT::kU32, DT::kU8))) { + opcode = opcode_table_ptr[2]; + opcode |= sz << 18u; + goto Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond; + } + } + } + + break; + } + + default: { + break; + } + } + + goto InvalidInstruction; + + // Emit - Bits + // ----------- + + Emit_R0At12Of4_R1At16Of4_R2At0Of4_R3At8Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + uint32_t rId3 = o3.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF); + opcode |= ((rId3 & 0xF) << 8); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4_R2At0Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0xF) << 16); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_Rel_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32_Rel; + } + + Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= ((rId1 << 1u) & 0xF) | (((rId1 << 1u) & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At0Of4_R2At8Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= (rId1 & 0xF); + opcode |= ((rId2 & 0xF) << 8); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At0Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= (rId1 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_Rel_Cond: { + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32_Rel; + } + + Emit_R0At12Of4_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_Cond: { + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At0Of4_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= (rId0 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_Rel_NoCond: { + goto Emit_Op32_Rel; + } + + Emit_NoCond: { + goto Emit_Op32; + } + + Emit_R0At16Of4_R1At0Of4_R2At8Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 16); + opcode |= (rId1 & 0xF); + opcode |= ((rId2 & 0xF) << 8); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At16Of4_R1At0Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 16); + opcode |= (rId1 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At16Of4_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 16); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_MemBaseAt16W21_Cond: { + opcode |= mem->base_id() << 16; + opcode |= uint32_t(mem->is_pre_index()) << 21; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_MemBaseAt16_Cond: { + opcode |= mem->base_id() << 16; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_P24W21_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + opcode |= mem->index_id() << 0; + opcode |= 1u << 23; + uint32_t n = mem->shift(); + uint32_t sop = uint32_t(mem->shift_op()); + + if (n > 31u) + goto InvalidAddressScale; + + if (sop > 3u) + goto InvalidAddress; + + opcode |= sop << 5; + opcode |= n << 7; + opcode |= uint32_t(mem->is_pre_index()) << 21; + opcode |= uint32_t(!mem->is_post_index()) << 24; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_SOffAt0Of12_P24W21_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= (off.imm() & 0xFFF); + opcode |= off.u() << 23u; + opcode |= uint32_t(mem->is_pre_index()) << 21; + opcode |= uint32_t(!mem->is_post_index()) << 24; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemPCRel_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32_MemPC; + } + + Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + opcode |= mem->index_id() << 0; + opcode |= 1u << 23; + uint32_t n = mem->shift(); + uint32_t sop = uint32_t(mem->shift_op()); + + if (n > 31u) + goto InvalidAddressScale; + + if (sop > 3u) + goto InvalidAddress; + + opcode |= sop << 5; + opcode |= n << 7; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_SOffAt0Of12_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= (off.imm() & 0xFFF); + opcode |= off.u() << 23u; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_P24W21_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + opcode |= mem->index_id() << 0; + opcode |= 1u << 23; + opcode |= uint32_t(mem->is_pre_index()) << 21; + opcode |= uint32_t(!mem->is_post_index()) << 24; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_P24W21_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= (off.imm() & 0xF) | ((off.imm() & 0xF0) << 4); + opcode |= off.u() << 23u; + opcode |= uint32_t(mem->is_pre_index()) << 21; + opcode |= uint32_t(!mem->is_post_index()) << 24; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_MemSIndexAt0_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + opcode |= mem->index_id() << 0; + opcode |= 1u << 23; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_MemBaseAt16_SOffAt0Of4_SOffAt8Of4_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= (off.imm() & 0xF) | ((off.imm() & 0xF0) << 4); + opcode |= off.u() << 23u; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R2At12Of4_R3At16Of4_R4At0Of4_Cond: { + uint32_t rId2 = o2.as().id(); + uint32_t rId3 = o3.as().id(); + uint32_t rId4 = o4.as().id(); + opcode |= ((rId2 & 0xF) << 12); + opcode |= ((rId3 & 0xF) << 16); + opcode |= (rId4 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R2At12Of4_R3At16Of4_R4At0Of4_NoCond: { + uint32_t rId2 = o2.as().id(); + uint32_t rId3 = o3.as().id(); + uint32_t rId4 = o4.as().id(); + opcode |= ((rId2 & 0xF) << 12); + opcode |= ((rId3 & 0xF) << 16); + opcode |= (rId4 & 0xF); + goto Emit_Op32; + } + + Emit_R0At16Of4_R1At0Of4_R2At8Of4_R3At12Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + uint32_t rId3 = o3.as().id(); + opcode |= ((rId0 & 0xF) << 16); + opcode |= (rId1 & 0xF); + opcode |= ((rId2 & 0xF) << 8); + opcode |= ((rId3 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R1At0Of4_Cond: { + uint32_t rId1 = o1.as().id(); + opcode |= (rId1 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_MemBaseAt16_MemSIndexAt0_SOPAt5_N5At7_NoCond: { + opcode |= mem->base_id() << 16; + opcode |= mem->index_id() << 0; + opcode |= 1u << 23; + uint32_t n = mem->shift(); + uint32_t sop = uint32_t(mem->shift_op()); + + if (n > 31u) + goto InvalidAddressScale; + + if (sop > 3u) + goto InvalidAddress; + + opcode |= sop << 5; + opcode |= n << 7; + goto Emit_Op32; + } + + Emit_MemBaseAt16_SOffAt0Of12_NoCond: { + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= (off.imm() & 0xFFF); + opcode |= off.u() << 23u; + goto Emit_Op32; + } + + Emit_MemPCRel_NoCond: { + goto Emit_Op32_MemPC; + } + + Emit_R0At12Of4_R1At0Of4_R2At16Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= (rId1 & 0xF); + opcode |= ((rId2 & 0xF) << 16); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_MemBaseAt16W21_NoCond: { + opcode |= mem->base_id() << 16; + opcode |= uint32_t(mem->is_pre_index()) << 21; + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= (((rId1 << 1u) & 0x10) << 3) | (((rId1 << 1u) & 0xF) << 16); + opcode |= ((rId2 << 1u) & 0xF) | (((rId2 << 1u) & 0x10) << 1); + goto Emit_Op32; + } + + EmitW21_NoCond: { + opcode |= uint32_t(mem->is_pre_index()) << 21; + goto Emit_Op32; + } + + Emit_R0At12Of4_R2At0Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= (rId2 & 0xF); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At0Of4_MemBaseAt16_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= (rId0 & 0xF); + opcode |= mem->base_id() << 16; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At0Of4_MemBaseAt16_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= (rId1 & 0xF); + opcode |= mem->base_id() << 16; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF) | ((rId2 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF) | ((rId2 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At0Of4Lo5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= ((rId1 & 0x1E) >> 1) | ((rId1 & 0x1) << 5); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At0Of4Hi5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At0Of4Lo5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= ((rId1 & 0x1E) >> 1) | ((rId1 & 0x1) << 5); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At0Of4Hi5_R2At16Of4Hi7_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1); + opcode |= ((rId2 & 0x10) << 3) | ((rId2 & 0xF) << 16); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_Q1At0Of4Hi5_Q2At16Of4Hi7_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= ((rId1 << 1u) & 0xF) | (((rId1 << 1u) & 0x10) << 1); + opcode |= (((rId2 << 1u) & 0x10) << 3) | (((rId2 << 1u) & 0xF) << 16); + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= ((rId1 & 0x1) << 7) | ((rId1 & 0x1E) << 15); + opcode |= ((rId2 & 0x1E) >> 1) | ((rId2 & 0x1) << 5); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4Hi5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF) | ((rId2 & 0x10) << 1); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= ((rId1 & 0x1) << 7) | ((rId1 & 0x1E) << 15); + opcode |= ((rId2 & 0x1E) >> 1) | ((rId2 & 0x1) << 5); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_Q1At16Of4Hi7_Q2At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= (((rId1 << 1u) & 0x10) << 3) | (((rId1 << 1u) & 0xF) << 16); + opcode |= ((rId2 << 1u) & 0xF) | (((rId2 << 1u) & 0x10) << 1); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= (((rId1 << 1u) & 0x10) << 3) | (((rId1 << 1u) & 0xF) << 16); + opcode |= (rId2 & 0xF) | ((rId2 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of4_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= (((rId1 << 1u) & 0x10) << 3) | (((rId1 << 1u) & 0xF) << 16); + opcode |= (rId2 & 0xF); + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At0Of4Hi5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At0Of4Lo5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x1E) >> 1) | ((rId1 & 0x1) << 5); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At12Of4Lo22_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= ((rId1 & 0x1E) << 11) | ((rId1 & 0x1) << 22); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At12Of4Hi22_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0xF) << 12) | ((rId1 & 0x10) << 18); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_Q1At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 << 1u) & 0xF) | (((rId1 << 1u) & 0x10) << 1); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_R1At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_R1At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At16Of4Hi7_R1At12Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x10) << 3) | ((rId0 & 0xF) << 16); + opcode |= ((rId1 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_Q0At16Of4Hi7_R1At12Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= (((rId0 << 1u) & 0x10) << 3) | (((rId0 << 1u) & 0xF) << 16); + opcode |= ((rId1 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_Q1At16Of4Hi7_R2At0Of3_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= (((rId1 << 1u) & 0x10) << 3) | (((rId1 << 1u) & 0xF) << 16); + opcode |= (rId2 & 0x7); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Lo7_R2At0Of4Lo5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x1) << 7) | ((rId1 & 0x1E) << 15); + opcode |= ((rId2 & 0x1E) >> 1) | ((rId2 & 0x1) << 5); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Lo7_R2At0Of3Lo5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x1) << 7) | ((rId1 & 0x1E) << 15); + opcode |= ((rId2 & 0xE) >> 1) | ((rId2 & 0x1) << 5); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0x7); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_MemBaseAt16_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= mem->base_id() << 16; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_MemBaseAt16_MemUIndexAt0_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= mem->base_id() << 16; + opcode |= mem->index_id() << 0; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_MemBaseAt16_SOffAt0Of8Mul4_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= ((off.imm() & 0x3FC) >> 2); + opcode |= off.u() << 23u; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_MemPCRel_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32_MemPC; + } + + Emit_R0At12Of4Hi22_MemBaseAt16_SOffAt0Of8Mul4_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= ((off.imm() & 0x3FC) >> 2); + opcode |= off.u() << 23u; + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_MemPCRel_Cond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32_MemPC; + } + + Emit_R0At12Of4Lo22_MemBaseAt16_SOffAt0Of8Mul2_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + opcode |= mem->base_id() << 16; + SOffsetEncode off(*mem); + opcode |= ((off.imm() & 0x1FE) >> 1); + opcode |= off.u() << 23u; + goto Emit_Op32; + } + + Emit_R0At12Of4Lo22_MemPCRel_NoCond: { + uint32_t rId0 = o0.as().id(); + opcode |= ((rId0 & 0x1E) << 11) | ((rId0 & 0x1) << 22); + goto Emit_Op32_MemPC; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R2At0Of3_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0x7); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_R1At16Of4Hi7_R2At0Of4_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF); + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4Lo7_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0x1) << 7) | ((rId1 & 0x1E) << 15); + goto Emit_Op32; + } + + Emit_R0At16Of4Lo7_R1At12Of4_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1) << 7) | ((rId0 & 0x1E) << 15); + opcode |= ((rId1 & 0xF) << 12); + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4Lo7_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0x1) << 7) | ((rId1 & 0x1E) << 15); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At16Of4Lo7_R1At12Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0x1) << 7) | ((rId0 & 0x1E) << 15); + opcode |= ((rId1 & 0xF) << 12); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4_R2At0Of4Lo5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0xF) << 16); + opcode |= ((rId2 & 0x1E) >> 1) | ((rId2 & 0x1) << 5); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At0Of4Lo5_R2At12Of4_R3At16Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId2 = o2.as().id(); + uint32_t rId3 = o3.as().id(); + opcode |= ((rId0 & 0x1E) >> 1) | ((rId0 & 0x1) << 5); + opcode |= ((rId2 & 0xF) << 12); + opcode |= ((rId3 & 0xF) << 16); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4_R2At0Of4Hi5_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0xF) << 16); + opcode |= (rId2 & 0xF) | ((rId2 & 0x10) << 1); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At0Of4Hi5_R1At12Of4_R2At16Of4_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId2 = o2.as().id(); + opcode |= (rId0 & 0xF) | ((rId0 & 0x10) << 1); + opcode |= ((rId1 & 0xF) << 12); + opcode |= ((rId2 & 0xF) << 16); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4_R1At16Of4Hi7_Cond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= encodeCond(cc) << 28u; + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At0Of4At16Of4Hi5Hi7_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= (rId1 & 0xF) | ((rId1 & 0x10) << 1) | ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + goto Emit_Op32; + } + + Emit_Q0At12Of4Hi22_Q1At0Of4At16Of4Hi5Hi7_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + opcode |= (((rId0 << 1u) & 0xF) << 12) | (((rId0 << 1u) & 0x10) << 18); + opcode |= ((rId1 << 1u) & 0xF) | (((rId1 << 1u) & 0x10) << 1) | (((rId1 << 1u) & 0x10) << 3) | (((rId1 << 1u) & 0xF) << 16); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R3At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId3 = o3.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId3 & 0xF) | ((rId3 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R4At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId4 = o4.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId4 & 0xF) | ((rId4 & 0x10) << 1); + goto Emit_Op32; + } + + Emit_R0At12Of4Hi22_R1At16Of4Hi7_R5At0Of4Hi5_NoCond: { + uint32_t rId0 = o0.as().id(); + uint32_t rId1 = o1.as().id(); + uint32_t rId5 = o5.as().id(); + opcode |= ((rId0 & 0xF) << 12) | ((rId0 & 0x10) << 18); + opcode |= ((rId1 & 0x10) << 3) | ((rId1 & 0xF) << 16); + opcode |= (rId5 & 0xF) | ((rId5 & 0x10) << 1); + goto Emit_Op32; + } + // ---------------------------------------------------------------------------- + // ${a32::Assembler::Impl:End} + + // Emit - Opcode - Label or Imm (Branch & Call) + // -------------------------------------------- + + Emit_Op32_Rel: { + if (rel->is_label()) { + uint32_t label_id = rel->as