diff --git a/examples/aarch64/ior-sequence.cc b/examples/aarch64/ior-sequence.cc new file mode 100644 index 00000000..35a8f9fe --- /dev/null +++ b/examples/aarch64/ior-sequence.cc @@ -0,0 +1,77 @@ +// Copyright 2022, VIXL authors +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of ARM Limited nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "examples.h" +#include "aarch64/io-reporter-aarch64.h" + +using namespace std; +using namespace vixl; +using namespace vixl::aarch64; + +// Example of using the IOReporter component to print the source and destination +// registers used by a code sequence executed on the simulator. + +#ifndef TEST_EXAMPLES +#ifdef VIXL_INCLUDE_SIMULATOR_AARCH64 +int main(void) { + MacroAssembler m; + Decoder d; + Simulator s(&d); + IOReporter ior; + d.AppendVisitor(&ior); + + Label fn, loop; + m.Bind(&fn); + m.Mov(x0, xzr); + m.Mov(x7, 10); + m.Bind(&loop); + m.Add(x0, x0, 42); + m.Sub(x7, x7, 1); + m.Cbnz(x7, &loop); + m.Ret(); + m.FinalizeCode(); + m.GetBuffer()->SetExecutable(); + s.RunFrom(m.GetLabelAddress(&fn)); + + unordered_set r = ior.GetSourceRegisters(); + cout << "Sequence reads: "; + for (CPURegister reg : r) { + cout << reg.GetArchitecturalName() << " "; + } + unordered_set w = ior.GetDestinationRegisters(); + cout << ", writes: "; + for (CPURegister reg : w) { + cout << reg.GetArchitecturalName() << " "; + } + cout << endl; + + return 0; +} +#else +// Without the simulator there is nothing to run. +int main(void) { return 0; } +#endif // VIXL_INCLUDE_SIMULATOR_AARCH64 +#endif // TEST_EXAMPLES diff --git a/examples/aarch64/ior-single.cc b/examples/aarch64/ior-single.cc new file mode 100644 index 00000000..5e03ea39 --- /dev/null +++ b/examples/aarch64/ior-single.cc @@ -0,0 +1,125 @@ +// Copyright 2022, VIXL authors +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of ARM Limited nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include "examples.h" +#include "aarch64/io-reporter-aarch64.h" + +using namespace std; +using namespace vixl; +using namespace vixl::aarch64; + +// Example of using the IOReporter component to print the source and destination +// registers used by individual instructions. + +#ifndef TEST_EXAMPLES +int main(void) { + MacroAssembler m; + Decoder d; + Disassembler dis; + IOReporter ior; + d.AppendVisitor(&dis); + d.AppendVisitor(&ior); + + CPUFeatures f; + f.Combine(CPUFeatures::kPAuth, CPUFeatures::kNEON); + m.SetCPUFeatures(f); + + // Sample code that uses a range of input and output registers - not + // something that should be executed. + Label fn; + m.Bind(&fn); + m.Paciasp(); + m.Mov(x0, 42); + m.Mov(x1, x10); + m.Add(x0, x0, 42); + m.Str(x9, MemOperand(x10, 8, PostIndex)); + m.Ld4(v30.V8B(), + v31.V8B(), + v0.V8B(), + v1.V8B(), + MemOperand(x0, x2, PostIndex)); + m.FinalizeCode(); + + Instruction* c = m.GetLabelAddress(&fn); + d.Decode(c); // paciasp + cout << dis.GetOutput() << " reads: "; + unordered_set r = ior.GetSourceRegisters(); + for (CPURegister reg : r) { + cout << reg.GetArchitecturalName() << " "; + } + cout << endl; + + ior.Reset(); + d.Decode(c + 4); // movz x0, #42 + cout << dis.GetOutput() << " writes: "; + unordered_set w = ior.GetDestinationRegisters(); + for (CPURegister reg : w) { + cout << reg.GetArchitecturalName() << " "; + } + cout << endl; + + ior.Reset(); + d.Decode(c + 8); // mov x1, x10 + cout << dis.GetOutput() << "; "; + d.Decode(c + 12); // add x0, x0, #42 + cout << dis.GetOutput() << " reads: "; + r = ior.GetSourceRegisters(); + for (CPURegister reg : r) { + cout << reg.GetArchitecturalName() << " "; + } + cout << endl; + + ior.Reset(); + d.Decode(c + 16); // str x9, [x10], #8 + cout << dis.GetOutput() << " reads: "; + r = ior.GetSourceRegisters(); + for (CPURegister reg : r) { + cout << reg.GetArchitecturalName() << " "; + } + cout << ", writes: "; + w = ior.GetDestinationRegisters(); + for (CPURegister reg : w) { + cout << reg.GetArchitecturalName() << " "; + } + cout << endl; + + ior.Reset(); + d.Decode(c + 20); // ld4 {v30.8b, v31.8b, v0.8b, v1.8b}, [x0], x2 + cout << dis.GetOutput() << " reads: "; + r = ior.GetSourceRegisters(); + for (CPURegister reg : r) { + cout << reg.GetArchitecturalName() << " "; + } + cout << ", writes: "; + w = ior.GetDestinationRegisters(); + for (CPURegister reg : w) { + cout << reg.GetArchitecturalName() << " "; + } + cout << endl; + + return 0; +} +#endif // TEST_EXAMPLES diff --git a/src/aarch64/io-reporter-aarch64.cc b/src/aarch64/io-reporter-aarch64.cc new file mode 100644 index 00000000..145cae46 --- /dev/null +++ b/src/aarch64/io-reporter-aarch64.cc @@ -0,0 +1,2764 @@ +// Copyright 2022, VIXL authors +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Arm Limited nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include +#include "globals-vixl.h" +#include "utils-vixl.h" + +#include "io-reporter-aarch64.h" + +namespace vixl { +namespace aarch64 { + + +void IOReporter::Visit(Metadata* metadata, const Instruction* instr) { + VIXL_ASSERT(metadata->count("form") > 0); + + const std::string& form = (*metadata)["form"]; + uint32_t form_hash = Hash(form.c_str()); + const FormToRegisterUseMap* fr = IOReporter::GetFormToRegisterUseMap(); + FormToRegisterUseMap::const_iterator it = fr->find(form_hash); + if (it == fr->end()) { + // TODO: how should a missing entry be reported? Assertion failure? + // An error polled from the IOReporter object? + } else { + AddRegistersFromTokens(instr, it->second); + } +} + +void IOReporter::AddRegistersFromTokens(const Instruction* instr, + const std::string& s) { + // All token strings contain a separator ',' with destination register tokens + // to the left and sources to the right. Either set may be empty. + VIXL_ASSERT(s.find(',') != std::string::npos); + + // Match tokens in the string. See the header file for a description of the + // tokens. + std::regex re("'([RVPI][^',]+)"); + std::string haystack = s; + std::smatch m; + bool is_dst = true; + + // Disabling linter on the following line due to possible clang-tidy bug. + // TODO: remove this when switching baseline linter version. + while (std::regex_search(haystack, m, re)) { // NOLINT + // The first token match found at the second character in a string indicates + // that a comma must be the first character. At that point, we switch to + // finding source tokens. + if (m.position() != 0) { + VIXL_ASSERT(haystack[0] == ','); + is_dst = false; + } + + CPURegister r = GetRegisterForToken(instr, m.str(1)); + if (r.IsValid()) { + if (is_dst) { + destination_.insert(r); + } else { + source_.insert(r); + } + } + + haystack = m.suffix().str(); + } +} + +CPURegister IOReporter::GetRegisterForToken(const Instruction* instr, + const std::string& t) { + VIXL_ASSERT((t[0] == 'R') || (t[0] == 'V') || (t[0] == 'P') || (t[0] == 'I')); + + // The token's register "name" indicates where to look in the instruction for + // the register used. There are basically four positions, but these may be + // modified (eg. by addition) or restricted (eg. being encoded in four + // rather than five bits) by later token characters. There is also the ability + // to express an explicit range of bits to look at for the register, if + // needed. + int code = -1; + switch (t[1]) { + case 'd': + code = instr->GetRd(); + break; + case 'n': + code = instr->GetRn(); + break; + case 'm': + code = instr->GetRm(); + break; + case 'a': + code = instr->GetRa(); + break; + case 'g': + VIXL_ASSERT(t[0] == 'P'); + code = instr->GetPgLow8(); + break; + default: + if (t.length() == 5) { // Explicit bit range, eg. V1816. + // Extract bit positions and get code from the instruction. + uint32_t msb = GetFiveBitNumberFromString(t.substr(1)); + uint32_t lsb = GetFiveBitNumberFromString(t.substr(3)); + code = instr->ExtractBits(msb, lsb); + } else { // Register implied by the instruction, eg. I30. + VIXL_ASSERT(t[0] == 'I'); + code = GetFiveBitNumberFromString(t.substr(1)); + } + } + VIXL_ASSERT(code != -1); + + // Registers that depend on a bit being set in the instruction to indicate + // whether it should be returned. + if (t[2] == '?') { // Pd?04 + int bit = GetFiveBitNumberFromString(t.substr(3)); + if (instr->ExtractBit(bit) == 0) { + // The bit was clear, so report nothing for this token. + return NoCPUReg; + } + } + + if (t[0] == 'R') { // Integer bank. + if (t[2] == '+') { // Rm+1, Rm+2 ... Rm+7. + VIXL_ASSERT((t[3] >= '1') && (t[3] <= '7')); + code = (code + (t[3] - '0')) % 32; + } else if (t[2] == 's') { // Code 31 is stack pointer. + code = (code == 31) ? kSPRegInternalCode : code; + } + + if (code == 31) { + return NoCPUReg; // Discard zero register. + } + return XRegister(code); + } else if (t[0] == 'V') { // Vector bank. + if (t[2] == 'i') { // Vmi - indexed vector register. + int size = instr->GetNEONSize(); + // The element size field may be 1 or 2, otherwise the instruction is + // unallocated. + if ((size != 1) && (size != 2)) { + return NoCPUReg; + } + if (size == 1) { + code %= 16; // Only 16 registers may be indexed for this size. + } + } else if (t[2] == '+') { // Vn+1, Vn+2 or Vn+3. + VIXL_ASSERT((t[3] >= '1') && (t[3] <= '3')); + code = (code + (t[3] - '0')) % 32; + } + return VRegister(code); + } else if (t[0] == 'P') { // Predicate bank. + code %= 16; // There are 16 predicate registers. + return PRegister(code); + } else if (t[0] == 'I') { // Implicit register, assumes integer bank. + return XRegister((code == 31) ? kSPRegInternalCode : code); + } + + // No token should reach here. + VIXL_UNREACHABLE(); + return NoCPUReg; +} + +uint32_t IOReporter::GetFiveBitNumberFromString(const std::string& s) { + VIXL_ASSERT(s.length() >= 2); + VIXL_ASSERT((s[0] >= '0') && (s[0] <= '3')); + VIXL_ASSERT((s[1] >= '0') && (s[1] <= '9')); + uint32_t code = ((s[0] - '0') * 10) + (s[1] - '0'); + VIXL_ASSERT(code <= 31); + return code; +} + +const IOReporter::FormToRegisterUseMap* IOReporter::GetFormToRegisterUseMap() { + static const std::unordered_map data = { + {"abs_asimdmisc_r"_h, "'Vd,'Vn"}, + {"abs_asisdmisc_r"_h, "'Vd,'Vn"}, + {"adcs_32_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"adcs_64_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"adc_32_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"adc_64_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"addg_64_addsub_immtags"_h, "'Rds,'Rns"}, + {"addhn_asimddiff_n"_h, "'Vd,'Vn'Vm"}, + {"addp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"addp_asisdpair_only"_h, "'Vd,'Vn"}, + {"adds_32s_addsub_ext"_h, "'Rd,'Rns'Rm"}, + {"adds_32s_addsub_imm"_h, "'Rd,'Rns"}, + {"adds_32_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"adds_64s_addsub_ext"_h, "'Rd,'Rns'Rm"}, + {"adds_64s_addsub_imm"_h, "'Rd,'Rns"}, + {"adds_64_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"addv_asimdall_only"_h, "'Vd,'Vn"}, + {"add_32_addsub_ext"_h, "'Rds,'Rns'Rm"}, + {"add_32_addsub_imm"_h, "'Rds,'Rns"}, + {"add_32_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"add_64_addsub_ext"_h, "'Rds,'Rns'Rm"}, + {"add_64_addsub_imm"_h, "'Rds,'Rns"}, + {"add_64_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"add_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"add_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"adrp_only_pcreladdr"_h, "'Rd,"}, + {"adr_only_pcreladdr"_h, "'Rd,"}, + {"ands_32s_log_imm"_h, "'Rd,'Rn"}, + {"ands_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"ands_64s_log_imm"_h, "'Rd,'Rn"}, + {"ands_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"and_32_log_imm"_h, "'Rds,'Rn"}, + {"and_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"and_64_log_imm"_h, "'Rds,'Rn"}, + {"and_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"and_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"asrv_32_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"asrv_64_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"autda_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"autdb_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"autdza_64z_dp_1src"_h, "'Rd,'Rd"}, + {"autdzb_64z_dp_1src"_h, "'Rd,'Rd"}, + {"autia1716_hi_hints"_h, "'I17,'I17'I16"}, + {"autiasp_hi_hints"_h, "'I30,'I30'I31"}, + {"autiaz_hi_hints"_h, "'I30,'I30"}, + {"autia_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"autib1716_hi_hints"_h, "'I17,'I17'I16"}, + {"autibsp_hi_hints"_h, "'I30,'I30'I31"}, + {"autibz_hi_hints"_h, "'I30,'I30"}, + {"autib_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"autiza_64z_dp_1src"_h, "'Rd,'Rd"}, + {"autizb_64z_dp_1src"_h, "'Rd,'Rd"}, + {"axflag_m_pstate"_h, ","}, + {"bfm_32m_bitfield"_h, "'Rd,'Rd'Rn"}, + {"bfm_64m_bitfield"_h, "'Rd,'Rd'Rn"}, + {"bics_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"bics_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"bic_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"bic_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"bic_asimdimm_l_hl"_h, "'Vd,'Vd"}, + {"bic_asimdimm_l_sl"_h, "'Vd,'Vd"}, + {"bic_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"bif_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"bit_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"blraaz_64_branch_reg"_h, "'I30,'Rn"}, + {"blraa_64p_branch_reg"_h, "'I30,'Rn'Rds"}, + {"blrabz_64_branch_reg"_h, "'I30,'Rn"}, + {"blrab_64p_branch_reg"_h, "'I30,'Rn'Rds"}, + {"blr_64_branch_reg"_h, "'I30,'Rn"}, + {"bl_only_branch_imm"_h, "'I30,"}, + {"braaz_64_branch_reg"_h, ",'Rn"}, + {"braa_64p_branch_reg"_h, ",'Rn'Rds"}, + {"brabz_64_branch_reg"_h, ",'Rn"}, + {"brab_64p_branch_reg"_h, ",'Rn'Rds"}, + {"brk_ex_exception"_h, ","}, + {"br_64_branch_reg"_h, ",'Rn"}, + {"bsl_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"bti_hb_hints"_h, ","}, + {"b_only_branch_imm"_h, ","}, + {"b_only_condbranch"_h, ","}, + {"casab_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casah_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casalb_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casalh_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casal_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casal_c64_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casa_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casa_c64_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casb_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"cash_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"caslb_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"caslh_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casl_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"casl_c64_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"caspal_cp32_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"caspal_cp64_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"caspa_cp32_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"caspa_cp64_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"caspl_cp32_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"caspl_cp64_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"casp_cp32_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"casp_cp64_ldstexcl"_h, "'Rm'Rm+1,'Rm'Rm+1'Rd'Rd+1'Rns"}, + {"cas_c32_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"cas_c64_ldstexcl"_h, "'Rm,'Rm'Rd'Rns"}, + {"cbnz_32_compbranch"_h, ",'Rd"}, + {"cbnz_64_compbranch"_h, ",'Rd"}, + {"cbz_32_compbranch"_h, ",'Rd"}, + {"cbz_64_compbranch"_h, ",'Rd"}, + {"ccmn_32_condcmp_imm"_h, ",'Rn"}, + {"ccmn_32_condcmp_reg"_h, ",'Rn'Rm"}, + {"ccmn_64_condcmp_imm"_h, ",'Rn"}, + {"ccmn_64_condcmp_reg"_h, ",'Rn'Rm"}, + {"ccmp_32_condcmp_imm"_h, ",'Rn"}, + {"ccmp_32_condcmp_reg"_h, ",'Rn'Rm"}, + {"ccmp_64_condcmp_imm"_h, ",'Rn"}, + {"ccmp_64_condcmp_reg"_h, ",'Rn'Rm"}, + {"cfinv_m_pstate"_h, ","}, + {"clrex_bn_barriers"_h, ","}, + {"cls_32_dp_1src"_h, "'Rd,'Rn"}, + {"cls_64_dp_1src"_h, "'Rd,'Rn"}, + {"cls_asimdmisc_r"_h, "'Vd,'Vn"}, + {"clz_32_dp_1src"_h, "'Rd,'Rn"}, + {"clz_64_dp_1src"_h, "'Rd,'Rn"}, + {"clz_asimdmisc_r"_h, "'Vd,'Vn"}, + {"cmeq_asimdmisc_z"_h, "'Vd,'Vn"}, + {"cmeq_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmeq_asisdmisc_z"_h, "'Vd,'Vn"}, + {"cmeq_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmge_asimdmisc_z"_h, "'Vd,'Vn"}, + {"cmge_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmge_asisdmisc_z"_h, "'Vd,'Vn"}, + {"cmge_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmgt_asimdmisc_z"_h, "'Vd,'Vn"}, + {"cmgt_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmgt_asisdmisc_z"_h, "'Vd,'Vn"}, + {"cmgt_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmhi_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmhi_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmhs_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmhs_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmle_asimdmisc_z"_h, "'Vd,'Vn"}, + {"cmle_asisdmisc_z"_h, "'Vd,'Vn"}, + {"cmlt_asimdmisc_z"_h, "'Vd,'Vn"}, + {"cmlt_asisdmisc_z"_h, "'Vd,'Vn"}, + {"cmtst_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cmtst_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"cnt_asimdmisc_r"_h, "'Vd,'Vn"}, + {"cpyen_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyern_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyewn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpye_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfen_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfern_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfewn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfe_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfmn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfmrn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfmwn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfm_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfpn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfprn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfpwn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyfp_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpymn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpymrn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpymwn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpym_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpypn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyprn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpypwn_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"cpyp_cpy_memcms"_h, "'Rd'Rn'Rm,'Rd'Rn'Rm"}, + {"crc32b_32c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32cb_32c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32ch_32c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32cw_32c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32cx_64c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32h_32c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32w_32c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"crc32x_64c_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"csdb_hi_hints"_h, ","}, + {"csel_32_condsel"_h, "'Rd,'Rn'Rm"}, + {"csel_64_condsel"_h, "'Rd,'Rn'Rm"}, + {"csinc_32_condsel"_h, "'Rd,'Rn'Rm"}, + {"csinc_64_condsel"_h, "'Rd,'Rn'Rm"}, + {"csinv_32_condsel"_h, "'Rd,'Rn'Rm"}, + {"csinv_64_condsel"_h, "'Rd,'Rn'Rm"}, + {"csneg_32_condsel"_h, "'Rd,'Rn'Rm"}, + {"csneg_64_condsel"_h, "'Rd,'Rn'Rm"}, + {"dcps1_dc_exception"_h, ","}, + {"dcps2_dc_exception"_h, ","}, + {"dcps3_dc_exception"_h, ","}, + {"dmb_bo_barriers"_h, ","}, + {"dsb_bo_barriers"_h, ","}, + {"dup_asimdins_dr_r"_h, "'Vd,'Rn"}, + {"dup_asimdins_dv_v"_h, "'Vd,'Vn"}, + {"dup_asisdone_only"_h, "'Vd,'Vn"}, + {"eon_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"eon_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"eor_32_log_imm"_h, "'Rds,'Rn"}, + {"eor_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"eor_64_log_imm"_h, "'Rds,'Rn"}, + {"eor_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"eor_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"extr_32_extract"_h, "'Rd,'Rn'Rm"}, + {"extr_64_extract"_h, "'Rd,'Rn'Rm"}, + {"ext_asimdext_only"_h, "'Vd,'Vn'Vm"}, + {"fabd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fabd_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fabd_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fabd_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fabs_d_floatdp1"_h, "'Vd,'Vn"}, + {"fabs_h_floatdp1"_h, "'Vd,'Vn"}, + {"fabs_s_floatdp1"_h, "'Vd,'Vn"}, + {"fabs_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fabs_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"facge_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"facge_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"facge_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"facge_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"facgt_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"facgt_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"facgt_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"facgt_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"faddp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"faddp_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"faddp_asisdpair_only_h"_h, "'Vd,'Vn"}, + {"faddp_asisdpair_only_sd"_h, "'Vd,'Vn"}, + {"fadd_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fadd_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fadd_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fadd_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcadd_asimdsame2_c"_h, "'Vd,'Vn'Vm"}, + {"fccmpe_d_floatccmp"_h, ",'Vn'Vm"}, + {"fccmpe_h_floatccmp"_h, ",'Vn'Vm"}, + {"fccmpe_s_floatccmp"_h, ",'Vn'Vm"}, + {"fccmp_d_floatccmp"_h, ",'Vn'Vm"}, + {"fccmp_h_floatccmp"_h, ",'Vn'Vm"}, + {"fccmp_s_floatccmp"_h, ",'Vn'Vm"}, + {"fcmeq_asimdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmeq_asimdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmeq_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fcmeq_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcmeq_asisdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmeq_asisdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmeq_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fcmeq_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcmge_asimdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmge_asimdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmge_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fcmge_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcmge_asisdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmge_asisdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmge_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fcmge_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcmgt_asimdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmgt_asimdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmgt_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fcmgt_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcmgt_asisdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmgt_asisdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmgt_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fcmgt_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fcmla_asimdelem_c_h"_h, "'Vd,'Vd'Vn'V1916"}, + {"fcmla_asimdelem_c_s"_h, "'Vd,'Vd'Vn'V1916"}, + {"fcmla_asimdsame2_c"_h, "'Vd,'Vd'Vn'Vm"}, + {"fcmle_asimdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmle_asimdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmle_asisdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmle_asisdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmlt_asimdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmlt_asimdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmlt_asisdmisc_fz"_h, "'Vd,'Vn"}, + {"fcmlt_asisdmiscfp16_fz"_h, "'Vd,'Vn"}, + {"fcmpe_dz_floatcmp"_h, ",'Vn"}, + {"fcmpe_d_floatcmp"_h, ",'Vn'Vm"}, + {"fcmpe_hz_floatcmp"_h, ",'Vn"}, + {"fcmpe_h_floatcmp"_h, ",'Vn'Vm"}, + {"fcmpe_sz_floatcmp"_h, ",'Vn"}, + {"fcmpe_s_floatcmp"_h, ",'Vn'Vm"}, + {"fcmp_dz_floatcmp"_h, ",'Vn"}, + {"fcmp_d_floatcmp"_h, ",'Vn'Vm"}, + {"fcmp_hz_floatcmp"_h, ",'Vn"}, + {"fcmp_h_floatcmp"_h, ",'Vn'Vm"}, + {"fcmp_sz_floatcmp"_h, ",'Vn"}, + {"fcmp_s_floatcmp"_h, ",'Vn'Vm"}, + {"fcsel_d_floatsel"_h, "'Vd,'Vn'Vm"}, + {"fcsel_h_floatsel"_h, "'Vd,'Vn'Vm"}, + {"fcsel_s_floatsel"_h, "'Vd,'Vn'Vm"}, + {"fcvtas_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtas_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtas_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtas_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtas_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtas_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtas_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtas_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtas_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtas_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtau_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtau_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtau_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtau_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtau_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtau_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtau_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtau_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtau_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtau_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtl_asimdmisc_l"_h, "'Vd,'Vn"}, + {"fcvtms_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtms_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtms_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtms_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtms_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtms_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtms_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtms_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtms_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtms_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtmu_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtmu_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtmu_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtmu_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtmu_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtmu_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtmu_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtmu_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtmu_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtmu_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtns_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtns_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtns_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtns_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtns_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtns_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtns_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtns_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtns_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtns_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtnu_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtnu_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtnu_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtnu_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtnu_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtnu_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtnu_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtnu_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtnu_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtnu_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtn_asimdmisc_n"_h, "'Vd,'Vn"}, + {"fcvtps_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtps_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtps_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtps_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtps_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtps_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtps_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtps_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtps_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtps_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtpu_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtpu_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtpu_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtpu_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtpu_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtpu_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtpu_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtpu_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtpu_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtpu_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtxn_asimdmisc_n"_h, "'Vd,'Vn"}, + {"fcvtxn_asisdmisc_n"_h, "'Vd,'Vn"}, + {"fcvtzs_32d_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzs_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtzs_32h_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzs_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtzs_32s_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzs_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtzs_64d_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzs_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtzs_64h_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzs_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtzs_64s_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzs_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtzs_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtzs_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtzs_asimdshf_c"_h, "'Vd,'Vn"}, + {"fcvtzs_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtzs_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtzs_asisdshf_c"_h, "'Vd,'Vn"}, + {"fcvtzu_32d_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzu_32d_float2int"_h, "'Rd,'Vn"}, + {"fcvtzu_32h_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzu_32h_float2int"_h, "'Rd,'Vn"}, + {"fcvtzu_32s_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzu_32s_float2int"_h, "'Rd,'Vn"}, + {"fcvtzu_64d_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzu_64d_float2int"_h, "'Rd,'Vn"}, + {"fcvtzu_64h_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzu_64h_float2int"_h, "'Rd,'Vn"}, + {"fcvtzu_64s_float2fix"_h, "'Rd,'Vn"}, + {"fcvtzu_64s_float2int"_h, "'Rd,'Vn"}, + {"fcvtzu_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtzu_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtzu_asimdshf_c"_h, "'Vd,'Vn"}, + {"fcvtzu_asisdmisc_r"_h, "'Vd,'Vn"}, + {"fcvtzu_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fcvtzu_asisdshf_c"_h, "'Vd,'Vn"}, + {"fcvt_dh_floatdp1"_h, "'Vd,'Vn"}, + {"fcvt_ds_floatdp1"_h, "'Vd,'Vn"}, + {"fcvt_hd_floatdp1"_h, "'Vd,'Vn"}, + {"fcvt_hs_floatdp1"_h, "'Vd,'Vn"}, + {"fcvt_sd_floatdp1"_h, "'Vd,'Vn"}, + {"fcvt_sh_floatdp1"_h, "'Vd,'Vn"}, + {"fdiv_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fdiv_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fdiv_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fdiv_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fdiv_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fjcvtzs_32d_float2int"_h, "'Rd,'Vn"}, + {"fmadd_d_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fmadd_h_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fmadd_s_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fmaxnmp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmaxnmp_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmaxnmp_asisdpair_only_h"_h, "'Vd,'Vn"}, + {"fmaxnmp_asisdpair_only_sd"_h, "'Vd,'Vn"}, + {"fmaxnmv_asimdall_only_h"_h, "'Vd,'Vn"}, + {"fmaxnmv_asimdall_only_sd"_h, "'Vd,'Vn"}, + {"fmaxnm_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmaxnm_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmaxnm_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmaxnm_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmaxnm_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmaxp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmaxp_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmaxp_asisdpair_only_h"_h, "'Vd,'Vn"}, + {"fmaxp_asisdpair_only_sd"_h, "'Vd,'Vn"}, + {"fmaxv_asimdall_only_h"_h, "'Vd,'Vn"}, + {"fmaxv_asimdall_only_sd"_h, "'Vd,'Vn"}, + {"fmax_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmax_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmax_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmax_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmax_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fminnmp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fminnmp_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fminnmp_asisdpair_only_h"_h, "'Vd,'Vn"}, + {"fminnmp_asisdpair_only_sd"_h, "'Vd,'Vn"}, + {"fminnmv_asimdall_only_h"_h, "'Vd,'Vn"}, + {"fminnmv_asimdall_only_sd"_h, "'Vd,'Vn"}, + {"fminnm_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fminnm_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fminnm_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fminnm_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fminnm_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fminp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fminp_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fminp_asisdpair_only_h"_h, "'Vd,'Vn"}, + {"fminp_asisdpair_only_sd"_h, "'Vd,'Vn"}, + {"fminv_asimdall_only_h"_h, "'Vd,'Vn"}, + {"fminv_asimdall_only_sd"_h, "'Vd,'Vn"}, + {"fmin_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmin_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmin_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmin_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmin_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmlal2_asimdelem_lh"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmlal2_asimdsame_f"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmlal_asimdelem_lh"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmlal_asimdsame_f"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmla_asimdelem_rh_h"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmla_asimdelem_r_sd"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmla_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmla_asimdsamefp16_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmla_asisdelem_rh_h"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmla_asisdelem_r_sd"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmlsl2_asimdelem_lh"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmlsl2_asimdsame_f"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmlsl_asimdelem_lh"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmlsl_asimdsame_f"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmls_asimdelem_rh_h"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmls_asimdelem_r_sd"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmls_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmls_asimdsamefp16_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmls_asisdelem_rh_h"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmls_asisdelem_r_sd"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmov_32h_float2int"_h, "'Rd,'Vn"}, + {"fmov_32s_float2int"_h, "'Rd,'Vn"}, + {"fmov_64d_float2int"_h, "'Rd,'Vn"}, + {"fmov_64h_float2int"_h, "'Rd,'Vn"}, + {"fmov_64vx_float2int"_h, "'Rd,'Vn"}, + {"fmov_d64_float2int"_h, "'Vd,'Rn"}, + {"fmov_d_floatdp1"_h, "'Vd,'Vn"}, + {"fmov_d_floatimm"_h, "'Vd,"}, + {"fmov_h32_float2int"_h, "'Vd,'Rn"}, + {"fmov_h64_float2int"_h, "'Vd,'Rn"}, + {"fmov_h_floatdp1"_h, "'Vd,'Vn"}, + {"fmov_h_floatimm"_h, "'Vd,"}, + {"fmov_s32_float2int"_h, "'Vd,'Rn"}, + {"fmov_s_floatdp1"_h, "'Vd,'Vn"}, + {"fmov_s_floatimm"_h, "'Vd,"}, + {"fmov_v64i_float2int"_h, "'Vd,'Vd'Rn"}, + {"fmov_asimdimm_d2_d"_h, "'Vd,"}, + {"fmov_asimdimm_h_h"_h, "'Vd,"}, + {"fmov_asimdimm_s_s"_h, "'Vd,"}, + {"fmsub_d_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fmsub_h_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fmsub_s_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fmulx_asimdelem_rh_h"_h, "'Vd,'Vn'V1916"}, + {"fmulx_asimdelem_r_sd"_h, "'Vd,'Vn'V1916"}, + {"fmulx_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmulx_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmulx_asisdelem_rh_h"_h, "'Vd,'Vn'V1916"}, + {"fmulx_asisdelem_r_sd"_h, "'Vd,'Vn'V1916"}, + {"fmulx_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmulx_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmul_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmul_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmul_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fmul_asimdelem_rh_h"_h, "'Vd,'Vn'V1916"}, + {"fmul_asimdelem_r_sd"_h, "'Vd,'Vn'V1916"}, + {"fmul_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fmul_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fmul_asisdelem_rh_h"_h, "'Vd,'Vn'V1916"}, + {"fmul_asisdelem_r_sd"_h, "'Vd,'Vn'V1916"}, + {"fneg_d_floatdp1"_h, "'Vd,'Vn"}, + {"fneg_h_floatdp1"_h, "'Vd,'Vn"}, + {"fneg_s_floatdp1"_h, "'Vd,'Vn"}, + {"fneg_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fneg_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fnmadd_d_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fnmadd_h_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fnmadd_s_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fnmsub_d_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fnmsub_h_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fnmsub_s_floatdp3"_h, "'Vd,'Vn'Vm'Va"}, + {"fnmul_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fnmul_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fnmul_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"frecpe_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frecpe_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frecpe_asisdmisc_r"_h, "'Vd,'Vn"}, + {"frecpe_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frecps_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"frecps_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"frecps_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"frecps_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"frecpx_asisdmisc_r"_h, "'Vd,'Vn"}, + {"frecpx_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frint32x_d_floatdp1"_h, "'Vd,'Vn"}, + {"frint32x_s_floatdp1"_h, "'Vd,'Vn"}, + {"frint32x_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frint32z_d_floatdp1"_h, "'Vd,'Vn"}, + {"frint32z_s_floatdp1"_h, "'Vd,'Vn"}, + {"frint32z_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frint64x_d_floatdp1"_h, "'Vd,'Vn"}, + {"frint64x_s_floatdp1"_h, "'Vd,'Vn"}, + {"frint64x_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frint64z_d_floatdp1"_h, "'Vd,'Vn"}, + {"frint64z_s_floatdp1"_h, "'Vd,'Vn"}, + {"frint64z_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frinta_d_floatdp1"_h, "'Vd,'Vn"}, + {"frinta_h_floatdp1"_h, "'Vd,'Vn"}, + {"frinta_s_floatdp1"_h, "'Vd,'Vn"}, + {"frinta_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frinta_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frinti_d_floatdp1"_h, "'Vd,'Vn"}, + {"frinti_h_floatdp1"_h, "'Vd,'Vn"}, + {"frinti_s_floatdp1"_h, "'Vd,'Vn"}, + {"frinti_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frinti_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frintm_d_floatdp1"_h, "'Vd,'Vn"}, + {"frintm_h_floatdp1"_h, "'Vd,'Vn"}, + {"frintm_s_floatdp1"_h, "'Vd,'Vn"}, + {"frintm_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frintm_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frintn_d_floatdp1"_h, "'Vd,'Vn"}, + {"frintn_h_floatdp1"_h, "'Vd,'Vn"}, + {"frintn_s_floatdp1"_h, "'Vd,'Vn"}, + {"frintn_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frintn_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frintp_d_floatdp1"_h, "'Vd,'Vn"}, + {"frintp_h_floatdp1"_h, "'Vd,'Vn"}, + {"frintp_s_floatdp1"_h, "'Vd,'Vn"}, + {"frintp_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frintp_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frintx_d_floatdp1"_h, "'Vd,'Vn"}, + {"frintx_h_floatdp1"_h, "'Vd,'Vn"}, + {"frintx_s_floatdp1"_h, "'Vd,'Vn"}, + {"frintx_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frintx_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frintz_d_floatdp1"_h, "'Vd,'Vn"}, + {"frintz_h_floatdp1"_h, "'Vd,'Vn"}, + {"frintz_s_floatdp1"_h, "'Vd,'Vn"}, + {"frintz_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frintz_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frsqrte_asimdmisc_r"_h, "'Vd,'Vn"}, + {"frsqrte_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frsqrte_asisdmisc_r"_h, "'Vd,'Vn"}, + {"frsqrte_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"frsqrts_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"frsqrts_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"frsqrts_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"frsqrts_asisdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"fsqrt_d_floatdp1"_h, "'Vd,'Vn"}, + {"fsqrt_h_floatdp1"_h, "'Vd,'Vn"}, + {"fsqrt_s_floatdp1"_h, "'Vd,'Vn"}, + {"fsqrt_asimdmisc_r"_h, "'Vd,'Vn"}, + {"fsqrt_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"fsub_d_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fsub_h_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fsub_s_floatdp2"_h, "'Vd,'Vn'Vm"}, + {"fsub_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"fsub_asimdsamefp16_only"_h, "'Vd,'Vn'Vm"}, + {"gmi_64g_dp_2src"_h, "'Rd,'Rns'Rm"}, + {"hint_hm_hints"_h, ","}, + {"ins_asimdins_ir_r"_h, "'Vd,'Vd'Rn"}, + {"ins_asimdins_iv_v"_h, "'Vd,'Vd'Vn"}, + {"irg_64i_dp_2src"_h, "'Rds,'Rns'Rm"}, + {"isb_bi_barriers"_h, ","}, + {"ld1r_asisdlso_r1"_h, "'Vd,'Rns"}, + {"ld1r_asisdlsop_r1_i"_h, "'Vd'Rns,'Rns"}, + {"ld1r_asisdlsop_rx1_r"_h, "'Vd'Rns,'Rns'Rm"}, + {"ld1_asisdlse_r1_1v"_h, "'Vd,'Rns"}, + {"ld1_asisdlse_r2_2v"_h, "'Vd'Vd+1,'Rns"}, + {"ld1_asisdlse_r3_3v"_h, "'Vd'Vd+1'Vd+2,'Rns"}, + {"ld1_asisdlse_r4_4v"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns"}, + {"ld1_asisdlsep_i1_i1"_h, "'Vd'Rns,'Rns"}, + {"ld1_asisdlsep_i2_i2"_h, "'Vd'Vd+1'Rns,'Rns"}, + {"ld1_asisdlsep_i3_i3"_h, "'Vd'Vd+1'Vd+2'Rns,'Rns"}, + {"ld1_asisdlsep_i4_i4"_h, "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Rns"}, + {"ld1_asisdlsep_r1_r1"_h, "'Vd'Rns,'Rns'Rm"}, + {"ld1_asisdlsep_r2_r2"_h, "'Vd'Vd+1'Rns,'Rns'Rm"}, + {"ld1_asisdlsep_r3_r3"_h, "'Vd'Vd+1'Vd+2'Rns,'Rns'Rm"}, + {"ld1_asisdlsep_r4_r4"_h, "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Rns'Rm"}, + {"ld1_asisdlso_b1_1b"_h, "'Vd,'Vd'Rns"}, + {"ld1_asisdlso_d1_1d"_h, "'Vd,'Vd'Rns"}, + {"ld1_asisdlso_h1_1h"_h, "'Vd,'Vd'Rns"}, + {"ld1_asisdlso_s1_1s"_h, "'Vd,'Vd'Rns"}, + {"ld1_asisdlsop_b1_i1b"_h, "'Vd'Rns,'Vd'Rns"}, + {"ld1_asisdlsop_bx1_r1b"_h, "'Vd'Rns,'Vd'Rns'Rm"}, + {"ld1_asisdlsop_d1_i1d"_h, "'Vd'Rns,'Vd'Rns"}, + {"ld1_asisdlsop_dx1_r1d"_h, "'Vd'Rns,'Vd'Rns'Rm"}, + {"ld1_asisdlsop_h1_i1h"_h, "'Vd'Rns,'Vd'Rns"}, + {"ld1_asisdlsop_hx1_r1h"_h, "'Vd'Rns,'Vd'Rns'Rm"}, + {"ld1_asisdlsop_s1_i1s"_h, "'Vd'Rns,'Vd'Rns"}, + {"ld1_asisdlsop_sx1_r1s"_h, "'Vd'Rns,'Vd'Rns'Rm"}, + {"ld2r_asisdlso_r2"_h, "'Vd'Vd+1,'Rns"}, + {"ld2r_asisdlsop_r2_i"_h, "'Vd'Vd+1'Rns,'Rns"}, + {"ld2r_asisdlsop_rx2_r"_h, "'Vd'Vd+1'Rns,'Rns'Rm"}, + {"ld2_asisdlse_r2"_h, "'Vd'Vd+1,'Rns"}, + {"ld2_asisdlsep_i2_i"_h, "'Vd'Vd+1'Rns,'Rns"}, + {"ld2_asisdlsep_r2_r"_h, "'Vd'Vd+1'Rns,'Rns'Rm"}, + {"ld2_asisdlso_b2_2b"_h, "'Vd'Vd+1,'Vd'Vd+1'Rns"}, + {"ld2_asisdlso_d2_2d"_h, "'Vd'Vd+1,'Vd'Vd+1'Rns"}, + {"ld2_asisdlso_h2_2h"_h, "'Vd'Vd+1,'Vd'Vd+1'Rns"}, + {"ld2_asisdlso_s2_2s"_h, "'Vd'Vd+1,'Vd'Vd+1'Rns"}, + {"ld2_asisdlsop_b2_i2b"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns"}, + {"ld2_asisdlsop_bx2_r2b"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns'Rm"}, + {"ld2_asisdlsop_d2_i2d"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns"}, + {"ld2_asisdlsop_dx2_r2d"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns'Rm"}, + {"ld2_asisdlsop_h2_i2h"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns"}, + {"ld2_asisdlsop_hx2_r2h"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns'Rm"}, + {"ld2_asisdlsop_s2_i2s"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns"}, + {"ld2_asisdlsop_sx2_r2s"_h, "'Vd'Vd+1'Rns,'Vd'Vd+1'Rns'Rm"}, + {"ld3r_asisdlso_r3"_h, "'Vd'Vd+1'Vd+2,'Rns"}, + {"ld3r_asisdlsop_r3_i"_h, "'Vd'Vd+1'Vd+2'Rns,'Rns"}, + {"ld3r_asisdlsop_rx3_r"_h, "'Vd'Vd+1'Vd+2'Rns,'Rns'Rm"}, + {"ld3_asisdlse_r3"_h, "'Vd'Vd+1'Vd+2,'Rns"}, + {"ld3_asisdlsep_i3_i"_h, "'Vd'Vd+1'Vd+2'Rns,'Rns"}, + {"ld3_asisdlsep_r3_r"_h, "'Vd'Vd+1'Vd+2'Rns,'Rns'Rm"}, + {"ld3_asisdlso_b3_3b"_h, "'Vd'Vd+1'Vd+2,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlso_d3_3d"_h, "'Vd'Vd+1'Vd+2,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlso_h3_3h"_h, "'Vd'Vd+1'Vd+2,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlso_s3_3s"_h, "'Vd'Vd+1'Vd+2,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlsop_b3_i3b"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlsop_bx3_r3b"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"ld3_asisdlsop_d3_i3d"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlsop_dx3_r3d"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"ld3_asisdlsop_h3_i3h"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlsop_hx3_r3h"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"ld3_asisdlsop_s3_i3s"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"ld3_asisdlsop_sx3_r3s"_h, "'Vd'Vd+1'Vd+2'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"ld4r_asisdlso_r4"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns"}, + {"ld4r_asisdlsop_r4_i"_h, "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Rns"}, + {"ld4r_asisdlsop_rx4_r"_h, "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Rns'Rm"}, + {"ld4_asisdlse_r4"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns"}, + {"ld4_asisdlsep_i4_i"_h, "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Rns"}, + {"ld4_asisdlsep_r4_r"_h, "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Rns'Rm"}, + {"ld4_asisdlso_b4_4b"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlso_d4_4d"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlso_h4_4h"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlso_s4_4s"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlsop_b4_i4b"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlsop_bx4_r4b"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"ld4_asisdlsop_d4_i4d"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlsop_dx4_r4d"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"ld4_asisdlsop_h4_i4h"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlsop_hx4_r4h"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"ld4_asisdlsop_s4_i4s"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"ld4_asisdlsop_sx4_r4s"_h, + "'Vd'Vd+1'Vd+2'Vd+3'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"ldaddab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldadda_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldadda_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaddl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldadd_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldadd_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldaprb_32l_memop"_h, "'Rd,'Rns"}, + {"ldaprh_32l_memop"_h, "'Rd,'Rns"}, + {"ldapr_32l_memop"_h, "'Rd,'Rns"}, + {"ldapr_64l_memop"_h, "'Rd,'Rns"}, + {"ldapurb_32_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapurh_32_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapursb_32_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapursb_64_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapursh_32_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapursh_64_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapursw_64_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapur_32_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldapur_64_ldapstl_unscaled"_h, "'Rd,'Rns"}, + {"ldarb_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldarh_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldar_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldar_lr64_ldstexcl"_h, "'Rd,'Rns"}, + {"ldaxp_lp32_ldstexcl"_h, "'Rd'Ra,'Rns"}, + {"ldaxp_lp64_ldstexcl"_h, "'Rd'Ra,'Rns"}, + {"ldaxrb_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldaxrh_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldaxr_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldaxr_lr64_ldstexcl"_h, "'Rd,'Rns"}, + {"ldclrab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclralb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclralh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclral_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclral_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclra_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclra_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclrl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclr_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldclr_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeoralb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeoralh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeoral_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeoral_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeora_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeora_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeorl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeor_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldeor_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldg_64loffset_ldsttags"_h, "'Rd,'Rns"}, + {"ldlarb_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldlarh_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldlar_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldlar_lr64_ldstexcl"_h, "'Rd,'Rns"}, + {"ldnp_32_ldstnapair_offs"_h, "'Rd'Ra,'Rns"}, + {"ldnp_64_ldstnapair_offs"_h, "'Rd'Ra,'Rns"}, + {"ldnp_d_ldstnapair_offs"_h, "'Vd'Va,'Rns"}, + {"ldnp_q_ldstnapair_offs"_h, "'Vd'Va,'Rns"}, + {"ldnp_s_ldstnapair_offs"_h, "'Vd'Va,'Rns"}, + {"ldpsw_64_ldstpair_off"_h, "'Rd'Ra,'Rns"}, + {"ldpsw_64_ldstpair_post"_h, "'Rd'Ra'Rns,'Rns"}, + {"ldpsw_64_ldstpair_pre"_h, "'Rd'Ra'Rns,'Rns"}, + {"ldp_32_ldstpair_off"_h, "'Rd'Ra,'Rns"}, + {"ldp_32_ldstpair_post"_h, "'Rd'Ra'Rns,'Rns"}, + {"ldp_32_ldstpair_pre"_h, "'Rd'Ra'Rns,'Rns"}, + {"ldp_64_ldstpair_off"_h, "'Rd'Ra,'Rns"}, + {"ldp_64_ldstpair_post"_h, "'Rd'Ra'Rns,'Rns"}, + {"ldp_64_ldstpair_pre"_h, "'Rd'Ra'Rns,'Rns"}, + {"ldp_d_ldstpair_off"_h, "'Vd'Va,'Rns"}, + {"ldp_d_ldstpair_post"_h, "'Vd'Va'Rns,'Rns"}, + {"ldp_d_ldstpair_pre"_h, "'Vd'Va'Rns,'Rns"}, + {"ldp_q_ldstpair_off"_h, "'Vd'Va,'Rns"}, + {"ldp_q_ldstpair_post"_h, "'Vd'Va'Rns,'Rns"}, + {"ldp_q_ldstpair_pre"_h, "'Vd'Va'Rns,'Rns"}, + {"ldp_s_ldstpair_off"_h, "'Vd'Va,'Rns"}, + {"ldp_s_ldstpair_post"_h, "'Vd'Va'Rns,'Rns"}, + {"ldp_s_ldstpair_pre"_h, "'Vd'Va'Rns,'Rns"}, + {"ldraa_64w_ldst_pac"_h, "'Rd'Rns,'Rns"}, + {"ldraa_64_ldst_pac"_h, "'Rd,'Rns"}, + {"ldrab_64w_ldst_pac"_h, "'Rd'Rns,'Rns"}, + {"ldrab_64_ldst_pac"_h, "'Rd,'Rns"}, + {"ldrb_32bl_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrb_32b_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrb_32_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrb_32_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrb_32_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrh_32_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrh_32_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrh_32_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrh_32_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsb_32bl_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsb_32b_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsb_32_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrsb_32_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrsb_32_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrsb_64bl_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsb_64b_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsb_64_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrsb_64_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrsb_64_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrsh_32_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrsh_32_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrsh_32_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrsh_32_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsh_64_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrsh_64_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrsh_64_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrsh_64_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsw_64_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldrsw_64_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldrsw_64_ldst_pos"_h, "'Rd,'Rns"}, + {"ldrsw_64_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldrsw_64_loadlit"_h, "'Rd,"}, + {"ldr_32_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldr_32_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldr_32_ldst_pos"_h, "'Rd,'Rns"}, + {"ldr_32_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldr_32_loadlit"_h, "'Rd,"}, + {"ldr_64_ldst_immpost"_h, "'Rd'Rns,'Rns"}, + {"ldr_64_ldst_immpre"_h, "'Rd'Rns,'Rns"}, + {"ldr_64_ldst_pos"_h, "'Rd,'Rns"}, + {"ldr_64_ldst_regoff"_h, "'Rd,'Rns'Rm"}, + {"ldr_64_loadlit"_h, "'Rd,"}, + {"ldr_bl_ldst_regoff"_h, "'Vd,'Rns'Rm"}, + {"ldr_b_ldst_immpost"_h, "'Vd'Rns,'Rns"}, + {"ldr_b_ldst_immpre"_h, "'Vd'Rns,'Rns"}, + {"ldr_b_ldst_pos"_h, "'Vd,'Rns"}, + {"ldr_b_ldst_regoff"_h, "'Vd,'Rns'Rm"}, + {"ldr_d_ldst_immpost"_h, "'Vd'Rns,'Rns"}, + {"ldr_d_ldst_immpre"_h, "'Vd'Rns,'Rns"}, + {"ldr_d_ldst_pos"_h, "'Vd,'Rns"}, + {"ldr_d_ldst_regoff"_h, "'Vd,'Rns'Rm"}, + {"ldr_d_loadlit"_h, "'Vd,"}, + {"ldr_h_ldst_immpost"_h, "'Vd'Rns,'Rns"}, + {"ldr_h_ldst_immpre"_h, "'Vd'Rns,'Rns"}, + {"ldr_h_ldst_pos"_h, "'Vd,'Rns"}, + {"ldr_h_ldst_regoff"_h, "'Vd,'Rns'Rm"}, + {"ldr_q_ldst_immpost"_h, "'Vd'Rns,'Rns"}, + {"ldr_q_ldst_immpre"_h, "'Vd'Rns,'Rns"}, + {"ldr_q_ldst_pos"_h, "'Vd,'Rns"}, + {"ldr_q_ldst_regoff"_h, "'Vd,'Rns'Rm"}, + {"ldr_q_loadlit"_h, "'Vd,"}, + {"ldr_s_ldst_immpost"_h, "'Vd'Rns,'Rns"}, + {"ldr_s_ldst_immpre"_h, "'Vd'Rns,'Rns"}, + {"ldr_s_ldst_pos"_h, "'Vd,'Rns"}, + {"ldr_s_ldst_regoff"_h, "'Vd,'Rns'Rm"}, + {"ldr_s_loadlit"_h, "'Vd,"}, + {"ldsetab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldseta_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldseta_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldseth_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsetl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldset_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldset_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxa_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxa_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmaxl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmax_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmax_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmina_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmina_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsminl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmin_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldsmin_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxa_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxa_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumaxl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumax_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumax_64_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumina_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumina_64_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminlb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminlh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"lduminl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumin_32_memop"_h, "'Rd,'Rns'Rm"}, + {"ldumin_64_memop"_h, "'Rd,'Rns'Rm"}, + {"ldurb_32_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldurh_32_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldursb_32_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldursb_64_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldursh_32_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldursh_64_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldursw_64_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldur_32_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldur_64_ldst_unscaled"_h, "'Rd,'Rns"}, + {"ldur_b_ldst_unscaled"_h, "'Vd,'Rns"}, + {"ldur_d_ldst_unscaled"_h, "'Vd,'Rns"}, + {"ldur_h_ldst_unscaled"_h, "'Vd,'Rns"}, + {"ldur_q_ldst_unscaled"_h, "'Vd,'Rns"}, + {"ldur_s_ldst_unscaled"_h, "'Vd,'Rns"}, + {"ldxp_lp32_ldstexcl"_h, "'Rd'Ra,'Rns"}, + {"ldxp_lp64_ldstexcl"_h, "'Rd'Ra,'Rns"}, + {"ldxrb_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldxrh_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldxr_lr32_ldstexcl"_h, "'Rd,'Rns"}, + {"ldxr_lr64_ldstexcl"_h, "'Rd,'Rns"}, + {"lslv_32_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"lslv_64_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"lsrv_32_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"lsrv_64_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"madd_32a_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"madd_64a_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"mla_asimdelem_r"_h, "'Vd,'Vd'Vn'Vmi"}, + {"mla_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"mls_asimdelem_r"_h, "'Vd,'Vd'Vn'Vmi"}, + {"mls_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"movi_asimdimm_d2_d"_h, "'Vd,"}, + {"movi_asimdimm_d_ds"_h, "'Vd,"}, + {"movi_asimdimm_l_hl"_h, "'Vd,"}, + {"movi_asimdimm_l_sl"_h, "'Vd,"}, + {"movi_asimdimm_m_sm"_h, "'Vd,"}, + {"movi_asimdimm_n_b"_h, "'Vd,"}, + {"movk_32_movewide"_h, "'Rd,'Rd"}, + {"movk_64_movewide"_h, "'Rd,'Rd"}, + {"movn_32_movewide"_h, "'Rd,"}, + {"movn_64_movewide"_h, "'Rd,"}, + {"movz_32_movewide"_h, "'Rd,"}, + {"movz_64_movewide"_h, "'Rd,"}, + {"msub_32a_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"msub_64a_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"mul_asimdelem_r"_h, "'Vd,'Vn'Vmi"}, + {"mul_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"mvni_asimdimm_l_hl"_h, "'Vd,"}, + {"mvni_asimdimm_l_sl"_h, "'Vd,"}, + {"mvni_asimdimm_m_sm"_h, "'Vd,"}, + {"neg_asimdmisc_r"_h, "'Vd,'Vn"}, + {"neg_asisdmisc_r"_h, "'Vd,'Vn"}, + {"nop_hi_hints"_h, ","}, + {"not_asimdmisc_r"_h, "'Vd,'Vn"}, + {"orn_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"orn_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"orn_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"orr_32_log_imm"_h, "'Rds,'Rn"}, + {"orr_32_log_shift"_h, "'Rd,'Rn'Rm"}, + {"orr_64_log_imm"_h, "'Rds,'Rn"}, + {"orr_64_log_shift"_h, "'Rd,'Rn'Rm"}, + {"orr_asimdimm_l_hl"_h, "'Vd,'Vd"}, + {"orr_asimdimm_l_sl"_h, "'Vd,'Vd"}, + {"orr_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"pacda_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"pacdb_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"pacdza_64z_dp_1src"_h, "'Rd,'Rd"}, + {"pacdzb_64z_dp_1src"_h, "'Rd,'Rd"}, + {"pacga_64p_dp_2src"_h, "'Rd,'Rn'Rms"}, + {"pacia1716_hi_hints"_h, "'I17,'I17'I16"}, + {"paciasp_hi_hints"_h, "'I30,'I30'I31"}, + {"paciaz_hi_hints"_h, "'I30,'I30"}, + {"pacia_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"pacib1716_hi_hints"_h, "'I17,'I17'I16"}, + {"pacibsp_hi_hints"_h, "'I30,'I30'I31"}, + {"pacibz_hi_hints"_h, "'I30,'I30"}, + {"pacib_64p_dp_1src"_h, "'Rd,'Rd'Rns"}, + {"paciza_64z_dp_1src"_h, "'Rd,'Rd"}, + {"pacizb_64z_dp_1src"_h, "'Rd,'Rd"}, + {"pmull_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"pmul_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"prfm_p_ldst_pos"_h, ",'Rns"}, + {"prfm_p_ldst_regoff"_h, ",'Rns'Rm"}, + {"prfm_p_loadlit"_h, ","}, + {"prfum_p_ldst_unscaled"_h, ",'Rns"}, + {"raddhn_asimddiff_n"_h, "'Vd,'Vn'Vm"}, + {"rbit_32_dp_1src"_h, "'Rd,'Rn"}, + {"rbit_64_dp_1src"_h, "'Rd,'Rn"}, + {"rbit_asimdmisc_r"_h, "'Vd,'Vn"}, + {"retaa_64e_branch_reg"_h, ",'I30'I31"}, + {"retab_64e_branch_reg"_h, ",'I30'I31"}, + {"ret_64r_branch_reg"_h, ",'Rn"}, + {"rev16_32_dp_1src"_h, "'Rd,'Rn"}, + {"rev16_64_dp_1src"_h, "'Rd,'Rn"}, + {"rev16_asimdmisc_r"_h, "'Vd,'Vn"}, + {"rev32_64_dp_1src"_h, "'Rd,'Rn"}, + {"rev32_asimdmisc_r"_h, "'Vd,'Vn"}, + {"rev64_asimdmisc_r"_h, "'Vd,'Vn"}, + {"rev_32_dp_1src"_h, "'Rd,'Rn"}, + {"rev_64_dp_1src"_h, "'Rd,'Rn"}, + {"rmif_only_rmif"_h, ",'Rn"}, + {"rorv_32_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"rorv_64_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"rshrn_asimdshf_n"_h, "'Vd,'Vn"}, + {"rsubhn_asimddiff_n"_h, "'Vd,'Vn'Vm"}, + {"sabal_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"saba_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sabdl_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"sabd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sadalp_asimdmisc_p"_h, "'Vd,'Vd'Vn"}, + {"saddlp_asimdmisc_p"_h, "'Vd,'Vn"}, + {"saddlv_asimdall_only"_h, "'Vd,'Vn"}, + {"saddl_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"saddw_asimddiff_w"_h, "'Vd,'Vn'Vm"}, + {"sbcs_32_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"sbcs_64_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"sbc_32_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"sbc_64_addsub_carry"_h, "'Rd,'Rn'Rm"}, + {"sbfm_32m_bitfield"_h, "'Rd,'Rn"}, + {"sbfm_64m_bitfield"_h, "'Rd,'Rn"}, + {"scvtf_d32_float2fix"_h, "'Vd,'Rn"}, + {"scvtf_d32_float2int"_h, "'Vd,'Rn"}, + {"scvtf_d64_float2fix"_h, "'Vd,'Rn"}, + {"scvtf_d64_float2int"_h, "'Vd,'Rn"}, + {"scvtf_h32_float2fix"_h, "'Vd,'Rn"}, + {"scvtf_h32_float2int"_h, "'Vd,'Rn"}, + {"scvtf_h64_float2fix"_h, "'Vd,'Rn"}, + {"scvtf_h64_float2int"_h, "'Vd,'Rn"}, + {"scvtf_s32_float2fix"_h, "'Vd,'Rn"}, + {"scvtf_s32_float2int"_h, "'Vd,'Rn"}, + {"scvtf_s64_float2fix"_h, "'Vd,'Rn"}, + {"scvtf_s64_float2int"_h, "'Vd,'Rn"}, + {"scvtf_asimdmisc_r"_h, "'Vd,'Vn"}, + {"scvtf_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"scvtf_asimdshf_c"_h, "'Vd,'Vn"}, + {"scvtf_asisdmisc_r"_h, "'Vd,'Vn"}, + {"scvtf_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"scvtf_asisdshf_c"_h, "'Vd,'Vn"}, + {"sdiv_32_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"sdiv_64_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"sdot_asimdelem_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"sdot_asimdsame2_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"seten_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"sete_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setf16_only_setf"_h, ",'Rn"}, + {"setf8_only_setf"_h, ",'Rn"}, + {"setgen_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setge_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setgmn_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setgm_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setgpn_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setgp_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setmn_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setm_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setpn_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"setp_set_memcms"_h, "'Rd'Rn,'Rd'Rn'Rm"}, + {"shadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"shll_asimdmisc_s"_h, "'Vd,'Vn"}, + {"shl_asimdshf_r"_h, "'Vd,'Vn"}, + {"shl_asisdshf_r"_h, "'Vd,'Vn"}, + {"shrn_asimdshf_n"_h, "'Vd,'Vn"}, + {"shsub_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sli_asimdshf_r"_h, "'Vd,'Vd'Vn"}, + {"sli_asisdshf_r"_h, "'Vd,'Vd'Vn"}, + {"smaddl_64wa_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"smaxp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"smaxv_asimdall_only"_h, "'Vd,'Vn"}, + {"smax_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sminp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sminv_asimdall_only"_h, "'Vd,'Vn"}, + {"smin_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"smlal_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"smlal_asimdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"smlsl_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"smlsl_asimdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"smmla_asimdsame2_g"_h, "'Vd,'Vd'Vn'Vm"}, + {"smov_asimdins_w_w"_h, "'Rd,'Vn"}, + {"smov_asimdins_x_x"_h, "'Rd,'Vn"}, + {"smsubl_64wa_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"smulh_64_dp_3src"_h, "'Rd,'Rn'Rm"}, + {"smull_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"smull_asimdelem_l"_h, "'Vd,'Vn'Vmi"}, + {"sqabs_asimdmisc_r"_h, "'Vd,'Vn"}, + {"sqabs_asisdmisc_r"_h, "'Vd,'Vn"}, + {"sqadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqadd_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqdmlal_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlal_asimdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqdmlal_asisddiff_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlal_asisdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqdmlsl_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlsl_asimdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqdmlsl_asisddiff_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlsl_asisdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqdmulh_asimdelem_r"_h, "'Vd,'Vn'Vmi"}, + {"sqdmulh_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqdmulh_asisdelem_r"_h, "'Vd,'Vn'Vmi"}, + {"sqdmulh_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqdmull_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"sqdmull_asimdelem_l"_h, "'Vd,'Vn'Vmi"}, + {"sqdmull_asisddiff_only"_h, "'Vd,'Vn'Vm"}, + {"sqdmull_asisdelem_l"_h, "'Vd,'Vn'Vmi"}, + {"sqneg_asimdmisc_r"_h, "'Vd,'Vn"}, + {"sqneg_asisdmisc_r"_h, "'Vd,'Vn"}, + {"sqrdmlah_asimdelem_r"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqrdmlah_asimdsame2_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdmlah_asisdelem_r"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqrdmlah_asisdsame2_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdmlsh_asimdelem_r"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqrdmlsh_asimdsame2_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdmlsh_asisdelem_r"_h, "'Vd,'Vd'Vn'Vmi"}, + {"sqrdmlsh_asisdsame2_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdmulh_asimdelem_r"_h, "'Vd,'Vn'Vmi"}, + {"sqrdmulh_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqrdmulh_asisdelem_r"_h, "'Vd,'Vn'Vmi"}, + {"sqrdmulh_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqrshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqrshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqrshrn_asimdshf_n"_h, "'Vd,'Vn"}, + {"sqrshrn_asisdshf_n"_h, "'Vd,'Vn"}, + {"sqrshrun_asimdshf_n"_h, "'Vd,'Vn"}, + {"sqrshrun_asisdshf_n"_h, "'Vd,'Vn"}, + {"sqshlu_asimdshf_r"_h, "'Vd,'Vn"}, + {"sqshlu_asisdshf_r"_h, "'Vd,'Vn"}, + {"sqshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqshl_asimdshf_r"_h, "'Vd,'Vn"}, + {"sqshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqshl_asisdshf_r"_h, "'Vd,'Vn"}, + {"sqshrn_asimdshf_n"_h, "'Vd,'Vn"}, + {"sqshrn_asisdshf_n"_h, "'Vd,'Vn"}, + {"sqshrun_asimdshf_n"_h, "'Vd,'Vn"}, + {"sqshrun_asisdshf_n"_h, "'Vd,'Vn"}, + {"sqsub_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqsub_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sqxtn_asimdmisc_n"_h, "'Vd,'Vn"}, + {"sqxtn_asisdmisc_n"_h, "'Vd,'Vn"}, + {"sqxtun_asimdmisc_n"_h, "'Vd,'Vn"}, + {"sqxtun_asisdmisc_n"_h, "'Vd,'Vn"}, + {"srhadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sri_asimdshf_r"_h, "'Vd,'Vd'Vn"}, + {"sri_asisdshf_r"_h, "'Vd,'Vd'Vn"}, + {"srshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"srshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"srshr_asimdshf_r"_h, "'Vd,'Vn"}, + {"srshr_asisdshf_r"_h, "'Vd,'Vn"}, + {"srsra_asimdshf_r"_h, "'Vd,'Vd'Vn"}, + {"srsra_asisdshf_r"_h, "'Vd,'Vd'Vn"}, + {"sshll_asimdshf_l"_h, "'Vd,'Vn"}, + {"sshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sshr_asimdshf_r"_h, "'Vd,'Vn"}, + {"sshr_asisdshf_r"_h, "'Vd,'Vn"}, + {"ssra_asimdshf_r"_h, "'Vd,'Vd'Vn"}, + {"ssra_asisdshf_r"_h, "'Vd,'Vd'Vn"}, + {"ssubl_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"ssubw_asimddiff_w"_h, "'Vd,'Vn'Vm"}, + {"st1_asisdlse_r1_1v"_h, ",'Vd'Rns"}, + {"st1_asisdlse_r2_2v"_h, ",'Vd'Vd+1'Rns"}, + {"st1_asisdlse_r3_3v"_h, ",'Vd'Vd+1'Vd+2'Rns"}, + {"st1_asisdlse_r4_4v"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st1_asisdlsep_i1_i1"_h, "'Rns,'Vd'Rns"}, + {"st1_asisdlsep_i2_i2"_h, "'Rns,'Vd'Vd+1'Rns"}, + {"st1_asisdlsep_i3_i3"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"st1_asisdlsep_i4_i4"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st1_asisdlsep_r1_r1"_h, "'Rns,'Vd'Rns'Rm"}, + {"st1_asisdlsep_r2_r2"_h, "'Rns,'Vd'Vd+1'Rns'Rm"}, + {"st1_asisdlsep_r3_r3"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"st1_asisdlsep_r4_r4"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"st1_asisdlso_b1_1b"_h, ",'Vd'Rns"}, + {"st1_asisdlso_d1_1d"_h, ",'Vd'Rns"}, + {"st1_asisdlso_h1_1h"_h, ",'Vd'Rns"}, + {"st1_asisdlso_s1_1s"_h, ",'Vd'Rns"}, + {"st1_asisdlsop_b1_i1b"_h, "'Rns,'Vd'Rns"}, + {"st1_asisdlsop_bx1_r1b"_h, "'Rns,'Vd'Rns'Rm"}, + {"st1_asisdlsop_d1_i1d"_h, "'Rns,'Vd'Rns"}, + {"st1_asisdlsop_dx1_r1d"_h, "'Rns,'Vd'Rns'Rm"}, + {"st1_asisdlsop_h1_i1h"_h, "'Rns,'Vd'Rns"}, + {"st1_asisdlsop_hx1_r1h"_h, "'Rns,'Vd'Rns'Rm"}, + {"st1_asisdlsop_s1_i1s"_h, "'Rns,'Vd'Rns"}, + {"st1_asisdlsop_sx1_r1s"_h, "'Rns,'Vd'Rns'Rm"}, + {"st2g_64soffset_ldsttags"_h, ",'Rns'Rds"}, + {"st2g_64spost_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"st2g_64spre_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"st2_asisdlse_r2"_h, ",'Vd'Vd+1'Rns"}, + {"st2_asisdlsep_i2_i"_h, "'Rns,'Vd'Vd+1'Rns"}, + {"st2_asisdlsep_r2_r"_h, "'Rns,'Vd'Vd+1'Rns'Rm"}, + {"st2_asisdlso_b2_2b"_h, ",'Vd'Vd+1'Rns"}, + {"st2_asisdlso_d2_2d"_h, ",'Vd'Vd+1'Rns"}, + {"st2_asisdlso_h2_2h"_h, ",'Vd'Vd+1'Rns"}, + {"st2_asisdlso_s2_2s"_h, ",'Vd'Vd+1'Rns"}, + {"st2_asisdlsop_b2_i2b"_h, "'Rns,'Vd'Vd+1'Rns"}, + {"st2_asisdlsop_bx2_r2b"_h, "'Rns,'Vd'Vd+1'Rns'Rm"}, + {"st2_asisdlsop_d2_i2d"_h, "'Rns,'Vd'Vd+1'Rns"}, + {"st2_asisdlsop_dx2_r2d"_h, "'Rns,'Vd'Vd+1'Rns'Rm"}, + {"st2_asisdlsop_h2_i2h"_h, "'Rns,'Vd'Vd+1'Rns"}, + {"st2_asisdlsop_hx2_r2h"_h, "'Rns,'Vd'Vd+1'Rns'Rm"}, + {"st2_asisdlsop_s2_i2s"_h, "'Rns,'Vd'Vd+1'Rns"}, + {"st2_asisdlsop_sx2_r2s"_h, "'Rns,'Vd'Vd+1'Rns'Rm"}, + {"st3_asisdlse_r3"_h, ",'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsep_i3_i"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsep_r3_r"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"st3_asisdlso_b3_3b"_h, ",'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlso_d3_3d"_h, ",'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlso_h3_3h"_h, ",'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlso_s3_3s"_h, ",'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsop_b3_i3b"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsop_bx3_r3b"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"st3_asisdlsop_d3_i3d"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsop_dx3_r3d"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"st3_asisdlsop_h3_i3h"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsop_hx3_r3h"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"st3_asisdlsop_s3_i3s"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns"}, + {"st3_asisdlsop_sx3_r3s"_h, "'Rns,'Vd'Vd+1'Vd+2'Rns'Rm"}, + {"st4_asisdlse_r4"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsep_i4_i"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsep_r4_r"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"st4_asisdlso_b4_4b"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlso_d4_4d"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlso_h4_4h"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlso_s4_4s"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsop_b4_i4b"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsop_bx4_r4b"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"st4_asisdlsop_d4_i4d"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsop_dx4_r4d"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"st4_asisdlsop_h4_i4h"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsop_hx4_r4h"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"st4_asisdlsop_s4_i4s"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns"}, + {"st4_asisdlsop_sx4_r4s"_h, "'Rns,'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm"}, + {"stgp_64_ldstpair_off"_h, ",'Rd'Ra'Rns"}, + {"stgp_64_ldstpair_post"_h, "'Rns,'Rd'Ra'Rns"}, + {"stgp_64_ldstpair_pre"_h, "'Rns,'Rd'Ra'Rns"}, + {"stg_64soffset_ldsttags"_h, ",'Rns'Rds"}, + {"stg_64spost_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"stg_64spre_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"stllrb_sl32_ldstexcl"_h, ",'Rd'Rns"}, + {"stllrh_sl32_ldstexcl"_h, ",'Rd'Rns"}, + {"stllr_sl32_ldstexcl"_h, ",'Rd'Rns"}, + {"stllr_sl64_ldstexcl"_h, ",'Rd'Rns"}, + {"stlrb_sl32_ldstexcl"_h, ",'Rd'Rns"}, + {"stlrh_sl32_ldstexcl"_h, ",'Rd'Rns"}, + {"stlr_sl32_ldstexcl"_h, ",'Rd'Rns"}, + {"stlr_sl64_ldstexcl"_h, ",'Rd'Rns"}, + {"stlurb_32_ldapstl_unscaled"_h, ",'Rd'Rns"}, + {"stlurh_32_ldapstl_unscaled"_h, ",'Rd'Rns"}, + {"stlur_32_ldapstl_unscaled"_h, ",'Rd'Rns"}, + {"stlur_64_ldapstl_unscaled"_h, ",'Rd'Rns"}, + {"stlxp_sp32_ldstexcl"_h, "'Rm,'Rd'Ra'Rns"}, + {"stlxp_sp64_ldstexcl"_h, "'Rm,'Rd'Ra'Rns"}, + {"stlxrb_sr32_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stlxrh_sr32_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stlxr_sr32_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stlxr_sr64_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stnp_32_ldstnapair_offs"_h, ",'Rd'Ra'Rns"}, + {"stnp_64_ldstnapair_offs"_h, ",'Rd'Ra'Rns"}, + {"stnp_d_ldstnapair_offs"_h, ",'Vd'Va'Rns"}, + {"stnp_q_ldstnapair_offs"_h, ",'Vd'Va'Rns"}, + {"stnp_s_ldstnapair_offs"_h, ",'Vd'Va'Rns"}, + {"stp_32_ldstpair_off"_h, ",'Rd'Ra'Rns"}, + {"stp_32_ldstpair_post"_h, "'Rns,'Rd'Ra'Rns"}, + {"stp_32_ldstpair_pre"_h, "'Rns,'Rd'Ra'Rns"}, + {"stp_64_ldstpair_off"_h, ",'Rd'Ra'Rns"}, + {"stp_64_ldstpair_post"_h, "'Rns,'Rd'Ra'Rns"}, + {"stp_64_ldstpair_pre"_h, "'Rns,'Rd'Ra'Rns"}, + {"stp_d_ldstpair_off"_h, ",'Vd'Va'Rns"}, + {"stp_d_ldstpair_post"_h, "'Rns,'Vd'Va'Rns"}, + {"stp_d_ldstpair_pre"_h, "'Rns,'Vd'Va'Rns"}, + {"stp_q_ldstpair_off"_h, ",'Vd'Va'Rns"}, + {"stp_q_ldstpair_post"_h, "'Rns,'Vd'Va'Rns"}, + {"stp_q_ldstpair_pre"_h, "'Rns,'Vd'Va'Rns"}, + {"stp_s_ldstpair_off"_h, ",'Vd'Va'Rns"}, + {"stp_s_ldstpair_post"_h, "'Rns,'Vd'Va'Rns"}, + {"stp_s_ldstpair_pre"_h, "'Rns,'Vd'Va'Rns"}, + {"strb_32bl_ldst_regoff"_h, ",'Rns'Rm'Rd"}, + {"strb_32b_ldst_regoff"_h, ",'Rns'Rm'Rd"}, + {"strb_32_ldst_immpost"_h, "'Rns,'Rd'Rns"}, + {"strb_32_ldst_immpre"_h, "'Rns,'Rd'Rns"}, + {"strb_32_ldst_pos"_h, ",'Rd'Rns"}, + {"strh_32_ldst_immpost"_h, "'Rns,'Rd'Rns"}, + {"strh_32_ldst_immpre"_h, "'Rns,'Rd'Rns"}, + {"strh_32_ldst_pos"_h, ",'Rd'Rns"}, + {"strh_32_ldst_regoff"_h, ",'Rns'Rm'Rd"}, + {"str_32_ldst_immpost"_h, "'Rns,'Rd'Rns"}, + {"str_32_ldst_immpre"_h, "'Rns,'Rd'Rns"}, + {"str_32_ldst_pos"_h, ",'Rd'Rns"}, + {"str_32_ldst_regoff"_h, ",'Rns'Rm'Rd"}, + {"str_64_ldst_immpost"_h, "'Rns,'Rd'Rns"}, + {"str_64_ldst_immpre"_h, "'Rns,'Rd'Rns"}, + {"str_64_ldst_pos"_h, ",'Rd'Rns"}, + {"str_64_ldst_regoff"_h, ",'Rns'Rm'Rd"}, + {"str_bl_ldst_regoff"_h, ",'Vd'Rns'Rm"}, + {"str_b_ldst_immpost"_h, "'Rns,'Vd'Rns"}, + {"str_b_ldst_immpre"_h, "'Rns,'Vd'Rns"}, + {"str_b_ldst_pos"_h, ",'Vd'Rns"}, + {"str_b_ldst_regoff"_h, ",'Vd'Rns'Rm"}, + {"str_d_ldst_immpost"_h, "'Rns,'Vd'Rns"}, + {"str_d_ldst_immpre"_h, "'Rns,'Vd'Rns"}, + {"str_d_ldst_pos"_h, ",'Vd'Rns"}, + {"str_d_ldst_regoff"_h, ",'Vd'Rns'Rm"}, + {"str_h_ldst_immpost"_h, "'Rns,'Vd'Rns"}, + {"str_h_ldst_immpre"_h, "'Rns,'Vd'Rns"}, + {"str_h_ldst_pos"_h, ",'Vd'Rns"}, + {"str_h_ldst_regoff"_h, ",'Vd'Rns'Rm"}, + {"str_q_ldst_immpost"_h, "'Rns,'Vd'Rns"}, + {"str_q_ldst_immpre"_h, "'Rns,'Vd'Rns"}, + {"str_q_ldst_pos"_h, ",'Vd'Rns"}, + {"str_q_ldst_regoff"_h, ",'Vd'Rns'Rm"}, + {"str_s_ldst_immpost"_h, "'Rns,'Vd'Rns"}, + {"str_s_ldst_immpre"_h, "'Rns,'Vd'Rns"}, + {"str_s_ldst_pos"_h, ",'Vd'Rns"}, + {"str_s_ldst_regoff"_h, ",'Vd'Rns'Rm"}, + {"sturb_32_ldst_unscaled"_h, ",'Rd'Rns"}, + {"sturh_32_ldst_unscaled"_h, ",'Rd'Rns"}, + {"stur_32_ldst_unscaled"_h, ",'Rd'Rns"}, + {"stur_64_ldst_unscaled"_h, ",'Rd'Rns"}, + {"stur_b_ldst_unscaled"_h, ",'Vd'Rns"}, + {"stur_d_ldst_unscaled"_h, ",'Vd'Rns"}, + {"stur_h_ldst_unscaled"_h, ",'Vd'Rns"}, + {"stur_q_ldst_unscaled"_h, ",'Vd'Rns"}, + {"stur_s_ldst_unscaled"_h, ",'Vd'Rns"}, + {"stxp_sp32_ldstexcl"_h, "'Rm,'Rd'Ra'Rns"}, + {"stxp_sp64_ldstexcl"_h, "'Rm,'Rd'Ra'Rns"}, + {"stxrb_sr32_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stxrh_sr32_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stxr_sr32_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stxr_sr64_ldstexcl"_h, "'Rm,'Rd'Rns"}, + {"stz2g_64soffset_ldsttags"_h, ",'Rns'Rds"}, + {"stz2g_64spost_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"stz2g_64spre_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"stzg_64soffset_ldsttags"_h, ",'Rns'Rds"}, + {"stzg_64spost_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"stzg_64spre_ldsttags"_h, "'Rns,'Rns'Rds"}, + {"subg_64_addsub_immtags"_h, "'Rds,'Rns"}, + {"subhn_asimddiff_n"_h, "'Vd,'Vn'Vm"}, + {"subps_64s_dp_2src"_h, "'Rd,'Rns'Rms"}, + {"subp_64s_dp_2src"_h, "'Rd,'Rns'Rms"}, + {"subs_32s_addsub_ext"_h, "'Rd,'Rns'Rm"}, + {"subs_32s_addsub_imm"_h, "'Rd,'Rns"}, + {"subs_32_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"subs_64s_addsub_ext"_h, "'Rd,'Rns'Rm"}, + {"subs_64s_addsub_imm"_h, "'Rd,'Rns"}, + {"subs_64_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"sub_32_addsub_ext"_h, "'Rds,'Rns'Rm"}, + {"sub_32_addsub_imm"_h, "'Rds,'Rns"}, + {"sub_32_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"sub_64_addsub_ext"_h, "'Rds,'Rns'Rm"}, + {"sub_64_addsub_imm"_h, "'Rds,'Rns"}, + {"sub_64_addsub_shift"_h, "'Rd,'Rn'Rm"}, + {"sub_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sub_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"sudot_asimdelem_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"suqadd_asimdmisc_r"_h, "'Vd,'Vn"}, + {"suqadd_asisdmisc_r"_h, "'Vd,'Vn"}, + {"swpab_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpah_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpalb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpalh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpal_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpal_64_memop"_h, "'Rd,'Rns'Rm"}, + {"swpa_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpa_64_memop"_h, "'Rd,'Rns'Rm"}, + {"swpb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swph_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swplb_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swplh_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpl_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swpl_64_memop"_h, "'Rd,'Rns'Rm"}, + {"swp_32_memop"_h, "'Rd,'Rns'Rm"}, + {"swp_64_memop"_h, "'Rd,'Rns'Rm"}, + {"tbl_asimdtbl_l1_1"_h, "'Vd,'Vn'Vm"}, + {"tbl_asimdtbl_l2_2"_h, "'Vd,'Vn'Vn+1'Vm"}, + {"tbl_asimdtbl_l3_3"_h, "'Vd,'Vn'Vn+1'Vn+2'Vm"}, + {"tbl_asimdtbl_l4_4"_h, "'Vd,'Vn'Vn+1'Vn+2'Vn+3'Vm"}, + {"tbnz_only_testbranch"_h, ",'Rd"}, + {"tbx_asimdtbl_l1_1"_h, "'Vd,'Vd'Vn'Vm"}, + {"tbx_asimdtbl_l2_2"_h, "'Vd,'Vd'Vn'Vn+1'Vm"}, + {"tbx_asimdtbl_l3_3"_h, "'Vd,'Vd'Vn'Vn+1'Vn+2'Vm"}, + {"tbx_asimdtbl_l4_4"_h, "'Vd,'Vd'Vn'Vn+1'Vn+2'Vn+3'Vm"}, + {"tbz_only_testbranch"_h, ",'Rd"}, + {"trn1_asimdperm_only"_h, "'Vd,'Vn'Vm"}, + {"trn2_asimdperm_only"_h, "'Vd,'Vn'Vm"}, + {"uabal_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"uaba_asimdsame_only"_h, "'Vd,'Vd'Vn'Vm"}, + {"uabdl_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"uabd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uadalp_asimdmisc_p"_h, "'Vd,'Vd'Vn"}, + {"uaddlp_asimdmisc_p"_h, "'Vd,'Vn"}, + {"uaddlv_asimdall_only"_h, "'Vd,'Vn"}, + {"uaddl_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"uaddw_asimddiff_w"_h, "'Vd,'Vn'Vm"}, + {"ubfm_32m_bitfield"_h, "'Rd,'Rn"}, + {"ubfm_64m_bitfield"_h, "'Rd,'Rn"}, + {"ucvtf_d32_float2fix"_h, "'Vd,'Rn"}, + {"ucvtf_d32_float2int"_h, "'Vd,'Rn"}, + {"ucvtf_d64_float2fix"_h, "'Vd,'Rn"}, + {"ucvtf_d64_float2int"_h, "'Vd,'Rn"}, + {"ucvtf_h32_float2fix"_h, "'Vd,'Rn"}, + {"ucvtf_h32_float2int"_h, "'Vd,'Rn"}, + {"ucvtf_h64_float2fix"_h, "'Vd,'Rn"}, + {"ucvtf_h64_float2int"_h, "'Vd,'Rn"}, + {"ucvtf_s32_float2fix"_h, "'Vd,'Rn"}, + {"ucvtf_s32_float2int"_h, "'Vd,'Rn"}, + {"ucvtf_s64_float2fix"_h, "'Vd,'Rn"}, + {"ucvtf_s64_float2int"_h, "'Vd,'Rn"}, + {"ucvtf_asimdmisc_r"_h, "'Vd,'Vn"}, + {"ucvtf_asimdmiscfp16_r"_h, "'Vd,'Vn"}, + {"ucvtf_asimdshf_c"_h, "'Vd,'Vn"}, + {"ucvtf_asisdmisc_r"_h, "'Vd,'Vn"}, + {"ucvtf_asisdmiscfp16_r"_h, "'Vd,'Vn"}, + {"ucvtf_asisdshf_c"_h, "'Vd,'Vn"}, + {"udf_only_perm_undef"_h, ","}, + {"udiv_32_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"udiv_64_dp_2src"_h, "'Rd,'Rn'Rm"}, + {"udot_asimdelem_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"udot_asimdsame2_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"uhadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uhsub_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"umaddl_64wa_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"umaxp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"umaxv_asimdall_only"_h, "'Vd,'Vn"}, + {"umax_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uminp_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uminv_asimdall_only"_h, "'Vd,'Vn"}, + {"umin_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"umlal_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"umlal_asimdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"umlsl_asimddiff_l"_h, "'Vd,'Vd'Vn'Vm"}, + {"umlsl_asimdelem_l"_h, "'Vd,'Vd'Vn'Vmi"}, + {"ummla_asimdsame2_g"_h, "'Vd,'Vd'Vn'Vm"}, + {"umov_asimdins_w_w"_h, "'Rd,'Vn"}, + {"umov_asimdins_x_x"_h, "'Rd,'Vn"}, + {"umsubl_64wa_dp_3src"_h, "'Rd,'Rn'Rm'Ra"}, + {"umulh_64_dp_3src"_h, "'Rd,'Rn'Rm"}, + {"umull_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"umull_asimdelem_l"_h, "'Vd,'Vn'Vmi"}, + {"uqadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqadd_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqrshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqrshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqrshrn_asimdshf_n"_h, "'Vd,'Vn"}, + {"uqrshrn_asisdshf_n"_h, "'Vd,'Vn"}, + {"uqshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqshl_asimdshf_r"_h, "'Vd,'Vn"}, + {"uqshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqshl_asisdshf_r"_h, "'Vd,'Vn"}, + {"uqshrn_asimdshf_n"_h, "'Vd,'Vn"}, + {"uqshrn_asisdshf_n"_h, "'Vd,'Vn"}, + {"uqsub_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqsub_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"uqxtn_asimdmisc_n"_h, "'Vd,'Vn"}, + {"uqxtn_asisdmisc_n"_h, "'Vd,'Vn"}, + {"urecpe_asimdmisc_r"_h, "'Vd,'Vn"}, + {"urhadd_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"urshl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"urshl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"urshr_asimdshf_r"_h, "'Vd,'Vn"}, + {"urshr_asisdshf_r"_h, "'Vd,'Vn"}, + {"ursqrte_asimdmisc_r"_h, "'Vd,'Vn"}, + {"ursra_asimdshf_r"_h, "'Vd,'Vd'Vn"}, + {"ursra_asisdshf_r"_h, "'Vd,'Vd'Vn"}, + {"usdot_asimdelem_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"usdot_asimdsame2_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"ushll_asimdshf_l"_h, "'Vd,'Vn"}, + {"ushl_asimdsame_only"_h, "'Vd,'Vn'Vm"}, + {"ushl_asisdsame_only"_h, "'Vd,'Vn'Vm"}, + {"ushr_asimdshf_r"_h, "'Vd,'Vn"}, + {"ushr_asisdshf_r"_h, "'Vd,'Vn"}, + {"usmmla_asimdsame2_g"_h, "'Vd,'Vd'Vn'Vm"}, + {"usqadd_asimdmisc_r"_h, "'Vd,'Vn"}, + {"usqadd_asisdmisc_r"_h, "'Vd,'Vn"}, + {"usra_asimdshf_r"_h, "'Vd,'Vd'Vn"}, + {"usra_asisdshf_r"_h, "'Vd,'Vd'Vn"}, + {"usubl_asimddiff_l"_h, "'Vd,'Vn'Vm"}, + {"usubw_asimddiff_w"_h, "'Vd,'Vn'Vm"}, + {"uzp1_asimdperm_only"_h, "'Vd,'Vn'Vm"}, + {"uzp2_asimdperm_only"_h, "'Vd,'Vn'Vm"}, + {"xaflag_m_pstate"_h, ","}, + {"xpacd_64z_dp_1src"_h, "'Rd,'Rd"}, + {"xpaci_64z_dp_1src"_h, "'Rd,'Rd"}, + {"xpaclri_hi_hints"_h, "'I30,'I30"}, + {"xtn_asimdmisc_n"_h, "'Vd,'Vn"}, + {"yield_hi_hints"_h, ","}, + {"zip1_asimdperm_only"_h, "'Vd,'Vn'Vm"}, + {"zip2_asimdperm_only"_h, "'Vd,'Vn'Vm"}, + {"abs_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"adclb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"adclt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"add_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"add_z_zi"_h, "'Vd,'Vd"}, + {"add_z_zz"_h, "'Vd,'Vn'Vm"}, + {"addhnb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"addhnt_z_zz"_h, "'Vd,'Vd'Vn'Vm"}, + {"addp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"addpl_r_ri"_h, "'Rds,'Rms"}, + {"addvl_r_ri"_h, "'Rds,'Rms"}, + {"adr_z_az_d_s32_scaled"_h, "'Vd,'Vn'Vm"}, + {"adr_z_az_d_u32_scaled"_h, "'Vd,'Vn'Vm"}, + {"adr_z_az_sd_same_scaled"_h, "'Vd,'Vn'Vm"}, + {"and_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"and_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"and_z_zi"_h, "'Vd,'Vd"}, + {"and_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ands_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"andv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"asr_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"asr_z_p_zw"_h, "'Vd,'Vd'Vn'Pg"}, + {"asr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"asr_z_zi"_h, "'Vd,'Vn"}, + {"asr_z_zw"_h, "'Vd,'Vn'Vm"}, + {"asrd_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"asrr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"bcax_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"bdep_z_zz"_h, "'Vd,'Vn'Vm"}, + {"bext_z_zz"_h, "'Vd,'Vn'Vm"}, + {"bgrp_z_zz"_h, "'Vd,'Vn'Vm"}, + {"bic_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"bic_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"bic_z_zz"_h, "'Vd,'Vn'Vm"}, + {"bics_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"brka_p_p_p"_h, "'Pd,'Pd?04'Pn'P1310"}, + {"brkas_p_p_p_z"_h, "'Pd,'Pn'P1310"}, + {"brkb_p_p_p"_h, "'Pd,'Pd?04'Pn'P1310"}, + {"brkbs_p_p_p_z"_h, "'Pd,'Pn'P1310"}, + {"brkn_p_p_pp"_h, "'Pd,'Pd'Pn'P1310"}, + {"brkns_p_p_pp"_h, "'Pd,'Pd'Pn'P1310"}, + {"brkpa_p_p_pp"_h, "'Pd,'Pn'Pm'P1310"}, + {"brkpas_p_p_pp"_h, "'Pd,'Pn'Pm'P1310"}, + {"brkpb_p_p_pp"_h, "'Pd,'Pn'Pm'P1310"}, + {"brkpbs_p_p_pp"_h, "'Pd,'Pn'Pm'P1310"}, + {"bsl1n_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"bsl2n_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"bsl_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"cadd_z_zz"_h, "'Vd,'Vd'Vn"}, + {"cdot_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"cdot_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"cdot_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"clasta_r_p_z"_h, "'Rd,'Rd'Vn'Pg"}, + {"clasta_v_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"clasta_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"clastb_r_p_z"_h, "'Rd,'Rd'Vn'Pg"}, + {"clastb_v_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"clastb_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"cls_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"clz_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"cmla_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"cmla_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"cmla_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1916"}, + {"cmpeq_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmpeq_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpeq_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpge_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmpge_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpge_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpgt_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmpgt_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpgt_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmphi_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmphi_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmphi_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmphs_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmphs_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmphs_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmple_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmple_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmplo_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmplo_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpls_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmpls_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmplt_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmplt_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpne_p_p_zi"_h, "'Pd,'Vn'Pg"}, + {"cmpne_p_p_zw"_h, "'Pd,'Vn'Vm'Pg"}, + {"cmpne_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"cnot_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"cnt_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"cntb_r_s"_h, "'Rd,"}, + {"cntd_r_s"_h, "'Rd,"}, + {"cnth_r_s"_h, "'Rd,"}, + {"cntp_r_p_p"_h, "'Rd,'Pn'P1310"}, + {"cntw_r_s"_h, "'Rd,"}, + {"compact_z_p_z"_h, "'Vd,'Vn'Pg"}, + {"cpy_z_o_i"_h, "'Vd,'P1916"}, + {"cpy_z_p_i"_h, "'Vd,'Vd'P1916"}, + {"cpy_z_p_r"_h, "'Vd,'Vd'Rn'Pg"}, + {"cpy_z_p_v"_h, "'Vd,'Vd'Vn'Pg"}, + {"ctermeq_rr"_h, ",'Rn'Rm"}, + {"ctermne_rr"_h, ",'Rn'Rm"}, + {"decb_r_rs"_h, "'Rd,'Rd"}, + {"decd_r_rs"_h, "'Rd,'Rd"}, + {"decd_z_zs"_h, "'Vd,'Vd"}, + {"dech_r_rs"_h, "'Rd,'Rd"}, + {"dech_z_zs"_h, "'Vd,'Vd"}, + {"decp_r_p_r"_h, "'Rd,'Rd'Pn"}, + {"decp_z_p_z"_h, "'Vd,'Vd'Pn"}, + {"decw_r_rs"_h, "'Rd,'Rd"}, + {"decw_z_zs"_h, "'Vd,'Vd"}, + {"dup_z_i"_h, "'Vd,"}, + {"dup_z_r"_h, "'Vd,'Rns"}, + {"dup_z_zi"_h, "'Vd,'Vn"}, + {"dupm_z_i"_h, "'Vd,"}, + {"eor3_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"eor_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"eor_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"eor_z_zi"_h, "'Vd,'Vd"}, + {"eor_z_zz"_h, "'Vd,'Vn'Vm"}, + {"eorbt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"eors_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"eortb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"eorv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"ext_z_zi_con"_h, "'Vd,'Vn'Vn+1"}, + {"ext_z_zi_des"_h, "'Vd,'Vd'Vn"}, + {"fabd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fabs_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"facge_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"facgt_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"fadd_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fadd_z_zz"_h, "'Vd,'Vn'Vm"}, + {"fadda_v_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"faddp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"faddv_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"fcadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcmeq_p_p_z0"_h, "'Pd,'Vn'Pg"}, + {"fcmeq_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"fcmge_p_p_z0"_h, "'Pd,'Vn'Pg"}, + {"fcmge_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"fcmgt_p_p_z0"_h, "'Pd,'Vn'Pg"}, + {"fcmgt_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"fcmla_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fcmla_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"fcmla_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1916"}, + {"fcmle_p_p_z0"_h, "'Pd,'Vn'Pg"}, + {"fcmlt_p_p_z0"_h, "'Pd,'Vn'Pg"}, + {"fcmne_p_p_z0"_h, "'Pd,'Vn'Pg"}, + {"fcmne_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"fcmuo_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"fcpy_z_p_i"_h, "'Vd,'Vd'P1916"}, + {"fcvt_z_p_z_d2h"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvt_z_p_z_d2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvt_z_p_z_h2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvt_z_p_z_h2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvt_z_p_z_s2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvt_z_p_z_s2h"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtlt_z_p_z_h2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtlt_z_p_z_s2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtnt_z_p_z_d2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtnt_z_p_z_s2h"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtx_z_p_z_d2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtxnt_z_p_z_d2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_d2w"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_d2x"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_fp162h"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_fp162w"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_fp162x"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_s2w"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzs_z_p_z_s2x"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_d2w"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_d2x"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_fp162h"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_fp162w"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_fp162x"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_s2w"_h, "'Vd,'Vd'Vn'Pg"}, + {"fcvtzu_z_p_z_s2x"_h, "'Vd,'Vd'Vn'Pg"}, + {"fdiv_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fdivr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fdup_z_i"_h, "'Vd,"}, + {"fexpa_z_z"_h, "'Vd,'Vn"}, + {"flogb_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"fmad_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fmax_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fmax_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fmaxnm_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fmaxnm_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fmaxnmp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fmaxnmv_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"fmaxp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fmaxv_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"fmin_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fmin_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fminnm_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fminnm_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fminnmp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fminnmv_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"fminp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fminv_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"fmla_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fmla_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmla_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmla_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmlalb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmlalb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmlalt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmlalt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmls_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fmls_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"fmls_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmls_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmlslb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmlslb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmlslt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmlslt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"fmmla_z_zzz_d"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmmla_z_zzz_s"_h, "'Vd,'Vd'Vn'Vm"}, + {"fmsb_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fmul_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fmul_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fmul_z_zz"_h, "'Vd,'Vn'Vm"}, + {"fmul_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"fmul_z_zzi_h"_h, "'Vd,'Vn'V1816"}, + {"fmul_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"fmulx_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fneg_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"fnmad_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fnmla_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fnmls_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"fnmsb_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"frecpe_z_z"_h, "'Vd,'Vn"}, + {"frecps_z_zz"_h, "'Vd,'Vn'Vm"}, + {"frecpx_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frinta_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frinti_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frintm_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frintn_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frintp_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frintx_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frintz_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"frsqrte_z_z"_h, "'Vd,'Vn"}, + {"frsqrts_z_zz"_h, "'Vd,'Vn'Vm"}, + {"fscale_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fsqrt_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"fsub_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fsub_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"fsub_z_zz"_h, "'Vd,'Vn'Vm"}, + {"fsubr_z_p_zs"_h, "'Vd,'Vd'Pg"}, + {"fsubr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"ftmad_z_zzi"_h, "'Vd,'Vd'Vn"}, + {"ftsmul_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ftssel_z_zz"_h, "'Vd,'Vn'Vm"}, + {"histcnt_z_p_zz"_h, "'Vd,'Vn'Vm'Pg"}, + {"histseg_z_zz"_h, "'Vd,'Vn'Vm"}, + {"incb_r_rs"_h, "'Rd,'Rd"}, + {"incd_r_rs"_h, "'Rd,'Rd"}, + {"incd_z_zs"_h, "'Vd,'Vd"}, + {"inch_r_rs"_h, "'Rd,'Rd"}, + {"inch_z_zs"_h, "'Vd,'Vd"}, + {"incp_r_p_r"_h, "'Rd,'Rd'Pn"}, + {"incp_z_p_z"_h, "'Vd,'Vd'Pn"}, + {"incw_r_rs"_h, "'Rd,'Rd"}, + {"incw_z_zs"_h, "'Vd,'Vd"}, + {"index_z_ii"_h, "'Vd,"}, + {"index_z_ir"_h, "'Vd,'Rm"}, + {"index_z_ri"_h, "'Vd,'Rn"}, + {"index_z_rr"_h, "'Vd,'Rn'Rm"}, + {"insr_z_r"_h, "'Vd,'Vd'Rn"}, + {"insr_z_v"_h, "'Vd,'Vd'Vn"}, + {"lasta_r_p_z"_h, "'Rd,'Vn'Pg"}, + {"lasta_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"lastb_r_p_z"_h, "'Rd,'Vn'Pg"}, + {"lastb_v_p_z"_h, "'Vd,'Vn'Pg"}, + {"ld1b_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1b_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ld1b_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ld1b_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1b_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1b_z_p_bi_u8"_h, "'Vd,'Rns'Pg"}, + {"ld1b_z_p_br_u16"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1b_z_p_br_u32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1b_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1b_z_p_br_u8"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1b_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1b_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1b_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1d_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1d_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1d_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1d_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1d_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1d_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1d_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1h_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1h_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ld1h_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ld1h_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1h_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1h_z_p_br_u16"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1h_z_p_br_u32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1h_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1h_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1h_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1h_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1h_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1h_z_p_bz_s_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1h_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1rb_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ld1rb_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1rb_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1rb_z_p_bi_u8"_h, "'Vd,'Rns'Pg"}, + {"ld1rd_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1rh_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ld1rh_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1rh_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1rob_z_p_bi_u8"_h, "'Vd,'Rns'Pg"}, + {"ld1rob_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1rod_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1rod_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1roh_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ld1roh_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1row_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1row_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1rqb_z_p_bi_u8"_h, "'Vd,'Rns'Pg"}, + {"ld1rqb_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1rqd_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1rqd_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1rqh_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ld1rqh_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1rqw_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1rqw_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1rsb_z_p_bi_s16"_h, "'Vd,'Rns'Pg"}, + {"ld1rsb_z_p_bi_s32"_h, "'Vd,'Rns'Pg"}, + {"ld1rsb_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ld1rsh_z_p_bi_s32"_h, "'Vd,'Rns'Pg"}, + {"ld1rsh_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ld1rsw_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ld1rw_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1rw_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1sb_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1sb_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ld1sb_z_p_bi_s16"_h, "'Vd,'Rns'Pg"}, + {"ld1sb_z_p_bi_s32"_h, "'Vd,'Rns'Pg"}, + {"ld1sb_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ld1sb_z_p_br_s16"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1sb_z_p_br_s32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1sb_z_p_br_s64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1sb_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sb_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sb_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sh_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1sh_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ld1sh_z_p_bi_s32"_h, "'Vd,'Rns'Pg"}, + {"ld1sh_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ld1sh_z_p_br_s32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1sh_z_p_br_s64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1sh_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sh_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sh_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sh_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sh_z_p_bz_s_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sh_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sw_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1sw_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ld1sw_z_p_br_s64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1sw_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sw_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sw_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1sw_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1w_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ld1w_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ld1w_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ld1w_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ld1w_z_p_br_u32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1w_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ld1w_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1w_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1w_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1w_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1w_z_p_bz_s_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld1w_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ld2b_z_p_bi_contiguous"_h, "'Vd'Vd+1,'Rns'Pg"}, + {"ld2b_z_p_br_contiguous"_h, "'Vd'Vd+1,'Rns'Rm'Pg"}, + {"ld2d_z_p_bi_contiguous"_h, "'Vd'Vd+1,'Rns'Pg"}, + {"ld2d_z_p_br_contiguous"_h, "'Vd'Vd+1,'Rns'Rm'Pg"}, + {"ld2h_z_p_bi_contiguous"_h, "'Vd'Vd+1,'Rns'Pg"}, + {"ld2h_z_p_br_contiguous"_h, "'Vd'Vd+1,'Rns'Rm'Pg"}, + {"ld2w_z_p_bi_contiguous"_h, "'Vd'Vd+1,'Rns'Pg"}, + {"ld2w_z_p_br_contiguous"_h, "'Vd'Vd+1,'Rns'Rm'Pg"}, + {"ld3b_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Pg"}, + {"ld3b_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Rm'Pg"}, + {"ld3d_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Pg"}, + {"ld3d_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Rm'Pg"}, + {"ld3h_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Pg"}, + {"ld3h_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Rm'Pg"}, + {"ld3w_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Pg"}, + {"ld3w_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2,'Rns'Rm'Pg"}, + {"ld4b_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Pg"}, + {"ld4b_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Rm'Pg"}, + {"ld4d_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Pg"}, + {"ld4d_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Rm'Pg"}, + {"ld4h_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Pg"}, + {"ld4h_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Rm'Pg"}, + {"ld4w_z_p_bi_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Pg"}, + {"ld4w_z_p_br_contiguous"_h, "'Vd'Vd+1'Vd+2'Vd+3,'Rns'Rm'Pg"}, + {"ldff1b_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1b_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ldff1b_z_p_br_u16"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1b_z_p_br_u32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1b_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1b_z_p_br_u8"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1b_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1b_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1b_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1d_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1d_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1d_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1d_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1d_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1d_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1h_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1h_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ldff1h_z_p_br_u16"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1h_z_p_br_u32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1h_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1h_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1h_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1h_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1h_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1h_z_p_bz_s_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1h_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sb_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1sb_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ldff1sb_z_p_br_s16"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1sb_z_p_br_s32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1sb_z_p_br_s64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1sb_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sb_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sb_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sh_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1sh_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ldff1sh_z_p_br_s32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1sh_z_p_br_s64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1sh_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sh_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sh_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sh_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sh_z_p_bz_s_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sh_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sw_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1sw_z_p_br_s64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1sw_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sw_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sw_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1sw_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1w_z_p_ai_d"_h, "'Vd,'Vn'Pg"}, + {"ldff1w_z_p_ai_s"_h, "'Vd,'Vn'Pg"}, + {"ldff1w_z_p_br_u32"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1w_z_p_br_u64"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldff1w_z_p_bz_d_64_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1w_z_p_bz_d_64_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1w_z_p_bz_d_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1w_z_p_bz_d_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1w_z_p_bz_s_x32_scaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldff1w_z_p_bz_s_x32_unscaled"_h, "'Vd,'Rns'Vm'Pg"}, + {"ldnf1b_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ldnf1b_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ldnf1b_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ldnf1b_z_p_bi_u8"_h, "'Vd,'Rns'Pg"}, + {"ldnf1d_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ldnf1h_z_p_bi_u16"_h, "'Vd,'Rns'Pg"}, + {"ldnf1h_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ldnf1h_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ldnf1sb_z_p_bi_s16"_h, "'Vd,'Rns'Pg"}, + {"ldnf1sb_z_p_bi_s32"_h, "'Vd,'Rns'Pg"}, + {"ldnf1sb_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ldnf1sh_z_p_bi_s32"_h, "'Vd,'Rns'Pg"}, + {"ldnf1sh_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ldnf1sw_z_p_bi_s64"_h, "'Vd,'Rns'Pg"}, + {"ldnf1w_z_p_bi_u32"_h, "'Vd,'Rns'Pg"}, + {"ldnf1w_z_p_bi_u64"_h, "'Vd,'Rns'Pg"}, + {"ldnt1b_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1b_z_p_ar_s_x32_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1b_z_p_bi_contiguous"_h, "'Vd,'Rns'Pg"}, + {"ldnt1b_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldnt1d_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1d_z_p_bi_contiguous"_h, "'Vd,'Rns'Pg"}, + {"ldnt1d_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldnt1h_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1h_z_p_ar_s_x32_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1h_z_p_bi_contiguous"_h, "'Vd,'Rns'Pg"}, + {"ldnt1h_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldnt1sb_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1sb_z_p_ar_s_x32_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1sh_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1sh_z_p_ar_s_x32_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1sw_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1w_z_p_ar_d_64_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1w_z_p_ar_s_x32_unscaled"_h, "'Vd,'Vn'Rm'Pg"}, + {"ldnt1w_z_p_bi_contiguous"_h, "'Vd,'Rns'Pg"}, + {"ldnt1w_z_p_br_contiguous"_h, "'Vd,'Rns'Rm'Pg"}, + {"ldr_p_bi"_h, "'Pd,'Rns"}, + {"ldr_z_bi"_h, "'Vd,'Rns"}, + {"lsl_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"lsl_z_p_zw"_h, "'Vd,'Vd'Vn'Pg"}, + {"lsl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"lsl_z_zi"_h, "'Vd,'Vn"}, + {"lsl_z_zw"_h, "'Vd,'Vn'Vm"}, + {"lslr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"lsr_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"lsr_z_p_zw"_h, "'Vd,'Vd'Vn'Pg"}, + {"lsr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"lsr_z_zi"_h, "'Vd,'Vn"}, + {"lsr_z_zw"_h, "'Vd,'Vn'Vm"}, + {"lsrr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"mad_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"match_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"mla_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"mla_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"mla_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"mla_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"mls_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"mls_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"mls_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"mls_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"movprfx_z_p_z"_h, "'Vd,'Vd?16'Vn'Pg"}, + {"movprfx_z_z"_h, "'Vd,'Vn"}, + {"msb_z_p_zzz"_h, "'Vd,'Vd'Vn'Vm'Pg"}, + {"mul_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"mul_z_zi"_h, "'Vd,'Vd"}, + {"mul_z_zz"_h, "'Vd,'Vn'Vm"}, + {"mul_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"mul_z_zzi_h"_h, "'Vd,'Vn'V1816"}, + {"mul_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"nand_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"nands_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"nbsl_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"neg_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"nmatch_p_p_zz"_h, "'Pd,'Vn'Vm'Pg"}, + {"nor_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"nors_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"not_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"orn_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"orns_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"orr_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"orr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"orr_z_zi"_h, "'Vd,'Vd"}, + {"orr_z_zz"_h, "'Vd,'Vn'Vm"}, + {"orrs_p_p_pp_z"_h, "'Pd,'Pn'Pm'P1310"}, + {"orv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"pfalse_p"_h, "'Pd,"}, + {"pfirst_p_p_p"_h, "'Pd,'Pd'Pn"}, + {"pmul_z_zz"_h, "'Vd,'Vn'Vm"}, + {"pmullb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"pmullt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"pnext_p_p_p"_h, "'Pd,'Pd'Pn"}, + {"prfb_i_p_ai_d"_h, ",'Vn'Pg"}, + {"prfb_i_p_ai_s"_h, ",'Vn'Pg"}, + {"prfb_i_p_bi_s"_h, ",'Rns'Pg"}, + {"prfb_i_p_br_s"_h, ",'Rns'Rm'Pg"}, + {"prfb_i_p_bz_d_64_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfb_i_p_bz_d_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfb_i_p_bz_s_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfd_i_p_ai_d"_h, ",'Vn'Pg"}, + {"prfd_i_p_ai_s"_h, ",'Vn'Pg"}, + {"prfd_i_p_bi_s"_h, ",'Rns'Pg"}, + {"prfd_i_p_br_s"_h, ",'Rns'Rm'Pg"}, + {"prfd_i_p_bz_d_64_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfd_i_p_bz_d_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfd_i_p_bz_s_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfh_i_p_ai_d"_h, ",'Vn'Pg"}, + {"prfh_i_p_ai_s"_h, ",'Vn'Pg"}, + {"prfh_i_p_bi_s"_h, ",'Rns'Pg"}, + {"prfh_i_p_br_s"_h, ",'Rns'Rm'Pg"}, + {"prfh_i_p_bz_d_64_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfh_i_p_bz_d_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfh_i_p_bz_s_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfw_i_p_ai_d"_h, ",'Vn'Pg"}, + {"prfw_i_p_ai_s"_h, ",'Vn'Pg"}, + {"prfw_i_p_bi_s"_h, ",'Rns'Pg"}, + {"prfw_i_p_br_s"_h, ",'Rns'Rm'Pg"}, + {"prfw_i_p_bz_d_64_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfw_i_p_bz_d_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"prfw_i_p_bz_s_x32_scaled"_h, ",'Rns'Vm'Pg"}, + {"ptest_p_p"_h, ",'P1310'Pn"}, + {"ptrue_p_s"_h, "'Pd,"}, + {"ptrues_p_s"_h, "'Pd,"}, + {"punpkhi_p_p"_h, "'Pd,'Pn"}, + {"punpklo_p_p"_h, "'Pd,'Pn"}, + {"raddhnb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"raddhnt_z_zz"_h, "'Vd,'Vd'Vn'Vm"}, + {"rax1_z_zz"_h, "'Vd,'Vn'Vm"}, + {"rbit_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"rdffr_p_f"_h, "'Pd,"}, + {"rdffr_p_p_f"_h, "'Pd,'Pn"}, + {"rdffrs_p_p_f"_h, "'Pd,'Pn"}, + {"rdvl_r_i"_h, "'Rd,"}, + {"rev_p_p"_h, "'Pd,'Pn"}, + {"rev_z_z"_h, "'Vd,'Vn"}, + {"revb_z_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"revh_z_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"revw_z_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"rshrnb_z_zi"_h, "'Vd,'Vn"}, + {"rshrnt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"rsubhnb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"rsubhnt_z_zz"_h, "'Vd,'Vd'Vn'Vm"}, + {"saba_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sabalb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sabalt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sabd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sabdlb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sabdlt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sadalp_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"saddlb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"saddlbt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"saddlt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"saddv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"saddwb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"saddwt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sbclb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sbclt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"scvtf_z_p_z_h2fp16"_h, "'Vd,'Vd'Vn'Pg"}, + {"scvtf_z_p_z_w2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"scvtf_z_p_z_w2fp16"_h, "'Vd,'Vd'Vn'Pg"}, + {"scvtf_z_p_z_w2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"scvtf_z_p_z_x2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"scvtf_z_p_z_x2fp16"_h, "'Vd,'Vd'Vn'Pg"}, + {"scvtf_z_p_z_x2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"sdiv_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sdivr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sdot_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sdot_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sdot_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sel_p_p_pp"_h, "'Pd,'Pn'Pm'P1310"}, + {"sel_z_p_zz"_h, "'Vd,'Vn'Vm'P1310"}, + {"setffr_f"_h, ","}, + {"shadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"shrnb_z_zi"_h, "'Vd,'Vn"}, + {"shrnt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"shsub_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"shsubr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sli_z_zzi"_h, "'Vd,'Vd'Vn"}, + {"smax_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"smax_z_zi"_h, "'Vd,'Vd"}, + {"smaxp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"smaxv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"smin_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"smin_z_zi"_h, "'Vd,'Vd"}, + {"sminp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sminv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"smlalb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"smlalb_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"smlalb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"smlalt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"smlalt_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"smlalt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"smlslb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"smlslb_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"smlslb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"smlslt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"smlslt_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"smlslt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"smmla_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"smulh_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"smulh_z_zz"_h, "'Vd,'Vn'Vm"}, + {"smullb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"smullb_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"smullb_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"smullt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"smullt_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"smullt_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"splice_z_p_zz_con"_h, "'Vd,'Vn'Vn+1'Pg"}, + {"splice_z_p_zz_des"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqabs_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqadd_z_zi"_h, "'Vd,'Vd"}, + {"sqadd_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sqcadd_z_zz"_h, "'Vd,'Vd'Vn"}, + {"sqdecb_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqdecb_r_rs_x"_h, "'Rd,'Rd"}, + {"sqdecd_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqdecd_r_rs_x"_h, "'Rd,'Rd"}, + {"sqdecd_z_zs"_h, "'Vd,'Vd"}, + {"sqdech_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqdech_r_rs_x"_h, "'Rd,'Rd"}, + {"sqdech_z_zs"_h, "'Vd,'Vd"}, + {"sqdecp_r_p_r_sx"_h, "'Rd,'Rd'Pn"}, + {"sqdecp_r_p_r_x"_h, "'Rd,'Rd'Pn"}, + {"sqdecp_z_p_z"_h, "'Vd,'Vd'Pn"}, + {"sqdecw_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqdecw_r_rs_x"_h, "'Rd,'Rd"}, + {"sqdecw_z_zs"_h, "'Vd,'Vd"}, + {"sqdmlalb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlalb_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqdmlalb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqdmlalbt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlalt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlalt_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqdmlalt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqdmlslb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlslb_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqdmlslb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqdmlslbt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlslt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqdmlslt_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqdmlslt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqdmulh_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sqdmulh_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"sqdmulh_z_zzi_h"_h, "'Vd,'Vn'V1816"}, + {"sqdmulh_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"sqdmullb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sqdmullb_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"sqdmullb_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"sqdmullt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sqdmullt_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"sqdmullt_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"sqincb_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqincb_r_rs_x"_h, "'Rd,'Rd"}, + {"sqincd_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqincd_r_rs_x"_h, "'Rd,'Rd"}, + {"sqincd_z_zs"_h, "'Vd,'Vd"}, + {"sqinch_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqinch_r_rs_x"_h, "'Rd,'Rd"}, + {"sqinch_z_zs"_h, "'Vd,'Vd"}, + {"sqincp_r_p_r_sx"_h, "'Rd,'Rd'Pn"}, + {"sqincp_r_p_r_x"_h, "'Rd,'Rd'Pn"}, + {"sqincp_z_p_z"_h, "'Vd,'Vd'Pn"}, + {"sqincw_r_rs_sx"_h, "'Rd,'Rd"}, + {"sqincw_r_rs_x"_h, "'Rd,'Rd"}, + {"sqincw_z_zs"_h, "'Vd,'Vd"}, + {"sqneg_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqrdcmlah_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdcmlah_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqrdcmlah_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqrdmlah_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdmlah_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqrdmlah_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqrdmlah_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqrdmlsh_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"sqrdmlsh_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"sqrdmlsh_z_zzzi_h"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqrdmlsh_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sqrdmulh_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sqrdmulh_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"sqrdmulh_z_zzi_h"_h, "'Vd,'Vn'V1816"}, + {"sqrdmulh_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"sqrshl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqrshlr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqrshrnb_z_zi"_h, "'Vd,'Vn"}, + {"sqrshrnt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"sqrshrunb_z_zi"_h, "'Vd,'Vn"}, + {"sqrshrunt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"sqshl_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"sqshl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqshlr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqshlu_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"sqshrnb_z_zi"_h, "'Vd,'Vn"}, + {"sqshrnt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"sqshrunb_z_zi"_h, "'Vd,'Vn"}, + {"sqshrunt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"sqsub_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqsub_z_zi"_h, "'Vd,'Vd"}, + {"sqsub_z_zz"_h, "'Vd,'Vn'Vm"}, + {"sqsubr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sqxtnb_z_zz"_h, "'Vd,'Vn"}, + {"sqxtnt_z_zz"_h, "'Vd,'Vd'Vn"}, + {"sqxtunb_z_zz"_h, "'Vd,'Vn"}, + {"sqxtunt_z_zz"_h, "'Vd,'Vd'Vn"}, + {"srhadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sri_z_zzi"_h, "'Vd,'Vd'Vn"}, + {"srshl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"srshlr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"srshr_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"srsra_z_zi"_h, "'Vd,'Vd'Vn"}, + {"sshllb_z_zi"_h, "'Vd,'Vn"}, + {"sshllt_z_zi"_h, "'Vd,'Vn"}, + {"ssra_z_zi"_h, "'Vd,'Vd'Vn"}, + {"ssublb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ssublbt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ssublt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ssubltb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ssubwb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ssubwt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"st1b_z_p_ai_d"_h, ",'Vd'Vn'Pg"}, + {"st1b_z_p_ai_s"_h, ",'Vd'Vn'Pg"}, + {"st1b_z_p_bi"_h, ",'Vd'Rns'Pg"}, + {"st1b_z_p_br"_h, ",'Vd'Rns'Rm'Pg"}, + {"st1b_z_p_bz_d_64_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1b_z_p_bz_d_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1b_z_p_bz_s_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1d_z_p_ai_d"_h, ",'Vd'Vn'Pg"}, + {"st1d_z_p_bi"_h, ",'Vd'Rns'Pg"}, + {"st1d_z_p_br"_h, ",'Vd'Rns'Rm'Pg"}, + {"st1d_z_p_bz_d_64_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1d_z_p_bz_d_64_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1d_z_p_bz_d_x32_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1d_z_p_bz_d_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1h_z_p_ai_d"_h, ",'Vd'Vn'Pg"}, + {"st1h_z_p_ai_s"_h, ",'Vd'Vn'Pg"}, + {"st1h_z_p_bi"_h, ",'Vd'Rns'Pg"}, + {"st1h_z_p_br"_h, ",'Vd'Rns'Rm'Pg"}, + {"st1h_z_p_bz_d_64_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1h_z_p_bz_d_64_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1h_z_p_bz_d_x32_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1h_z_p_bz_d_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1h_z_p_bz_s_x32_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1h_z_p_bz_s_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1w_z_p_ai_d"_h, ",'Vd'Vn'Pg"}, + {"st1w_z_p_ai_s"_h, ",'Vd'Vn'Pg"}, + {"st1w_z_p_bi"_h, ",'Vd'Rns'Pg"}, + {"st1w_z_p_br"_h, ",'Vd'Rns'Rm'Pg"}, + {"st1w_z_p_bz_d_64_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1w_z_p_bz_d_64_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1w_z_p_bz_d_x32_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1w_z_p_bz_d_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1w_z_p_bz_s_x32_scaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st1w_z_p_bz_s_x32_unscaled"_h, ",'Vd'Rns'Vm'Pg"}, + {"st2b_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Rns'Pg"}, + {"st2b_z_p_br_contiguous"_h, ",'Vd'Vd+1'Rns'Rm'Pg"}, + {"st2d_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Rns'Pg"}, + {"st2d_z_p_br_contiguous"_h, ",'Vd'Vd+1'Rns'Rm'Pg"}, + {"st2h_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Rns'Pg"}, + {"st2h_z_p_br_contiguous"_h, ",'Vd'Vd+1'Rns'Rm'Pg"}, + {"st2w_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Rns'Pg"}, + {"st2w_z_p_br_contiguous"_h, ",'Vd'Vd+1'Rns'Rm'Pg"}, + {"st3b_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Pg"}, + {"st3b_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Rm'Pg"}, + {"st3d_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Pg"}, + {"st3d_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Rm'Pg"}, + {"st3h_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Pg"}, + {"st3h_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Rm'Pg"}, + {"st3w_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Pg"}, + {"st3w_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Rns'Rm'Pg"}, + {"st4b_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Pg"}, + {"st4b_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm'Pg"}, + {"st4d_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Pg"}, + {"st4d_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm'Pg"}, + {"st4h_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Pg"}, + {"st4h_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm'Pg"}, + {"st4w_z_p_bi_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Pg"}, + {"st4w_z_p_br_contiguous"_h, ",'Vd'Vd+1'Vd+2'Vd+3'Rns'Rm'Pg"}, + {"stnt1b_z_p_ar_d_64_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1b_z_p_ar_s_x32_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1b_z_p_bi_contiguous"_h, ",'Vd'Rns'Pg"}, + {"stnt1b_z_p_br_contiguous"_h, ",'Vd'Rns'Rm'Pg"}, + {"stnt1d_z_p_ar_d_64_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1d_z_p_bi_contiguous"_h, ",'Vd'Rns'Pg"}, + {"stnt1d_z_p_br_contiguous"_h, ",'Vd'Rns'Rm'Pg"}, + {"stnt1h_z_p_ar_d_64_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1h_z_p_ar_s_x32_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1h_z_p_bi_contiguous"_h, ",'Vd'Rns'Pg"}, + {"stnt1h_z_p_br_contiguous"_h, ",'Vd'Rns'Rm'Pg"}, + {"stnt1w_z_p_ar_d_64_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1w_z_p_ar_s_x32_unscaled"_h, ",'Vd'Vn'Rm'Pg"}, + {"stnt1w_z_p_bi_contiguous"_h, ",'Vd'Rns'Pg"}, + {"stnt1w_z_p_br_contiguous"_h, ",'Vd'Rns'Rm'Pg"}, + {"str_p_bi"_h, ",'Pd'Rns"}, + {"str_z_bi"_h, ",'Vd'Rns"}, + {"sub_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sub_z_zi"_h, "'Vd,'Vd"}, + {"sub_z_zz"_h, "'Vd,'Vn'Vm"}, + {"subhnb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"subhnt_z_zz"_h, "'Vd,'Vd'Vn'Vm"}, + {"subr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"subr_z_zi"_h, "'Vd,'Vd"}, + {"sudot_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"sunpkhi_z_z"_h, "'Vd,'Vn"}, + {"sunpklo_z_z"_h, "'Vd,'Vn"}, + {"suqadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"sxtb_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"sxth_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"sxtw_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"tbl_z_zz_1"_h, "'Vd,'Vn'Vm"}, + {"tbl_z_zz_2"_h, "'Vd,'Vn'Vn+1'Vm"}, + {"tbx_z_zz"_h, "'Vd,'Vd'Vn'Vm"}, + {"trn1_p_pp"_h, "'Pd,'Pn'Pm"}, + {"trn1_z_zz"_h, "'Vd,'Vn'Vm"}, + {"trn2_p_pp"_h, "'Pd,'Pn'Pm"}, + {"trn2_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uaba_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"uabalb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"uabalt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"uabd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uabdlb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uabdlt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uadalp_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"uaddlb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uaddlt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uaddv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"uaddwb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uaddwt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"ucvtf_z_p_z_h2fp16"_h, "'Vd,'Vd'Vn'Pg"}, + {"ucvtf_z_p_z_w2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"ucvtf_z_p_z_w2fp16"_h, "'Vd,'Vd'Vn'Pg"}, + {"ucvtf_z_p_z_w2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"ucvtf_z_p_z_x2d"_h, "'Vd,'Vd'Vn'Pg"}, + {"ucvtf_z_p_z_x2fp16"_h, "'Vd,'Vd'Vn'Pg"}, + {"ucvtf_z_p_z_x2s"_h, "'Vd,'Vd'Vn'Pg"}, + {"udiv_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"udivr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"udot_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"udot_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"udot_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"uhadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uhsub_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uhsubr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"umax_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"umax_z_zi"_h, "'Vd,'Vd"}, + {"umaxp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"umaxv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"umin_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"umin_z_zi"_h, "'Vd,'Vd"}, + {"uminp_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uminv_r_p_z"_h, "'Vd,'Vn'Pg"}, + {"umlalb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"umlalb_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"umlalb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"umlalt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"umlalt_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"umlalt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"umlslb_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"umlslb_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"umlslb_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"umlslt_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"umlslt_z_zzzi_d"_h, "'Vd,'Vd'Vn'V1916"}, + {"umlslt_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"ummla_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"umulh_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"umulh_z_zz"_h, "'Vd,'Vn'Vm"}, + {"umullb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"umullb_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"umullb_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"umullt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"umullt_z_zzi_d"_h, "'Vd,'Vn'V1916"}, + {"umullt_z_zzi_s"_h, "'Vd,'Vn'V1816"}, + {"uqadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqadd_z_zi"_h, "'Vd,'Vd"}, + {"uqadd_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uqdecb_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqdecb_r_rs_x"_h, "'Rd,'Rd"}, + {"uqdecd_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqdecd_r_rs_x"_h, "'Rd,'Rd"}, + {"uqdecd_z_zs"_h, "'Vd,'Vd"}, + {"uqdech_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqdech_r_rs_x"_h, "'Rd,'Rd"}, + {"uqdech_z_zs"_h, "'Vd,'Vd"}, + {"uqdecp_r_p_r_uw"_h, "'Rd,'Rd'Pn"}, + {"uqdecp_r_p_r_x"_h, "'Rd,'Rd'Pn"}, + {"uqdecp_z_p_z"_h, "'Vd,'Vd'Pn"}, + {"uqdecw_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqdecw_r_rs_x"_h, "'Rd,'Rd"}, + {"uqdecw_z_zs"_h, "'Vd,'Vd"}, + {"uqincb_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqincb_r_rs_x"_h, "'Rd,'Rd"}, + {"uqincd_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqincd_r_rs_x"_h, "'Rd,'Rd"}, + {"uqincd_z_zs"_h, "'Vd,'Vd"}, + {"uqinch_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqinch_r_rs_x"_h, "'Rd,'Rd"}, + {"uqinch_z_zs"_h, "'Vd,'Vd"}, + {"uqincp_r_p_r_uw"_h, "'Rd,'Rd'Pn"}, + {"uqincp_r_p_r_x"_h, "'Rd,'Rd'Pn"}, + {"uqincp_z_p_z"_h, "'Vd,'Vd'Pn"}, + {"uqincw_r_rs_uw"_h, "'Rd,'Rd"}, + {"uqincw_r_rs_x"_h, "'Rd,'Rd"}, + {"uqincw_z_zs"_h, "'Vd,'Vd"}, + {"uqrshl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqrshlr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqrshrnb_z_zi"_h, "'Vd,'Vn"}, + {"uqrshrnt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"uqshl_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"uqshl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqshlr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqshrnb_z_zi"_h, "'Vd,'Vn"}, + {"uqshrnt_z_zi"_h, "'Vd,'Vd'Vn"}, + {"uqsub_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqsub_z_zi"_h, "'Vd,'Vd"}, + {"uqsub_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uqsubr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"uqxtnb_z_zz"_h, "'Vd,'Vn"}, + {"uqxtnt_z_zz"_h, "'Vd,'Vd'Vn"}, + {"urecpe_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"urhadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"urshl_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"urshlr_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"urshr_z_p_zi"_h, "'Vd,'Vd'Pg"}, + {"ursqrte_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"ursra_z_zi"_h, "'Vd,'Vd'Vn"}, + {"usdot_z_zzz_s"_h, "'Vd,'Vd'Vn'Vm"}, + {"usdot_z_zzzi_s"_h, "'Vd,'Vd'Vn'V1816"}, + {"ushllb_z_zi"_h, "'Vd,'Vn"}, + {"ushllt_z_zi"_h, "'Vd,'Vn"}, + {"usmmla_z_zzz"_h, "'Vd,'Vd'Vn'Vm"}, + {"usqadd_z_p_zz"_h, "'Vd,'Vd'Vn'Pg"}, + {"usra_z_zi"_h, "'Vd,'Vd'Vn"}, + {"usublb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"usublt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"usubwb_z_zz"_h, "'Vd,'Vn'Vm"}, + {"usubwt_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uunpkhi_z_z"_h, "'Vd,'Vn"}, + {"uunpklo_z_z"_h, "'Vd,'Vn"}, + {"uxtb_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"uxth_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"uxtw_z_p_z"_h, "'Vd,'Vd'Vn'Pg"}, + {"uzp1_p_pp"_h, "'Pd,'Pn'Pm"}, + {"uzp1_z_zz"_h, "'Vd,'Vn'Vm"}, + {"uzp2_p_pp"_h, "'Pd,'Pn'Pm"}, + {"uzp2_z_zz"_h, "'Vd,'Vn'Vm"}, + {"whilege_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilegt_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilehi_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilehs_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilele_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilelo_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilels_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilelt_p_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilerw_p_rr"_h, "'Pd,'Rn'Rm"}, + {"whilewr_p_rr"_h, "'Pd,'Rn'Rm"}, + {"wrffr_f_p"_h, ",'Pn"}, + {"xar_z_zzi"_h, "'Vd,'Vd'Vn"}, + {"zip1_p_pp"_h, "'Pd,'Pn'Pm"}, + {"zip1_z_zz"_h, "'Vd,'Vn'Vm"}, + {"zip2_p_pp"_h, "'Pd,'Pn'Pm"}, + {"zip2_z_zz"_h, "'Vd,'Vn'Vm"}, + }; + return &data; +} // NOLINT(readability/fn_size) + +} // namespace aarch64 +} // namespace vixl diff --git a/src/aarch64/io-reporter-aarch64.h b/src/aarch64/io-reporter-aarch64.h new file mode 100644 index 00000000..3aba7d09 --- /dev/null +++ b/src/aarch64/io-reporter-aarch64.h @@ -0,0 +1,94 @@ +// Copyright 2022, VIXL authors +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of Arm Limited nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#ifndef VIXL_AARCH64_IO_REPORTER_AARCH64_H_ +#define VIXL_AARCH64_IO_REPORTER_AARCH64_H_ + +#include +#include + +#include "decoder-aarch64.h" +#include "registers-aarch64.h" + +namespace vixl { +namespace aarch64 { + +class IOReporter : public DecoderVisitor { + public: + IOReporter() {} + + virtual void Visit(Metadata* metadata, + const Instruction* instr) VIXL_OVERRIDE; + + // Clear the contents of the seen register storage. + void Reset() { + source_.clear(); + destination_.clear(); + } + + // Return the set of source and destination registers. + std::unordered_set GetSourceRegisters() const { return source_; } + std::unordered_set GetDestinationRegisters() const { + return destination_; + } + + private: + // Given a form, look up the source and desination registers it uses. + using FormToRegisterUseMap = std::unordered_map; + static const FormToRegisterUseMap* GetFormToRegisterUseMap(); + + // Return the register this token represents by examining the encoding of the + // instruction. + // There are four types of token that represent how to decode the registers + // used by an instruction: + // 'R - integer register bank, representing 64-bit registers x0-x30 and sp. + // 'V - vector register bank, representing registers v0-v31, including + // overlapping z registers. + // 'P - predicate register bank, representing registers p0-p15. + // 'I - implicit registers, where an instruction encodes no explicit + // register, but uses one implicitly, eg. bl or autia1716. These are + // assumed to be in the integer register bank. + // A token is between two (eg. Rd) and five (eg. V1816) characters long. + CPURegister GetRegisterForToken(const Instruction* instr, + const std::string& t); + + // Add entries to the source and destination register sets using the tokens + // for this instruction. + void AddRegistersFromTokens(const Instruction* instr, const std::string& s); + + // Convert the first two digit characters in s into a value between 0 and 31. + // Commonly used to convert a bit position in a token to a number. + uint32_t GetFiveBitNumberFromString(const std::string& s); + + // The sets of source and destination registers seen so far. + std::unordered_set source_; + std::unordered_set destination_; +}; + +} // namespace aarch64 +} // namespace vixl + +#endif // VIXL_AARCH64_IO_REPORTER_AARCH64_H_ diff --git a/src/aarch64/registers-aarch64.cc b/src/aarch64/registers-aarch64.cc index 90201a60..5c34bf06 100644 --- a/src/aarch64/registers-aarch64.cc +++ b/src/aarch64/registers-aarch64.cc @@ -54,6 +54,16 @@ std::string CPURegister::GetArchitecturalName() const { name << "/z"; break; } + } else if (IsRegister()) { + if (IsZero()) { + name << "xzr"; + } else if (IsSP()) { + name << "sp"; + } else { + name << 'x' << GetCode(); + } + } else if (IsVRegister()) { + name << 'v' << GetCode(); } else { VIXL_UNIMPLEMENTED(); } diff --git a/src/aarch64/registers-aarch64.h b/src/aarch64/registers-aarch64.h index f9a6d897..ee9a0e21 100644 --- a/src/aarch64/registers-aarch64.h +++ b/src/aarch64/registers-aarch64.h @@ -264,6 +264,24 @@ class CPURegister { } } + // The equivalence operator is newer than Is() above, and does not provide the + // legacy behaviour relating to W and X registers. Consequently, it doesn't + // wrap Is(). + bool operator==(const CPURegister& other) const { + return GetEncodedCPURegister() == other.GetEncodedCPURegister(); + } + + // Combine the data fields of the object and return as a single value. The + // encoding is intended to be opaque, and may change between versions. + uint64_t GetEncodedCPURegister() const { + uint64_t result = lane_size_; + result = (result << 8) | qualifiers_; + result = (result << 8) | size_; + result = (result << 8) | bank_; + result = (result << 8) | code_; + return result; + } + // Conversions to specific register types. The result is a register that // aliases the original CPURegister. That is, the original register bank // (`GetBank()`) is checked and the code (`GetCode()`) preserved, but all @@ -898,4 +916,14 @@ bool AreSameLaneSize(const CPURegister& reg1, } } // namespace vixl::aarch64 +// Specialised hash for CPURegisters, allowing container construction. +namespace std { +template <> +struct hash { + size_t operator()(const vixl::aarch64::CPURegister& reg) const { + return reg.GetEncodedCPURegister(); + } +}; +} // namespace std + #endif // VIXL_AARCH64_REGISTERS_AARCH64_H_ diff --git a/test/aarch64/test-ior-aarch64.cc b/test/aarch64/test-ior-aarch64.cc new file mode 100644 index 00000000..b5c537a5 --- /dev/null +++ b/test/aarch64/test-ior-aarch64.cc @@ -0,0 +1,5049 @@ +// Copyright 2022, VIXL authors +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of ARM Limited nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +#include +#include +#include + +#include "test-runner.h" + +#include "aarch64/disasm-aarch64.h" +#include "aarch64/io-reporter-aarch64.h" +#include "aarch64/macro-assembler-aarch64.h" +#include "test-ior-aarch64.h" + +namespace vixl { +namespace aarch64 { + +#define R(...) \ + { __VA_ARGS__ } + +// These tests are generated using limited parsing of the Disassembler output +// for randomly encoded instruction inputs, which have then been corrected by +// hand. They use "dci" as that's the simplest way to obtain an instruction +// from random data. +// +// Subsequent tests for new instructions should use normal Assembler methods +// instead, eg. adc(w6, w20, w28) rather than dci(0x1a1c0286). +// +// The grouping below is an arbitrary partitioning into 32-instruction blocks, +// to improve testing speed when executed in parallel. + +TEST(group_0) { + SETUP(); + + CMP_IO(dci(0x0ea0ba38), R(v24), R(v17)); // abs v24.2s, v17.2s + CMP_IO(dci(0x5ee0b9de), R(v30), R(v14)); // abs d30, d14 + CMP_IO(dci(0x0456aa45), R(v5), R(v5, p2, v18)); // abs z5.h, p2/m, z18.h + CMP_IO(dci(0x1a1c0286), R(x6), R(x20, x28)); // adc w6, w20, w28 + CMP_IO(dci(0x9a1c00ef), R(x15), R(x7, x28)); // adc x15, x7, x28 + CMP_IO(dci(0x451ad14c), + R(v12), + R(v12, v10, v26)); // adclb z12.s, z10.s, z26.s + CMP_IO(dci(0x4559d78e), + R(v14), + R(v14, v28, v25)); // adclt z14.d, z28.d, z25.d + CMP_IO(dci(0x3a1c037f), R(), R(x27, x28)); // adcs wzr, w27, w28 + CMP_IO(dci(0xba1c0116), R(x22), R(x8, x28)); // adcs x22, x8, x28 + CMP_IO(dci(0x0b3b27e9), R(x9), R(sp, x27)); // add w9, wsp, w27, uxth #1 + CMP_IO(dci(0x117b33e9), R(x9), R(sp)); // add w9, wsp, #0xecc000 (15515648) + CMP_IO(dci(0x0b1a6b0a), R(x10), R(x24, x26)); // add w10, w24, w26, lsl #26 + CMP_IO(dci(0x8b3b5324), R(x4), R(x25, x27)); // add x4, x25, w27, uxtw #4 + CMP_IO(dci(0x911b5324), R(x4), R(x25)); // add x4, x25, #0x6d4 (1748) + CMP_IO(dci(0x8b5af573), R(x19), R(x11, x26)); // add x19, x11, x26, lsr #61 + CMP_IO(dci(0x0e3d8557), R(v23), R(v10, v29)); // add v23.8b, v10.8b, v29.8b + CMP_IO(dci(0x5efe84b9), R(v25), R(v5, v30)); // add d25, d5, d30 + CMP_IO(dci(0x048009e8), + R(v8), + R(p2, v8, v15)); // add z8.s, p2/m, z8.s, z15.s + CMP_IO(dci(0x2520c0ac), R(v12), R(v12)); // add z12.b, z12.b, #5 + CMP_IO(dci(0x04fd02e1), R(v1), R(v23, v29)); // add z1.d, z23.d, z29.d + CMP_IO(dci(0x919cb516), R(x22), R(x8)); // addg x22, x8, #448, #13 + CMP_IO(dci(0x0e374146), R(v6), R(v10, v23)); // addhn v6.8b, v10.8h, v23.8h + CMP_IO(dci(0x45796125), R(v5), R(v9, v25)); // addhnb z5.b, z9.h, z25.h + CMP_IO(dci(0x45ba66e3), R(v3), R(v3, v23, v26)); // addhnt z3.h, z23.s, z26.s + CMP_IO(dci(0x4e3abc87), R(v7), R(v4, v26)); // addp v7.16b, v4.16b, v26.16b + CMP_IO(dci(0x5ef1b959), R(v25), R(v10)); // addp d25, v10.2d + CMP_IO(dci(0x4491a358), + R(v24), + R(p0, v24, v26)); // addp z24.s, p0/m, z24.s, z26.s + CMP_IO(dci(0x047e5708), R(x8), R(x30)); // addpl x8, x30, #-8 + CMP_IO(dci(0x2b5c6923), R(x3), R(x9, x28)); // adds w3, w9, w28, lsr #26 + CMP_IO(dci(0x2b3b27e9), R(x9), R(sp, x27)); // adds w9, wsp, w27, uxth #1 + CMP_IO(dci(0x317b33e9), R(x9), R(sp)); // adds w9, wsp, #0xecc000 (15515648) + CMP_IO(dci(0xab5cdeba), R(x26), R(x21, x28)); // adds x26, x21, x28, lsr #55 + + CLEANUP(); +} + +TEST(group_1) { + SETUP(); + + CMP_IO(dci(0xab3b5324), R(x4), R(x25, x27)); // adds x4, x25, w27, uxtw #4 + CMP_IO(dci(0xb11b5324), R(x4), R(x25)); // adds x4, x25, #0x6d4 (1748) + CMP_IO(dci(0x0e31b964), R(v4), R(v11)); // addv b4, v11.8b + CMP_IO(dci(0x043d5092), R(x18), R(x29)); // addvl x18, x29, #4 + CMP_IO(dci(0x101d9a1c), R(x28), R()); // adr x28, #+0x3b340 + CMP_IO(dci(0x043baa79), + R(v25), + R(v19, v27)); // adr z25.d, [z19.d, z27.d, sxtw #2] + CMP_IO(dci(0x047ca8ef), + R(v15), + R(v7, v28)); // adr z15.d, [z7.d, z28.d, uxtw #2] + CMP_IO(dci(0x04baafdc), + R(v28), + R(v30, v26)); // adr z28.s, [z30.s, z26.s, lsl #3] + CMP_IO(dci(0xb01a594c), R(x12), R()); // adrp x12, #+0x34b29000 + CMP_IO(dci(0x121c4cfc), R(x28), R(x7)); // and w28, w7, #0xfffff0 + CMP_IO(dci(0x0a9c15db), R(x27), R(x14, x28)); // and w27, w14, w28, asr #5 + CMP_IO(dci(0x927c2dc1), R(x1), R(x14)); // and x1, x14, #0xfff0 + CMP_IO(dci(0x8a5c8b72), R(x18), R(x27, x28)); // and x18, x27, x28, lsr #34 + CMP_IO(dci(0x4e3d1fcd), + R(v13), + R(v30, v29)); // and v13.16b, v30.16b, v29.16b + CMP_IO(dci(0x250d60eb), + R(p11), + R(p8, p7, p13)); // and p11.b, p8/z, p7.b, p13.b + CMP_IO(dci(0x04da01ce), + R(v14), + R(p0, v14, v14)); // and z14.d, p0/m, z14.d, z14.d + CMP_IO(dci(0x05827f22), R(v2), R(v2)); // and z2.d, z2.d, #0xfffe07ffffffffff + CMP_IO(dci(0x043d32fb), R(v27), R(v23, v29)); // and z27.d, z23.d, z29.d + CMP_IO(dci(0x6a5b64e2), R(x2), R(x7, x27)); // ands w2, w7, w27, lsr #25 + CMP_IO(dci(0x721c4cfc), R(x28), R(x7)); // ands w28, w7, #0xfffff0 + CMP_IO(dci(0xea9bef4b), R(x11), R(x26, x27)); // ands x11, x26, x27, asr #59 + CMP_IO(dci(0xf27c2dc1), R(x1), R(x14)); // ands x1, x14, #0xfff0 + CMP_IO(dci(0x254a55c2), + R(p2), + R(p5, p14, p10)); // ands p2.b, p5/z, p14.b, p10.b + CMP_IO(dci(0x045a382a), R(v10), R(p6, v1)); // andv h10, p6, z1.h + CMP_IO(dci(0x04c09ba6), R(v6), R(p6, v6)); // asr z6.d, p6/m, z6.d, #3 + CMP_IO(dci(0x04188cfc), + R(v28), + R(p3, v28, v7)); // asr z28.b, p3/m, z28.b, z7.d + CMP_IO(dci(0x04109f7f), + R(v31), + R(p7, v31, v27)); // asr z31.b, p7/m, z31.b, z27.b + CMP_IO(dci(0x04be9243), R(v3), R(v18)); // asr z3.d, z18.d, #34 + CMP_IO(dci(0x047d83cd), R(v13), R(v30, v29)); // asr z13.h, z30.h, z29.d + CMP_IO(dci(0x044484e2), R(v2), R(p1, v2)); // asrd z2.s, p1/m, z2.s, #25 + CMP_IO(dci(0x0454841d), + R(v29), + R(p1, v29, v0)); // asrr z29.h, p1/m, z29.h, z0.h + CMP_IO(dci(0x1ade2a50), R(x16), R(x18, x30)); // asr w16, w18, w30 + + CLEANUP(); +} + +TEST(group_2) { + SETUP(); + + CMP_IO(dci(0x9ade2b15), R(x21), R(x24, x30)); // asr x21, x24, x30 + CMP_IO(dci(0xdac11b15), R(x21), R(x21, x24)); // autda x21, x24 + CMP_IO(dci(0xdac11e50), R(x16), R(x16, x18)); // autdb x16, x18 + CMP_IO(dci(0xdac13be5), R(x5), R(x5)); // autdza x5 + CMP_IO(dci(0xdac13fe0), R(x0), R(x0)); // autdzb x0 + CMP_IO(dci(0xd503219f), R(x17), R(x17, x16)); // autia1716 + CMP_IO(dci(0xdac11322), R(x2), R(x2, x25)); // autia x2, x25 + CMP_IO(dci(0xd50323bf), R(x30), R(x30, sp)); // autiasp + CMP_IO(dci(0xd503239f), R(x30), R(x30)); // autiaz + CMP_IO(dci(0xd50321df), R(x17), R(x17, x16)); // autib1716 + CMP_IO(dci(0xdac1158b), R(x11), R(x11, x12)); // autib x11, x12 + CMP_IO(dci(0xd50323ff), R(x30), R(x30, sp)); // autibsp + CMP_IO(dci(0xd50323df), R(x30), R(x30)); // autibz + CMP_IO(dci(0xdac133f2), R(x18), R(x18)); // autiza x18 + CMP_IO(dci(0xdac137fb), R(x27), R(x27)); // autizb x27 + CMP_IO(dci(0xd5004d5f), R(), R()); // axflag + CMP_IO(dci(0x159b7cc8), R(), R()); // b #+0x66df320 + CMP_IO(dci(0x549ad628), R(), R()); // b.hi #-0xca53c + CMP_IO(dci(0x047d3a1c), + R(v28), + R(v28, v29, v16)); // bcax z28.d, z28.d, z29.d, z16.d + CMP_IO(dci(0x459ab6e3), R(v3), R(v23, v26)); // bdep z3.s, z23.s, z26.s + CMP_IO(dci(0x4599b39b), R(v27), R(v28, v25)); // bext z27.s, z28.s, z25.s + CMP_IO(dci(0x330075c2), R(x2), R(x2, x14)); // bfxil w2, w14, #0, #30 + CMP_IO(dci(0xb37d7ae1), R(x1), R(x1, x23)); // bfi x1, x23, #3, #31 + CMP_IO(dci(0x4519b9f7), R(v23), R(v15, v25)); // bgrp z23.b, z15.b, z25.b + CMP_IO(dci(0x0a7c0b72), R(x18), R(x27, x28)); // bic w18, w27, w28, lsr #2 + CMP_IO(dci(0x8abc95db), R(x27), R(x14, x28)); // bic x27, x14, x28, asr #37 + CMP_IO(dci(0x2f04b758), R(v24), R(v24)); // bic v24.4h, #0x9a, lsl #8 + CMP_IO(dci(0x2f031645), R(v5), R(v5)); // bic v5.2s, #0x72, lsl #0 + CMP_IO(dci(0x4e7e1f08), R(v8), R(v24, v30)); // bic v8.16b, v24.16b, v30.16b + CMP_IO(dci(0x250d5892), + R(p2), + R(p6, p4, p13)); // bic p2.b, p6/z, p4.b, p13.b + CMP_IO(dci(0x041b0c37), + R(v23), + R(p3, v23, v1)); // bic z23.b, p3/m, z23.b, z1.b + + CLEANUP(); +} + +TEST(group_3) { + SETUP(); + + CMP_IO(dci(0x04fd3092), R(v18), R(v4, v29)); // bic z18.d, z4.d, z29.d + CMP_IO(dci(0x6abb6f4b), R(x11), R(x26, x27)); // bics w11, w26, w27, asr #27 + CMP_IO(dci(0xea7be4e2), R(x2), R(x7, x27)); // bics x2, x7, x27, lsr #57 + CMP_IO(dci(0x254a603b), + R(p11), + R(p8, p1, p10)); // bics p11.b, p8/z, p1.b, p10.b + CMP_IO(dci(0x6efd1efb), + R(v27), + R(v27, v23, v29)); // bif v27.16b, v23.16b, v29.16b + CMP_IO(dci(0x6ebe1cb9), + R(v25), + R(v25, v5, v30)); // bit v25.16b, v5.16b, v30.16b + CMP_IO(dci(0x951c4cfc), R(x30), R()); // bl #+0x47133f0 + CMP_IO(dci(0xd63f00e0), R(x30), R(x7)); // blr x7 + CMP_IO(dci(0xd73f0b7f), R(x30), R(x27, sp)); // blraa x27, sp + CMP_IO(dci(0xd63f0b7f), R(x30), R(x27)); // blraaz x27 + CMP_IO(dci(0xd73f0d16), R(x30), R(x8, x22)); // blrab x8, x22 + CMP_IO(dci(0xd63f0ebf), R(x30), R(x21)); // blrabz x21 + CMP_IO(dci(0xd61f0120), R(), R(x9)); // br x9 + CMP_IO(dci(0xd71f0973), R(), R(x11, x19)); // braa x11, x19 + CMP_IO(dci(0xd61f0bdf), R(), R(x30)); // braaz x30 + CMP_IO(dci(0xd71f0f0a), R(), R(x24, x10)); // brab x24, x10 + CMP_IO(dci(0xd61f0f3f), R(), R(x25)); // brabz x25 + CMP_IO(dci(0xd43de2e0), R(), R()); // brk #0xef17 + CMP_IO(dci(0x25107d7e), + R(p14), + R(p14, p15, p11)); // brka p14.b, p15/m, p11.b + CMP_IO(dci(0x25504d49), R(p9), R(p3, p10)); // brkas p9.b, p3/z, p10.b + CMP_IO(dci(0x25907516), R(p6), R(p6, p13, p8)); // brkb p6.b, p13/m, p8.b + CMP_IO(dci(0x25d06c84), R(p4), R(p11, p4)); // brkbs p4.b, p11/z, p4.b + CMP_IO(dci(0x2518518a), + R(p10), + R(p4, p12, p10)); // brkn p10.b, p4/z, p12.b, p10.b + CMP_IO(dci(0x25584083), + R(p3), + R(p0, p4, p3)); // brkns p3.b, p0/z, p4.b, p3.b + CMP_IO(dci(0x250cfd6f), + R(p15), + R(p15, p11, p12)); // brkpa p15.b, p15/z, p11.b, p12.b + CMP_IO(dci(0x254ccc86), + R(p6), + R(p3, p4, p12)); // brkpas p6.b, p3/z, p4.b, p12.b + CMP_IO(dci(0x250cf516), + R(p6), + R(p13, p8, p12)); // brkpb p6.b, p13/z, p8.b, p12.b + CMP_IO(dci(0x254cd8ff), + R(p15), + R(p6, p7, p12)); // brkpbs p15.b, p6/z, p7.b, p12.b + CMP_IO(dci(0x047d3e02), + R(v2), + R(v2, v29, v16)); // bsl1n z2.d, z2.d, z29.d, z16.d + CMP_IO(dci(0x04bd3c6b), + R(v11), + R(v11, v29, v3)); // bsl2n z11.d, z11.d, z29.d, z3.d + CMP_IO(dci(0x2e7e1d8b), + R(v11), + R(v11, v12, v30)); // bsl v11.8b, v12.8b, v30.8b + CMP_IO(dci(0x04393df7), + R(v23), + R(v23, v25, v15)); // bsl z23.d, z23.d, z25.d, z15.d + + CLEANUP(); +} + +TEST(group_4) { + SETUP(); + + CMP_IO(dci(0xd503245f), R(), R()); // bti c + CMP_IO(dci(0x4500dabc), + R(v28), + R(v28, v21)); // cadd z28.b, z28.b, z21.b, #90 + CMP_IO(dci(0x88be7d7d), R(x30), R(x30, x29, x11)); // cas w30, w29, [x11] + CMP_IO(dci(0xc8be7fe7), R(x30), R(x30, x7, sp)); // cas x30, x7, [sp] + CMP_IO(dci(0x88fa7fb5), R(x26), R(x26, x21, x29)); // casa w26, w21, [x29] + CMP_IO(dci(0xc8fa7ef0), R(x26), R(x26, x16, x23)); // casa x26, x16, [x23] + CMP_IO(dci(0x08fe7fe7), R(x30), R(x30, x7, sp)); // casab w30, w7, [sp] + CMP_IO(dci(0x48fe7e5d), R(x30), R(x30, x29, x18)); // casah w30, w29, [x18] + CMP_IO(dci(0x88fefcb9), R(x30), R(x30, x25, x5)); // casal w30, w25, [x5] + CMP_IO(dci(0xc8fefff4), R(x30), R(x30, x20, sp)); // casal x30, x20, [sp] + CMP_IO(dci(0x08fafe2b), R(x26), R(x26, x11, x17)); // casalb w26, w11, [x17] + CMP_IO(dci(0x48fafe11), R(x26), R(x26, x17, x16)); // casalh w26, w17, [x16] + CMP_IO(dci(0x08ba7ef0), R(x26), R(x26, x16, x23)); // casb w26, w16, [x23] + CMP_IO(dci(0x48ba7d66), R(x26), R(x26, x6, x11)); // cash w26, w6, [x11] + CMP_IO(dci(0x88baffc2), R(x26), R(x26, x2, x30)); // casl w26, w2, [x30] + CMP_IO(dci(0xc8bafe2b), R(x26), R(x26, x11, x17)); // casl x26, x11, [x17] + CMP_IO(dci(0x08befff4), R(x30), R(x30, x20, sp)); // caslb w30, w20, [sp] + CMP_IO(dci(0x48beffda), R(x30), R(x30, x26, x30)); // caslh w30, w26, [x30] + CMP_IO(dci(0x083e7d7e), + R(x30), + R(x30, x11)); // casp w30, wzr, w30, wzr, [x11] + CMP_IO(dci(0x482a7cf8), + R(x10, x11), + R(x10, x11, x24, x25, x7)); // casp x10, x11, x24, x25, [x7] + CMP_IO(dci(0x086e7c76), + R(x14, x15), + R(x14, x15, x22, x23, x3)); // caspa w14, w15, w22, w23, [x3] + CMP_IO(dci(0x487a7ef0), + R(x26, x27), + R(x26, x27, x16, x17, x23)); // caspa x26, x27, x16, x17, [x23] + CMP_IO(dci(0x086afc70), + R(x10, x11), + R(x10, x11, x16, x17, x3)); // caspal w10, w11, w16, w17, [x3] + CMP_IO(dci(0x487efff4), + R(x30), + R(x30, x20, x21, sp)); // caspal x30, xzr, x20, x21, [sp] + CMP_IO(dci(0x083affc2), + R(x26, x27), + R(x26, x27, x2, x3, x30)); // caspl w26, w27, w2, w3, [x30] + CMP_IO(dci(0x4838fedc), + R(x24, x25), + R(x24, x25, x28, x29, x22)); // caspl x24, x25, x28, x29, [x22] + CMP_IO(dci(0x35bde2fb), R(), R(x27)); // cbnz w27, #-0x843a4 + CMP_IO(dci(0xb55dd892), R(), R(x18)); // cbnz x18, #+0xbbb10 + CMP_IO(dci(0x3479bd25), R(), R(x5)); // cbz w5, #+0xf37a4 + CMP_IO(dci(0xb499dc60), R(), R(x0)); // cbz x0, #-0xcc474 + CMP_IO(dci(0x3a5bd800), R(), R(x0)); // ccmn w0, #27, #nzcv, le + CMP_IO(dci(0x3a5b724f), R(), R(x18, x27)); // ccmn w18, w27, #NZCV, vc + + CLEANUP(); +} + +TEST(group_5) { + SETUP(); + + CMP_IO(dci(0xba5bb8c5), R(), R(x6)); // ccmn x6, #27, #nZcV, lt + CMP_IO(dci(0xba5b63e6), R(), R(x27)); // ccmn xzr, x27, #nZCv, vs + CMP_IO(dci(0x7a5b3a42), R(), R(x18)); // ccmp w18, #27, #nzCv, lo + CMP_IO(dci(0x7a5b8321), R(), R(x25, x27)); // ccmp w25, w27, #nzcV, hi + CMP_IO(dci(0xfa5b48ab), R(), R(x5)); // ccmp x5, #27, #NzCV, mi + CMP_IO(dci(0xfa5ba26c), R(), R(x19, x27)); // ccmp x19, x27, #NZcv, ge + CMP_IO(dci(0x449d13c0), + R(v0), + R(v0, v30, v29)); // cdot z0.s, z30.b, z29.b, #0 + CMP_IO(dci(0x44fb4b3e), + R(v30), + R(v30, v25, v11)); // cdot z30.d, z25.h, z11.h[1], #180 + CMP_IO(dci(0x44ba4573), + R(v19), + R(v19, v11, v2)); // cdot z19.s, z11.b, z2.b[3], #90 + CMP_IO(dci(0xd5004e1f), R(), R()); // cfinv + CMP_IO(dci(0x0570bdf5), + R(x21), + R(p7, x21, v15)); // clasta w21, p7, w21, z15.h + CMP_IO(dci(0x05ea9451), R(v17), R(p5, v17, v2)); // clasta d17, p5, d17, z2.d + CMP_IO(dci(0x05289f17), + R(v23), + R(p7, v23, v24)); // clasta z23.b, p7, z23.b, z24.b + CMP_IO(dci(0x05b1bd30), R(x16), R(p7, x16, v9)); // clastb w16, p7, w16, z9.s + CMP_IO(dci(0x052b938c), + R(v12), + R(p4, v12, v28)); // clastb b12, p4, b12, z28.b + CMP_IO(dci(0x05e994ae), + R(v14), + R(p5, v14, v5)); // clastb z14.d, p5, z14.d, z5.d + CMP_IO(dci(0xd503375f), R(), R()); // clrex #0x7 + CMP_IO(dci(0x5ac017cf), R(x15), R(x30)); // cls w15, w30 + CMP_IO(dci(0xdac01566), R(x6), R(x11)); // cls x6, x11 + CMP_IO(dci(0x0e20494c), R(v12), R(v10)); // cls v12.8b, v10.8b + CMP_IO(dci(0x04d8b3e9), R(v9), R(v9, p4, v31)); // cls z9.d, p4/m, z31.d + CMP_IO(dci(0x5ac012f0), R(x16), R(x23)); // clz w16, w23 + CMP_IO(dci(0xdac013b5), R(x21), R(x29)); // clz x21, x29 + CMP_IO(dci(0x2ea04a2b), R(v11), R(v17)); // clz v11.2s, v17.2s + CMP_IO(dci(0x0459ab0a), R(v10), R(v10, p2, v24)); // clz z10.h, p2/m, z24.h + CMP_IO(dci(0x4ee098c6), R(v6), R(v6)); // cmeq v6.2d, v6.2d, #0 + CMP_IO(dci(0x6efd8c0f), R(v15), R(v0, v29)); // cmeq v15.2d, v0.2d, v29.2d + CMP_IO(dci(0x5ee09a14), R(v20), R(v16)); // cmeq d20, d16, #0 + CMP_IO(dci(0x7eec8e34), R(v20), R(v17, v12)); // cmeq d20, d17, d12 + CMP_IO(dci(0x2e208964), R(v4), R(v11)); // cmge v4.8b, v11.8b, #0 + CMP_IO(dci(0x0e3a3e04), R(v4), R(v16, v26)); // cmge v4.8b, v16.8b, v26.8b + CMP_IO(dci(0x7ee0897e), R(v30), R(v11)); // cmge d30, d11, #0 + + CLEANUP(); +} + +TEST(group_6) { + SETUP(); + + CMP_IO(dci(0x5efa3e1e), R(v30), R(v16, v26)); // cmge d30, d16, d26 + CMP_IO(dci(0x0ea0898b), R(v11), R(v12)); // cmgt v11.2s, v12.2s, #0 + CMP_IO(dci(0x0eba362b), R(v11), R(v17, v26)); // cmgt v11.2s, v17.2s, v26.2s + CMP_IO(dci(0x5ee08ac9), R(v9), R(v22)); // cmgt d9, d22, #0 + CMP_IO(dci(0x5ef636e9), R(v9), R(v23, v22)); // cmgt d9, d23, d22 + CMP_IO(dci(0x6ef936c9), R(v9), R(v22, v25)); // cmhi v9.2d, v22.2d, v25.2d + CMP_IO(dci(0x7ef33662), R(v2), R(v19, v19)); // cmhi d2, d19, d19 + CMP_IO(dci(0x6eba3ee3), R(v3), R(v23, v26)); // cmhs v3.4s, v23.4s, v26.4s + CMP_IO(dci(0x7eeb3fee), R(v14), R(v31, v11)); // cmhs d14, d31, d11 + CMP_IO(dci(0x44de24b9), + R(v25), + R(v25, v5, v30)); // cmla z25.d, z5.d, z30.d, #90 + CMP_IO(dci(0x44bb6f17), + R(v23), + R(v23, v24, v3)); // cmla z23.h, z24.h, z3.h[3], #270 + CMP_IO(dci(0x44fc6e86), + R(v6), + R(v6, v20, v12)); // cmla z6.s, z20.s, z12.s[1], #270 + CMP_IO(dci(0x6ee09ae1), R(v1), R(v23)); // cmle v1.2d, v23.2d, #0 + CMP_IO(dci(0x7ee0992b), R(v11), R(v9)); // cmle d11, d9, #0 + CMP_IO(dci(0x4e60abda), R(v26), R(v30)); // cmlt v26.8h, v30.8h, #0 + CMP_IO(dci(0x5ee0a818), R(v24), R(v0)); // cmlt d24, d0, #0 + CMP_IO(dci(0x25dd9ba6), R(p6), R(p6, v29)); // cmpeq p6.d, p6/z, z29.d, #-3 + CMP_IO(dci(0x241c2cec), + R(p12), + R(p3, v7, v28)); // cmpeq p12.b, p3/z, z7.b, z28.d + CMP_IO(dci(0x241cbf6f), + R(p15), + R(p7, v27, v28)); // cmpeq p15.b, p7/z, z27.b, z28.b + CMP_IO(dci(0x251c0044), R(p4), R(p0, v2)); // cmpge p4.b, p0/z, z2.b, #-4 + CMP_IO(dci(0x24dd484e), + R(p14), + R(p2, v2, v29)); // cmpge p14.d, p2/z, z2.d, z29.d + CMP_IO(dci(0x24dd8789), + R(p9), + R(p1, v28, v29)); // cmpge p9.d, p1/z, z28.d, z29.d + CMP_IO(dci(0x259d1c7b), R(p11), R(p7, v3)); // cmpgt p11.s, p7/z, z3.s, #-3 + CMP_IO(dci(0x245c5775), + R(p5), + R(p5, v27, v28)); // cmpgt p5.h, p5/z, z27.h, z28.d + CMP_IO(dci(0x245c8b72), + R(p2), + R(p2, v27, v28)); // cmpgt p2.h, p2/z, z27.h, z28.h + CMP_IO(dci(0x24fc8119), R(p9), R(p0, v8)); // cmphi p9.d, p0/z, z8.d, #114 + CMP_IO(dci(0x241dd2d7), + R(p7), + R(p4, v22, v29)); // cmphi p7.b, p4/z, z22.b, z29.d + CMP_IO(dci(0x241d06d4), + R(p4), + R(p1, v22, v29)); // cmphi p4.b, p1/z, z22.b, z29.b + CMP_IO(dci(0x24bcc923), R(p3), R(p2, v9)); // cmphs p3.s, p2/z, z9.s, #115 + CMP_IO(dci(0x245ccaad), + R(p13), + R(p2, v21, v28)); // cmphs p13.h, p2/z, z21.h, z28.d + CMP_IO(dci(0x245c182a), + R(p10), + R(p6, v1, v28)); // cmphs p10.h, p6/z, z1.h, z28.h + CMP_IO(dci(0x25dc2dd1), R(p1), R(p3, v14)); // cmple p1.d, p3/z, z14.d, #-4 + + CLEANUP(); +} + +TEST(group_7) { + SETUP(); + + CMP_IO(dci(0x241d661f), + R(p15), + R(p1, v16, v29)); // cmple p15.b, p1/z, z16.b, z29.d + CMP_IO(dci(0x24bcb5cb), + R(p11), + R(p5, v14)); // cmplo p11.s, p5/z, z14.s, #114 + CMP_IO(dci(0x245cfde5), + R(p5), + R(p7, v15, v28)); // cmplo p5.h, p7/z, z15.h, z28.d + CMP_IO(dci(0x243d32d7), R(p7), R(p4, v22)); // cmpls p7.b, p4/z, z22.b, #116 + CMP_IO(dci(0x24dce119), + R(p9), + R(p0, v8, v28)); // cmpls p9.d, p0/z, z8.d, z28.d + CMP_IO(dci(0x255c3eaa), R(p10), R(p7, v21)); // cmplt p10.h, p7/z, z21.h, #-4 + CMP_IO(dci(0x249c69e8), + R(p8), + R(p2, v15, v28)); // cmplt p8.s, p2/z, z15.s, z28.d + CMP_IO(dci(0x259c8293), R(p3), R(p0, v20)); // cmpne p3.s, p0/z, z20.s, #-4 + CMP_IO(dci(0x245d313d), + R(p13), + R(p4, v9, v29)); // cmpne p13.h, p4/z, z9.h, z29.d + CMP_IO(dci(0x245cbeba), + R(p10), + R(p7, v21, v28)); // cmpne p10.h, p7/z, z21.h, z28.h + CMP_IO(dci(0x0ebe8d8b), R(v11), R(v12, v30)); // cmtst v11.2s, v12.2s, v30.2s + CMP_IO(dci(0x5ee08ec9), R(v9), R(v22, v0)); // cmtst d9, d22, d0 + CMP_IO(dci(0x049ba293), R(v19), R(v19, p0, v20)); // cnot z19.s, p0/m, z20.s + CMP_IO(dci(0x4e205887), R(v7), R(v4)); // cnt v7.16b, v4.16b + CMP_IO(dci(0x04daa7f6), R(v22), R(v22, p1, v31)); // cnt z22.d, p1/m, z31.d + CMP_IO(dci(0x042de14a), R(x10), R()); // cntb x10, vl32, mul #14 + CMP_IO(dci(0x04ede3c0), R(x0), R()); // cntd x0, mul3, mul #14 + CMP_IO(dci(0x046de164), R(x4), R()); // cnth x4, vl64, mul #14 + CMP_IO(dci(0x25a0b078), R(x24), R(p12, p3)); // cntp x24, p12, p3.s + CMP_IO(dci(0x04aee315), R(x21), R()); // cntw x21, #0x18, mul #15 + CMP_IO(dci(0x05e18024), R(v4), R(p0, v1)); // compact z4.d, p0, z1.d + CMP_IO(dci(0x059b1c03), R(v3), R(p11)); // mov z3.s, p11/z, #-32 + CMP_IO(dci(0x05db67f6), + R(v22), + R(v22, p11)); // mov z22.d, p11/m, #63, lsl #8 + CMP_IO(dci(0x0528a5a7), R(v7), R(v7, p1, x13)); // mov z7.b, p1/m, w13 + CMP_IO(dci(0x05a09c03), R(v3), R(v3, p7, v0)); // mov z3.s, p7/m, s0 + CMP_IO(dci(0x1d8407bb), + R(x27, x4, x29), + R(x27, x4, x29)); // cpye [x27]!, [x4]!, x29! + CMP_IO(dci(0x1d9dc629), + R(x9, x29, x17), + R(x9, x29, x17)); // cpyen [x9]!, [x29]!, x17! + CMP_IO(dci(0x1d9a862b), + R(x11, x26, x17), + R(x11, x26, x17)); // cpyern [x11]!, [x26]!, x17! + CMP_IO(dci(0x1d88446e), + R(x14, x8, x3), + R(x14, x8, x3)); // cpyewn [x14]!, [x8]!, x3! + CMP_IO(dci(0x199e0655), + R(x21, x30, x18), + R(x21, x30, x18)); // cpyfe [x21]!, [x30]!, x18! + CMP_IO(dci(0x1996c72b), + R(x11, x22, x25), + R(x11, x22, x25)); // cpyfen [x11]!, [x22]!, x25! + CMP_IO(dci(0x199e865d), + R(x29, x30, x18), + R(x29, x30, x18)); // cpyfern [x29]!, [x30]!, x18! + + CLEANUP(); +} + +TEST(group_8) { + SETUP(); + + CMP_IO(dci(0x199e4722), + R(x2, x30, x25), + R(x2, x30, x25)); // cpyfewn [x2]!, [x30]!, x25! + CMP_IO(dci(0x195d0629), + R(x9, x29, x17), + R(x9, x29, x17)); // cpyfm [x9]!, [x29]!, x17! + CMP_IO(dci(0x1944c7bb), + R(x27, x4, x29), + R(x27, x4, x29)); // cpyfmn [x27]!, [x4]!, x29! + CMP_IO(dci(0x19558545), + R(x5, x21, x10), + R(x5, x21, x10)); // cpyfmrn [x5]!, [x21]!, x10! + CMP_IO(dci(0x1948448e), + R(x14, x8, x4), + R(x14, x8, x4)); // cpyfmwn [x14]!, [x8]!, x4! + CMP_IO(dci(0x190f0582), + R(x2, x15, x12), + R(x2, x15, x12)); // cpyfp [x2]!, [x15]!, x12! + CMP_IO(dci(0x190ec72c), + R(x12, x14, x25), + R(x12, x14, x25)); // cpyfpn [x12]!, [x14]!, x25! + CMP_IO(dci(0x19028663), + R(x3, x2, x19), + R(x3, x2, x19)); // cpyfprn [x3]!, [x2]!, x19! + CMP_IO(dci(0x191d44f1), + R(x17, x29, x7), + R(x17, x29, x7)); // cpyfpwn [x17]!, [x29]!, x7! + CMP_IO(dci(0x1d56072b), + R(x11, x22, x25), + R(x11, x22, x25)); // cpym [x11]!, [x22]!, x25! + CMP_IO(dci(0x1d5ec655), + R(x21, x30, x18), + R(x21, x30, x18)); // cpymn [x21]!, [x30]!, x18! + CMP_IO(dci(0x1d558654), + R(x20, x21, x18), + R(x20, x21, x18)); // cpymrn [x20]!, [x21]!, x18! + CMP_IO(dci(0x1d434458), + R(x24, x3, x2), + R(x24, x3, x2)); // cpymwn [x24]!, [x3]!, x2! + CMP_IO(dci(0x1d1a054c), + R(x12, x26, x10), + R(x12, x26, x10)); // cpyp [x12]!, [x26]!, x10! + CMP_IO(dci(0x1d01c66f), + R(x15, x1, x19), + R(x15, x1, x19)); // cpypn [x15]!, [x1]!, x19! + CMP_IO(dci(0x1d0d86b0), + R(x16, x13, x21), + R(x16, x13, x21)); // cpyprn [x16]!, [x13]!, x21! + CMP_IO(dci(0x1d1d45c9), + R(x9, x29, x14), + R(x9, x29, x14)); // cpypwn [x9]!, [x29]!, x14! + CMP_IO(dci(0x1ada414c), R(x12), R(x10, x26)); // crc32b w12, w10, w26 + CMP_IO(dci(0x1ade5171), R(x17), R(x11, x30)); // crc32cb w17, w11, w30 + CMP_IO(dci(0x1ade558b), R(x11), R(x12, x30)); // crc32ch w11, w12, w30 + CMP_IO(dci(0x1add5aee), R(x14), R(x23, x29)); // crc32cw w14, w23, w29 + CMP_IO(dci(0x9add5c92), R(x18), R(x4, x29)); // crc32cx w18, w4, x29 + CMP_IO(dci(0x1ada47c2), R(x2), R(x30, x26)); // crc32h w2, w30, w26 + CMP_IO(dci(0x1ad949f7), R(x23), R(x15, x25)); // crc32w w23, w15, w25 + CMP_IO(dci(0x9ad94f9b), R(x27), R(x28, x25)); // crc32x w27, w28, x25 + CMP_IO(dci(0xd503229f), R(), R()); // csdb + CMP_IO(dci(0x1a9ad238), R(x24), R(x17, x26)); // csel w24, w17, w26, le + CMP_IO(dci(0x9a9ab2fd), R(x29), R(x23, x26)); // csel x29, x23, x26, lt + CMP_IO(dci(0x1a9e3643), R(x3), R(x18, x30)); // csinc w3, w18, w30, lo + CMP_IO(dci(0x9a9e27da), R(x26), R(x30)); // cinc x26, x30, lo + CMP_IO(dci(0x5a9dc3c0), R(x0), R(x30, x29)); // csinv w0, w30, w29, gt + CMP_IO(dci(0xda9da085), R(x5), R(x4, x29)); // csinv x5, x4, x29, ge + + CLEANUP(); +} + +TEST(group_9) { + SETUP(); + + CMP_IO(dci(0x5a9e858b), R(x11), R(x12, x30)); // csneg w11, w12, w30, hi + CMP_IO(dci(0xda9e7722), R(x2), R(x25, x30)); // csneg x2, x25, x30, vc + CMP_IO(dci(0x25fd23a0), R(), R(x29, x29)); // ctermeq x29, x29 + CMP_IO(dci(0x25bc2290), R(), R(x20, x28)); // ctermne w20, w28 + CMP_IO(dci(0xd4bc18e1), R(), R()); // dcps1 {#0xe0c7} + CMP_IO(dci(0xd4bc0e82), R(), R()); // dcps2 {#0xe074} + CMP_IO(dci(0xd4bc0403), R(), R()); // dcps3 {#0xe020} + CMP_IO(dci(0x0439e6c9), R(x9), R(x9)); // decb x9, #0x16, mul #10 + CMP_IO(dci(0x04fae53e), R(x30), R(x30)); // decd x30, vl16, mul #11 + CMP_IO(dci(0x04fac53f), R(v31), R(v31)); // decd z31.d, vl16, mul #11 + CMP_IO(dci(0x0479e453), R(x19), R(x19)); // dech x19, vl2, mul #10 + CMP_IO(dci(0x0479c453), R(v19), R(v19)); // dech z19.h, vl2, mul #10 + CMP_IO(dci(0x252d8837), R(x23), R(x23, p1)); // decp x23, p1.b + CMP_IO(dci(0x252d8037), R(v23), R(v23, p1)); // decp z23.b, p1 + CMP_IO(dci(0x04bae566), R(x6), R(x6)); // decw x6, vl64, mul #11 + CMP_IO(dci(0x04bac566), R(v6), R(v6)); // decw z6.s, vl64, mul #11 + CMP_IO(dci(0xd50339bf), R(), R()); // dmb ishld + CMP_IO(dci(0xd5033a9f), R(), R()); // dsb ishst + CMP_IO(dci(0x0e1b0d80), R(v0), R(x12)); // dup v0.8b, w12 + CMP_IO(dci(0x4e0807a8), R(v8), R(v29)); // dup v8.2d, v29.d[0] + CMP_IO(dci(0x5e1905f7), R(v23), R(v15)); // mov b23, v15.b[12] + CMP_IO(dci(0x2578f132), R(v18), R()); // mov z18.h, #-119, lsl #8 + CMP_IO(dci(0x05a03ae3), R(v3), R(x23)); // mov z3.s, w23 + CMP_IO(dci(0x053e20ac), R(v12), R(v5)); // mov z12.h, z5.h[7] + CMP_IO(dci(0x05c1a485), R(v5), R()); // mov z5.h, #0xf001 + CMP_IO(dci(0x4afc61ce), R(x14), R(x14, x28)); // eon w14, w14, w28, ror #24 + CMP_IO(dci(0xca3c6c37), R(x23), R(x1, x28)); // eon x23, x1, x28, lsl #27 + CMP_IO(dci(0x043b3b31), + R(v17), + R(v17, v27, v25)); // eor3 z17.d, z17.d, z27.d, z25.d + CMP_IO(dci(0x523cd451), R(x17), R(x2)); // eor w17, w2, #0xf3f3f3f3 + CMP_IO(dci(0x4a5d3202), R(x2), R(x16, x29)); // eor w2, w16, w29, lsr #12 + CMP_IO(dci(0xd21cf38c), R(x12), R(x28)); // eor x12, x28, #0x5555555555555555 + CMP_IO(dci(0xca9d3c6b), R(x11), R(x3, x29)); // eor x11, x3, x29, asr #15 + + CLEANUP(); +} + +TEST(group_10) { + SETUP(); + + CMP_IO(dci(0x2e3e1d98), R(v24), R(v12, v30)); // eor v24.8b, v12.8b, v30.8b + CMP_IO(dci(0x250e7f22), + R(p2), + R(p15, p9, p14)); // eor p2.b, p15/z, p9.b, p14.b + CMP_IO(dci(0x041912c7), + R(v7), + R(p4, v7, v22)); // eor z7.b, p4/m, z7.b, z22.b + CMP_IO(dci(0x0541e2fb), R(v27), R(v27)); // eor z27.s, z27.s, #0xffffff0 + CMP_IO(dci(0x04be3322), R(v2), R(v25, v30)); // eor z2.d, z25.d, z30.d + CMP_IO(dci(0x459e9308), R(v8), R(v24, v30)); // eorbt z8.s, z24.s, z30.s + CMP_IO(dci(0x25497b8b), + R(p11), + R(p14, p12, p9)); // eors p11.b, p14/z, p12.b, p9.b + CMP_IO(dci(0x459e9708), R(v8), R(v24, v30)); // eortb z8.s, z24.s, z30.s + CMP_IO(dci(0x04992923), R(v3), R(p2, v9)); // eorv s3, p2, z9.s + CMP_IO(dci(0x2e041896), R(v22), R(v4, v4)); // ext v22.8b, v4.8b, v4.8b, #3 + CMP_IO(dci(0x057c0c37), R(v23), R(v1, v2)); // ext z23.b, {z1.b, z2.b}, #227 + CMP_IO(dci(0x053d12c7), R(v7), R(v7, v22)); // ext z7.b, z7.b, z22.b, #236 + CMP_IO(dci(0x139a106d), R(x13), R(x3, x26)); // extr w13, w3, w26, #4 + CMP_IO(dci(0x93da2fa8), R(x8), R(x29, x26)); // extr x8, x29, x26, #11 + CMP_IO(dci(0x6eb9d5f7), R(v23), R(v15, v25)); // fabd v23.4s, v15.4s, v25.4s + CMP_IO(dci(0x6eda16f0), R(v16), R(v23, v26)); // fabd v16.8h, v23.8h, v26.8h + CMP_IO(dci(0x7efad559), R(v25), R(v10, v26)); // fabd d25, d10, d26 + CMP_IO(dci(0x7ed91532), R(v18), R(v9, v25)); // fabd h18, h9, h25 + CMP_IO(dci(0x65889cc8), R(v8), R(p7, v8, v6)); // fabd z8.s, p7/m, z8.s, z6.s + CMP_IO(dci(0x4ee0f9a2), R(v2), R(v13)); // fabs v2.2d, v13.2d + CMP_IO(dci(0x0ef8fa29), R(v9), R(v17)); // fabs v9.4h, v17.4h + CMP_IO(dci(0x1e60c13d), R(v29), R(v9)); // fabs d29, d9 + CMP_IO(dci(0x1ee0c051), R(v17), R(v2)); // fabs h17, h2 + CMP_IO(dci(0x1e20c044), R(v4), R(v2)); // fabs s4, s2 + CMP_IO(dci(0x049ca293), R(v19), R(v19, p0, v20)); // fabs z19.s, p0/m, z20.s + CMP_IO(dci(0x2e26ec93), R(v19), R(v4, v6)); // facge v19.2s, v4.2s, v6.2s + CMP_IO(dci(0x2e5e2d71), R(v17), R(v11, v30)); // facge v17.4h, v11.4h, v30.4h + CMP_IO(dci(0x7e3eed98), R(v24), R(v12, v30)); // facge s24, s12, s30 + CMP_IO(dci(0x7e5e2c9f), R(v31), R(v4, v30)); // facge h31, h4, h30 + CMP_IO(dci(0x659cc293), + R(p3), + R(p0, v20, v28)); // facge p3.s, p0/z, z20.s, z28.s + CMP_IO(dci(0x6ee1ef45), R(v5), R(v26, v1)); // facgt v5.2d, v26.2d, v1.2d + CMP_IO(dci(0x2edd2d4a), R(v10), R(v10, v29)); // facgt v10.4h, v10.4h, v29.4h + + CLEANUP(); +} + +TEST(group_11) { + SETUP(); + + CMP_IO(dci(0x7ebeec9f), R(v31), R(v4, v30)); // facgt s31, s4, s30 + CMP_IO(dci(0x7ede2d98), R(v24), R(v12, v30)); // facgt h24, h12, h30 + CMP_IO(dci(0x65c3fd78), + R(p8), + R(p7, v11, v3)); // facgt p8.d, p7/z, z11.d, z3.d + CMP_IO(dci(0x0e2bd415), R(v21), R(v0, v11)); // fadd v21.2s, v0.2s, v11.2s + CMP_IO(dci(0x0e5a147a), R(v26), R(v3, v26)); // fadd v26.4h, v3.4h, v26.4h + CMP_IO(dci(0x1e7c2b7f), R(v31), R(v27, v28)); // fadd d31, d27, d28 + CMP_IO(dci(0x1efc2a93), R(v19), R(v20, v28)); // fadd h19, h20, h28 + CMP_IO(dci(0x1e3d2a02), R(v2), R(v16, v29)); // fadd s2, s16, s29 + CMP_IO(dci(0x65d88021), R(v1), R(p0, v1)); // fadd z1.d, p0/m, z1.d, #1.0 + CMP_IO(dci(0x65409e52), + R(v18), + R(p7, v18, v18)); // fadd z18.h, p7/m, z18.h, z18.h + CMP_IO(dci(0x65cc0053), R(v19), R(v2, v12)); // fadd z19.d, z2.d, z12.d + CMP_IO(dci(0x655833eb), + R(v11), + R(p4, v11, v31)); // fadda h11, p4, h11, z31.h + CMP_IO(dci(0x6e61d745), R(v5), R(v26, v1)); // faddp v5.2d, v26.2d, v1.2d + CMP_IO(dci(0x2e5d154a), R(v10), R(v10, v29)); // faddp v10.4h, v10.4h, v29.4h + CMP_IO(dci(0x5e30dbb2), R(v18), R(v29)); // faddp h18, v29.2h + CMP_IO(dci(0x7e30d9a7), R(v7), R(v13)); // faddp s7, v13.2s + CMP_IO(dci(0x64509202), + R(v2), + R(p4, v2, v16)); // faddp z2.h, p4/m, z2.h, z16.h + CMP_IO(dci(0x65403e52), R(v18), R(p7, v18)); // faddv h18, p7, z18.h + CMP_IO(dci(0x2e1bf717), + R(v23), + R(v24, v27)); // fcadd v23.8b, v24.8b, v27.8b, #270 + CMP_IO(dci(0x648095db), + R(v27), + R(p5, v27, v14)); // fcadd z27.s, p5/m, z27.s, z14.s, #90 + CMP_IO(dci(0x1e79f522), R(), R(v9, v25)); // fccmp d9, d25, #nzCv, nv + CMP_IO(dci(0x1ef9c78e), R(), R(v28, v25)); // fccmp h28, h25, #NZCv, gt + CMP_IO(dci(0x1e3ac7cf), R(), R(v30, v26)); // fccmp s30, s26, #NZCV, gt + CMP_IO(dci(0x1e7df7dd), R(), R(v30, v29)); // fccmpe d30, d29, #NZcV, nv + CMP_IO(dci(0x1efd76f1), R(), R(v23, v29)); // fccmpe h23, h29, #nzcV, vc + CMP_IO(dci(0x1e3e97f4), R(), R(v31, v30)); // fccmpe s31, s30, #nZcv, ls + CMP_IO(dci(0x4ee0d8c6), R(v6), R(v6)); // fcmeq v6.2d, v6.2d, #0.0 + CMP_IO(dci(0x4ef8dbcd), R(v13), R(v30)); // fcmeq v13.8h, v30.8h, #0.0 + CMP_IO(dci(0x4e3ee7f4), R(v20), R(v31, v30)); // fcmeq v20.4s, v31.4s, v30.4s + CMP_IO(dci(0x4e5d26fb), R(v27), R(v23, v29)); // fcmeq v27.8h, v23.8h, v29.8h + CMP_IO(dci(0x5ea0da1c), R(v28), R(v16)); // fcmeq s28, s16, #0.0 + CMP_IO(dci(0x5ef8da43), R(v3), R(v18)); // fcmeq h3, h18, #0.0 + + CLEANUP(); +} + +TEST(group_12) { + SETUP(); + + CMP_IO(dci(0x5e7de6ee), R(v14), R(v23, v29)); // fcmeq d14, d23, d29 + CMP_IO(dci(0x5e5e2715), R(v21), R(v24, v30)); // fcmeq h21, h24, h30 + CMP_IO(dci(0x65922ee3), R(p3), R(p3, v23)); // fcmeq p3.s, p3/z, z23.s, #0.0 + CMP_IO(dci(0x65dd6789), + R(p9), + R(p1, v28, v29)); // fcmeq p9.d, p1/z, z28.d, z29.d + CMP_IO(dci(0x2ea0c964), R(v4), R(v11)); // fcmge v4.2s, v11.2s, #0.0 + CMP_IO(dci(0x2ef8c98b), R(v11), R(v12)); // fcmge v11.4h, v12.4h, #0.0 + CMP_IO(dci(0x2e3be55f), R(v31), R(v10, v27)); // fcmge v31.2s, v10.2s, v27.2s + CMP_IO(dci(0x2e5e265d), R(v29), R(v18, v30)); // fcmge v29.4h, v18.4h, v30.4h + CMP_IO(dci(0x7ee0c97e), R(v30), R(v11)); // fcmge d30, d11, #0.0 + CMP_IO(dci(0x7ef8c885), R(v5), R(v4)); // fcmge h5, h4, #0.0 + CMP_IO(dci(0x7e3ee4ac), R(v12), R(v5, v30)); // fcmge s12, s5, s30 + CMP_IO(dci(0x7e5d27b3), R(v19), R(v29, v29)); // fcmge h19, h29, h29 + CMP_IO(dci(0x65503d25), R(p5), R(p7, v9)); // fcmge p5.h, p7/z, z9.h, #0.0 + CMP_IO(dci(0x65d35f2b), + R(p11), + R(p7, v25, v19)); // fcmge p11.d, p7/z, z25.d, z19.d + CMP_IO(dci(0x0ea0c98b), R(v11), R(v12)); // fcmgt v11.2s, v12.2s, #0.0 + CMP_IO(dci(0x0ef8c964), R(v4), R(v11)); // fcmgt v4.4h, v11.4h, #0.0 + CMP_IO(dci(0x2ea8e53f), R(v31), R(v9, v8)); // fcmgt v31.2s, v9.2s, v8.2s + CMP_IO(dci(0x2ede2636), R(v22), R(v17, v30)); // fcmgt v22.4h, v17.4h, v30.4h + CMP_IO(dci(0x5ee0c885), R(v5), R(v4)); // fcmgt d5, d4, #0.0 + CMP_IO(dci(0x5ef8c97e), R(v30), R(v11)); // fcmgt h30, h11, #0.0 + CMP_IO(dci(0x7ebde7b3), R(v19), R(v29, v29)); // fcmgt s19, s29, s29 + CMP_IO(dci(0x7ede24ac), R(v12), R(v5, v30)); // fcmgt h12, h5, h30 + CMP_IO(dci(0x65d02e1e), + R(p14), + R(p3, v16)); // fcmgt p14.d, p3/z, z16.d, #0.0 + CMP_IO(dci(0x659d5078), + R(p8), + R(p4, v3, v29)); // fcmgt p8.s, p4/z, z3.s, z29.s + CMP_IO(dci(0x6f5b70e2), + R(v2), + R(v2, v7, v11)); // fcmla v2.8h, v7.8h, v11.h[0], #270 + CMP_IO(dci(0x6fbb7b9a), + R(v26), + R(v26, v28, v11)); // fcmla v26.4s, v28.4s, v11.s[1], #270 + CMP_IO(dci(0x2e9bcd80), + R(v0), + R(v0, v12, v27)); // fcmla v0.2s, v12.2s, v27.2s, #90 + CMP_IO(dci(0x645b119a), + R(v26), + R(v26, p4, v12, v27)); // fcmla z26.h, p4/m, z12.h, z27.h, #0 + CMP_IO(dci(0x64bc1dc1), + R(v1), + R(v1, v14, v4)); // fcmla z1.h, z14.h, z4.h[3], #270 + CMP_IO(dci(0x64fd16d4), + R(v20), + R(v20, v22, v13)); // fcmla z20.s, z22.s, z13.s[1], #90 + CMP_IO(dci(0x6ee0dae1), R(v1), R(v23)); // fcmle v1.2d, v23.2d, #0.0 + CMP_IO(dci(0x6ef8dbda), R(v26), R(v30)); // fcmle v26.8h, v30.8h, #0.0 + + CLEANUP(); +} + +TEST(group_13) { + SETUP(); + + CMP_IO(dci(0x7ea0db2f), R(v15), R(v25)); // fcmle s15, s25, #0.0 + CMP_IO(dci(0x7ef8db08), R(v8), R(v24)); // fcmle h8, h24, #0.0 + CMP_IO(dci(0x65912fb8), R(p8), R(p3, v29)); // fcmle p8.s, p3/z, z29.s, #0.0 + CMP_IO(dci(0x4ee0ebda), R(v26), R(v30)); // fcmlt v26.2d, v30.2d, #0.0 + CMP_IO(dci(0x4ef8eae1), R(v1), R(v23)); // fcmlt v1.8h, v23.8h, #0.0 + CMP_IO(dci(0x5ea0eb08), R(v8), R(v24)); // fcmlt s8, s24, #0.0 + CMP_IO(dci(0x5ef8eb2f), R(v15), R(v25)); // fcmlt h15, h25, #0.0 + CMP_IO(dci(0x65d13d4b), + R(p11), + R(p7, v10)); // fcmlt p11.d, p7/z, z10.d, #0.0 + CMP_IO(dci(0x65d33ac6), R(p6), R(p6, v22)); // fcmne p6.d, p6/z, z22.d, #0.0 + CMP_IO(dci(0x659c76b0), + R(p0), + R(p5, v21, v28)); // fcmne p0.s, p5/z, z21.s, z28.s + CMP_IO(dci(0x1e792120), R(), R(v9, v25)); // fcmp d9, d25 + CMP_IO(dci(0x1e7e20a8), R(), R(v5)); // fcmp d5, #0.0 + CMP_IO(dci(0x1ef92380), R(), R(v28, v25)); // fcmp h28, h25 + CMP_IO(dci(0x1efe2188), R(), R(v12)); // fcmp h12, #0.0 + CMP_IO(dci(0x1e3a23c0), R(), R(v30, v26)); // fcmp s30, s26 + CMP_IO(dci(0x1e3d2088), R(), R(v4)); // fcmp s4, #0.0 + CMP_IO(dci(0x1e7d23d0), R(), R(v30, v29)); // fcmpe d30, d29 + CMP_IO(dci(0x1e7a2098), R(), R(v4)); // fcmpe d4, #0.0 + CMP_IO(dci(0x1efd22f0), R(), R(v23, v29)); // fcmpe h23, h29 + CMP_IO(dci(0x1efa2238), R(), R(v17)); // fcmpe h17, #0.0 + CMP_IO(dci(0x1e3e23f0), R(), R(v31, v30)); // fcmpe s31, s30 + CMP_IO(dci(0x1e3921f8), R(), R(v15)); // fcmpe s15, #0.0 + CMP_IO(dci(0x6549c4e3), + R(p3), + R(p1, v7, v9)); // fcmuo p3.h, p1/z, z7.h, z9.h + CMP_IO(dci(0x05d3d11c), + R(v28), + R(v28, p3)); // fmov z28.d, p3/m, #0x88 (-3.0000) + CMP_IO(dci(0x1e7deefb), R(v27), R(v23, v29)); // fcsel d27, d23, d29, al + CMP_IO(dci(0x1efdbd57), R(v23), R(v10, v29)); // fcsel h23, h10, h29, lt + CMP_IO(dci(0x1e3eacc6), R(v6), R(v6, v30)); // fcsel s6, s6, s30, ge + CMP_IO(dci(0x1ee2c0ae), R(v14), R(v5)); // fcvt d14, h5 + CMP_IO(dci(0x1e22c0ef), R(v15), R(v7)); // fcvt d15, s7 + CMP_IO(dci(0x1e63c0ae), R(v14), R(v5)); // fcvt h14, d5 + CMP_IO(dci(0x1e23c003), R(v3), R(v0)); // fcvt h3, s0 + CMP_IO(dci(0x1e6240ef), R(v15), R(v7)); // fcvt s15, d7 + + CLEANUP(); +} + +TEST(group_14) { + SETUP(); + + CMP_IO(dci(0x1ee24003), R(v3), R(v0)); // fcvt s3, h0 + CMP_IO(dci(0x65c8bc03), R(v3), R(v3, p7, v0)); // fcvt z3.h, p7/m, z0.d + CMP_IO(dci(0x65cabe52), R(v18), R(v18, p7, v18)); // fcvt z18.s, p7/m, z18.d + CMP_IO(dci(0x65c9bc03), R(v3), R(v3, p7, v0)); // fcvt z3.d, p7/m, z0.h + CMP_IO(dci(0x6589b4ae), R(v14), R(v14, p5, v5)); // fcvt z14.s, p5/m, z5.h + CMP_IO(dci(0x65cbbe52), R(v18), R(v18, p7, v18)); // fcvt z18.d, p7/m, z18.s + CMP_IO(dci(0x6588b4ae), R(v14), R(v14, p5, v5)); // fcvt z14.h, p5/m, z5.s + CMP_IO(dci(0x1e64034b), R(x11), R(v26)); // fcvtas w11, d26 + CMP_IO(dci(0x1ee401a7), R(x7), R(v13)); // fcvtas w7, h13 + CMP_IO(dci(0x1e2403f6), R(x22), R(v31)); // fcvtas w22, s31 + CMP_IO(dci(0x9e6400e2), R(x2), R(v7)); // fcvtas x2, d7 + CMP_IO(dci(0x9ee4033e), R(x30), R(v25)); // fcvtas x30, h25 + CMP_IO(dci(0x9e24025f), R(), R(v18)); // fcvtas xzr, s18 + CMP_IO(dci(0x0e21c98b), R(v11), R(v12)); // fcvtas v11.2s, v12.2s + CMP_IO(dci(0x0e79c964), R(v4), R(v11)); // fcvtas v4.4h, v11.4h + CMP_IO(dci(0x5e61c885), R(v5), R(v4)); // fcvtas d5, d4 + CMP_IO(dci(0x5e79c97e), R(v30), R(v11)); // fcvtas h30, h11 + CMP_IO(dci(0x1e65001d), R(x29), R(v0)); // fcvtau w29, d0 + CMP_IO(dci(0x1ee50331), R(x17), R(v25)); // fcvtau w17, h25 + CMP_IO(dci(0x1e250324), R(x4), R(v25)); // fcvtau w4, s25 + CMP_IO(dci(0x9e650358), R(x24), R(v26)); // fcvtau x24, d26 + CMP_IO(dci(0x9ee5026c), R(x12), R(v19)); // fcvtau x12, h19 + CMP_IO(dci(0x9e2503e9), R(x9), R(v31)); // fcvtau x9, s31 + CMP_IO(dci(0x2e21c93f), R(v31), R(v9)); // fcvtau v31.2s, v9.2s + CMP_IO(dci(0x2e79ca36), R(v22), R(v17)); // fcvtau v22.4h, v17.4h + CMP_IO(dci(0x7e21cbb3), R(v19), R(v29)); // fcvtau s19, s29 + CMP_IO(dci(0x7e79c8ac), R(v12), R(v5)); // fcvtau h12, h5 + CMP_IO(dci(0x0e217a2b), R(v11), R(v17)); // fcvtl v11.4s, v17.4h + CMP_IO(dci(0x6489ae86), R(v6), R(v6, p3, v20)); // fcvtlt z6.s, p3/m, z20.h + CMP_IO(dci(0x64cbb19a), + R(v26), + R(v26, p4, v12)); // fcvtlt z26.d, p4/m, z12.s + CMP_IO(dci(0x1e7001a7), R(x7), R(v13)); // fcvtms w7, d13 + CMP_IO(dci(0x1ef0034b), R(x11), R(v26)); // fcvtms w11, h26 + + CLEANUP(); +} + +TEST(group_15) { + SETUP(); + + CMP_IO(dci(0x1e30030a), R(x10), R(v24)); // fcvtms w10, s24 + CMP_IO(dci(0x9e70033e), R(x30), R(v25)); // fcvtms x30, d25 + CMP_IO(dci(0x9ef000e2), R(x2), R(v7)); // fcvtms x2, h7 + CMP_IO(dci(0x9e300173), R(x19), R(v11)); // fcvtms x19, s11 + CMP_IO(dci(0x4e21bbe7), R(v7), R(v31)); // fcvtms v7.4s, v31.4s + CMP_IO(dci(0x4e79bbc0), R(v0), R(v30)); // fcvtms v0.8h, v30.8h + CMP_IO(dci(0x5e61ba29), R(v9), R(v17)); // fcvtms d9, d17 + CMP_IO(dci(0x5e79bb22), R(v2), R(v25)); // fcvtms h2, h25 + CMP_IO(dci(0x1e710331), R(x17), R(v25)); // fcvtmu w17, d25 + CMP_IO(dci(0x1ef1001d), R(x29), R(v0)); // fcvtmu w29, h0 + CMP_IO(dci(0x1e310180), R(x0), R(v12)); // fcvtmu w0, s12 + CMP_IO(dci(0x9e71026c), R(x12), R(v19)); // fcvtmu x12, d19 + CMP_IO(dci(0x9ef10358), R(x24), R(v26)); // fcvtmu x24, h26 + CMP_IO(dci(0x9e310245), R(x5), R(v18)); // fcvtmu x5, s18 + CMP_IO(dci(0x6e61bb45), R(v5), R(v26)); // fcvtmu v5.2d, v26.2d + CMP_IO(dci(0x2e79b94a), R(v10), R(v10)); // fcvtmu v10.4h, v10.4h + CMP_IO(dci(0x7e21b89f), R(v31), R(v4)); // fcvtmu s31, s4 + CMP_IO(dci(0x7e79b998), R(v24), R(v12)); // fcvtmu h24, h12 + CMP_IO(dci(0x0e216a2b), R(v11), R(v17)); // fcvtn v11.4h, v17.4s + CMP_IO(dci(0x1e60033e), R(x30), R(v25)); // fcvtns w30, d25 + CMP_IO(dci(0x1ee000e2), R(x2), R(v7)); // fcvtns w2, h7 + CMP_IO(dci(0x1e200173), R(x19), R(v11)); // fcvtns w19, s11 + CMP_IO(dci(0x9e6001a7), R(x7), R(v13)); // fcvtns x7, d13 + CMP_IO(dci(0x9ee0034b), R(x11), R(v26)); // fcvtns x11, h26 + CMP_IO(dci(0x9e20030a), R(x10), R(v24)); // fcvtns x10, s24 + CMP_IO(dci(0x4e21aace), R(v14), R(v22)); // fcvtns v14.4s, v22.4s + CMP_IO(dci(0x0e79a885), R(v5), R(v4)); // fcvtns v5.4h, v4.4h + CMP_IO(dci(0x5e21a964), R(v4), R(v11)); // fcvtns s4, s11 + CMP_IO(dci(0x5e79a98b), R(v11), R(v12)); // fcvtns h11, h12 + CMP_IO(dci(0x64caa66c), + R(v12), + R(v12, p1, v19)); // fcvtnt z12.s, p1/m, z19.d + CMP_IO(dci(0x6488a358), + R(v24), + R(v24, p0, v26)); // fcvtnt z24.h, p0/m, z26.s + CMP_IO(dci(0x1e61026c), R(x12), R(v19)); // fcvtnu w12, d19 + + CLEANUP(); +} + +TEST(group_16) { + SETUP(); + + CMP_IO(dci(0x1ee10358), R(x24), R(v26)); // fcvtnu w24, h26 + CMP_IO(dci(0x1e210245), R(x5), R(v18)); // fcvtnu w5, s18 + CMP_IO(dci(0x9e610331), R(x17), R(v25)); // fcvtnu x17, d25 + CMP_IO(dci(0x9ee1001d), R(x29), R(v0)); // fcvtnu x29, h0 + CMP_IO(dci(0x9e210180), R(x0), R(v12)); // fcvtnu x0, s12 + CMP_IO(dci(0x6e21a8ac), R(v12), R(v5)); // fcvtnu v12.4s, v5.4s + CMP_IO(dci(0x6e79abb3), R(v19), R(v29)); // fcvtnu v19.8h, v29.8h + CMP_IO(dci(0x7e61aa36), R(v22), R(v17)); // fcvtnu d22, d17 + CMP_IO(dci(0x7e79aa5d), R(v29), R(v18)); // fcvtnu h29, h18 + CMP_IO(dci(0x1e680324), R(x4), R(v25)); // fcvtps w4, d25 + CMP_IO(dci(0x1ee80180), R(x0), R(v12)); // fcvtps w0, h12 + CMP_IO(dci(0x1e28001d), R(x29), R(v0)); // fcvtps w29, s0 + CMP_IO(dci(0x9e6803e9), R(x9), R(v31)); // fcvtps x9, d31 + CMP_IO(dci(0x9ee80245), R(x5), R(v18)); // fcvtps x5, h18 + CMP_IO(dci(0x9e280358), R(x24), R(v26)); // fcvtps x24, s26 + CMP_IO(dci(0x0ea1a964), R(v4), R(v11)); // fcvtps v4.2s, v11.2s + CMP_IO(dci(0x0ef9a98b), R(v11), R(v12)); // fcvtps v11.4h, v12.4h + CMP_IO(dci(0x5ee1a97e), R(v30), R(v11)); // fcvtps d30, d11 + CMP_IO(dci(0x5ef9a885), R(v5), R(v4)); // fcvtps h5, h4 + CMP_IO(dci(0x1e6903f6), R(x22), R(v31)); // fcvtpu w22, d31 + CMP_IO(dci(0x1ee9030a), R(x10), R(v24)); // fcvtpu w10, h24 + CMP_IO(dci(0x1e29034b), R(x11), R(v26)); // fcvtpu w11, s26 + CMP_IO(dci(0x9e69025f), R(), R(v18)); // fcvtpu xzr, d18 + CMP_IO(dci(0x9ee90173), R(x19), R(v11)); // fcvtpu x19, h11 + CMP_IO(dci(0x9e2900e2), R(x2), R(v7)); // fcvtpu x2, s7 + CMP_IO(dci(0x2ea1a95f), R(v31), R(v10)); // fcvtpu v31.2s, v10.2s + CMP_IO(dci(0x2ef9aa5d), R(v29), R(v18)); // fcvtpu v29.4h, v18.4h + CMP_IO(dci(0x7ea1a8ac), R(v12), R(v5)); // fcvtpu s12, s5 + CMP_IO(dci(0x7ef9abb3), R(v19), R(v29)); // fcvtpu h19, h29 + CMP_IO(dci(0x650abeba), R(v26), R(v26, p7, v21)); // fcvtx z26.s, p7/m, z21.d + CMP_IO(dci(0x6e61695f), R(v31), R(v10)); // fcvtxn2 v31.4s, v10.2d + CMP_IO(dci(0x7e616a5d), R(v29), R(v18)); // fcvtxn s29, d18 + + CLEANUP(); +} + +TEST(group_17) { + SETUP(); + + CMP_IO(dci(0x640aa044), R(v4), R(v4, p0, v2)); // fcvtxnt z4.s, p0/m, z2.d + CMP_IO(dci(0x1e5894ae), R(x14), R(v5)); // fcvtzs w14, d5, #27 + CMP_IO(dci(0x1e78030a), R(x10), R(v24)); // fcvtzs w10, d24 + CMP_IO(dci(0x1ed8be52), R(x18), R(v18)); // fcvtzs w18, h18, #17 + CMP_IO(dci(0x1ef803f6), R(x22), R(v31)); // fcvtzs w22, h31 + CMP_IO(dci(0x1e189c03), R(x3), R(v0)); // fcvtzs w3, s0, #25 + CMP_IO(dci(0x1e3801a7), R(x7), R(v13)); // fcvtzs w7, s13 + CMP_IO(dci(0x9e581f17), R(x23), R(v24)); // fcvtzs x23, d24, #57 + CMP_IO(dci(0x9e780173), R(x19), R(v11)); // fcvtzs x19, d11 + CMP_IO(dci(0x9ed848bb), R(x27), R(v5)); // fcvtzs x27, h5, #46 + CMP_IO(dci(0x9ef8025f), R(), R(v18)); // fcvtzs xzr, h18 + CMP_IO(dci(0x9e18919a), R(x26), R(v12)); // fcvtzs x26, s12, #28 + CMP_IO(dci(0x9e38033e), R(x30), R(v25)); // fcvtzs x30, s25 + CMP_IO(dci(0x0ea1b893), R(v19), R(v4)); // fcvtzs v19.2s, v4.2s + CMP_IO(dci(0x0ef9b971), R(v17), R(v11)); // fcvtzs v17.4h, v11.4h + CMP_IO(dci(0x4f42ffc2), R(v2), R(v30)); // fcvtzs v2.2d, v30.2d, #62 + CMP_IO(dci(0x5ea1b998), R(v24), R(v12)); // fcvtzs s24, s12 + CMP_IO(dci(0x5ef9b89f), R(v31), R(v4)); // fcvtzs h31, h4 + CMP_IO(dci(0x5f11fc60), R(v0), R(v3)); // fcvtzs h0, h3, #15 + CMP_IO(dci(0x65d8aa45), R(v5), R(v5, p2, v18)); // fcvtzs z5.s, p2/m, z18.d + CMP_IO(dci(0x65deb324), R(v4), R(v4, p4, v25)); // fcvtzs z4.d, p4/m, z25.d + CMP_IO(dci(0x655abf7f), + R(v31), + R(v31, p7, v27)); // fcvtzs z31.h, p7/m, z27.h + CMP_IO(dci(0x655cbeba), + R(v26), + R(v26, p7, v21)); // fcvtzs z26.s, p7/m, z21.h + CMP_IO(dci(0x655ea60f), + R(v15), + R(v15, p1, v16)); // fcvtzs z15.d, p1/m, z16.h + CMP_IO(dci(0x659ca66c), + R(v12), + R(v12, p1, v19)); // fcvtzs z12.s, p1/m, z19.s + CMP_IO(dci(0x65dca41d), R(v29), R(v29, p1, v0)); // fcvtzs z29.d, p1/m, z0.s + CMP_IO(dci(0x1e59ffdc), R(x28), R(v30)); // fcvtzu w28, d30, #1 + CMP_IO(dci(0x1e790180), R(x0), R(v12)); // fcvtzu w0, d12 + CMP_IO(dci(0x1ed9fcc8), R(x8), R(v6)); // fcvtzu w8, h6, #1 + CMP_IO(dci(0x1ef90324), R(x4), R(v25)); // fcvtzu w4, h25 + CMP_IO(dci(0x1e19b0d5), R(x21), R(v6)); // fcvtzu w21, s6, #20 + CMP_IO(dci(0x1e390331), R(x17), R(v25)); // fcvtzu w17, s25 + + CLEANUP(); +} + +TEST(group_18) { + SETUP(); + + CMP_IO(dci(0x9e59e0a1), R(x1), R(v5)); // fcvtzu x1, d5, #8 + CMP_IO(dci(0x9e790245), R(x5), R(v18)); // fcvtzu x5, d18 + CMP_IO(dci(0x9ed95d8d), R(x13), R(v12)); // fcvtzu x13, h12, #41 + CMP_IO(dci(0x9ef903e9), R(x9), R(v31)); // fcvtzu x9, h31 + CMP_IO(dci(0x9e19d010), R(x16), R(v0)); // fcvtzu x16, s0, #12 + CMP_IO(dci(0x9e39026c), R(x12), R(v19)); // fcvtzu x12, s19 + CMP_IO(dci(0x6ea1bbc0), R(v0), R(v30)); // fcvtzu v0.4s, v30.4s + CMP_IO(dci(0x6ef9bbe7), R(v7), R(v31)); // fcvtzu v7.8h, v31.8h + CMP_IO(dci(0x6f22fc27), R(v7), R(v1)); // fcvtzu v7.4s, v1.4s, #30 + CMP_IO(dci(0x7ee1bb22), R(v2), R(v25)); // fcvtzu d2, d25 + CMP_IO(dci(0x7ef9ba29), R(v9), R(v17)); // fcvtzu h9, h17 + CMP_IO(dci(0x7f21fdea), R(v10), R(v15)); // fcvtzu s10, s15, #31 + CMP_IO(dci(0x65d9b573), + R(v19), + R(v19, p5, v11)); // fcvtzu z19.s, p5/m, z11.d + CMP_IO(dci(0x65dfa7f6), + R(v22), + R(v22, p1, v31)); // fcvtzu z22.d, p1/m, z31.d + CMP_IO(dci(0x655ba109), R(v9), R(v9, p0, v8)); // fcvtzu z9.h, p0/m, z8.h + CMP_IO(dci(0x655dbd30), R(v16), R(v16, p7, v9)); // fcvtzu z16.s, p7/m, z9.h + CMP_IO(dci(0x655fa799), + R(v25), + R(v25, p1, v28)); // fcvtzu z25.d, p1/m, z28.h + CMP_IO(dci(0x659dbb3e), + R(v30), + R(v30, p6, v25)); // fcvtzu z30.s, p6/m, z25.s + CMP_IO(dci(0x65ddaf4b), + R(v11), + R(v11, p3, v26)); // fcvtzu z11.d, p3/m, z26.s + CMP_IO(dci(0x2e3afe2b), R(v11), R(v17, v26)); // fdiv v11.2s, v17.2s, v26.2s + CMP_IO(dci(0x2e5a3e04), R(v4), R(v16, v26)); // fdiv v4.4h, v16.4h, v26.4h + CMP_IO(dci(0x1e7c19f5), R(v21), R(v15, v28)); // fdiv d21, d15, d28 + CMP_IO(dci(0x1efd1b99), R(v25), R(v28, v29)); // fdiv h25, h28, h29 + CMP_IO(dci(0x1e3c18fc), R(v28), R(v7, v28)); // fdiv s28, s7, s28 + CMP_IO(dci(0x65cd8024), R(v4), R(p0, v4, v1)); // fdiv z4.d, p0/m, z4.d, z1.d + CMP_IO(dci(0x654c982a), + R(v10), + R(p6, v10, v1)); // fdivr z10.h, p6/m, z10.h, z1.h + CMP_IO(dci(0x25b9d708), R(v8), R()); // fmov z8.s, #0xb8 (-24.0000) + CMP_IO(dci(0x0460b87a), R(v26), R(v3)); // fexpa z26.h, z3.h + CMP_IO(dci(0x1e7e0044), R(x4), R(v2)); // fjcvtzs w4, d2 + CMP_IO(dci(0x651ab0d5), R(v21), R(v21, p4, v6)); // flogb z21.h, p4/m, z6.h + CMP_IO(dci(0x65bd9c6b), + R(v11), + R(v11, p7, v3, v29)); // fmad z11.s, p7/m, z3.s, z29.s + CMP_IO(dci(0x1f5a7573), + R(v19), + R(v11, v26, v29)); // fmadd d19, d11, d26, d29 + + CLEANUP(); +} + +TEST(group_19) { + SETUP(); + + CMP_IO(dci(0x1fdb725f), + R(v31), + R(v18, v27, v28)); // fmadd h31, h18, h27, h28 + CMP_IO(dci(0x1f1b3b3e), + R(v30), + R(v25, v27, v14)); // fmadd s30, s25, s27, s14 + CMP_IO(dci(0x0e2df6ee), R(v14), R(v23, v13)); // fmax v14.2s, v23.2s, v13.2s + CMP_IO(dci(0x0e593525), R(v5), R(v9, v25)); // fmax v5.4h, v9.4h, v25.4h + CMP_IO(dci(0x1e7d4ad4), R(v20), R(v22, v29)); // fmax d20, d22, d29 + CMP_IO(dci(0x1efd4930), R(v16), R(v9, v29)); // fmax h16, h9, h29 + CMP_IO(dci(0x1e3c4aad), R(v13), R(v21, v28)); // fmax s13, s21, s28 + CMP_IO(dci(0x65de983e), R(v30), R(p6, v30)); // fmax z30.d, p6/m, z30.d, #1.0 + CMP_IO(dci(0x6546841d), + R(v29), + R(p1, v29, v0)); // fmax z29.h, p1/m, z29.h, z0.h + CMP_IO(dci(0x4e3ac487), R(v7), R(v4, v26)); // fmaxnm v7.4s, v4.4s, v26.4s + CMP_IO(dci(0x0e590460), R(v0), R(v3, v25)); // fmaxnm v0.4h, v3.4h, v25.4h + CMP_IO(dci(0x1e7d6b99), R(v25), R(v28, v29)); // fmaxnm d25, d28, d29 + CMP_IO(dci(0x1efc69f5), R(v21), R(v15, v28)); // fmaxnm h21, h15, h28 + CMP_IO(dci(0x1e3c69e8), R(v8), R(v15, v28)); // fmaxnm s8, s15, s28 + CMP_IO(dci(0x65dc8c03), R(v3), R(p3, v3)); // fmaxnm z3.d, p3/m, z3.d, #0.0 + CMP_IO(dci(0x65848358), + R(v24), + R(p0, v24, v26)); // fmaxnm z24.s, p0/m, z24.s, z26.s + CMP_IO(dci(0x2e3dc557), + R(v23), + R(v10, v29)); // fmaxnmp v23.2s, v10.2s, v29.2s + CMP_IO(dci(0x2e5e0650), + R(v16), + R(v18, v30)); // fmaxnmp v16.4h, v18.4h, v30.4h + CMP_IO(dci(0x5e30c878), R(v24), R(v3)); // fmaxnmp h24, v3.2h + CMP_IO(dci(0x7e70c8a1), R(v1), R(v5)); // fmaxnmp d1, v5.2d + CMP_IO(dci(0x649489e8), + R(v8), + R(p2, v8, v15)); // fmaxnmp z8.s, p2/m, z8.s, z15.s + CMP_IO(dci(0x4e30c98d), R(v13), R(v12)); // fmaxnmv h13, v12.8h + CMP_IO(dci(0x6e30cac4), R(v4), R(v22)); // fmaxnmv s4, v22.4s + CMP_IO(dci(0x65842358), R(v24), R(p0, v26)); // fmaxnmv s24, p0, z26.s + CMP_IO(dci(0x6e7df6ee), R(v14), R(v23, v29)); // fmaxp v14.2d, v23.2d, v29.2d + CMP_IO(dci(0x6e5e3715), R(v21), R(v24, v30)); // fmaxp v21.8h, v24.8h, v30.8h + CMP_IO(dci(0x5e30f921), R(v1), R(v9)); // fmaxp h1, v9.2h + CMP_IO(dci(0x7e30fbdc), R(v28), R(v30)); // fmaxp s28, v30.2s + CMP_IO(dci(0x64568aad), + R(v13), + R(p2, v13, v21)); // fmaxp z13.h, p2/m, z13.h, z21.h + CMP_IO(dci(0x4e30f8c8), R(v8), R(v6)); // fmaxv h8, v6.8h + CMP_IO(dci(0x6e30f91c), R(v28), R(v8)); // fmaxv s28, v8.4s + CMP_IO(dci(0x6546241d), R(v29), R(p1, v0)); // fmaxv h29, p1, z0.h + + CLEANUP(); +} + +TEST(group_20) { + SETUP(); + + CMP_IO(dci(0x0ebaf604), R(v4), R(v16, v26)); // fmin v4.2s, v16.2s, v26.2s + CMP_IO(dci(0x0eda362b), R(v11), R(v17, v26)); // fmin v11.4h, v17.4h, v26.4h + CMP_IO(dci(0x1e7c59ce), R(v14), R(v14, v28)); // fmin d14, d14, d28 + CMP_IO(dci(0x1efc5b72), R(v18), R(v27, v28)); // fmin h18, h27, h28 + CMP_IO(dci(0x1e3c5923), R(v3), R(v9, v28)); // fmin s3, s9, s28 + CMP_IO(dci(0x655f983c), R(v28), R(p6, v28)); // fmin z28.h, p6/m, z28.h, #1.0 + CMP_IO(dci(0x65879573), + R(v19), + R(p5, v19, v11)); // fmin z19.s, p5/m, z19.s, z11.s + CMP_IO(dci(0x4ef9c6c9), R(v9), R(v22, v25)); // fminnm v9.2d, v22.2d, v25.2d + CMP_IO(dci(0x4eda07c2), R(v2), R(v30, v26)); // fminnm v2.8h, v30.8h, v26.8h + CMP_IO(dci(0x1e7c7837), R(v23), R(v1, v28)); // fminnm d23, d1, d28 + CMP_IO(dci(0x1efc79db), R(v27), R(v14, v28)); // fminnm h27, h14, h28 + CMP_IO(dci(0x1e3c7aba), R(v26), R(v21, v28)); // fminnm s26, s21, s28 + CMP_IO(dci(0x65dd9029), R(v9), R(p4, v9)); // fminnm z9.d, p4/m, z9.d, #1.0 + CMP_IO(dci(0x65458b0a), + R(v10), + R(p2, v10, v24)); // fminnm z10.h, p2/m, z10.h, z24.h + CMP_IO(dci(0x6efec4b9), R(v25), R(v5, v30)); // fminnmp v25.2d, v5.2d, v30.2d + CMP_IO(dci(0x2edd0492), R(v18), R(v4, v29)); // fminnmp v18.4h, v4.4h, v29.4h + CMP_IO(dci(0x5eb0ca73), R(v19), R(v19)); // fminnmp h19, v19.2h + CMP_IO(dci(0x7eb0c8ef), R(v15), R(v7)); // fminnmp s15, v7.2s + CMP_IO(dci(0x64559eba), + R(v26), + R(p7, v26, v21)); // fminnmp z26.h, p7/m, z26.h, z21.h + CMP_IO(dci(0x4eb0c803), R(v3), R(v0)); // fminnmv h3, v0.8h + CMP_IO(dci(0x6eb0c85e), R(v30), R(v2)); // fminnmv s30, v2.4s + CMP_IO(dci(0x65452b0a), R(v10), R(p2, v24)); // fminnmv h10, p2, z24.h + CMP_IO(dci(0x6ebef7f4), R(v20), R(v31, v30)); // fminp v20.4s, v31.4s, v30.4s + CMP_IO(dci(0x6edd36fb), R(v27), R(v23, v29)); // fminp v27.8h, v23.8h, v29.8h + CMP_IO(dci(0x5eb0fa93), R(v19), R(v20)); // fminp h19, v20.2h + CMP_IO(dci(0x7ef0fa86), R(v6), R(v20)); // fminp d6, v20.2d + CMP_IO(dci(0x64978923), + R(v3), + R(p2, v3, v9)); // fminp z3.s, p2/m, z3.s, z9.s + CMP_IO(dci(0x4eb0f99a), R(v26), R(v12)); // fminv h26, v12.8h + CMP_IO(dci(0x6eb0fa37), R(v23), R(v17)); // fminv s23, v17.4s + CMP_IO(dci(0x65873573), R(v19), R(p5, v11)); // fminv s19, p5, z11.s + CMP_IO(dci(0x4ffb10d5), + R(v21), + R(v21, v6, v11)); // fmla v21.2d, v6.2d, v11.d[0] + CMP_IO(dci(0x4f1a1bdc), + R(v28), + R(v28, v30, v10)); // fmla v28.8h, v30.8h, v10.h[5] + + CLEANUP(); +} + +TEST(group_21) { + SETUP(); + + CMP_IO(dci(0x4e79cdea), + R(v10), + R(v10, v15, v25)); // fmla v10.2d, v15.2d, v25.2d + CMP_IO(dci(0x0e5a0e11), + R(v17), + R(v17, v16, v26)); // fmla v17.4h, v16.4h, v26.4h + CMP_IO(dci(0x5fbb18bb), R(v27), R(v27, v5, v11)); // fmla s27, s5, v11.s[3] + CMP_IO(dci(0x5f1c1a86), R(v6), R(v6, v20, v12)); // fmla h6, h20, v12.h[5] + CMP_IO(dci(0x65bc0923), + R(v3), + R(v3, p2, v9, v28)); // fmla z3.s, p2/m, z9.s, z28.s + CMP_IO(dci(0x64fb00c8), R(v8), R(v8, v6, v11)); // fmla z8.d, z6.d, z11.d[1] + CMP_IO(dci(0x643a03dc), + R(v28), + R(v28, v30, v2)); // fmla z28.h, z30.h, z2.h[3] + CMP_IO(dci(0x64bb0279), + R(v25), + R(v25, v19, v3)); // fmla z25.s, z19.s, z3.s[3] + CMP_IO(dci(0x6fbc89f5), + R(v21), + R(v21, v15, v12)); // fmlal2 v21.4s, v15.4h, v12.h[7] + CMP_IO(dci(0x6e3bcff6), + R(v22), + R(v22, v31, v27)); // fmlal2 v22.4s, v31.4h, v27.4h + CMP_IO(dci(0x0fbd0957), + R(v23), + R(v23, v10, v13)); // fmlal v23.2s, v10.2h, v13.h[7] + CMP_IO(dci(0x0e3aee38), + R(v24), + R(v24, v17, v26)); // fmlal v24.2s, v17.2h, v26.2h + CMP_IO(dci(0x64be80ac), + R(v12), + R(v12, v5, v30)); // fmlalb z12.s, z5.h, z30.h + CMP_IO(dci(0x64bb41a7), + R(v7), + R(v7, v13, v3)); // fmlalb z7.s, z13.h, z3.h[6] + CMP_IO(dci(0x64bd86ee), + R(v14), + R(v14, v23, v29)); // fmlalt z14.s, z23.h, z29.h + CMP_IO(dci(0x64ba44a1), R(v1), R(v1, v5, v2)); // fmlalt z1.s, z5.h, z2.h[6] + CMP_IO(dci(0x0fbb5b17), + R(v23), + R(v23, v24, v11)); // fmls v23.2s, v24.2s, v11.s[3] + CMP_IO(dci(0x4f1b519a), + R(v26), + R(v26, v12, v11)); // fmls v26.8h, v12.8h, v11.h[1] + CMP_IO(dci(0x0ebacd4c), + R(v12), + R(v12, v10, v26)); // fmls v12.2s, v10.2s, v26.2s + CMP_IO(dci(0x0ed90c53), + R(v19), + R(v19, v2, v25)); // fmls v19.4h, v2.4h, v25.4h + CMP_IO(dci(0x5ffb5a79), R(v25), R(v25, v19, v11)); // fmls d25, d19, v11.d[1] + CMP_IO(dci(0x5f1b58c8), R(v8), R(v8, v6, v11)); // fmls h8, h6, v11.h[5] + CMP_IO(dci(0x65fc2dc1), + R(v1), + R(v1, p3, v14, v28)); // fmls z1.d, p3/m, z14.d, z28.d + CMP_IO(dci(0x64fc0686), + R(v6), + R(v6, v20, v12)); // fmls z6.d, z20.d, z12.d[1] + CMP_IO(dci(0x647b059a), + R(v26), + R(v26, v12, v3)); // fmls z26.h, z12.h, z3.h[7] + CMP_IO(dci(0x64bb04bb), R(v27), R(v27, v5, v3)); // fmls z27.s, z5.s, z3.s[3] + CMP_IO(dci(0x2fbcc837), + R(v23), + R(v23, v1, v12)); // fmlsl2 v23.2s, v1.2h, v12.h[7] + CMP_IO(dci(0x2ebccf58), + R(v24), + R(v24, v26, v28)); // fmlsl2 v24.2s, v26.2h, v28.2h + CMP_IO(dci(0x4fbe4b15), + R(v21), + R(v21, v24, v14)); // fmlsl v21.4s, v24.4h, v14.h[7] + CMP_IO(dci(0x4ebaeed6), R(v22), R(v22, v26)); // fmlsl v22.4s, v22.4h, v26.4h + CMP_IO(dci(0x64bda14a), R(v10), R(v10, v29)); // fmlslb z10.s, z10.h, z29.h + CMP_IO(dci(0x64bb6a45), + R(v5), + R(v5, v18, v3)); // fmlslb z5.s, z18.h, z3.h[7] + + CLEANUP(); +} + +TEST(group_22) { + SETUP(); + + CMP_IO(dci(0x64bea650), + R(v16), + R(v16, v18, v30)); // fmlslt z16.s, z18.h, z30.h + CMP_IO(dci(0x64bb6c03), R(v3), R(v0, v3)); // fmlslt z3.s, z0.h, z3.h[7] + CMP_IO(dci(0x64fbe724), R(v4), R(v4, v25, v27)); // fmmla z4.d, z25.d, z27.d + CMP_IO(dci(0x64bce41d), R(v29), R(v29, v0, v28)); // fmmla z29.s, z0.s, z28.s + CMP_IO(dci(0x1ee6019a), R(x26), R(v12)); // fmov w26, h12 + CMP_IO(dci(0x1e2600bb), R(x27), R(v5)); // fmov w27, s5 + CMP_IO(dci(0x9e6600ef), R(x15), R(v7)); // fmov x15, d7 + CMP_IO(dci(0x9ee60003), R(x3), R(v0)); // fmov x3, h0 + CMP_IO(dci(0x9eae01f5), R(x21), R(v15)); // fmov x21, v15.D[1] + CMP_IO(dci(0x6f02f638), R(v24), R()); // fmov v24.2d, #0x51 (0.2656) + CMP_IO(dci(0x4f03fff6), R(v22), R()); // fmov v22.8h, #0x7f (1.9375) + CMP_IO(dci(0x4f03f7f6), R(v22), R()); // fmov v22.4s, #0x7f (1.9375) + CMP_IO(dci(0x9e6700ef), R(v15), R(x7)); // fmov d15, x7 + CMP_IO(dci(0x1e604399), R(v25), R(v28)); // fmov d25, d28 + CMP_IO(dci(0x1e7a7015), R(v21), R()); // fmov d21, #0xd3 (-0.2969) + CMP_IO(dci(0x1ee7019a), R(v26), R(x12)); // fmov h26, w12 + CMP_IO(dci(0x9ee70003), R(v3), R(x0)); // fmov h3, x0 + CMP_IO(dci(0x1ee041f5), R(v21), R(v15)); // fmov h21, h15 + CMP_IO(dci(0x1efa9019), R(v25), R()); // fmov h25, #0xd4 (-0.3125) + CMP_IO(dci(0x1e2700bb), R(v27), R(x5)); // fmov s27, w5 + CMP_IO(dci(0x1e2041e8), R(v8), R(v15)); // fmov s8, s15 + CMP_IO(dci(0x1e39b01c), R(v28), R()); // fmov s28, #0xcd (-0.2266) + CMP_IO(dci(0x9eaf01ce), R(v14), R(v14, x14)); // fmov v14.D[1], x14 + CMP_IO(dci(0x65f3bf3b), + R(v27), + R(v27, p7, v25, v19)); // fmsb z27.d, p7/m, z25.d, z19.d + CMP_IO(dci(0x1f5ba980), R(v0), R(v12, v27, v10)); // fmsub d0, d12, d27, d10 + CMP_IO(dci(0x1fdbd324), R(v4), R(v25, v27, v20)); // fmsub h4, h25, h27, h20 + CMP_IO(dci(0x1f1b8731), R(v17), R(v25, v27, v1)); // fmsub s17, s25, s27, s1 + CMP_IO(dci(0x4ffa90a1), R(v1), R(v5, v10)); // fmul v1.2d, v5.2d, v10.d[0] + CMP_IO(dci(0x0f1b9010), R(v16), R(v0, v11)); // fmul v16.4h, v0.4h, v11.h[1] + CMP_IO(dci(0x2e2ddeee), R(v14), R(v23, v13)); // fmul v14.2s, v23.2s, v13.2s + CMP_IO(dci(0x2e591d25), R(v5), R(v9, v25)); // fmul v5.4h, v9.4h, v25.4h + CMP_IO(dci(0x5fbc98ef), R(v15), R(v7, v12)); // fmul s15, s7, v12.s[3] + + CLEANUP(); +} + +TEST(group_23) { + SETUP(); + + CMP_IO(dci(0x5f1b9a52), R(v18), R(v18, v11)); // fmul h18, h18, v11.h[5] + CMP_IO(dci(0x1e7d0ad4), R(v20), R(v22, v29)); // fmul d20, d22, d29 + CMP_IO(dci(0x1efd0930), R(v16), R(v9, v29)); // fmul h16, h9, h29 + CMP_IO(dci(0x1e3c0aad), R(v13), R(v21, v28)); // fmul s13, s21, s28 + CMP_IO(dci(0x65da983e), R(v30), R(p6, v30)); // fmul z30.d, p6/m, z30.d, #2.0 + CMP_IO(dci(0x6542841d), + R(v29), + R(p1, v29, v0)); // fmul z29.h, p1/m, z29.h, z0.h + CMP_IO(dci(0x65580984), R(v4), R(v12, v24)); // fmul z4.h, z12.h, z24.h + CMP_IO(dci(0x64fc202a), R(v10), R(v1, v12)); // fmul z10.d, z1.d, z12.d[1] + CMP_IO(dci(0x647c2116), R(v22), R(v8, v4)); // fmul z22.h, z8.h, z4.h[7] + CMP_IO(dci(0x64bd22c7), R(v7), R(v22, v5)); // fmul z7.s, z22.s, z5.s[3] + CMP_IO(dci(0x6ffd9399), + R(v25), + R(v28, v13)); // fmulx v25.2d, v28.2d, v13.d[0] + CMP_IO(dci(0x6f1c99e8), R(v8), R(v15, v12)); // fmulx v8.8h, v15.8h, v12.h[5] + CMP_IO(dci(0x0e3bdd5f), R(v31), R(v10, v27)); // fmulx v31.2s, v10.2s, v27.2s + CMP_IO(dci(0x0e5e1e5d), R(v29), R(v18, v30)); // fmulx v29.4h, v18.4h, v30.4h + CMP_IO(dci(0x7fbc9837), R(v23), R(v1, v12)); // fmulx s23, s1, v12.s[3] + CMP_IO(dci(0x7f1c9aba), R(v26), R(v21, v12)); // fmulx h26, h21, v12.h[5] + CMP_IO(dci(0x5e3edcac), R(v12), R(v5, v30)); // fmulx s12, s5, s30 + CMP_IO(dci(0x5e5d1fb3), R(v19), R(v29, v29)); // fmulx h19, h29, h29 + CMP_IO(dci(0x654a9765), + R(v5), + R(p5, v5, v27)); // fmulx z5.h, p5/m, z5.h, z27.h + CMP_IO(dci(0x6ee0faee), R(v14), R(v23)); // fneg v14.2d, v23.2d + CMP_IO(dci(0x6ef8fb15), R(v21), R(v24)); // fneg v21.8h, v24.8h + CMP_IO(dci(0x1e6141c1), R(v1), R(v14)); // fneg d1, d14 + CMP_IO(dci(0x1ee142ad), R(v13), R(v21)); // fneg h13, h21 + CMP_IO(dci(0x1e214130), R(v16), R(v9)); // fneg s16, s9 + CMP_IO(dci(0x049daa8b), R(v11), R(v11, p2, v20)); // fneg z11.s, p2/m, z20.s + CMP_IO(dci(0x657bd0d5), + R(v21), + R(v21, p4, v6, v27)); // fnmad z21.h, p4/m, z6.h, z27.h + CMP_IO(dci(0x1f7c2aad), + R(v13), + R(v21, v28, v10)); // fnmadd d13, d21, d28, d10 + CMP_IO(dci(0x1ffc2dc1), R(v1), R(v14, v28, v11)); // fnmadd h1, h14, h28, h11 + CMP_IO(dci(0x1f3d46d4), + R(v20), + R(v22, v29, v17)); // fnmadd s20, s22, s29, s17 + CMP_IO(dci(0x657c441d), + R(v29), + R(v29, p1, v0, v28)); // fnmla z29.h, p1/m, z0.h, z28.h + CMP_IO(dci(0x65bb689b), + R(v27), + R(v27, p2, v4, v27)); // fnmls z27.s, p2/m, z4.s, z27.s + CMP_IO(dci(0x65fae0a1), + R(v1), + R(v1, p0, v5, v26)); // fnmsb z1.d, p0/m, z5.d, z26.d + + CLEANUP(); +} + +TEST(group_24) { + SETUP(); + + CMP_IO(dci(0x1f7c8b72), R(v18), R(v27, v28, v2)); // fnmsub d18, d27, d28, d2 + CMP_IO(dci(0x1ffce1ce), + R(v14), + R(v14, v28, v24)); // fnmsub h14, h14, h28, h24 + CMP_IO(dci(0x1f3de60f), + R(v15), + R(v16, v29, v25)); // fnmsub s15, s16, s29, s25 + CMP_IO(dci(0x1e7b8b3e), R(v30), R(v25, v27)); // fnmul d30, d25, d27 + CMP_IO(dci(0x1efb88e2), R(v2), R(v7, v27)); // fnmul h2, h7, h27 + CMP_IO(dci(0x1e3a8973), R(v19), R(v11, v26)); // fnmul s19, s11, s26 + CMP_IO(dci(0x4ea1d99d), R(v29), R(v12)); // frecpe v29.4s, v12.4s + CMP_IO(dci(0x0ef9db22), R(v2), R(v25)); // frecpe v2.4h, v25.4h + CMP_IO(dci(0x5ea1dbe7), R(v7), R(v31)); // frecpe s7, s31 + CMP_IO(dci(0x5ef9dbc0), R(v0), R(v30)); // frecpe h0, h30 + CMP_IO(dci(0x654e325d), R(v29), R(v18)); // frecpe z29.h, z18.h + CMP_IO(dci(0x4e3afc87), R(v7), R(v4, v26)); // frecps v7.4s, v4.4s, v26.4s + CMP_IO(dci(0x0e593c60), R(v0), R(v3, v25)); // frecps v0.4h, v3.4h, v25.4h + CMP_IO(dci(0x5e79fec9), R(v9), R(v22, v25)); // frecps d9, d22, d25 + CMP_IO(dci(0x5e5a3fc2), R(v2), R(v30, v26)); // frecps h2, h30, h26 + CMP_IO(dci(0x65da1a11), R(v17), R(v16, v26)); // frecps z17.d, z16.d, z26.d + CMP_IO(dci(0x5ea1f964), R(v4), R(v11)); // frecpx s4, s11 + CMP_IO(dci(0x5ef9f98b), R(v11), R(v12)); // frecpx h11, h12 + CMP_IO(dci(0x65ccbf3b), + R(v27), + R(v27, p7, v25)); // frecpx z27.d, p7/m, z25.d + CMP_IO(dci(0x6e61ebda), R(v26), R(v30)); // frint32x v26.2d, v30.2d + CMP_IO(dci(0x1e68c1f5), R(v21), R(v15)); // frint32x d21, d15 + CMP_IO(dci(0x1e28c0fc), R(v28), R(v7)); // frint32x s28, s7 + CMP_IO(dci(0x4e21e8ac), R(v12), R(v5)); // frint32z v12.4s, v5.4s + CMP_IO(dci(0x1e6842c7), R(v7), R(v22)); // frint32z d7, d22 + CMP_IO(dci(0x1e28402a), R(v10), R(v1)); // frint32z s10, s1 + CMP_IO(dci(0x2e21fa43), R(v3), R(v18)); // frint64x v3.2s, v18.2s + CMP_IO(dci(0x1e69c130), R(v16), R(v9)); // frint64x d16, d9 + CMP_IO(dci(0x1e29c1c1), R(v1), R(v14)); // frint64x s1, s14 + CMP_IO(dci(0x4e61fb45), R(v5), R(v26)); // frint64z v5.2d, v26.2d + CMP_IO(dci(0x1e69405e), R(v30), R(v2)); // frint64z d30, d2 + CMP_IO(dci(0x1e294293), R(v19), R(v20)); // frint64z s19, s20 + CMP_IO(dci(0x2e218a52), R(v18), R(v18)); // frinta v18.2s, v18.2s + + CLEANUP(); +} + +TEST(group_25) { + SETUP(); + + CMP_IO(dci(0x6e7988b9), R(v25), R(v5)); // frinta v25.8h, v5.8h + CMP_IO(dci(0x1e6642ad), R(v13), R(v21)); // frinta d13, d21 + CMP_IO(dci(0x1ee641c1), R(v1), R(v14)); // frinta h1, h14 + CMP_IO(dci(0x1e2642d4), R(v20), R(v22)); // frinta s20, s22 + CMP_IO(dci(0x6584a923), R(v3), R(v3, p2, v9)); // frinta z3.s, p2/m, z9.s + CMP_IO(dci(0x2ea19893), R(v19), R(v4)); // frinti v19.2s, v4.2s + CMP_IO(dci(0x2ef99971), R(v17), R(v11)); // frinti v17.4h, v11.4h + CMP_IO(dci(0x1e67c365), R(v5), R(v27)); // frinti d5, d27 + CMP_IO(dci(0x1ee7c109), R(v9), R(v8)); // frinti h9, h8 + CMP_IO(dci(0x1e27c38c), R(v12), R(v28)); // frinti s12, s28 + CMP_IO(dci(0x6587bc6b), R(v11), R(v11, p7, v3)); // frinti z11.s, p7/m, z3.s + CMP_IO(dci(0x4e619aee), R(v14), R(v23)); // frintm v14.2d, v23.2d + CMP_IO(dci(0x4e799b15), R(v21), R(v24)); // frintm v21.8h, v24.8h + CMP_IO(dci(0x1e6541c1), R(v1), R(v14)); // frintm d1, d14 + CMP_IO(dci(0x1ee542ad), R(v13), R(v21)); // frintm h13, h21 + CMP_IO(dci(0x1e254130), R(v16), R(v9)); // frintm s16, s9 + CMP_IO(dci(0x6582aa8b), + R(v11), + R(v11, p2, v20)); // frintm z11.s, p2/m, z20.s + CMP_IO(dci(0x0e218957), R(v23), R(v10)); // frintn v23.2s, v10.2s + CMP_IO(dci(0x0e798a50), R(v16), R(v18)); // frintn v16.4h, v18.4h + CMP_IO(dci(0x1e6440fc), R(v28), R(v7)); // frintn d28, d7 + CMP_IO(dci(0x1ee441e8), R(v8), R(v15)); // frintn h8, h15 + CMP_IO(dci(0x1e2441f5), R(v21), R(v15)); // frintn s21, s15 + CMP_IO(dci(0x65c0bba6), R(v6), R(v6, p6, v29)); // frintn z6.d, p6/m, z29.d + CMP_IO(dci(0x4ee188b9), R(v25), R(v5)); // frintp v25.2d, v5.2d + CMP_IO(dci(0x0ef98892), R(v18), R(v4)); // frintp v18.4h, v4.4h + CMP_IO(dci(0x1e64c3a6), R(v6), R(v29)); // frintp d6, d29 + CMP_IO(dci(0x1ee4c2ba), R(v26), R(v21)); // frintp h26, h21 + CMP_IO(dci(0x1e24c1db), R(v27), R(v14)); // frintp s27, s14 + CMP_IO(dci(0x6541ab74), + R(v20), + R(v20, p2, v27)); // frintp z20.h, p2/m, z27.h + CMP_IO(dci(0x6e619b45), R(v5), R(v26)); // frintx v5.2d, v26.2d + CMP_IO(dci(0x2e79994a), R(v10), R(v10)); // frintx v10.4h, v10.4h + CMP_IO(dci(0x1e67405e), R(v30), R(v2)); // frintx d30, d2 + + CLEANUP(); +} + +TEST(group_26) { + SETUP(); + + CMP_IO(dci(0x1ee74202), R(v2), R(v16)); // frintx h2, h16 + CMP_IO(dci(0x1e274293), R(v19), R(v20)); // frintx s19, s20 + CMP_IO(dci(0x65c6b11c), R(v28), R(v28, p4, v8)); // frintx z28.d, p4/m, z8.d + CMP_IO(dci(0x0ea19a43), R(v3), R(v18)); // frintz v3.2s, v18.2s + CMP_IO(dci(0x0ef99a1c), R(v28), R(v16)); // frintz v28.4h, v16.4h + CMP_IO(dci(0x1e65c130), R(v16), R(v9)); // frintz d16, d9 + CMP_IO(dci(0x1ee5c2d4), R(v20), R(v22)); // frintz h20, h22 + CMP_IO(dci(0x1e25c1c1), R(v1), R(v14)); // frintz s1, s14 + CMP_IO(dci(0x6543ab72), + R(v18), + R(v18, p2, v27)); // frintz z18.h, p2/m, z27.h + CMP_IO(dci(0x2ea1da2b), R(v11), R(v17)); // frsqrte v11.2s, v17.2s + CMP_IO(dci(0x2ef9da04), R(v4), R(v16)); // frsqrte v4.4h, v16.4h + CMP_IO(dci(0x7ee1d925), R(v5), R(v9)); // frsqrte d5, d9 + CMP_IO(dci(0x7ef9da1e), R(v30), R(v16)); // frsqrte h30, h16 + CMP_IO(dci(0x654f31fb), R(v27), R(v15)); // frsqrte z27.h, z15.h + CMP_IO(dci(0x4ee0fec9), R(v9), R(v22, v0)); // frsqrts v9.2d, v22.2d, v0.2d + CMP_IO(dci(0x0ede3d7e), + R(v30), + R(v11, v30)); // frsqrts v30.4h, v11.4h, v30.4h + CMP_IO(dci(0x5ebefd8b), R(v11), R(v12, v30)); // frsqrts s11, s12, s30 + CMP_IO(dci(0x5edd3d64), R(v4), R(v11, v29)); // frsqrts h4, h11, h29 + CMP_IO(dci(0x659d1fb3), R(v19), R(v29, v29)); // frsqrts z19.s, z29.s, z29.s + CMP_IO(dci(0x65c98731), + R(v17), + R(v17, p1, v17, v25)); // fscale z17.d, p1/m, z17.d, z25.d + CMP_IO(dci(0x6ee1fad6), R(v22), R(v22)); // fsqrt v22.2d, v22.2d + CMP_IO(dci(0x6ef9fafd), R(v29), R(v23)); // fsqrt v29.8h, v23.8h + CMP_IO(dci(0x1e61c3e9), R(v9), R(v31)); // fsqrt d9, d31 + CMP_IO(dci(0x1ee1c245), R(v5), R(v18)); // fsqrt h5, h18 + CMP_IO(dci(0x1e21c358), R(v24), R(v26)); // fsqrt s24, s26 + CMP_IO(dci(0x65cdae43), R(v3), R(v3, p3, v18)); // fsqrt z3.d, p3/m, z18.d + CMP_IO(dci(0x4ef9d78e), R(v14), R(v28, v25)); // fsub v14.2d, v28.2d, v25.2d + CMP_IO(dci(0x4eda17b5), R(v21), R(v29, v26)); // fsub v21.8h, v29.8h, v26.8h + CMP_IO(dci(0x1e7c3844), R(v4), R(v2, v28)); // fsub d4, d2, d28 + CMP_IO(dci(0x1efc3aa0), R(v0), R(v21, v28)); // fsub h0, h21, h28 + CMP_IO(dci(0x1e3d393d), R(v29), R(v9, v29)); // fsub s29, s9, s29 + CMP_IO(dci(0x65d9942e), R(v14), R(p5, v14)); // fsub z14.d, p5/m, z14.d, #1.0 + + CLEANUP(); +} + +TEST(group_27) { + SETUP(); + + CMP_IO(dci(0x65419d8d), + R(v13), + R(p7, v13, v12)); // fsub z13.h, p7/m, z13.h, z12.h + CMP_IO(dci(0x65cc0634), R(v20), R(v17, v12)); // fsub z20.d, z17.d, z12.d + CMP_IO(dci(0x659b9c30), + R(v16), + R(p7, v16)); // fsubr z16.s, p7/m, z16.s, #1.0 + CMP_IO(dci(0x65838a8b), + R(v11), + R(p2, v11, v20)); // fsubr z11.s, p2/m, z11.s, z20.s + CMP_IO(dci(0x659282e3), R(v3), R(v3, v23)); // ftmad z3.s, z3.s, z23.s, #2 + CMP_IO(dci(0x655a0fb5), R(v21), R(v29, v26)); // ftsmul z21.h, z29.h, z26.h + CMP_IO(dci(0x04bab22b), R(v11), R(v17, v26)); // ftssel z11.s, z17.s, z26.s + CMP_IO(dci(0x9add1557), R(x23), R(x10, x29)); // gmi x23, x10, x29 + CMP_IO(dci(0xd5032fdf), R(), R()); // hint #126 + CMP_IO(dci(0x45e0c383), + R(v3), + R(p0, v28, v0)); // histcnt z3.d, p0/z, z28.d, z0.d + CMP_IO(dci(0x453ea3e7), R(v7), R(v31, v30)); // histseg z7.b, z31.b, z30.b + CMP_IO(dci(0x043ae13f), R(), R()); // incb xzr, vl16, mul #11 + CMP_IO(dci(0x04f9e2c9), R(x9), R(x9)); // incd x9, #0x16, mul #10 + CMP_IO(dci(0x04f9c2c9), R(v9), R(v9)); // incd z9.d, #0x16, mul #10 + CMP_IO(dci(0x0479e125), R(x5), R(x5)); // inch x5, vl16, mul #10 + CMP_IO(dci(0x0479c125), R(v5), R(v5)); // inch z5.h, vl16, mul #10 + CMP_IO(dci(0x25ec89c1), R(x1), R(x1, p14)); // incp x1, p14.d + CMP_IO(dci(0x25ec81c1), R(v1), R(v1, p14)); // incp z1.d, p14 + CMP_IO(dci(0x04bae094), R(x20), R(x20)); // incw x20, vl4, mul #11 + CMP_IO(dci(0x04bac094), R(v20), R(v20)); // incw z20.s, vl4, mul #11 + CMP_IO(dci(0x04be4198), R(v24), R()); // index z24.s, #12, #-2 + CMP_IO(dci(0x047d4885), R(v5), R(x29)); // index z5.h, #4, w29 + CMP_IO(dci(0x047d4485), R(v5), R(x4)); // index z5.h, w4, #-3 + CMP_IO(dci(0x04be4d98), R(v24), R(x12, x30)); // index z24.s, w12, w30 + CMP_IO(dci(0x4e1d1f58), R(v24), R(v24, x26)); // mov v24.b[14], w26 + CMP_IO(dci(0x6e1e2758), R(v24), R(v24, v26)); // mov v24.h[7], v26.h[2] + CMP_IO(dci(0x05e4397e), R(v30), R(v30, x11)); // insr z30.d, x11 + CMP_IO(dci(0x05743bda), R(v26), R(v26, v30)); // insr z26.h, h30 + CMP_IO(dci(0x9ade1250), R(x16), R(x18, x30)); // irg x16, x18, x30 + CMP_IO(dci(0xd50331df), R(), R()); // isb + CMP_IO(dci(0x05a0b010), R(x16), R(p4, v0)); // lasta w16, p4, z0.s + CMP_IO(dci(0x0522866c), R(v12), R(p1, v19)); // lasta b12, p1, z19.b + + CLEANUP(); +} + +TEST(group_28) { + SETUP(); + + CMP_IO(dci(0x0561b0d5), R(x21), R(p4, v6)); // lastb w21, p4, z6.h + CMP_IO(dci(0x05e38731), R(v17), R(p1, v25)); // lastb d17, p1, z25.d + CMP_IO(dci(0x4c407fa8), R(v8), R(x29)); // ld1 {v8.2d}, [x29] + CMP_IO(dci(0x4c40afa8), R(v8, v9), R(x29)); // ld1 {v8.2d, v9.2d}, [x29] + CMP_IO(dci(0x4c406fa8), + R(v8, v9, v10), + R(x29)); // ld1 {v8.2d, v9.2d, v10.2d}, [x29] + CMP_IO(dci(0x4c402fa8), + R(v8, v9, v10, v11), + R(x29)); // ld1 {v8.2d, v9.2d, v10.2d, v11.2d}, [x29] + CMP_IO(dci(0x4cdf73f4), R(v20, sp), R(sp)); // ld1 {v20.16b}, [sp], #16 + CMP_IO(dci(0x4cdfa3f4), + R(v20, v21, sp), + R(sp)); // ld1 {v20.16b, v21.16b}, [sp], #32 + CMP_IO(dci(0x4cdf63f4), + R(v20, v21, v22, sp), + R(sp)); // ld1 {v20.16b, v21.16b, v22.16b}, [sp], #48 + CMP_IO(dci(0x4cdf23f4), + R(v20, v21, v22, v23, sp), + R(sp)); // ld1 {v20.16b, v21.16b, v22.16b, v23.16b}, [sp], #64 + CMP_IO(dci(0x4cc373f4), R(v20, sp), R(sp, x3)); // ld1 {v20.16b}, [sp], x3 + CMP_IO(dci(0x4cd3a3f4), + R(v20, v21, sp), + R(sp, x19)); // ld1 {v20.16b, v21.16b}, [sp], x19 + CMP_IO(dci(0x4cca63f4), + R(v20, v21, v22, sp), + R(sp, x10)); // ld1 {v20.16b, v21.16b, v22.16b}, [sp], x10 + CMP_IO(dci(0x4cc223f4), + R(v20, v21, v22, v23, sp), + R(sp, x2)); // ld1 {v20.16b, v21.16b, v22.16b, v23.16b}, [sp], x2 + CMP_IO(dci(0x4d401dea), R(v10), R(v10, x15)); // ld1 {v10.b}[15], [x15] + CMP_IO(dci(0x4d4085ea), R(v10), R(v10, x15)); // ld1 {v10.d}[1], [x15] + CMP_IO(dci(0x4d4059ea), R(v10), R(v10, x15)); // ld1 {v10.h}[7], [x15] + CMP_IO(dci(0x4d4091ea), R(v10), R(v10, x15)); // ld1 {v10.s}[3], [x15] + CMP_IO(dci(0x0ddf0d59), + R(v25, x10), + R(v25, x10)); // ld1 {v25.b}[3], [x10], #1 + CMP_IO(dci(0x4ddc13f4), + R(v20, sp), + R(v20, sp, x28)); // ld1 {v20.b}[12], [sp], x28 + CMP_IO(dci(0x0ddf8559), + R(v25, x10), + R(v25, x10)); // ld1 {v25.d}[0], [x10], #8 + CMP_IO(dci(0x4dd387f4), + R(v20, sp), + R(v20, sp, x19)); // ld1 {v20.d}[1], [sp], x19 + CMP_IO(dci(0x0ddf4959), + R(v25, x10), + R(v25, x10)); // ld1 {v25.h}[1], [x10], #2 + CMP_IO(dci(0x4dd053f4), + R(v20, sp), + R(v20, sp, x16)); // ld1 {v20.h}[6], [sp], x16 + CMP_IO(dci(0x0ddf8159), + R(v25, x10), + R(v25, x10)); // ld1 {v25.s}[0], [x10], #4 + CMP_IO(dci(0x4dc493f4), + R(v20, sp), + R(v20, sp, x4)); // ld1 {v20.s}[3], [sp], x4 + CMP_IO(dci(0xc43ccc37), + R(v23), + R(p3, v1)); // ld1b {z23.d}, p3/z, [z1.d, #28] + CMP_IO(dci(0x843cdeba), + R(v26), + R(p7, v21)); // ld1b {z26.s}, p7/z, [z21.s, #28] + CMP_IO(dci(0xa42cb38c), + R(v12), + R(p4, x28)); // ld1b {z12.h}, p4/z, [x28, #-4, mul vl] + CMP_IO(dci(0xa44da85e), + R(v30), + R(p2, x2)); // ld1b {z30.s}, p2/z, [x2, #-3, mul vl] + CMP_IO(dci(0xa46db2c7), + R(v7), + R(p4, x22)); // ld1b {z7.d}, p4/z, [x22, #-3, mul vl] + CMP_IO(dci(0xa40db7cd), + R(v13), + R(p5, x30)); // ld1b {z13.b}, p5/z, [x30, #-3, mul vl] + + CLEANUP(); +} + +TEST(group_29) { + SETUP(); + + CMP_IO(dci(0xa43c4109), + R(v9), + R(p0, x8, x28)); // ld1b {z9.h}, p0/z, [x8, x28] + CMP_IO(dci(0xa45c5f7f), + R(v31), + R(p7, x27, x28)); // ld1b {z31.s}, p7/z, [x27, x28] + CMP_IO(dci(0xa47c5516), + R(v22), + R(p5, x8, x28)); // ld1b {z22.d}, p5/z, [x8, x28] + CMP_IO(dci(0xa41e4a50), + R(v16), + R(p2, x18, x30)); // ld1b {z16.b}, p2/z, [x18, x30] + CMP_IO(dci(0xc45cd38c), + R(v12), + R(p4, x28, v28)); // ld1b {z12.d}, p4/z, [x28, z28.d] + CMP_IO(dci(0xc45b53e9), + R(v9), + R(p4, sp, v27)); // ld1b {z9.d}, p4/z, [sp, z27.d, sxtw] + CMP_IO(dci(0x841c4358), + R(v24), + R(p0, x26, v28)); // ld1b {z24.s}, p0/z, [x26, z28.s, uxtw] + CMP_IO(dci(0xc5bccdc1), + R(v1), + R(p3, v14)); // ld1d {z1.d}, p3/z, [z14.d, #224] + CMP_IO(dci(0xa5ecb451), + R(v17), + R(p5, x2)); // ld1d {z17.d}, p5/z, [x2, #-4, mul vl] + CMP_IO(dci(0xa5fc4044), + R(v4), + R(p0, x2, x28)); // ld1d {z4.d}, p0/z, [x2, x28, lsl #3] + CMP_IO(dci(0xc5fcdf7f), + R(v31), + R(p7, x27, v28)); // ld1d {z31.d}, p7/z, [x27, z28.d, lsl #3] + CMP_IO(dci(0xc5ddc85e), + R(v30), + R(p2, x2, v29)); // ld1d {z30.d}, p2/z, [x2, z29.d] + CMP_IO(dci(0xc5fb5b3e), + R(v30), + R(p6, x25, v27)); // ld1d {z30.d}, p6/z, [x25, z27.d, sxtw #3] + CMP_IO(dci(0xc59b525f), + R(v31), + R(p4, x18, v27)); // ld1d {z31.d}, p4/z, [x18, z27.d, uxtw] + CMP_IO(dci(0xc4bccaad), + R(v13), + R(p2, v21)); // ld1h {z13.d}, p2/z, [z21.d, #56] + CMP_IO(dci(0x84bdc6d4), + R(v20), + R(p1, v22)); // ld1h {z20.s}, p1/z, [z22.s, #58] + CMP_IO(dci(0xa4adb202), + R(v2), + R(p4, x16)); // ld1h {z2.h}, p4/z, [x16, #-3, mul vl] + CMP_IO(dci(0xa4cdb078), + R(v24), + R(p4, x3)); // ld1h {z24.s}, p4/z, [x3, #-3, mul vl] + CMP_IO(dci(0xa4edb13d), + R(v29), + R(p4, x9)); // ld1h {z29.d}, p4/z, [x9, #-3, mul vl] + CMP_IO(dci(0xa4bc4293), + R(v19), + R(p0, x20, x28)); // ld1h {z19.h}, p0/z, [x20, x28, lsl #1] + CMP_IO(dci(0xa4dc5765), + R(v5), + R(p5, x27, x28)); // ld1h {z5.s}, p5/z, [x27, x28, lsl #1] + CMP_IO(dci(0xa4fc56a0), + R(v0), + R(p5, x21, x28)); // ld1h {z0.d}, p5/z, [x21, x28, lsl #1] + CMP_IO(dci(0xc4fcc293), + R(v19), + R(p0, x20, v28)); // ld1h {z19.d}, p0/z, [x20, z28.d, lsl #1] + CMP_IO(dci(0xc4ddd202), + R(v2), + R(p4, x16, v29)); // ld1h {z2.d}, p4/z, [x16, z29.d] + CMP_IO(dci(0xc4fb44e2), + R(v2), + R(p1, x7, v27)); // ld1h {z2.d}, p1/z, [x7, z27.d, sxtw #1] + CMP_IO(dci(0xc49a5573), + R(v19), + R(p5, x11, v26)); // ld1h {z19.d}, p5/z, [x11, z26.d, uxtw] + CMP_IO(dci(0x84bb525f), + R(v31), + R(p4, x18, v27)); // ld1h {z31.s}, p4/z, [x18, z27.s, uxtw #1] + CMP_IO(dci(0x84db5b3e), + R(v30), + R(p6, x25, v27)); // ld1h {z30.s}, p6/z, [x25, z27.s, sxtw] + CMP_IO(dci(0x4d40c708), R(v8), R(x24)); // ld1r {v8.8h}, [x24] + CMP_IO(dci(0x0ddfce52), R(v18, x18), R(x18)); // ld1r {v18.1d}, [x18], #8 + CMP_IO(dci(0x4dd4c5db), + R(v27, x14), + R(x14, x20)); // ld1r {v27.8h}, [x14], x20 + CMP_IO(dci(0x845aab0a), + R(v10), + R(p2, x24)); // ld1rb {z10.h}, p2/z, [x24, #26] + + CLEANUP(); +} + +TEST(group_30) { + SETUP(); + + CMP_IO(dci(0x845bc980), R(v0), R(p2, x12)); // ld1rb {z0.s}, p2/z, [x12, #27] + CMP_IO(dci(0x847bea45), R(v5), R(p2, x18)); // ld1rb {z5.d}, p2/z, [x18, #59] + CMP_IO(dci(0x847a8bcf), + R(v15), + R(p2, x30)); // ld1rb {z15.b}, p2/z, [x30, #58] + CMP_IO(dci(0x85faf573), + R(v19), + R(p5, x11)); // ld1rd {z19.d}, p5/z, [x11, #464] + CMP_IO(dci(0x84dbb324), R(v4), R(p4, x25)); // ld1rh {z4.h}, p4/z, [x25, #54] + CMP_IO(dci(0x84dbc7f6), R(v22), R(p1, sp)); // ld1rh {z22.s}, p1/z, [sp, #54] + CMP_IO(dci(0x84fbf25f), + R(v31), + R(p4, x18)); // ld1rh {z31.d}, p4/z, [x18, #118] + CMP_IO(dci(0xa42e2bda), + R(v26), + R(p2, x30)); // ld1rob {z26.b}, p2/z, [x30, #-64] + CMP_IO(dci(0xa43a1fdc), + R(v28), + R(p7, x30, x26)); // ld1rob {z28.b}, p7/z, [x30, x26] + CMP_IO(dci(0xa5ac3516), + R(v22), + R(p5, x8)); // ld1rod {z22.d}, p5/z, [x8, #-128] + CMP_IO(dci(0xa5bb14ae), + R(v14), + R(p5, x5, x27)); // ld1rod {z14.d}, p5/z, [x5, x27, lsl #3] + CMP_IO(dci(0xa4ac3765), + R(v5), + R(p5, x27)); // ld1roh {z5.h}, p5/z, [x27, #-128] + CMP_IO(dci(0xa4bb1e52), + R(v18), + R(p7, x18, x27)); // ld1roh {z18.h}, p7/z, [x18, x27, lsl #1] + CMP_IO(dci(0xa52d3ba6), + R(v6), + R(p6, x29)); // ld1row {z6.s}, p6/z, [x29, #-96] + CMP_IO(dci(0xa53b05a7), + R(v7), + R(p1, x13, x27)); // ld1row {z7.s}, p1/z, [x13, x27, lsl #2] + CMP_IO(dci(0xa40e3708), + R(v8), + R(p5, x24)); // ld1rqb {z8.b}, p5/z, [x24, #-32] + CMP_IO(dci(0xa41c0e86), + R(v6), + R(p3, x20, x28)); // ld1rqb {z6.b}, p3/z, [x20, x28] + CMP_IO(dci(0xa58c338c), + R(v12), + R(p4, x28)); // ld1rqd {z12.d}, p4/z, [x28, #-64] + CMP_IO(dci(0xa59b19b4), + R(v20), + R(p6, x13, x27)); // ld1rqd {z20.d}, p6/z, [x13, x27, lsl #3] + CMP_IO(dci(0xa48d3c6b), + R(v11), + R(p7, x3)); // ld1rqh {z11.h}, p7/z, [x3, #-48] + CMP_IO(dci(0xa49b1010), + R(v16), + R(p4, x0, x27)); // ld1rqh {z16.h}, p4/z, [x0, x27, lsl #1] + CMP_IO(dci(0xa50c2cfc), + R(v28), + R(p3, x7)); // ld1rqw {z28.s}, p3/z, [x7, #-64] + CMP_IO(dci(0xa51b13e9), + R(v9), + R(p4, sp, x27)); // ld1rqw {z9.s}, p4/z, [sp, x27, lsl #2] + CMP_IO(dci(0x85fcddf5), + R(v21), + R(p7, x15)); // ld1rsb {z21.h}, p7/z, [x15, #60] + CMP_IO(dci(0x85fca923), R(v3), R(p2, x9)); // ld1rsb {z3.s}, p2/z, [x9, #60] + CMP_IO(dci(0x85dc9eba), + R(v26), + R(p7, x21)); // ld1rsb {z26.d}, p7/z, [x21, #28] + CMP_IO(dci(0x857da799), + R(v25), + R(p1, x28)); // ld1rsh {z25.s}, p1/z, [x28, #122] + CMP_IO(dci(0x855d86d4), + R(v20), + R(p1, x22)); // ld1rsh {z20.d}, p1/z, [x22, #58] + CMP_IO(dci(0x84fc9765), + R(v5), + R(p5, x27)); // ld1rsw {z5.d}, p5/z, [x27, #240] + CMP_IO(dci(0x857bdc03), R(v3), R(p7, x0)); // ld1rw {z3.s}, p7/z, [x0, #236] + CMP_IO(dci(0x855bf19a), + R(v26), + R(p4, x12)); // ld1rw {z26.d}, p4/z, [x12, #108] + CMP_IO(dci(0xc43b9b3e), + R(v30), + R(p6, v25)); // ld1sb {z30.d}, p6/z, [z25.d, #27] + + CLEANUP(); +} + +TEST(group_31) { + SETUP(); + + CMP_IO(dci(0x843a9573), + R(v19), + R(p5, v11)); // ld1sb {z19.s}, p5/z, [z11.s, #26] + CMP_IO(dci(0xa5cbbf17), + R(v23), + R(p7, x24)); // ld1sb {z23.h}, p7/z, [x24, #-5, mul vl] + CMP_IO(dci(0xa5aaa0a1), + R(v1), + R(p0, x5)); // ld1sb {z1.s}, p0/z, [x5, #-6, mul vl] + CMP_IO(dci(0xa58abfdc), + R(v28), + R(p7, x30)); // ld1sb {z28.d}, p7/z, [x30, #-6, mul vl] + CMP_IO(dci(0xa5dc4e86), + R(v6), + R(p3, x20, x28)); // ld1sb {z6.h}, p3/z, [x20, x28] + CMP_IO(dci(0xa5bb59b4), + R(v20), + R(p6, x13, x27)); // ld1sb {z20.s}, p6/z, [x13, x27] + CMP_IO(dci(0xa59b5a79), + R(v25), + R(p6, x19, x27)); // ld1sb {z25.d}, p6/z, [x19, x27] + CMP_IO(dci(0xc45a80a1), + R(v1), + R(p0, x5, v26)); // ld1sb {z1.d}, p0/z, [x5, z26.d] + CMP_IO(dci(0xc41d06d4), + R(v20), + R(p1, x22, v29)); // ld1sb {z20.d}, p1/z, [x22, z29.d, uxtw] + CMP_IO(dci(0x845c0aad), + R(v13), + R(p2, x21, v28)); // ld1sb {z13.s}, p2/z, [x21, z28.s, sxtw] + CMP_IO(dci(0xc4bc8358), + R(v24), + R(p0, v26)); // ld1sh {z24.d}, p0/z, [z26.d, #56] + CMP_IO(dci(0x84bb93e9), + R(v9), + R(p4, v31)); // ld1sh {z9.s}, p4/z, [z31.s, #54] + CMP_IO(dci(0xa52ba8bb), + R(v27), + R(p2, x5)); // ld1sh {z27.s}, p2/z, [x5, #-5, mul vl] + CMP_IO(dci(0xa50bbe52), + R(v18), + R(p7, x18)); // ld1sh {z18.d}, p7/z, [x18, #-5, mul vl] + CMP_IO(dci(0xa53b519a), + R(v26), + R(p4, x12, x27)); // ld1sh {z26.s}, p4/z, [x12, x27, lsl #1] + CMP_IO(dci(0xa51b5c03), + R(v3), + R(p7, x0, x27)); // ld1sh {z3.d}, p7/z, [x0, x27, lsl #1] + CMP_IO(dci(0xc4fb919a), + R(v26), + R(p4, x12, v27)); // ld1sh {z26.d}, p4/z, [x12, z27.d, lsl #1] + CMP_IO(dci(0xc4db88bb), + R(v27), + R(p2, x5, v27)); // ld1sh {z27.d}, p2/z, [x5, z27.d] + CMP_IO(dci(0xc4bc15db), + R(v27), + R(p5, x14, v28)); // ld1sh {z27.d}, p5/z, [x14, z28.d, uxtw #1] + CMP_IO(dci(0xc4dc1eba), + R(v26), + R(p7, x21, v28)); // ld1sh {z26.d}, p7/z, [x21, z28.d, sxtw] + CMP_IO(dci(0x84fd1ba6), + R(v6), + R(p6, x29, v29)); // ld1sh {z6.s}, p6/z, [x29, z29.s, sxtw #1] + CMP_IO(dci(0x849c0c37), + R(v23), + R(p3, x1, v28)); // ld1sh {z23.s}, p3/z, [x1, z28.s, uxtw] + CMP_IO(dci(0xc53a80a1), + R(v1), + R(p0, v5)); // ld1sw {z1.d}, p0/z, [z5.d, #104] + CMP_IO(dci(0xa48ba5a7), + R(v7), + R(p1, x13)); // ld1sw {z7.d}, p1/z, [x13, #-5, mul vl] + CMP_IO(dci(0xa49b47f6), + R(v22), + R(p1, sp, x27)); // ld1sw {z22.d}, p1/z, [sp, x27, lsl #2] + CMP_IO(dci(0xc57b925f), + R(v31), + R(p4, x18, v27)); // ld1sw {z31.d}, p4/z, [x18, z27.d, lsl #2] + CMP_IO(dci(0xc55b9b3e), + R(v30), + R(p6, x25, v27)); // ld1sw {z30.d}, p6/z, [x25, z27.d] + CMP_IO(dci(0xc57d085e), + R(v30), + R(p2, x2, v29)); // ld1sw {z30.d}, p2/z, [x2, z29.d, sxtw #2] + CMP_IO(dci(0xc51c1f7f), + R(v31), + R(p7, x27, v28)); // ld1sw {z31.d}, p7/z, [x27, z28.d, uxtw] + CMP_IO(dci(0xc53cd38c), + R(v12), + R(p4, v28)); // ld1w {z12.d}, p4/z, [z28.d, #112] + CMP_IO(dci(0x853cd765), + R(v5), + R(p5, v27)); // ld1w {z5.s}, p5/z, [z27.s, #112] + CMP_IO(dci(0xa54cadc1), + R(v1), + R(p3, x14)); // ld1w {z1.s}, p3/z, [x14, #-4, mul vl] + + CLEANUP(); +} + +TEST(group_32) { + SETUP(); + + CMP_IO(dci(0xa56cacfc), + R(v28), + R(p3, x7)); // ld1w {z28.d}, p3/z, [x7, #-4, mul vl] + CMP_IO(dci(0xa55d46d4), + R(v20), + R(p1, x22, x29)); // ld1w {z20.s}, p1/z, [x22, x29, lsl #2] + CMP_IO(dci(0xa57d4799), + R(v25), + R(p1, x28, x29)); // ld1w {z25.d}, p1/z, [x28, x29, lsl #2] + CMP_IO(dci(0xc57ddba6), + R(v6), + R(p6, x29, v29)); // ld1w {z6.d}, p6/z, [x29, z29.d, lsl #2] + CMP_IO(dci(0xc55ccc37), + R(v23), + R(p3, x1, v28)); // ld1w {z23.d}, p3/z, [x1, z28.d] + CMP_IO(dci(0xc53b5f17), + R(v23), + R(p7, x24, v27)); // ld1w {z23.d}, p7/z, [x24, z27.d, uxtw #2] + CMP_IO(dci(0xc55c4e86), + R(v6), + R(p3, x20, v28)); // ld1w {z6.d}, p3/z, [x20, z28.d, sxtw] + CMP_IO(dci(0x857b519a), + R(v26), + R(p4, x12, v27)); // ld1w {z26.s}, p4/z, [x12, z27.s, sxtw #2] + CMP_IO(dci(0x851b48bb), + R(v27), + R(p2, x5, v27)); // ld1w {z27.s}, p2/z, [x5, z27.s, uxtw] + CMP_IO(dci(0x4c4082f0), + R(v16, v17), + R(x23)); // ld2 {v16.16b, v17.16b}, [x23] + CMP_IO(dci(0x4cdf85db), + R(v27, v28, x14), + R(x14)); // ld2 {v27.8h, v28.8h}, [x14], #32 + CMP_IO(dci(0x4cc585db), + R(v27, v28, x14), + R(x14, x5)); // ld2 {v27.8h, v28.8h}, [x14], x5 + CMP_IO(dci(0x0d600853), + R(v19, v20), + R(v19, v20, x2)); // ld2 {v19.b, v20.b}[2], [x2] + CMP_IO(dci(0x0d608453), + R(v19, v20), + R(v19, v20, x2)); // ld2 {v19.d, v20.d}[0], [x2] + CMP_IO(dci(0x0d604853), + R(v19, v20), + R(v19, v20, x2)); // ld2 {v19.h, v20.h}[1], [x2] + CMP_IO(dci(0x0d608053), + R(v19, v20), + R(v19, v20, x2)); // ld2 {v19.s, v20.s}[0], [x2] + CMP_IO(dci(0x4dff0c94), + R(v20, v21, x4), + R(v20, v21, x4)); // ld2 {v20.b, v21.b}[11], [x4], #2 + CMP_IO(dci(0x4de714b9), + R(v25, v26, x5), + R(v25, v26, x5, x7)); // ld2 {v25.b, v26.b}[13], [x5], x7 + CMP_IO(dci(0x4dff8494), + R(v20, v21, x4), + R(v20, v21, x4)); // ld2 {v20.d, v21.d}[1], [x4], #16 + CMP_IO(dci(0x4dec84b9), + R(v25, v26, x5), + R(v25, v26, x5, x12)); // ld2 {v25.d, v26.d}[1], [x5], x12 + CMP_IO(dci(0x4dff4894), + R(v20, v21, x4), + R(v20, v21, x4)); // ld2 {v20.h, v21.h}[5], [x4], #4 + CMP_IO(dci(0x4dfe50b9), + R(v25, v26, x5), + R(v25, v26, x5, x30)); // ld2 {v25.h, v26.h}[6], [x5], x30 + CMP_IO(dci(0x4dff8094), + R(v20, v21, x4), + R(v20, v21, x4)); // ld2 {v20.s, v21.s}[2], [x4], #8 + CMP_IO(dci(0x4de290b9), + R(v25, v26, x5), + R(v25, v26, x5, x2)); // ld2 {v25.s, v26.s}[3], [x5], x2 + CMP_IO(dci(0xa42bff17), + R(v23, v24), + R(p7, x24)); // ld2b {z23.b, z24.b}, p7/z, [x24, #-10, mul vl] + CMP_IO(dci(0xa43cce86), + R(v6, v7), + R(p3, x20, x28)); // ld2b {z6.b, z7.b}, p3/z, [x20, x28] + CMP_IO(dci(0xa5aae0a1), + R(v1, v2), + R(p0, x5)); // ld2d {z1.d, z2.d}, p0/z, [x5, #-12, mul vl] + CMP_IO(dci(0xa5bbd9b4), + R(v20, v21), + R(p6, x13, x27)); // ld2d {z20.d, z21.d}, p6/z, [x13, x27, lsl #3] + CMP_IO(dci(0xa4abfd8d), + R(v13, v14), + R(p7, x12)); // ld2h {z13.h, z14.h}, p7/z, [x12, #-10, mul vl] + CMP_IO(dci(0xa4bbd010), + R(v16, v17), + R(p4, x0, x27)); // ld2h {z16.h, z17.h}, p4/z, [x0, x27, lsl #1] + CMP_IO(dci(0x4d60c708), R(v8, v9), R(x24)); // ld2r {v8.8h, v9.8h}, [x24] + CMP_IO(dci(0x0dffce52), + R(v18, v19, x18), + R(x18)); // ld2r {v18.1d, v19.1d}, [x18], #16 + + CLEANUP(); +} + +TEST(group_33) { + SETUP(); + + CMP_IO(dci(0x4deac5db), + R(v27, v28, x14), + R(x14, x10)); // ld2r {v27.8h, v28.8h}, [x14], x10 + CMP_IO(dci(0xa52be66c), + R(v12, v13), + R(p1, x19)); // ld2w {z12.s, z13.s}, p1/z, [x19, #-10, mul vl] + CMP_IO(dci(0xa53bd3e9), + R(v9, v10), + R(p4, sp, x27)); // ld2w {z9.s, z10.s}, p4/z, [sp, x27, lsl #2] + CMP_IO(dci(0x4c4042f0), + R(v16, v17, v18), + R(x23)); // ld3 {v16.16b, v17.16b, v18.16b}, [x23] + CMP_IO(dci(0x4cdf45db), + R(v27, v28, v29, x14), + R(x14)); // ld3 {v27.8h, v28.8h, v29.8h}, [x14], #48 + CMP_IO(dci(0x4cc745db), + R(v27, v28, v29, x14), + R(x14, x7)); // ld3 {v27.8h, v28.8h, v29.8h}, [x14], x7 + CMP_IO(dci(0x4d4032bc), + R(v28, v29, v30), + R(v28, v29, v30, x21)); // ld3 {v28.b, v29.b, v30.b}[12], [x21] + CMP_IO(dci(0x4d40a6bc), + R(v28, v29, v30), + R(v28, v29, v30, x21)); // ld3 {v28.d, v29.d, v30.d}[1], [x21] + CMP_IO(dci(0x4d4072bc), + R(v28, v29, v30), + R(v28, v29, v30, x21)); // ld3 {v28.h, v29.h, v30.h}[6], [x21] + CMP_IO(dci(0x4d40b2bc), + R(v28, v29, v30), + R(v28, v29, v30, x21)); // ld3 {v28.s, v29.s, v30.s}[3], [x21] + CMP_IO(dci(0x0ddf222b), + R(v11, v12, v13, x17), + R(v11, v12, v13, x17)); // ld3 {v11.b, v12.b, v13.b}[0], [x17], #3 + CMP_IO(dci(0x0dda3f22), + R(v2, v3, v4, x25), + R(v2, v3, v4, x25, x26)); // ld3 {v2.b, v3.b, v4.b}[7], [x25], x26 + CMP_IO(dci(0x0ddfa62b), + R(v11, v12, v13, x17), + R(v11, v12, v13, x17)); // ld3 {v11.d, v12.d, v13.d}[0], [x17], #24 + CMP_IO(dci(0x0dcba722), + R(v2, v3, v4, x25), + R(v2, v3, v4, x25, x11)); // ld3 {v2.d, v3.d, v4.d}[0], [x25], x11 + CMP_IO(dci(0x0ddf622b), + R(v11, v12, v13, x17), + R(v11, v12, v13, x17)); // ld3 {v11.h, v12.h, v13.h}[0], [x17], #6 + CMP_IO(dci(0x0dc77b22), + R(v2, v3, v4, x25), + R(v2, v3, v4, x25, x7)); // ld3 {v2.h, v3.h, v4.h}[3], [x25], x7 + CMP_IO(dci(0x0ddfa22b), + R(v11, v12, v13, x17), + R(v11, v12, v13, x17)); // ld3 {v11.s, v12.s, v13.s}[0], [x17], #12 + CMP_IO(dci(0x0dd7b322), + R(v2, v3, v4, x25), + R(v2, v3, v4, x25, x23)); // ld3 {v2.s, v3.s, v4.s}[1], [x25], x23 + CMP_IO(dci(0xa44be980), + R(v0, v1, v2), + R(p2, x12)); // ld3b {z0.b, z1.b, z2.b}, p2/z, [x12, #-15, mul vl] + CMP_IO(dci(0xa45cc41d), + R(v29, v30, v31), + R(p1, x0, x28)); // ld3b {z29.b, z30.b, z31.b}, p1/z, [x0, x28] + CMP_IO(dci(0xa5caeb0a), + R(v10, v11, v12), + R(p2, x24)); // ld3d {z10.d, z11.d, z12.d}, p2/z, [x24, #-18, mul vl] + CMP_IO(dci(0xa5dbcf4b), + R(v11, v12, v13), + R(p3, + x26, + x27)); // ld3d {z11.d, z12.d, z13.d}, p3/z, [x26, x27, lsl #3] + CMP_IO(dci(0xa4cbe7f6), + R(v22, v23, v24), + R(p1, sp)); // ld3h {z22.h, z23.h, z24.h}, p1/z, [sp, #-15, mul vl] + CMP_IO(dci(0xa4dbc5a7), + R(v7, v8, v9), + R(p1, x13, x27)); // ld3h {z7.h, z8.h, z9.h}, p1/z, [x13, x27, lsl #1] + CMP_IO(dci(0x4d40e708), + R(v8, v9, v10), + R(x24)); // ld3r {v8.8h, v9.8h, v10.8h}, [x24] + CMP_IO(dci(0x0ddfee52), + R(v18, v19, v20, x18), + R(x18)); // ld3r {v18.1d, v19.1d, v20.1d}, [x18], #24 + CMP_IO(dci(0x4dd5e5db), + R(v27, v28, v29, x14), + R(x14, x21)); // ld3r {v27.8h, v28.8h, v29.8h}, [x14], x21 + CMP_IO(dci(0xa54bfc03), + R(v3, v4, v5), + R(p7, x0)); // ld3w {z3.s, z4.s, z5.s}, p7/z, [x0, #-15, mul vl] + CMP_IO(dci(0xa55bde52), + R(v18, v19, v20), + R(p7, + x18, + x27)); // ld3w {z18.s, z19.s, z20.s}, p7/z, [x18, x27, lsl #2] + CMP_IO(dci(0x4c4002f0), + R(v16, v17, v18, v19), + R(x23)); // ld4 {v16.16b, v17.16b, v18.16b, v19.16b}, [x23] + CMP_IO(dci(0x4cdf05db), + R(v27, v28, v29, v30, x14), + R(x14)); // ld4 {v27.8h, v28.8h, v29.8h, v30.8h}, [x14], #64 + CMP_IO(dci(0x4cce05db), + R(v27, v28, v29, v30, x14), + R(x14)); // ld4 {v27.8h, v28.8h, v29.8h, v30.8h}, [x14], x14 + + CLEANUP(); +} + +TEST(group_34) { + SETUP(); + + CMP_IO(dci(0x0d603d25), + R(v5, v6, v7, v8), + R(v5, v6, v7, v8, x9)); // ld4 {v5.b, v6.b, v7.b, v8.b}[7], [x9] + CMP_IO(dci(0x0d60a525), + R(v5, v6, v7, v8), + R(v5, v6, v7, v8, x9)); // ld4 {v5.d, v6.d, v7.d, v8.d}[0], [x9] + CMP_IO(dci(0x0d607925), + R(v5, v6, v7, v8), + R(v5, v6, v7, v8, x9)); // ld4 {v5.h, v6.h, v7.h, v8.h}[3], [x9] + CMP_IO(dci(0x0d60b125), + R(v5, v6, v7, v8), + R(v5, v6, v7, v8, x9)); // ld4 {v5.s, v6.s, v7.s, v8.s}[1], [x9] + CMP_IO(dci(0x0dff2166), + R(v6, v7, v8, v9, x11), + R(v6, v7, v8, v9, x11)); // ld4 {v6.b, v7.b, v8.b, v9.b}[0], [x11], #4 + CMP_IO(dci(0x0de4332f), + R(v15, v16, v17, v18, x25), + R(v15, v16, v17, v18, x25, x4)); // ld4 {v15.b, v16.b, v17.b, + // v18.b}[4], [x25], x4 + CMP_IO(dci(0x0dffa566), + R(v6, v7, v8, v9, x11), + R(v6, + v7, + v8, + v9, + x11)); // ld4 {v6.d, v7.d, v8.d, v9.d}[0], [x11], #32 + CMP_IO(dci(0x0defa72f), + R(v15, v16, v17, v18, x25), + R(v15, v16, v17, v18, x25, x15)); // ld4 {v15.d, v16.d, v17.d, + // v18.d}[0], [x25], x15 + CMP_IO(dci(0x0dff6166), + R(v6, v7, v8, v9, x11), + R(v6, v7, v8, v9, x11)); // ld4 {v6.h, v7.h, v8.h, v9.h}[0], [x11], #8 + CMP_IO(dci(0x0de9732f), + R(v15, v16, v17, v18, x25), + R(v15, v16, v17, v18, x25, x9)); // ld4 {v15.h, v16.h, v17.h, + // v18.h}[2], [x25], x9 + CMP_IO(dci(0x0dffa166), + R(v6, v7, v8, v9, x11), + R(v6, + v7, + v8, + v9, + x11)); // ld4 {v6.s, v7.s, v8.s, v9.s}[0], [x11], #16 + CMP_IO(dci(0x0dfdb32f), + R(v15, v16, v17, v18, x25), + R(v15, v16, v17, v18, x25, x29)); // ld4 {v15.s, v16.s, v17.s, + // v18.s}[1], [x25], x29 + CMP_IO(dci(0xa46ae0a1), + R(v1, v2, v3, v4), + R(p0, x5)); // ld4b {z1.b, z2.b, z3.b, z4.b}, p0/z, [x5, #-24, mul vl] + CMP_IO(dci(0xa47bd9b4), + R(v20, v21, v22, v23), + R(p6, + x13, + x27)); // ld4b {z20.b, z21.b, z22.b, z23.b}, p6/z, [x13, x27] + CMP_IO(dci(0xa5ebff17), R(v23, v24, v25, v26), R(p7, x24)); // ld4d {z23.d, + // z24.d, z25.d, + // z26.d}, p7/z, + // [x24, #-20, + // mul vl] + CMP_IO(dci(0xa5fcce86), + R(v6, v7, v8, v9), + R(p3, + x20, + x28)); // ld4d {z6.d, z7.d, z8.d, z9.d}, p3/z, [x20, x28, lsl #3] + CMP_IO(dci(0xa4ebe8bb), + R(v27, v28, v29, v30), + R(p2, + x5)); // ld4h {z27.h, z28.h, z29.h, z30.h}, p2/z, [x5, #-20, mul vl] + CMP_IO(dci(0xa4fbd19a), + R(v26, v27, v28, v29), + R(p4, x12, x27)); // ld4h {z26.h, z27.h, z28.h, z29.h}, p4/z, [x12, + // x27, lsl #1] + CMP_IO(dci(0x4d60e708), + R(v8, v9, v10, v11), + R(x24)); // ld4r {v8.8h, v9.8h, v10.8h, v11.8h}, [x24] + CMP_IO(dci(0x0dffee52), + R(v18, v19, v20, v21, x18), + R(x18)); // ld4r {v18.1d, v19.1d, v20.1d, v21.1d}, [x18], #32 + CMP_IO(dci(0x4df8e5db), + R(v27, v28, v29, v30, x14), + R(x14, x24)); // ld4r {v27.8h, v28.8h, v29.8h, v30.8h}, [x14], x24 + CMP_IO(dci(0xa56bfb3e), + R(v30, v31, v0, v1), + R(p6, + x25)); // ld4w {z30.s, z31.s, z0.s, z1.s}, p6/z, [x25, #-20, mul vl] + CMP_IO(dci(0xa57bd25f), + R(v31, v0, v1, v2), + R(p4, + x18, + x27)); // ld4w {z31.s, z0.s, z1.s, z2.s}, p4/z, [x18, x27, lsl #2] + CMP_IO(dci(0xb83d0092), R(x18), R(x29, x4)); // ldadd w29, w18, [x4] + CMP_IO(dci(0xf83d02fb), R(x27), R(x29, x23)); // ldadd x29, x27, [x23] + CMP_IO(dci(0xb8b902c9), R(x9), R(x25, x22)); // ldadda w25, w9, [x22] + CMP_IO(dci(0xf8ba0204), R(x4), R(x26, x16)); // ldadda x26, x4, [x16] + CMP_IO(dci(0x38bd02fb), R(x27), R(x29, x23)); // ldaddab w29, w27, [x23] + CMP_IO(dci(0x78bd02e1), R(x1), R(x29, x23)); // ldaddah w29, w1, [x23] + CMP_IO(dci(0xb8fd0085), R(x5), R(x29, x4)); // ldaddal w29, w5, [x4] + CMP_IO(dci(0xf8fd03c0), R(x0), R(x29, x30)); // ldaddal x29, x0, [x30] + CMP_IO(dci(0x38f901f7), R(x23), R(x25, x15)); // ldaddalb w25, w23, [x15] + + CLEANUP(); +} + +TEST(group_35) { + SETUP(); + + CMP_IO(dci(0x78fa006d), R(x13), R(x26, x3)); // ldaddalh w26, w13, [x3] + CMP_IO(dci(0x383a0204), R(x4), R(x26, x16)); // ldaddb w26, w4, [x16] + CMP_IO(dci(0x783901ea), R(x10), R(x25, x15)); // ldaddh w25, w10, [x15] + CMP_IO(dci(0xb879038e), R(x14), R(x25, x28)); // ldaddl w25, w14, [x28] + CMP_IO(dci(0xf87901f7), R(x23), R(x25, x15)); // ldaddl x25, x23, [x15] + CMP_IO(dci(0x387d03c0), R(x0), R(x29, x30)); // ldaddlb w29, w0, [x30] + CMP_IO(dci(0x787e0236), R(x22), R(x30, x17)); // ldaddlh w30, w22, [x17] + CMP_IO(dci(0xb8b9c060), R(x0), R(x3)); // ldapr w0, [x3] + CMP_IO(dci(0xf8b9c125), R(x5), R(x9)); // ldapr x5, [x9] + CMP_IO(dci(0x38bdc2ee), R(x14), R(x23)); // ldaprb w14, [x23] + CMP_IO(dci(0x78bec308), R(x8), R(x24)); // ldaprh w8, [x24] + CMP_IO(dci(0x995cb37f), R(), R(x27)); // ldapur wzr, [x27, #-53] + CMP_IO(dci(0xd95cb116), R(x22), R(x8)); // ldapur x22, [x8, #-53] + CMP_IO(dci(0x195b518d), R(x13), R(x12)); // ldapurb w13, [x12, #-75] + CMP_IO(dci(0x595b1317), R(x23), R(x24)); // ldapurh w23, [x24, #-79] + CMP_IO(dci(0x19dd7078), R(x24), R(x3)); // ldapursb w24, [x3, #-41] + CMP_IO(dci(0x199d513d), R(x29), R(x9)); // ldapursb x29, [x9, #-43] + CMP_IO(dci(0x59dd005e), R(x30), R(x2)); // ldapursh w30, [x2, #-48] + CMP_IO(dci(0x599d12c7), R(x7), R(x22)); // ldapursh x7, [x22, #-47] + CMP_IO(dci(0x999c8372), R(x18), R(x27)); // ldapursw x18, [x27, #-56] + CMP_IO(dci(0x88dd8fb3), R(x19), R(x29)); // ldar w19, [x29] + CMP_IO(dci(0xc8dd854a), R(x10), R(x10)); // ldar x10, [x10] + CMP_IO(dci(0x08d99381), R(x1), R(x28)); // ldarb w1, [x28] + CMP_IO(dci(0x48d9fb9b), R(x27), R(x28)); // ldarh w27, [x28] + CMP_IO(dci(0x887aa22b), R(x11, x8), R(x17)); // ldaxp w11, w8, [x17] + CMP_IO(dci(0xc87a97c2), R(x2, x5), R(x30)); // ldaxp x2, x5, [x30] + CMP_IO(dci(0x885aa22b), R(x11), R(x17)); // ldaxr w11, [x17] + CMP_IO(dci(0xc85a97c2), R(x2), R(x30)); // ldaxr x2, [x30] + CMP_IO(dci(0x085ef4b9), R(x25), R(x5)); // ldaxrb w25, [x5] + CMP_IO(dci(0x485eb643), R(x3), R(x18)); // ldaxrh w3, [x18] + CMP_IO(dci(0xb83e117e), R(x30), R(x30, x11)); // ldclr w30, w30, [x11] + CMP_IO(dci(0xf83e13e7), R(x7), R(x30, sp)); // ldclr x30, x7, [sp] + + CLEANUP(); +} + +TEST(group_36) { + SETUP(); + + CMP_IO(dci(0xb8ba13b5), R(x21), R(x26, x29)); // ldclra w26, w21, [x29] + CMP_IO(dci(0xf8ba12f0), R(x16), R(x26, x23)); // ldclra x26, x16, [x23] + CMP_IO(dci(0x38be13e7), R(x7), R(x30, sp)); // ldclrab w30, w7, [sp] + CMP_IO(dci(0x78be125d), R(x29), R(x30, x18)); // ldclrah w30, w29, [x18] + CMP_IO(dci(0xb8fe10b9), R(x25), R(x30, x5)); // ldclral w30, w25, [x5] + CMP_IO(dci(0xf8fe13f4), R(x20), R(x30, sp)); // ldclral x30, x20, [sp] + CMP_IO(dci(0x38fa122b), R(x11), R(x26, x17)); // ldclralb w26, w11, [x17] + CMP_IO(dci(0x78fa1211), R(x17), R(x26, x16)); // ldclralh w26, w17, [x16] + CMP_IO(dci(0x383a12f0), R(x16), R(x26, x23)); // ldclrb w26, w16, [x23] + CMP_IO(dci(0x783a1166), R(x6), R(x26, x11)); // ldclrh w26, w6, [x11] + CMP_IO(dci(0xb87a13c2), R(x2), R(x26, x30)); // ldclrl w26, w2, [x30] + CMP_IO(dci(0xf87a122b), R(x11), R(x26, x17)); // ldclrl x26, x11, [x17] + CMP_IO(dci(0x387e13f4), R(x20), R(x30, sp)); // ldclrlb w30, w20, [sp] + CMP_IO(dci(0x787e13da), R(x26), R(x30, x30)); // ldclrlh w30, w26, [x30] + CMP_IO(dci(0xb83e2171), R(x17), R(x30, x11)); // ldeor w30, w17, [x11] + CMP_IO(dci(0xf83e20ac), R(x12), R(x30, x5)); // ldeor x30, x12, [x5] + CMP_IO(dci(0xb8ba207a), R(x26), R(x26, x3)); // ldeora w26, w26, [x3] + CMP_IO(dci(0xf8ba22e3), R(x3), R(x26, x23)); // ldeora x26, x3, [x23] + CMP_IO(dci(0x38be20ac), R(x12), R(x30, x5)); // ldeorab w30, w12, [x5] + CMP_IO(dci(0x78be2322), R(x2), R(x30, x25)); // ldeorah w30, w2, [x25] + CMP_IO(dci(0xb8fe20c6), R(x6), R(x30, x6)); // ldeoral w30, w6, [x6] + CMP_IO(dci(0xf8fe232f), R(x15), R(x30, x25)); // ldeoral x30, x15, [x25] + CMP_IO(dci(0x38fa2238), R(x24), R(x26, x17)); // ldeoralb w26, w24, [x17] + CMP_IO(dci(0x78fa221e), R(x30), R(x26, x16)); // ldeoralh w26, w30, [x16] + CMP_IO(dci(0x383a22e3), R(x3), R(x26, x23)); // ldeorb w26, w3, [x23] + CMP_IO(dci(0x783a2159), R(x25), R(x26, x10)); // ldeorh w26, w25, [x10] + CMP_IO(dci(0xb87a22fd), R(x29), R(x26, x23)); // ldeorl w26, w29, [x23] + CMP_IO(dci(0xf87a2238), R(x24), R(x26, x17)); // ldeorl x26, x24, [x17] + CMP_IO(dci(0x387e232f), R(x15), R(x30, x25)); // ldeorlb w30, w15, [x25] + CMP_IO(dci(0x787e2315), R(x21), R(x30, x24)); // ldeorlh w30, w21, [x24] + CMP_IO(dci(0xc43cec37), + R(v23), + R(p3, v1)); // ldff1b {z23.d}, p3/z, [z1.d, #28] + CMP_IO(dci(0x843cfeba), + R(v26), + R(p7, v21)); // ldff1b {z26.s}, p7/z, [z21.s, #28] + + CLEANUP(); +} + +TEST(group_37) { + SETUP(); + + CMP_IO(dci(0xa43c6109), + R(v9), + R(p0, x8, x28)); // ldff1b {z9.h}, p0/z, [x8, x28] + CMP_IO(dci(0xa45c7f7f), + R(v31), + R(p7, x27, x28)); // ldff1b {z31.s}, p7/z, [x27, x28] + CMP_IO(dci(0xa47c7516), + R(v22), + R(p5, x8, x28)); // ldff1b {z22.d}, p5/z, [x8, x28] + CMP_IO(dci(0xa41e6a50), + R(v16), + R(p2, x18, x30)); // ldff1b {z16.b}, p2/z, [x18, x30] + CMP_IO(dci(0xc45cf38c), + R(v12), + R(p4, x28, v28)); // ldff1b {z12.d}, p4/z, [x28, z28.d] + CMP_IO(dci(0xc45b73e9), + R(v9), + R(p4, sp, v27)); // ldff1b {z9.d}, p4/z, [sp, z27.d, sxtw] + CMP_IO(dci(0x841c6358), + R(v24), + R(p0, x26, v28)); // ldff1b {z24.s}, p0/z, [x26, z28.s, uxtw] + CMP_IO(dci(0xc5bcedc1), + R(v1), + R(p3, v14)); // ldff1d {z1.d}, p3/z, [z14.d, #224] + CMP_IO(dci(0xa5fc6044), + R(v4), + R(p0, x2, x28)); // ldff1d {z4.d}, p0/z, [x2, x28, lsl #3] + CMP_IO(dci(0xc5fcff7f), + R(v31), + R(p7, x27, v28)); // ldff1d {z31.d}, p7/z, [x27, z28.d, lsl #3] + CMP_IO(dci(0xc5dde85e), + R(v30), + R(p2, x2, v29)); // ldff1d {z30.d}, p2/z, [x2, z29.d] + CMP_IO(dci(0xc5fb7b3e), + R(v30), + R(p6, x25, v27)); // ldff1d {z30.d}, p6/z, [x25, z27.d, sxtw #3] + CMP_IO(dci(0xc59b725f), + R(v31), + R(p4, x18, v27)); // ldff1d {z31.d}, p4/z, [x18, z27.d, uxtw] + CMP_IO(dci(0xc4bceaad), + R(v13), + R(p2, v21)); // ldff1h {z13.d}, p2/z, [z21.d, #56] + CMP_IO(dci(0x84bde6d4), + R(v20), + R(p1, v22)); // ldff1h {z20.s}, p1/z, [z22.s, #58] + CMP_IO(dci(0xa4bc6293), + R(v19), + R(p0, x20, x28)); // ldff1h {z19.h}, p0/z, [x20, x28, lsl #1] + CMP_IO(dci(0xa4dc7765), + R(v5), + R(p5, x27, x28)); // ldff1h {z5.s}, p5/z, [x27, x28, lsl #1] + CMP_IO(dci(0xa4fc76a0), + R(v0), + R(p5, x21, x28)); // ldff1h {z0.d}, p5/z, [x21, x28, lsl #1] + CMP_IO(dci(0xc4fce293), + R(v19), + R(p0, x20, v28)); // ldff1h {z19.d}, p0/z, [x20, z28.d, lsl #1] + CMP_IO(dci(0xc4ddf202), + R(v2), + R(p4, x16, v29)); // ldff1h {z2.d}, p4/z, [x16, z29.d] + CMP_IO(dci(0xc4fb64e2), + R(v2), + R(p1, x7, v27)); // ldff1h {z2.d}, p1/z, [x7, z27.d, sxtw #1] + CMP_IO(dci(0xc49a7573), + R(v19), + R(p5, x11, v26)); // ldff1h {z19.d}, p5/z, [x11, z26.d, uxtw] + CMP_IO(dci(0x84bb725f), + R(v31), + R(p4, x18, v27)); // ldff1h {z31.s}, p4/z, [x18, z27.s, uxtw #1] + CMP_IO(dci(0x84db7b3e), + R(v30), + R(p6, x25, v27)); // ldff1h {z30.s}, p6/z, [x25, z27.s, sxtw] + CMP_IO(dci(0xc43bbb3e), + R(v30), + R(p6, v25)); // ldff1sb {z30.d}, p6/z, [z25.d, #27] + CMP_IO(dci(0x843ab573), + R(v19), + R(p5, v11)); // ldff1sb {z19.s}, p5/z, [z11.s, #26] + CMP_IO(dci(0xa5dc6e86), + R(v6), + R(p3, x20, x28)); // ldff1sb {z6.h}, p3/z, [x20, x28] + CMP_IO(dci(0xa5bb79b4), + R(v20), + R(p6, x13, x27)); // ldff1sb {z20.s}, p6/z, [x13, x27] + CMP_IO(dci(0xa59b7a79), + R(v25), + R(p6, x19, x27)); // ldff1sb {z25.d}, p6/z, [x19, x27] + CMP_IO(dci(0xc45aa0a1), + R(v1), + R(p0, x5, v26)); // ldff1sb {z1.d}, p0/z, [x5, z26.d] + CMP_IO(dci(0xc41d26d4), + R(v20), + R(p1, x22, v29)); // ldff1sb {z20.d}, p1/z, [x22, z29.d, uxtw] + CMP_IO(dci(0x845c2aad), + R(v13), + R(p2, x21, v28)); // ldff1sb {z13.s}, p2/z, [x21, z28.s, sxtw] + + CLEANUP(); +} + +TEST(group_38) { + SETUP(); + + CMP_IO(dci(0xc4bca358), + R(v24), + R(p0, v26)); // ldff1sh {z24.d}, p0/z, [z26.d, #56] + CMP_IO(dci(0x84bbb3e9), + R(v9), + R(p4, v31)); // ldff1sh {z9.s}, p4/z, [z31.s, #54] + CMP_IO(dci(0xa53b719a), + R(v26), + R(p4, x12, x27)); // ldff1sh {z26.s}, p4/z, [x12, x27, lsl #1] + CMP_IO(dci(0xa51b7c03), + R(v3), + R(p7, x0, x27)); // ldff1sh {z3.d}, p7/z, [x0, x27, lsl #1] + CMP_IO(dci(0xc4fbb19a), + R(v26), + R(p4, x12, v27)); // ldff1sh {z26.d}, p4/z, [x12, z27.d, lsl #1] + CMP_IO(dci(0xc4dba8bb), + R(v27), + R(p2, x5, v27)); // ldff1sh {z27.d}, p2/z, [x5, z27.d] + CMP_IO(dci(0xc4bc35db), + R(v27), + R(p5, x14, v28)); // ldff1sh {z27.d}, p5/z, [x14, z28.d, uxtw #1] + CMP_IO(dci(0xc4dc3eba), + R(v26), + R(p7, x21, v28)); // ldff1sh {z26.d}, p7/z, [x21, z28.d, sxtw] + CMP_IO(dci(0x84fd3ba6), + R(v6), + R(p6, x29, v29)); // ldff1sh {z6.s}, p6/z, [x29, z29.s, sxtw #1] + CMP_IO(dci(0x849c2c37), + R(v23), + R(p3, x1, v28)); // ldff1sh {z23.s}, p3/z, [x1, z28.s, uxtw] + CMP_IO(dci(0xc53aa0a1), + R(v1), + R(p0, v5)); // ldff1sw {z1.d}, p0/z, [z5.d, #104] + CMP_IO(dci(0xa49b67f6), + R(v22), + R(p1, sp, x27)); // ldff1sw {z22.d}, p1/z, [sp, x27, lsl #2] + CMP_IO(dci(0xc57bb25f), + R(v31), + R(p4, x18, v27)); // ldff1sw {z31.d}, p4/z, [x18, z27.d, lsl #2] + CMP_IO(dci(0xc55bbb3e), + R(v30), + R(p6, x25, v27)); // ldff1sw {z30.d}, p6/z, [x25, z27.d] + CMP_IO(dci(0xc57d285e), + R(v30), + R(p2, x2, v29)); // ldff1sw {z30.d}, p2/z, [x2, z29.d, sxtw #2] + CMP_IO(dci(0xc51c3f7f), + R(v31), + R(p7, x27, v28)); // ldff1sw {z31.d}, p7/z, [x27, z28.d, uxtw] + CMP_IO(dci(0xc53cf38c), + R(v12), + R(p4, v28)); // ldff1w {z12.d}, p4/z, [z28.d, #112] + CMP_IO(dci(0x853cf765), + R(v5), + R(p5, v27)); // ldff1w {z5.s}, p5/z, [z27.s, #112] + CMP_IO(dci(0xa55d66d4), + R(v20), + R(p1, x22, x29)); // ldff1w {z20.s}, p1/z, [x22, x29, lsl #2] + CMP_IO(dci(0xa57d6799), + R(v25), + R(p1, x28, x29)); // ldff1w {z25.d}, p1/z, [x28, x29, lsl #2] + CMP_IO(dci(0xc57dfba6), + R(v6), + R(p6, x29, v29)); // ldff1w {z6.d}, p6/z, [x29, z29.d, lsl #2] + CMP_IO(dci(0xc55cec37), + R(v23), + R(p3, x1, v28)); // ldff1w {z23.d}, p3/z, [x1, z28.d] + CMP_IO(dci(0xc53b7f17), + R(v23), + R(p7, x24, v27)); // ldff1w {z23.d}, p7/z, [x24, z27.d, uxtw #2] + CMP_IO(dci(0xc55c6e86), + R(v6), + R(p3, x20, v28)); // ldff1w {z6.d}, p3/z, [x20, z28.d, sxtw] + CMP_IO(dci(0x857b719a), + R(v26), + R(p4, x12, v27)); // ldff1w {z26.s}, p4/z, [x12, z27.s, sxtw #2] + CMP_IO(dci(0x851b68bb), + R(v27), + R(p2, x5, v27)); // ldff1w {z27.s}, p2/z, [x5, z27.s, uxtw] + CMP_IO(dci(0xd97e7322), R(x2), R(x25)); // ldg x2, [x25, #-400] + CMP_IO(dci(0x88da253f), R(), R(x9)); // ldlar wzr, [x9] + CMP_IO(dci(0xc8da1ad6), R(x22), R(x22)); // ldlar x22, [x22] + CMP_IO(dci(0x08dd77cd), R(x13), R(x30)); // ldlarb w13, [x30] + CMP_IO(dci(0x48dd3957), R(x23), R(x10)); // ldlarh w23, [x10] + CMP_IO(dci(0xa43da6d4), + R(v20), + R(p1, x22)); // ldnf1b {z20.h}, p1/z, [x22, #-3, mul vl] + + CLEANUP(); +} + +TEST(group_39) { + SETUP(); + + CMP_IO(dci(0xa45dbba6), + R(v6), + R(p6, x29)); // ldnf1b {z6.s}, p6/z, [x29, #-3, mul vl] + CMP_IO(dci(0xa47da60f), + R(v15), + R(p1, x16)); // ldnf1b {z15.d}, p1/z, [x16, #-3, mul vl] + CMP_IO(dci(0xa41da485), + R(v5), + R(p1, x4)); // ldnf1b {z5.b}, p1/z, [x4, #-3, mul vl] + CMP_IO(dci(0xa5fda799), + R(v25), + R(p1, x28)); // ldnf1d {z25.d}, p1/z, [x28, #-3, mul vl] + CMP_IO(dci(0xa4bcbeba), + R(v26), + R(p7, x21)); // ldnf1h {z26.h}, p7/z, [x21, #-4, mul vl] + CMP_IO(dci(0xa4ddbd30), + R(v16), + R(p7, x9)); // ldnf1h {z16.s}, p7/z, [x9, #-3, mul vl] + CMP_IO(dci(0xa4fcbdf5), + R(v21), + R(p7, x15)); // ldnf1h {z21.d}, p7/z, [x15, #-4, mul vl] + CMP_IO(dci(0xa5dbb25f), + R(v31), + R(p4, x18)); // ldnf1sb {z31.h}, p4/z, [x18, #-5, mul vl] + CMP_IO(dci(0xa5bbb3e9), + R(v9), + R(p4, sp)); // ldnf1sb {z9.s}, p4/z, [sp, #-5, mul vl] + CMP_IO(dci(0xa59bb324), + R(v4), + R(p4, x25)); // ldnf1sb {z4.d}, p4/z, [x25, #-5, mul vl] + CMP_IO(dci(0xa53ab573), + R(v19), + R(p5, x11)); // ldnf1sh {z19.s}, p5/z, [x11, #-6, mul vl] + CMP_IO(dci(0xa51aab0a), + R(v10), + R(p2, x24)); // ldnf1sh {z10.d}, p2/z, [x24, #-6, mul vl] + CMP_IO(dci(0xa49cb8ef), + R(v15), + R(p6, x7)); // ldnf1sw {z15.d}, p6/z, [x7, #-4, mul vl] + CMP_IO(dci(0xa55ca109), + R(v9), + R(p0, x8)); // ldnf1w {z9.s}, p0/z, [x8, #-4, mul vl] + CMP_IO(dci(0xa57ca044), + R(v4), + R(p0, x2)); // ldnf1w {z4.d}, p0/z, [x2, #-4, mul vl] + CMP_IO(dci(0x285b14ae), R(x14, x5), R(x5)); // ldnp w14, w5, [x5, #216] + CMP_IO(dci(0xa87b1f17), R(x23, x7), R(x24)); // ldnp x23, x7, [x24, #-80] + CMP_IO(dci(0x6c7c2dc1), R(v1, v11), R(x14)); // ldnp d1, d11, [x14, #-64] + CMP_IO(dci(0xac5d085e), R(v30, v2), R(x2)); // ldnp q30, q2, [x2, #928] + CMP_IO(dci(0x2c5d1d30), R(v16, v7), R(x9)); // ldnp s16, s7, [x9, #232] + CMP_IO(dci(0xc41cc293), + R(v19), + R(p0, v20, x28)); // ldnt1b {z19.d}, p0/z, [z20.d, x28] + CMP_IO(dci(0x841bb25f), + R(v31), + R(p4, v18, x27)); // ldnt1b {z31.s}, p4/z, [z18.s, x27] + CMP_IO(dci(0xa40ce358), + R(v24), + R(p0, x26)); // ldnt1b {z24.b}, p0/z, [x26, #-4, mul vl] + CMP_IO(dci(0xa41bca45), + R(v5), + R(p2, x18, x27)); // ldnt1b {z5.b}, p2/z, [x18, x27] + CMP_IO(dci(0xc59cd765), + R(v5), + R(p5, v27, x28)); // ldnt1d {z5.d}, p5/z, [z27.d, x28] + CMP_IO(dci(0xa58be4e2), + R(v2), + R(p1, x7)); // ldnt1d {z2.d}, p1/z, [x7, #-5, mul vl] + CMP_IO(dci(0xa59ad573), + R(v19), + R(p5, x11, x26)); // ldnt1d {z19.d}, p5/z, [x11, x26, lsl #3] + CMP_IO(dci(0xc49cc109), + R(v9), + R(p0, v8, x28)); // ldnt1h {z9.d}, p0/z, [z8.d, x28] + CMP_IO(dci(0x849baa45), + R(v5), + R(p2, v18, x27)); // ldnt1h {z5.s}, p2/z, [z18.s, x27] + CMP_IO(dci(0xa48bfb3e), + R(v30), + R(p6, x25)); // ldnt1h {z30.h}, p6/z, [x25, #-5, mul vl] + CMP_IO(dci(0xa49bd25f), + R(v31), + R(p4, x18, x27)); // ldnt1h {z31.h}, p4/z, [x18, x27, lsl #1] + CMP_IO(dci(0xc41b919a), + R(v26), + R(p4, v12, x27)); // ldnt1sb {z26.d}, p4/z, [z12.d, x27] + + CLEANUP(); +} + +TEST(group_40) { + SETUP(); + + CMP_IO(dci(0x841d9ba6), + R(v6), + R(p6, v29, x29)); // ldnt1sb {z6.s}, p6/z, [z29.s, x29] + CMP_IO(dci(0xc49b99b4), + R(v20), + R(p6, v13, x27)); // ldnt1sh {z20.d}, p6/z, [z13.d, x27] + CMP_IO(dci(0x849d9d30), + R(v16), + R(p7, v9, x29)); // ldnt1sh {z16.s}, p7/z, [z9.s, x29] + CMP_IO(dci(0xc51b8a45), + R(v5), + R(p2, v18, x27)); // ldnt1sw {z5.d}, p2/z, [z18.d, x27] + CMP_IO(dci(0xc51ddd30), + R(v16), + R(p7, v9, x29)); // ldnt1w {z16.d}, p7/z, [z9.d, x29] + CMP_IO(dci(0x851bb9b4), + R(v20), + R(p6, v13, x27)); // ldnt1w {z20.s}, p6/z, [z13.s, x27] + CMP_IO(dci(0xa50be8bb), + R(v27), + R(p2, x5)); // ldnt1w {z27.s}, p2/z, [x5, #-5, mul vl] + CMP_IO(dci(0xa51bd19a), + R(v26), + R(p4, x12, x27)); // ldnt1w {z26.s}, p4/z, [x12, x27, lsl #2] + CMP_IO(dci(0x295bd010), R(x16, x20), R(x0)); // ldp w16, w20, [x0, #220] + CMP_IO(dci(0x28fc2dc1), R(x1, x11, x14), R(x14)); // ldp w1, w11, [x14], #-32 + CMP_IO(dci(0x29dc2358), + R(x24, x8, x26), + R(x26)); // ldp w24, w8, [x26, #224]! + CMP_IO(dci(0xa97bb0d5), R(x21, x12), R(x6)); // ldp x21, x12, [x6, #-72] + CMP_IO(dci(0xa8dc4cfc), R(x28, x19, x7), R(x7)); // ldp x28, x19, [x7], #448 + CMP_IO(dci(0xa9fc041d), R(x29, x1, x0), R(x0)); // ldp x29, x1, [x0, #-64]! + CMP_IO(dci(0x6d7ce923), R(v3, v26), R(x9)); // ldp d3, d26, [x9, #-56] + CMP_IO(dci(0x6cdb14ae), R(v14, v5, x5), R(x5)); // ldp d14, d5, [x5], #432 + CMP_IO(dci(0x6dfd3c6b), R(v11, v15, x3), R(x3)); // ldp d11, d15, [x3, #-48]! + CMP_IO(dci(0xad5c76a0), R(v0, v29), R(x21)); // ldp q0, q29, [x21, #896] + CMP_IO(dci(0xacfb8731), + R(v17, v1, x25), + R(x25)); // ldp q17, q1, [x25], #-144 + CMP_IO(dci(0xaddcc9e8), + R(v8, v18, x15), + R(x15)); // ldp q8, q18, [x15, #912]! + CMP_IO(dci(0x2d5c61ce), R(v14, v24), R(x14)); // ldp s14, s24, [x14, #224] + CMP_IO(dci(0x2cfb9c03), R(v3, v7, x0), R(x0)); // ldp s3, s7, [x0], #-36 + CMP_IO(dci(0x2ddcb516), R(v22, v13, x8), R(x8)); // ldp s22, s13, [x8, #228]! + CMP_IO(dci(0x697b8731), R(x17, x1), R(x25)); // ldpsw x17, x1, [x25, #-36] + CMP_IO(dci(0x68dc76a0), + R(x0, x29, x21), + R(x21)); // ldpsw x0, x29, [x21], #224 + CMP_IO(dci(0x69fbda79), + R(x25, x22, x19), + R(x19)); // ldpsw x25, x22, [x19, #-36]! + CMP_IO(dci(0xb85ae70a), R(x10, x24), R(x24)); // ldr w10, [x24], #-82 + CMP_IO(dci(0xb85d6e0f), R(x15, x16), R(x16)); // ldr w15, [x16, #-42]! + CMP_IO(dci(0xb97c041d), R(x29), R(x0)); // ldr w29, [x0, #15364] + CMP_IO(dci(0xb87cc9e8), R(x8), R(x15, x28)); // ldr w8, [x15, w28, sxtw] + CMP_IO(dci(0xf85af573), R(x19, x11), R(x11)); // ldr x19, [x11], #-81 + CMP_IO(dci(0xf85d5fa6), R(x6, x29), R(x29)); // ldr x6, [x29, #-43]! + + CLEANUP(); +} + +TEST(group_41) { + SETUP(); + + CMP_IO(dci(0xf95c2358), R(x24), R(x26)); // ldr x24, [x26, #14400] + CMP_IO(dci(0xf87caaad), + R(x13), + R(x21, x28)); // ldr x13, [x21, x28, undefined] + CMP_IO(dci(0x3c5c4693), R(v19, x20), R(x20)); // ldr b19, [x20], #-60 + CMP_IO(dci(0x3c5c0e86), R(v6, x20), R(x20)); // ldr b6, [x20, #-64]! + CMP_IO(dci(0x3d5d7078), R(v24), R(x3)); // ldr b24, [x3, #1884] + CMP_IO(dci(0x3c7b998d), + R(v13), + R(x12, x27)); // ldr b13, [x12, x27, undefined #0] + CMP_IO(dci(0x3c7c69c1), R(v1), R(x14, x28)); // ldr b1, [x14, x28] + CMP_IO(dci(0xfc5c5765), R(v5, x27), R(x27)); // ldr d5, [x27], #-59 + CMP_IO(dci(0xfc5bfdb4), R(v20, x13), R(x13)); // ldr d20, [x13, #-65]! + CMP_IO(dci(0xfd5d3202), R(v2), R(x16)); // ldr d2, [x16, #14944] + CMP_IO(dci(0xfc7b48bb), R(v27), R(x5, x27)); // ldr d27, [x5, w27, uxtw] + CMP_IO(dci(0x7c5c8509), R(v9, x8), R(x8)); // ldr h9, [x8], #-56 + CMP_IO(dci(0x7c5bdc10), R(v16, x0), R(x0)); // ldr h16, [x0, #-67]! + CMP_IO(dci(0x7d5d085e), R(v30), R(x2)); // ldr h30, [x2, #3716] + CMP_IO(dci(0x7c7b1b17), + R(v23), + R(x24, x27)); // ldr h23, [x24, x27, undefined #1] + CMP_IO(dci(0x85be098b), R(p11), R(x12)); // ldr p11, [x12, #-14, mul vl] + CMP_IO(dci(0x3cdcd6ba), R(v26, x21), R(x21)); // ldr q26, [x21], #-51 + CMP_IO(dci(0x3cdb7e5f), R(v31, x18), R(x18)); // ldr q31, [x18, #-73]! + CMP_IO(dci(0x3dfcaaad), R(v13), R(x21)); // ldr q13, [x21, #62112] + CMP_IO(dci(0x3cfc2b58), + R(v24), + R(x26, x28)); // ldr q24, [x26, x28, undefined] + CMP_IO(dci(0xbc5cf78c), R(v12, x28), R(x28)); // ldr s12, [x28], #-49 + CMP_IO(dci(0xbc5b5d8d), R(v13, x12), R(x12)); // ldr s13, [x12, #-75]! + CMP_IO(dci(0xbd7cbf7f), R(v31), R(x27)); // ldr s31, [x27, #15548] + CMP_IO(dci(0xbc7c0a86), R(v6), R(x20, x28)); // ldr s6, [x20, x28, undefined] + CMP_IO(dci(0x85be4171), R(v17), R(x11)); // ldr z17, [x11, #-16, mul vl] + CMP_IO(dci(0xf87ae70a), R(x10), R(x24)); // ldraa x10, [x24, #-656] + CMP_IO(dci(0xf83d1ec7), R(x7, x22), R(x22)); // ldraa x7, [x22, #3720]! + CMP_IO(dci(0xf8baf573), R(x19), R(x11)); // ldrab x19, [x11, #3448] + CMP_IO(dci(0xf8fd0c5e), R(x30, x2), R(x2)); // ldrab x30, [x2, #-384]! + CMP_IO(dci(0x385c44fc), R(x28, x7), R(x7)); // ldrb w28, [x7], #-60 + CMP_IO(dci(0x385c0c1d), R(x29, x0), R(x0)); // ldrb w29, [x0, #-64]! + CMP_IO(dci(0x397d660f), R(x15), R(x16)); // ldrb w15, [x16, #3929] + + CLEANUP(); +} + +TEST(group_42) { + SETUP(); + + CMP_IO(dci(0x387ca9e8), + R(x8), + R(x15, x28)); // ldrb w8, [x15, x28, undefined] + CMP_IO(dci(0x387a7bdc), R(x28), R(x30, x26)); // ldrb w28, [x30, x26, lsl #0] + CMP_IO(dci(0x785c8772), R(x18, x27), R(x27)); // ldrh w18, [x27], #-56 + CMP_IO(dci(0x785bcda7), R(x7, x13), R(x13)); // ldrh w7, [x13, #-68]! + CMP_IO(dci(0x797cfdf5), R(x21), R(x15)); // ldrh w21, [x15, #7806] + CMP_IO(dci(0x787b2980), + R(x0), + R(x12, x27)); // ldrh w0, [x12, x27, undefined] + CMP_IO(dci(0x38db8731), R(x17, x25), R(x25)); // ldrsb w17, [x25], #-72 + CMP_IO(dci(0x38dccde8), R(x8, x15), R(x15)); // ldrsb w8, [x15, #-52]! + CMP_IO(dci(0x39db67f6), R(x22), R(sp)); // ldrsb w22, [sp, #1753] + CMP_IO(dci(0x38fca81d), + R(x29), + R(x0, x28)); // ldrsb w29, [x0, x28, undefined] + CMP_IO(dci(0x38fc7851), R(x17), R(x2, x28)); // ldrsb w17, [x2, x28, lsl #0] + CMP_IO(dci(0x389ba66c), R(x12, x19), R(x19)); // ldrsb x12, [x19], #-70 + CMP_IO(dci(0x389caead), R(x13, x21), R(x21)); // ldrsb x13, [x21, #-54]! + CMP_IO(dci(0x39bb725f), R(), R(x18)); // ldrsb xzr, [x18, #3804] + CMP_IO(dci(0x38bc2b58), + R(x24), + R(x26, x28)); // ldrsb x24, [x26, x28, undefined] + CMP_IO(dci(0x38bc7b8c), + R(x12), + R(x28, x28)); // ldrsb x12, [x28, x28, lsl #0] + CMP_IO(dci(0x78dbe74b), R(x11, x26), R(x26)); // ldrsh w11, [x26], #-66 + CMP_IO(dci(0x78dc6dce), R(x14), R(x14)); // ldrsh w14, [x14, #-58]! + CMP_IO(dci(0x79db2980), R(x0), R(x12)); // ldrsh w0, [x12, #3476] + CMP_IO(dci(0x78fcf9f5), + R(x21), + R(x15, x28)); // ldrsh w21, [x15, x28, sxtx #1] + CMP_IO(dci(0x789be4e2), R(x2, x7), R(x7)); // ldrsh x2, [x7], #-66 + CMP_IO(dci(0x789c6c37), R(x23, x1), R(x1)); // ldrsh x23, [x1, #-58]! + CMP_IO(dci(0x79bb0a45), R(x5), R(x18)); // ldrsh x5, [x18, #7556] + CMP_IO(dci(0x78bd1930), + R(x16), + R(x9, x29)); // ldrsh x16, [x9, x29, undefined #1] + CMP_IO(dci(0xb89b1717), R(x23, x24), R(x24)); // ldrsw x23, [x24], #-79 + CMP_IO(dci(0xb89d3e02), R(x2, x16), R(x16)); // ldrsw x2, [x16, #-45]! + CMP_IO(dci(0xb99bf9b4), R(x20), R(x13)); // ldrsw x20, [x13, #7160] + CMP_IO(dci(0xb8bc8909), R(x9), R(x8, x28)); // ldrsw x9, [x8, x28, undefined] + CMP_IO(dci(0xb83d32fb), R(x27), R(x29, x23)); // ldset w29, w27, [x23] + CMP_IO(dci(0xf83d3092), R(x18), R(x29, x4)); // ldset x29, x18, [x4] + CMP_IO(dci(0xb8ba3204), R(x4), R(x26, x16)); // ldseta w26, w4, [x16] + CMP_IO(dci(0xf8b932c9), R(x9), R(x25, x22)); // ldseta x25, x9, [x22] + + CLEANUP(); +} + +TEST(group_43) { + SETUP(); + + CMP_IO(dci(0x38bd3092), R(x18), R(x29, x4)); // ldsetab w29, w18, [x4] + CMP_IO(dci(0x78bd321c), R(x28), R(x29, x16)); // ldsetah w29, w28, [x16] + CMP_IO(dci(0xb8fd33c0), R(x0), R(x29, x30)); // ldsetal w29, w0, [x30] + CMP_IO(dci(0xf8fd3085), R(x5), R(x29, x4)); // ldsetal x29, x5, [x4] + CMP_IO(dci(0x38f9338e), R(x14), R(x25, x28)); // ldsetalb w25, w14, [x28] + CMP_IO(dci(0x78fa33a8), R(x8), R(x26, x29)); // ldsetalh w26, w8, [x29] + CMP_IO(dci(0x383932c9), R(x9), R(x25, x22)); // ldsetb w25, w9, [x22] + CMP_IO(dci(0x78393053), R(x19), R(x25, x2)); // ldseth w25, w19, [x2] + CMP_IO(dci(0xb87931f7), R(x23), R(x25, x15)); // ldsetl w25, w23, [x15] + CMP_IO(dci(0xf879338e), R(x14), R(x25, x28)); // ldsetl x25, x14, [x28] + CMP_IO(dci(0x387d3085), R(x5), R(x29, x4)); // ldsetlb w29, w5, [x4] + CMP_IO(dci(0x787e309f), R(), R(x30, x4)); // stsetlh w30, [x4] + CMP_IO(dci(0xb83a43a8), R(x8), R(x26, x29)); // ldsmax w26, w8, [x29] + CMP_IO(dci(0xf83a406d), R(x13), R(x26, x3)); // ldsmax x26, x13, [x3] + CMP_IO(dci(0xb8be409f), R(), R(x30, x4)); // stsmaxa w30, [x4] + CMP_IO(dci(0xf8be4236), R(x22), R(x30, x17)); // ldsmaxa x30, x22, [x17] + CMP_IO(dci(0x38ba406d), R(x13), R(x26, x3)); // ldsmaxab w26, w13, [x3] + CMP_IO(dci(0x78b941f7), R(x23), R(x25, x15)); // ldsmaxah w25, w23, [x15] + CMP_IO(dci(0xb8f94053), R(x19), R(x25, x2)); // ldsmaxal w25, w19, [x2] + CMP_IO(dci(0xf8f941ea), R(x10), R(x25, x15)); // ldsmaxal x25, x10, [x15] + CMP_IO(dci(0x38fd42e1), R(x1), R(x29, x23)); // ldsmaxalb w29, w1, [x23] + CMP_IO(dci(0x78fd42fb), R(x27), R(x29, x23)); // ldsmaxalh w29, w27, [x23] + CMP_IO(dci(0x383e4236), R(x22), R(x30, x17)); // ldsmaxb w30, w22, [x17] + CMP_IO(dci(0x783d43c0), R(x0), R(x29, x30)); // ldsmaxh w29, w0, [x30] + CMP_IO(dci(0xb87d421c), R(x28), R(x29, x16)); // ldsmaxl w29, w28, [x16] + CMP_IO(dci(0xf87d42e1), R(x1), R(x29, x23)); // ldsmaxl x29, x1, [x23] + CMP_IO(dci(0x387941ea), R(x10), R(x25, x15)); // ldsmaxlb w25, w10, [x15] + CMP_IO(dci(0x787a4204), R(x4), R(x26, x16)); // ldsmaxlh w26, w4, [x16] + CMP_IO(dci(0xb83a507a), R(x26), R(x26, x3)); // ldsmin w26, w26, [x3] + CMP_IO(dci(0xf83a52e3), R(x3), R(x26, x23)); // ldsmin x26, x3, [x23] + CMP_IO(dci(0xb8be5171), R(x17), R(x30, x11)); // ldsmina w30, w17, [x11] + CMP_IO(dci(0xf8be50ac), R(x12), R(x30, x5)); // ldsmina x30, x12, [x5] + + CLEANUP(); +} + +TEST(group_44) { + SETUP(); + + CMP_IO(dci(0x38ba52e3), R(x3), R(x26, x23)); // ldsminab w26, w3, [x23] + CMP_IO(dci(0x78ba5159), R(x25), R(x26, x10)); // ldsminah w26, w25, [x10] + CMP_IO(dci(0xb8fa52fd), R(x29), R(x26, x23)); // ldsminal w26, w29, [x23] + CMP_IO(dci(0xf8fa5238), R(x24), R(x26, x17)); // ldsminal x26, x24, [x17] + CMP_IO(dci(0x38fe532f), R(x15), R(x30, x25)); // ldsminalb w30, w15, [x25] + CMP_IO(dci(0x78fe5315), R(x21), R(x30, x24)); // ldsminalh w30, w21, [x24] + CMP_IO(dci(0x383e50ac), R(x12), R(x30, x5)); // ldsminb w30, w12, [x5] + CMP_IO(dci(0x783e5322), R(x2), R(x30, x25)); // ldsminh w30, w2, [x25] + CMP_IO(dci(0xb87e50c6), R(x6), R(x30, x6)); // ldsminl w30, w6, [x6] + CMP_IO(dci(0xf87e532f), R(x15), R(x30, x25)); // ldsminl x30, x15, [x25] + CMP_IO(dci(0x387a5238), R(x24), R(x26, x17)); // ldsminlb w26, w24, [x17] + CMP_IO(dci(0x787a521e), R(x30), R(x26, x16)); // ldsminlh w26, w30, [x16] + CMP_IO(dci(0xb8396132), R(x18), R(x25, x9)); // ldumax w25, w18, [x9] + CMP_IO(dci(0xf839639b), R(x27), R(x25, x28)); // ldumax x25, x27, [x28] + CMP_IO(dci(0xb8bd6229), R(x9), R(x29, x17)); // ldumaxa w29, w9, [x17] + CMP_IO(dci(0xf8bd6164), R(x4), R(x29, x11)); // ldumaxa x29, x4, [x11] + CMP_IO(dci(0x38b9639b), R(x27), R(x25, x28)); // ldumaxab w25, w27, [x28] + CMP_IO(dci(0x78b96381), R(x1), R(x25, x28)); // ldumaxah w25, w1, [x28] + CMP_IO(dci(0xb8f96125), R(x5), R(x25, x9)); // ldumaxal w25, w5, [x9] + CMP_IO(dci(0xf8f96060), R(x0), R(x25, x3)); // ldumaxal x25, x0, [x3] + CMP_IO(dci(0x38fd6157), R(x23), R(x29, x10)); // ldumaxalb w29, w23, [x10] + CMP_IO(dci(0x78fd63cd), R(x13), R(x29, x30)); // ldumaxalh w29, w13, [x30] + CMP_IO(dci(0x383d6164), R(x4), R(x29, x11)); // ldumaxb w29, w4, [x11] + CMP_IO(dci(0x783d614a), R(x10), R(x29, x10)); // ldumaxh w29, w10, [x10] + CMP_IO(dci(0xb87d62ee), R(x14), R(x29, x23)); // ldumaxl w29, w14, [x23] + CMP_IO(dci(0xf87d6157), R(x23), R(x29, x10)); // ldumaxl x29, x23, [x10] + CMP_IO(dci(0x38796060), R(x0), R(x25, x3)); // ldumaxlb w25, w0, [x3] + CMP_IO(dci(0x787a62d6), R(x22), R(x26, x22)); // ldumaxlh w26, w22, [x22] + CMP_IO(dci(0xb83a72f0), R(x16), R(x26, x23)); // ldumin w26, w16, [x23] + CMP_IO(dci(0xf83a73b5), R(x21), R(x26, x29)); // ldumin x26, x21, [x29] + CMP_IO(dci(0xb8be73e7), R(x7), R(x30, sp)); // ldumina w30, w7, [sp] + CMP_IO(dci(0xf8be717e), R(x30), R(x30, x11)); // ldumina x30, x30, [x11] + + CLEANUP(); +} + +TEST(group_45) { + SETUP(); + + CMP_IO(dci(0x38ba73b5), R(x21), R(x26, x29)); // lduminab w26, w21, [x29] + CMP_IO(dci(0x78ba73cf), R(x15), R(x26, x30)); // lduminah w26, w15, [x30] + CMP_IO(dci(0xb8fa722b), R(x11), R(x26, x17)); // lduminal w26, w11, [x17] + CMP_IO(dci(0xf8fa73c2), R(x2), R(x26, x30)); // lduminal x26, x2, [x30] + CMP_IO(dci(0x38fe70b9), R(x25), R(x30, x5)); // lduminalb w30, w25, [x5] + CMP_IO(dci(0x78fe7243), R(x3), R(x30, x18)); // lduminalh w30, w3, [x18] + CMP_IO(dci(0x383e717e), R(x30), R(x30, x11)); // lduminb w30, w30, [x11] + CMP_IO(dci(0x783e7198), R(x24), R(x30, x12)); // lduminh w30, w24, [x12] + CMP_IO(dci(0xb87e73f4), R(x20), R(x30, sp)); // lduminl w30, w20, [sp] + CMP_IO(dci(0xf87e70b9), R(x25), R(x30, x5)); // lduminl x30, x25, [x5] + CMP_IO(dci(0x387a73c2), R(x2), R(x26, x30)); // lduminlb w26, w2, [x30] + CMP_IO(dci(0x787a714c), R(x12), R(x26, x10)); // lduminlh w26, w12, [x10] + CMP_IO(dci(0xb85af173), R(x19), R(x11)); // ldur w19, [x11, #-81] + CMP_IO(dci(0xf85ae30a), R(x10), R(x24)); // ldur x10, [x24, #-82] + CMP_IO(dci(0x3c5c302a), R(v10), R(x1)); // ldur b10, [x1, #-61] + CMP_IO(dci(0xfc5c72a0), R(v0), R(x21)); // ldur d0, [x21, #-57] + CMP_IO(dci(0x7c5ca044), R(v4), R(x2)); // ldur h4, [x2, #-54] + CMP_IO(dci(0x3cdce123), R(v3), R(x9)); // ldur q3, [x9, #-50] + CMP_IO(dci(0xbc5cd051), R(v17), R(x2)); // ldur s17, [x2, #-51] + CMP_IO(dci(0x385c21c1), R(x1), R(x14)); // ldurb w1, [x14, #-62] + CMP_IO(dci(0x785c91db), R(x27), R(x14)); // ldurh w27, [x14, #-55] + CMP_IO(dci(0x38dba26c), R(x12), R(x19)); // ldursb w12, [x19, #-70] + CMP_IO(dci(0x389b8331), R(x17), R(x25)); // ldursb x17, [x25, #-72] + CMP_IO(dci(0x78dbe0e2), R(x2), R(x7)); // ldursh w2, [x7, #-66] + CMP_IO(dci(0x789be34b), R(x11), R(x26)); // ldursh x11, [x26, #-66] + CMP_IO(dci(0xb89b10ae), R(x14), R(x5)); // ldursw x14, [x5, #-79] + CMP_IO(dci(0x887e13f4), R(x20, x4), R(sp)); // ldxp w20, w4, [sp] + CMP_IO(dci(0xc87e74b9), R(x25, x29), R(x5)); // ldxp x25, x29, [x5] + CMP_IO(dci(0x885e13f4), R(x20), R(sp)); // ldxr w20, [sp] + CMP_IO(dci(0xc85e74b9), R(x25), R(x5)); // ldxr x25, [x5] + CMP_IO(dci(0x085a17c2), R(x2), R(x30)); // ldxrb w2, [x30] + CMP_IO(dci(0x485a594c), R(x12), R(x10)); // ldxrh w12, [x10] + + CLEANUP(); +} + +TEST(group_46) { + SETUP(); + + CMP_IO(dci(0x04039f7f), R(v31), R(p7, v31)); // lsl z31.h, p7/m, z31.h, #11 + CMP_IO(dci(0x041b88a5), R(v5), R(p2, v5, v5)); // lsl z5.b, p2/m, z5.b, z5.d + CMP_IO(dci(0x04d39ba6), + R(v6), + R(p6, v6, v29)); // lsl z6.d, p6/m, z6.d, z29.d + CMP_IO(dci(0x047d9d4a), R(v10), R(v10)); // lsl z10.s, z10.s, #29 + CMP_IO(dci(0x04be8d98), R(v24), R(v12, v30)); // lsl z24.s, z12.s, z30.d + CMP_IO(dci(0x04979cc8), R(v8), R(p7, v8, v6)); // lslr z8.s, p7/m, z8.s, z6.s + CMP_IO(dci(0x1add2085), R(x5), R(x4, x29)); // lsl w5, w4, w29 + CMP_IO(dci(0x9add23c0), R(x0), R(x30, x29)); // lsl x0, x30, x29 + CMP_IO(dci(0x04c19451), R(v17), R(p5, v17)); // lsr z17.d, p5/m, z17.d, #30 + CMP_IO(dci(0x04199f7f), + R(v31), + R(p7, v31, v27)); // lsr z31.b, p7/m, z31.b, z27.d + CMP_IO(dci(0x04118cfc), + R(v28), + R(p3, v28, v7)); // lsr z28.b, p3/m, z28.b, z7.b + CMP_IO(dci(0x04be9598), R(v24), R(v12)); // lsr z24.d, z12.d, #34 + CMP_IO(dci(0x047d854a), R(v10), R(v10, v29)); // lsr z10.h, z10.h, z29.d + CMP_IO(dci(0x0455919a), + R(v26), + R(p4, v26, v12)); // lsrr z26.h, p4/m, z26.h, z12.h + CMP_IO(dci(0x1ade258b), R(x11), R(x12, x30)); // lsr w11, w12, w30 + CMP_IO(dci(0x9ade2722), R(x2), R(x25, x30)); // lsr x2, x25, x30 + CMP_IO(dci(0x045cc41d), + R(v29), + R(v29, p1, v28, v0)); // mad z29.h, p1/m, z28.h, z0.h + CMP_IO(dci(0x1b1a1ad6), R(x22), R(x22, x26, x6)); // madd w22, w22, w26, w6 + CMP_IO(dci(0x9b1a253f), R(), R(x9, x26, x9)); // madd xzr, x9, x26, x9 + CMP_IO(dci(0x45748988), + R(p8), + R(p2, v12, v20)); // match p8.h, p2/z, z12.h, z20.h + CMP_IO(dci(0x2fba022b), + R(v11), + R(v11, v17, v26)); // mla v11.2s, v17.2s, v26.s[1] + CMP_IO(dci(0x4ebd97c0), R(v0), R(v0, v30, v29)); // mla v0.4s, v30.4s, v29.4s + CMP_IO(dci(0x045b50d5), + R(v21), + R(v21, p4, v6, v27)); // mla z21.h, p4/m, z6.h, z27.h + CMP_IO(dci(0x44fc0b72), + R(v18), + R(v18, v27, v12)); // mla z18.d, z27.d, z12.d[1] + CMP_IO(dci(0x447c09ce), R(v14), R(v14, v4)); // mla z14.h, z14.h, z4.h[7] + CMP_IO(dci(0x44bd0a0f), + R(v15), + R(v15, v16, v5)); // mla z15.s, z16.s, z5.s[3] + CMP_IO(dci(0x6f984b89), + R(v9), + R(v9, v28, v24)); // mls v9.4s, v28.4s, v24.s[2] + CMP_IO(dci(0x6eb796ce), + R(v14), + R(v14, v22, v23)); // mls v14.4s, v22.4s, v23.4s + CMP_IO(dci(0x041b7f17), + R(v23), + R(v23, p7, v24, v27)); // mls z23.b, p7/m, z24.b, z27.b + CMP_IO(dci(0x44fd0ed4), + R(v20), + R(v20, v22, v13)); // mls z20.d, z22.d, z13.d[1] + CMP_IO(dci(0x443d0d30), R(v16), R(v16, v9, v5)); // mls z16.h, z9.h, z5.h[3] + CMP_IO(dci(0x44bc0ead), + R(v13), + R(v13, v21, v4)); // mls z13.s, z21.s, z4.s[3] + + CLEANUP(); +} + +TEST(group_47) { + SETUP(); + + CMP_IO(dci(0x6f02e611), R(v17), R()); // movi v17.2d, #0xff00ff00000000 + CMP_IO(dci(0x2f04e6ba), R(v26), R()); // movi d26, #0xff0000ff00ff00ff + CMP_IO(dci(0x4f0485db), R(v27), R()); // movi v27.8h, #0x8e, lsl #0 + CMP_IO(dci(0x4f0446ba), R(v26), R()); // movi v26.4s, #0x95, lsl #16 + CMP_IO(dci(0x4f04d6ba), R(v26), R()); // movi v26.4s, #0x95, msl #16 + CMP_IO(dci(0x0f03e65f), R(v31), R()); // movi v31.8b, #0x72 + CMP_IO(dci(0x729ded64), R(x4), R(x4)); // movk w4, #0xef6b + CMP_IO(dci(0xf2fdce29), R(x9), R(x9)); // movk x9, #0xee71, lsl #48 + CMP_IO(dci(0x12be0c9f), R(), R()); // mov wzr, #0xf9bffff + CMP_IO(dci(0x92de0236), R(x22), R()); // mov x22, #0xffff0feeffffffff + CMP_IO(dci(0x0450241d), R(v29), R(p1, v0)); // movprfx z29.h, p1/z, z0.h + CMP_IO(dci(0x0420bd4c), R(v12), R(v10)); // movprfx z12, z10 + CMP_IO(dci(0x52be898b), R(x11), R()); // mov w11, #0xf44c0000 + CMP_IO(dci(0xd2de7f22), R(x2), R()); // mov x2, #0xf3f900000000 + CMP_IO(dci(0x04dbf3e9), + R(v9), + R(v9, p4, v27, v31)); // msb z9.d, p4/m, z27.d, z31.d + CMP_IO(dci(0x1b19e6c9), R(x9), R(x22, x25, x25)); // msub w9, w22, w25, w25 + CMP_IO(dci(0x9b1a8604), R(x4), R(x16, x26, x1)); // msub x4, x16, x26, x1 + CMP_IO(dci(0x4f4281fb), R(v27), R(v15, v2)); // mul v27.8h, v15.8h, v2.h[0] + CMP_IO(dci(0x4e3e9cac), R(v12), R(v5, v30)); // mul v12.16b, v5.16b, v30.16b + CMP_IO(dci(0x04901c6b), + R(v11), + R(v11, p7, v11, v3)); // mul z11.s, p7/m, z11.s, z3.s + CMP_IO(dci(0x2530d957), R(v23), R(v23)); // mul z23.b, z23.b, #-54 + CMP_IO(dci(0x04fe617e), R(v30), R(v11, v30)); // mul z30.d, z11.d, z30.d + CMP_IO(dci(0x44fbf980), R(v0), R(v12, v11)); // mul z0.d, z12.d, z11.d[1] + CMP_IO(dci(0x443bfb24), R(v4), R(v25, v3)); // mul z4.h, z25.h, z3.h[3] + CMP_IO(dci(0x44bbfb31), R(v17), R(v25, v3)); // mul z17.s, z25.s, z3.s[3] + CMP_IO(dci(0x2f04a444), R(v4), R()); // mvni v4.4h, #0x82, lsl #8 + CMP_IO(dci(0x2f044451), R(v17), R()); // mvni v17.2s, #0x82, lsl #16 + CMP_IO(dci(0x2f04d451), R(v17), R()); // mvni v17.2s, #0x82, msl #16 + CMP_IO(dci(0x25897f35), + R(p5), + R(p15, p9, p9)); // nand p5.b, p15/z, p9.b, p9.b + CMP_IO(dci(0x25ce6a50), + R(p0), + R(p10, p2, p14)); // nands p0.b, p10/z, p2.b, p14.b + CMP_IO(dci(0x04fd3e29), + R(v9), + R(v9, v29, v17)); // nbsl z9.d, z9.d, z29.d, z17.d + CMP_IO(dci(0x6e20babc), R(v28), R(v21)); // neg v28.16b, v21.16b + + CLEANUP(); +} + +TEST(group_48) { + SETUP(); + + CMP_IO(dci(0x7ee0b966), R(v6), R(v11)); // neg d6, d11 + CMP_IO(dci(0x04d7ba79), R(v25), R(v25, p6, v19)); // neg z25.d, p6/m, z19.d + CMP_IO(dci(0x457b84f2), + R(p2), + R(p1, v7, v27)); // nmatch p2.h, p1/z, z7.h, z27.h + CMP_IO(dci(0xd503201f), R(), R()); // nop + CMP_IO(dci(0x258e7643), + R(p3), + R(p13, p2, p14)); // nor p3.b, p13/z, p2.b, p14.b + CMP_IO(dci(0x25c95fea), + R(p10), + R(p7, p15, p9)); // nors p10.b, p7/z, p15.b, p9.b + CMP_IO(dci(0x2e205a2b), R(v11), R(v17)); // mvn v11.8b, v17.8b + CMP_IO(dci(0x045eab0a), R(v10), R(v10, p2, v24)); // not z10.h, p2/m, z24.h + CMP_IO(dci(0x2abc6923), R(x3), R(x9, x28)); // orn w3, w9, w28, asr #26 + CMP_IO(dci(0xaa7cdeba), R(x26), R(x21, x28)); // orn x26, x21, x28, lsr #55 + CMP_IO(dci(0x4efe1f15), + R(v21), + R(v24, v30)); // orn v21.16b, v24.16b, v30.16b + CMP_IO(dci(0x258e7453), + R(p3), + R(p13, p2, p14)); // orn p3.b, p13/z, p2.b, p14.b + CMP_IO(dci(0x25c95dfa), + R(p10), + R(p7, p15, p9)); // orns p10.b, p7/z, p15.b, p9.b + CMP_IO(dci(0x321c76a0), R(x0), R(x21)); // orr w0, w21, #0xfffffff3 + CMP_IO(dci(0x2a1c3f7f), R(), R(x27, x28)); // orr wzr, w27, w28, lsl #15 + CMP_IO(dci(0xb27c5765), R(x5), R(x27)); // orr x5, x27, #0x3fffff0 + CMP_IO(dci(0xaadcb516), R(x22), R(x8, x28)); // orr x22, x8, x28, ror #45 + CMP_IO(dci(0x0f039679), R(v25), R(v25)); // orr v25.4h, #0x73, lsl #0 + CMP_IO(dci(0x4f0277dc), R(v28), R(v28)); // orr v28.4s, #0x5e, lsl #24 + CMP_IO(dci(0x0ebd1e29), R(v9), R(v17, v29)); // orr v9.8b, v17.8b, v29.8b + CMP_IO(dci(0x258e4c8f), + R(p15), + R(p3, p4, p14)); // orr p15.b, p3/z, p4.b, p14.b + CMP_IO(dci(0x0458182a), + R(v10), + R(p6, v10, v1)); // orr z10.h, p6/m, z10.h, z1.h + CMP_IO(dci(0x0502a8c6), R(v6), R(v6)); // orr z6.d, z6.d, #0x3f80000000000 + CMP_IO(dci(0x047e309f), R(v31), R(v4, v30)); // orr z31.d, z4.d, z30.d + CMP_IO(dci(0x25ca4166), + R(p6), + R(p0, p11, p10)); // orrs p6.b, p0/z, p11.b, p10.b + CMP_IO(dci(0x04983010), R(v16), R(p4, v0)); // orv s16, p4, z0.s + CMP_IO(dci(0xdac10957), R(x23), R(x23, x10)); // pacda x23, x10 + CMP_IO(dci(0xdac10eee), R(x14), R(x14, x23)); // pacdb x14, x23 + CMP_IO(dci(0xdac12be7), R(x7), R(x7)); // pacdza x7 + CMP_IO(dci(0xdac12ffe), R(x30), R(x30)); // pacdzb x30 + CMP_IO(dci(0x9add3157), R(x23), R(x10, x29)); // pacga x23, x10, x29 + CMP_IO(dci(0xd503211f), R(x17), R(x17, x16)); // pacia1716 + + CLEANUP(); +} + +TEST(group_49) { + SETUP(); + + CMP_IO(dci(0xdac10164), R(x4), R(x4, x11)); // pacia x4, x11 + CMP_IO(dci(0xd503233f), R(x30), R(x30, sp)); // paciasp + CMP_IO(dci(0xd503231f), R(x30), R(x30)); // paciaz + CMP_IO(dci(0xd503215f), R(x17), R(x17, x16)); // pacib1716 + CMP_IO(dci(0xdac10629), R(x9), R(x9, x17)); // pacib x9, x17 + CMP_IO(dci(0xd503237f), R(x30), R(x30, sp)); // pacibsp + CMP_IO(dci(0xd503235f), R(x30), R(x30)); // pacibz + CMP_IO(dci(0xdac123f4), R(x20), R(x20)); // paciza x20 + CMP_IO(dci(0xdac127f9), R(x25), R(x25)); // pacizb x25 + CMP_IO(dci(0x2518e402), R(p2), R()); // pfalse p2.b + CMP_IO(dci(0x2558c00f), R(p15), R(p0, p15)); // pfirst p15.b, p0, p15.b + CMP_IO(dci(0x6e399ebc), + R(v28), + R(v21, v25)); // pmul v28.16b, v21.16b, v25.16b + CMP_IO(dci(0x0439678e), R(v14), R(v28, v25)); // pmul z14.b, z28.b, z25.b + CMP_IO(dci(0x4e2ae3e5), + R(v5), + R(v31, v10)); // pmull2 v5.8h, v31.16b, v10.16b + CMP_IO(dci(0x459e68dd), R(v29), R(v6, v30)); // pmullb z29.s, z6.h, z30.h + CMP_IO(dci(0x45da6d66), R(v6), R(v11, v26)); // pmullt z6.d, z11.s, z26.s + CMP_IO(dci(0x2519c5cc), R(p12), R(p14, p12)); // pnext p12.b, p14, p12.b + CMP_IO(dci(0xc419e6c9), R(), R(p1, v22)); // prfb pstl1strm, p1, [z22.d, #25] + CMP_IO(dci(0x841af628), R(), R(p5, v17)); // prfb pstl1keep, p5, [z17.s, #26] + CMP_IO(dci(0x85fa16ed), + R(), + R(p5, x23)); // prfb pstl3strm, p5, [x23, #-6, mul vl] + CMP_IO(dci(0x8419dc60), + R(), + R(p7, x3, x25)); // prfb pldl1keep, p7, [x3, x25] + CMP_IO(dci(0xc47991e7), + R(), + R(p4, x15, v25)); // prfb #0b0111, p4, [x15, z25.d] + CMP_IO(dci(0xc47e08c6), + R(), + R(p2, x6, v30)); // prfb #0b0110, p2, [x6, z30.d, sxtw ] + CMP_IO(dci(0x843d02eb), + R(), + R(p0, x23, v29)); // prfb pstl2strm, p0, [x23, z29.s, uxtw] + CMP_IO(dci(0xc59ae52f), R(), R(p1, v9)); // prfd #0b1111, p1, [z9.d, #26] + CMP_IO(dci(0x859af7c2), R(), R(p5, v30)); // prfd pldl2keep, p5, [z30.s, #26] + CMP_IO(dci(0x85fa622b), + R(), + R(p0, x17)); // prfd pstl2strm, p0, [x17, #-6, mul vl] + CMP_IO(dci(0x8599ddea), + R(), + R(p7, x15, x25)); // prfd pstl2keep, p7, [x15, x25, lsl #3] + CMP_IO(dci(0xc479f381), + R(), + R(p4, x28, v25)); // prfd pldl1strm, p4, [x28, z25.d, lsl #3] + CMP_IO(dci(0xc43e73e4), + R(), + R(p4, sp, v30)); // prfd pldl3keep, p4, [sp, z30.d, uxtw #3] + CMP_IO(dci(0x847d77cd), + R(), + R(p5, x30, v29)); // prfd pstl3strm, p5, [x30, z29.s, sxtw #3] + CMP_IO(dci(0xc499e843), R(), R(p2, v2)); // prfh pldl2strm, p2, [z2.d, #25] + + CLEANUP(); +} + +TEST(group_50) { + SETUP(); + + CMP_IO(dci(0x849aee0e), R(), R(p3, v16)); // prfh #0b1110, p3, [z16.s, #26] + CMP_IO(dci(0x85fa3887), + R(), + R(p6, x4)); // prfh #0b0111, p6, [x4, #-6, mul vl] + CMP_IO(dci(0x849adac6), + R(), + R(p6, x22, x26)); // prfh #0b0110, p6, [x22, x26, lsl #1] + CMP_IO(dci(0xc47ab06d), + R(), + R(p4, x3, v26)); // prfh pstl3strm, p4, [x3, z26.d, lsl #1] + CMP_IO(dci(0xc43e2a40), + R(), + R(p2, x18, v30)); // prfh pldl1keep, p2, [x18, z30.d, uxtw #1] + CMP_IO(dci(0x847d3ae1), + R(), + R(p6, x23, v29)); // prfh pldl1strm, p6, [x23, z29.s, sxtw #1] + CMP_IO(dci(0xf9bc18ef), R(), R(x7)); // prfm #0b01111, [x7, #30768] + CMP_IO(dci(0xf8bcb916), + R(), + R(x8, x28)); // prfm #0b10110, [x8, x28, undefined #3] + CMP_IO(dci(0xf89ae0a1), R(), R(x5)); // prfum pldl1strm, [x5, #-82] + CMP_IO(dci(0xc51ae166), R(), R(p0, v11)); // prfw #0b0110, p0, [z11.d, #26] + CMP_IO(dci(0x8519fb8b), R(), R(p6, v28)); // prfw pstl2strm, p6, [z28.s, #25] + CMP_IO(dci(0x85d95122), + R(), + R(p4, x9)); // prfw pldl2keep, p4, [x9, #25, mul vl] + CMP_IO(dci(0x851acee3), + R(), + R(p3, x23, x26)); // prfw pldl2strm, p3, [x23, x26, lsl #2] + CMP_IO(dci(0xc47ad94c), + R(), + R(p6, x10, v26)); // prfw pstl3keep, p6, [x10, z26.d] + CMP_IO(dci(0xc47d4e29), + R(), + R(p3, x17, v29)); // prfw pstl1strm, p3, [x17, z29.d, sxtw ] + CMP_IO(dci(0x843e5d88), + R(), + R(p7, x12, v30)); // prfw pstl1keep, p7, [x12, z30.s, uxtw #2] + CMP_IO(dci(0x2550c160), R(), R(p0, p11)); // ptest p0, p11.b + CMP_IO(dci(0x2518e3cf), R(p15), R()); // ptrue p15.b, mul3 + CMP_IO(dci(0x25d9e226), R(p6), R()); // ptrues p6.d, #0x11 + CMP_IO(dci(0x0531418b), R(p11), R(p12)); // punpkhi p11.h, p12.b + CMP_IO(dci(0x053040c9), R(p9), R(p6)); // punpklo p9.h, p6.b + CMP_IO(dci(0x2ebe4198), + R(v24), + R(v12, v30)); // raddhn v24.2s, v12.2d, v30.2d + CMP_IO(dci(0x45a26b83), R(v3), R(v28, v2)); // raddhnb z3.h, z28.s, z2.s + CMP_IO(dci(0x45fd6ee1), + R(v1), + R(v1, v23, v29)); // raddhnt z1.s, z23.d, z29.d + CMP_IO(dci(0x453df6d4), R(v20), R(v22, v29)); // rax1 z20.d, z22.d, z29.d + CMP_IO(dci(0x5ac00308), R(x8), R(x24)); // rbit w8, w24 + CMP_IO(dci(0xdac003cd), R(x13), R(x30)); // rbit x13, x30 + CMP_IO(dci(0x6e605bb3), R(v19), R(v29)); // rbit v19.16b, v29.16b + CMP_IO(dci(0x05679202), R(v2), R(v2, p4, v16)); // rbit z2.h, p4/m, z16.h + CMP_IO(dci(0x2519f002), R(p2), R()); // rdffr p2.b + CMP_IO(dci(0x2518f107), R(p7), R(p8)); // rdffr p7.b, p8/z + CMP_IO(dci(0x2558f04e), R(p14), R(p2)); // rdffrs p14.b, p2/z + + CLEANUP(); +} + +TEST(group_51) { + SETUP(); + + CMP_IO(dci(0x04bf57cd), R(x13), R()); // rdvl x13, #-2 + CMP_IO(dci(0xd65f0380), R(), R(x28)); // ret x28 + CMP_IO(dci(0xd65f0bff), R(), R(sp, x30)); // retaa + CMP_IO(dci(0xd65f0fff), R(), R(sp, x30)); // retab + CMP_IO(dci(0x5ac00525), R(x5), R(x9)); // rev16 w5, w9 + CMP_IO(dci(0xdac00460), R(x0), R(x3)); // rev16 x0, x3 + CMP_IO(dci(0x0e201a72), R(v18), R(v19)); // rev16 v18.8b, v19.8b + CMP_IO(dci(0xdac009ea), R(x10), R(x15)); // rev32 x10, x15 + CMP_IO(dci(0x2e600ab0), R(v16), R(v21)); // rev32 v16.4h, v21.4h + CMP_IO(dci(0x0e60086d), R(v13), R(v3)); // rev64 v13.4h, v3.4h + CMP_IO(dci(0x5ac00abc), R(x28), R(x21)); // rev w28, w21 + CMP_IO(dci(0xdac00f81), R(x1), R(x28)); // rev x1, x28 + CMP_IO(dci(0x05b4402b), R(p11), R(p1)); // rev p11.s, p1.s + CMP_IO(dci(0x05b83a2b), R(v11), R(v17)); // rev z11.s, z17.s + CMP_IO(dci(0x05e494b9), R(v25), R(v25, p5, v5)); // revb z25.d, p5/m, z5.d + CMP_IO(dci(0x05a59643), R(v3), R(v3, p5, v18)); // revh z3.s, p5/m, z18.s + CMP_IO(dci(0x05e68236), R(v22), R(v22, p0, v17)); // revw z22.d, p0/m, z17.d + CMP_IO(dci(0xba1e0708), R(), R(x24)); // rmif x24, #60, #Nzcv + CMP_IO(dci(0x1ade2cb9), R(x25), R(x5, x30)); // ror w25, w5, w30 + CMP_IO(dci(0x9ade2ff4), R(x20), R(x30)); // ror x20, xzr, x30 + CMP_IO(dci(0x0f158faa), R(v10), R(v29)); // rshrn v10.4h, v29.4s, #11 + CMP_IO(dci(0x45791b8e), R(v14), R(v28)); // rshrnb z14.s, z28.d, #7 + CMP_IO(dci(0x453a1d4c), R(v12), R(v12, v10)); // rshrnt z12.h, z10.s, #6 + CMP_IO(dci(0x2ebe618b), + R(v11), + R(v12, v30)); // rsubhn v11.2s, v12.2d, v30.2d + CMP_IO(dci(0x45a27964), R(v4), R(v11, v2)); // rsubhnb z4.h, z11.s, z2.s + CMP_IO(dci(0x45fd7eee), + R(v14), + R(v14, v23, v29)); // rsubhnt z14.s, z23.d, z29.d + CMP_IO(dci(0x4e3a7c87), + R(v7), + R(v7, v4, v26)); // saba v7.16b, v4.16b, v26.16b + CMP_IO(dci(0x459dfafb), + R(v27), + R(v27, v23, v29)); // saba z27.s, z23.s, z29.s + CMP_IO(dci(0x0ead52ee), + R(v14), + R(v14, v23, v13)); // sabal v14.2d, v23.2s, v13.2s + CMP_IO(dci(0x455dc085), R(v5), R(v5, v4, v29)); // sabalb z5.h, z4.b, z29.b + CMP_IO(dci(0x459ec643), R(v3), R(v3, v18, v30)); // sabalt z3.s, z18.h, z30.h + CMP_IO(dci(0x0e3a754c), R(v12), R(v10, v26)); // sabd v12.8b, v10.8b, v26.8b + + CLEANUP(); +} + +TEST(group_52) { + SETUP(); + + CMP_IO(dci(0x048c0f4b), + R(v11), + R(p3, v11, v26)); // sabd z11.s, p3/m, z11.s, z26.s + CMP_IO(dci(0x4e787365), R(v5), R(v27, v24)); // sabdl2 v5.4s, v27.8h, v24.8h + CMP_IO(dci(0x45ce332c), R(v12), R(v25, v14)); // sabdlb z12.d, z25.s, z14.s + CMP_IO(dci(0x45da36d6), R(v22), R(v22, v26)); // sabdlt z22.d, z22.s, z26.s + CMP_IO(dci(0x0e206957), R(v23), R(v23, v10)); // sadalp v23.4h, v10.8b + CMP_IO(dci(0x4484b078), R(v24), R(v24, p4, v3)); // sadalp z24.s, p4/m, z3.h + CMP_IO(dci(0x4e3a0087), R(v7), R(v4, v26)); // saddl2 v7.8h, v4.16b, v26.16b + CMP_IO(dci(0x45da0166), R(v6), R(v11, v26)); // saddlb z6.d, z11.s, z26.s + CMP_IO(dci(0x455d8092), R(v18), R(v4, v29)); // saddlbt z18.h, z4.b, z29.b + CMP_IO(dci(0x0e202a1c), R(v28), R(v16)); // saddlp v28.4h, v16.8b + CMP_IO(dci(0x459e04dd), R(v29), R(v6, v30)); // saddlt z29.s, z6.h, z30.h + CMP_IO(dci(0x4e703b15), R(v21), R(v24)); // saddlv s21, v24.8h + CMP_IO(dci(0x04c03a79), R(v25), R(p6, v19)); // saddv d25, p6, z19.d + CMP_IO(dci(0x4e3a1087), R(v7), R(v4, v26)); // saddw2 v7.8h, v4.8h, v26.16b + CMP_IO(dci(0x45cc4053), R(v19), R(v2, v12)); // saddwb z19.d, z2.d, z12.s + CMP_IO(dci(0x45da4611), R(v17), R(v16, v26)); // saddwt z17.d, z16.d, z26.s + CMP_IO(dci(0x5a1b0252), R(x18), R(x18, x27)); // sbc w18, w18, w27 + CMP_IO(dci(0xda1b00bb), R(x27), R(x5, x27)); // sbc x27, x5, x27 + CMP_IO(dci(0x4599d060), R(v0), R(v0, v3, v25)); // sbclb z0.s, z3.s, z25.s + CMP_IO(dci(0x45dad47a), R(v26), R(v26, v3, v26)); // sbclt z26.d, z3.d, z26.d + CMP_IO(dci(0x7a1d006b), R(x11), R(x3, x29)); // sbcs w11, w3, w29 + CMP_IO(dci(0xfa1d0202), R(x2), R(x16, x29)); // sbcs x2, x16, x29 + CMP_IO(dci(0x13181b65), R(x5), R(x27)); // sbfiz w5, w27, #8, #7 + CMP_IO(dci(0x935a594c), R(x12), R(x10)); // sbfiz x12, x10, #38, #23 + CMP_IO(dci(0x4e21d894), R(v20), R(v4)); // scvtf v20.4s, v4.4s + CMP_IO(dci(0x4e79db9b), R(v27), R(v28)); // scvtf v27.8h, v28.8h + CMP_IO(dci(0x0f1de61c), R(v28), R(v16)); // scvtf v28.4h, v16.4h, #3 + CMP_IO(dci(0x5e61db8e), R(v14), R(v28)); // scvtf d14, d28 + CMP_IO(dci(0x5e79dbb5), R(v21), R(v29)); // scvtf h21, h29 + CMP_IO(dci(0x5f7ee4c6), R(v6), R(v6)); // scvtf d6, d6, #2 + CMP_IO(dci(0x1e42f078), R(v24), R(x3)); // scvtf d24, w3, #4 + CMP_IO(dci(0x1e6202d4), R(v20), R(x22)); // scvtf d20, w22 + + CLEANUP(); +} + +TEST(group_53) { + SETUP(); + + CMP_IO(dci(0x9e42513d), R(v29), R(x9)); // scvtf d29, x9, #44 + CMP_IO(dci(0x9e620399), R(v25), R(x28)); // scvtf d25, x28 + CMP_IO(dci(0x1ec2f38c), R(v12), R(x28)); // scvtf h12, w28, #4 + CMP_IO(dci(0x1ee20130), R(v16), R(x9)); // scvtf h16, w9 + CMP_IO(dci(0x9ec2d451), R(v17), R(x2)); // scvtf h17, x2, #11 + CMP_IO(dci(0x9ee201f5), R(v21), R(x15)); // scvtf h21, x15 + CMP_IO(dci(0x1e028109), R(v9), R(x8)); // scvtf s9, w8, #32 + CMP_IO(dci(0x1e2202ad), R(v13), R(x21)); // scvtf s13, w21 + CMP_IO(dci(0x9e02a044), R(v4), R(x2)); // scvtf s4, x2, #24 + CMP_IO(dci(0x9e2201e8), R(v8), R(x15)); // scvtf s8, x15 + CMP_IO(dci(0x6552b0d5), R(v21), R(v21, p4, v6)); // scvtf z21.h, p4/m, z6.h + CMP_IO(dci(0x65d0a60f), R(v15), R(v15, p1, v16)); // scvtf z15.d, p1/m, z16.s + CMP_IO(dci(0x6554b324), R(v4), R(v4, p4, v25)); // scvtf z4.h, p4/m, z25.s + CMP_IO(dci(0x6594ab72), R(v18), R(v18, p2, v27)); // scvtf z18.s, p2/m, z27.s + CMP_IO(dci(0x65d6beba), R(v26), R(v26, p7, v21)); // scvtf z26.d, p7/m, z21.d + CMP_IO(dci(0x6556aa45), R(v5), R(v5, p2, v18)); // scvtf z5.h, p2/m, z18.d + CMP_IO(dci(0x65d4ac37), R(v23), R(v23, p3, v1)); // scvtf z23.s, p3/m, z1.d + CMP_IO(dci(0x1add0c92), R(x18), R(x4, x29)); // sdiv w18, w4, w29 + CMP_IO(dci(0x9add0efb), R(x27), R(x23, x29)); // sdiv x27, x23, x29 + CMP_IO(dci(0x04d412af), + R(v15), + R(p4, v15, v21)); // sdiv z15.d, p4/m, z15.d, z21.d + CMP_IO(dci(0x04961da5), + R(v5), + R(p7, v5, v13)); // sdivr z5.s, p7/m, z5.s, z13.s + CMP_IO(dci(0x4ffdeae1), + R(v1), + R(v1, v23, v29)); // sdot v1.4s, v23.16b, v29.4b[3] + CMP_IO(dci(0x0e5c9772), + R(v18), + R(v18, v27, v28)); // sdot v18.4h, v27.8b, v28.8b + CMP_IO(dci(0x449e0250), + R(v16), + R(v16, v18, v30)); // sdot z16.s, z18.b, z30.b + CMP_IO(dci(0x44fb00ae), + R(v14), + R(v14, v5, v11)); // sdot z14.d, z5.h, z11.h[1] + CMP_IO(dci(0x44bb0003), R(v3), R(v0, v3)); // sdot z3.s, z0.b, z3.b[3] + CMP_IO(dci(0x250d661f), + R(p15), + R(p9, p0, p13)); // sel p15.b, p9, p0.b, p13.b + CMP_IO(dci(0x057cfdf5), + R(v21), + R(p15, v15, v28)); // sel z21.h, p15, z15.h, z28.h + CMP_IO(dci(0x19c487bb), + R(x27, x29), + R(x27, x29, x4)); // sete [x27]!, x29!, x4 + CMP_IO(dci(0x19dda629), + R(x9, x17), + R(x9, x17, x29)); // seten [x9]!, x17!, x29 + CMP_IO(dci(0x3a004a2d), R(), R(x17)); // setf16 w17 + CMP_IO(dci(0x3a00092d), R(), R(x9)); // setf8 w9 + + CLEANUP(); +} + +TEST(group_54) { + SETUP(); + + CMP_IO(dci(0x252c9000), R(), R()); // setffr + CMP_IO(dci(0x1dc68493), R(x19, x4), R(x19, x4, x6)); // setge [x19]!, x4!, x6 + CMP_IO(dci(0x1dcda6b0), + R(x16, x21), + R(x16, x21, x13)); // setgen [x16]!, x21!, x13 + CMP_IO(dci(0x1dc24663), R(x3, x19), R(x3, x19, x2)); // setgm [x3]!, x19!, x2 + CMP_IO(dci(0x1dcd6499), + R(x25, x4), + R(x25, x4, x13)); // setgmn [x25]!, x4!, x13 + CMP_IO(dci(0x1dd50545), + R(x5, x10), + R(x5, x10, x21)); // setgp [x5]!, x10!, x21 + CMP_IO(dci(0x1dda262b), + R(x11, x17), + R(x11, x17, x26)); // setgpn [x11]!, x17!, x26 + CMP_IO(dci(0x19d6472b), + R(x11, x25), + R(x11, x25, x22)); // setm [x11]!, x25!, x22 + CMP_IO(dci(0x19de6655), + R(x21, x18), + R(x21, x18, x30)); // setmn [x21]!, x18!, x30 + CMP_IO(dci(0x19da054c), + R(x12, x10), + R(x12, x10, x26)); // setp [x12]!, x10!, x26 + CMP_IO(dci(0x19c1266f), + R(x15, x19), + R(x15, x19, x1)); // setpn [x15]!, x19!, x1 + CMP_IO(dci(0x0ea1066f), R(v15), R(v19, v1)); // shadd v15.2s, v19.2s, v1.2s + CMP_IO(dci(0x44509df5), + R(v21), + R(p7, v21, v15)); // shadd z21.h, p7/m, z21.h, z15.h + CMP_IO(dci(0x4f5e57da), R(v26), R(v30)); // shl v26.2d, v30.2d, #30 + CMP_IO(dci(0x5f775555), R(v21), R(v10)); // shl d21, d10, #55 + CMP_IO(dci(0x6ea13ace), R(v14), R(v22)); // shll2 v14.2d, v22.4s, #32 + CMP_IO(dci(0x0f158677), R(v23), R(v19)); // shrn v23.4h, v19.4s, #11 + CMP_IO(dci(0x453e1250), R(v16), R(v18)); // shrnb z16.h, z18.s, #2 + CMP_IO(dci(0x457d156a), R(v10), R(v10, v11)); // shrnt z10.s, z11.d, #3 + CMP_IO(dci(0x0eb824ed), R(v13), R(v7, v24)); // shsub v13.2s, v7.2s, v24.2s + CMP_IO(dci(0x44529eba), + R(v26), + R(p7, v26, v21)); // shsub z26.h, p7/m, z26.h, z21.h + CMP_IO(dci(0x44169fdc), + R(v28), + R(p7, v28, v30)); // shsubr z28.b, p7/m, z28.b, z30.b + CMP_IO(dci(0x6f515745), R(v5), R(v5, v26)); // sli v5.2d, v26.2d, #17 + CMP_IO(dci(0x7f4f5612), R(v18), R(v18, v16)); // sli d18, d16, #15 + CMP_IO(dci(0x451af7cf), R(v15), R(v15, v30)); // sli z15.h, z30.h, #10 + CMP_IO(dci(0x9b3d3957), + R(x23), + R(x10, x29, x14)); // smaddl x23, w10, w29, x14 + CMP_IO(dci(0x0eab6415), R(v21), R(v0, v11)); // smax v21.2s, v0.2s, v11.2s + CMP_IO(dci(0x04481e52), + R(v18), + R(p7, v18, v18)); // smax z18.h, p7/m, z18.h, z18.h + CMP_IO(dci(0x25e8ce1e), R(v30), R(v30)); // smax z30.d, z30.d, #112 + CMP_IO(dci(0x4e61a745), R(v5), R(v26, v1)); // smaxp v5.8h, v26.8h, v1.8h + CMP_IO(dci(0x4454b202), + R(v2), + R(p4, v2, v16)); // smaxp z2.h, p4/m, z2.h, z16.h + CMP_IO(dci(0x0e30a946), R(v6), R(v10)); // smaxv b6, v10.8b + + CLEANUP(); +} + +TEST(group_55) { + SETUP(); + + CMP_IO(dci(0x04c827f6), R(v22), R(p1, v31)); // smaxv d22, p1, z31.d + CMP_IO(dci(0x4e3a6fcf), + R(v15), + R(v30, v26)); // smin v15.16b, v30.16b, v26.16b + CMP_IO(dci(0x048a1010), + R(v16), + R(p4, v16, v0)); // smin z16.s, p4/m, z16.s, z0.s + CMP_IO(dci(0x252ac604), R(v4), R(v4)); // smin z4.b, z4.b, #48 + CMP_IO(dci(0x4e3eac9f), + R(v31), + R(v4, v30)); // sminp v31.16b, v4.16b, v30.16b + CMP_IO(dci(0x4496b6a0), + R(v0), + R(p5, v0, v21)); // sminp z0.s, p5/m, z0.s, z21.s + CMP_IO(dci(0x0e31a94c), R(v12), R(v10)); // sminv b12, v10.8b + CMP_IO(dci(0x040a266c), R(v12), R(p1, v19)); // sminv b12, p1, z19.b + CMP_IO(dci(0x4eba82f0), + R(v16), + R(v16, v23, v26)); // smlal2 v16.2d, v23.4s, v26.4s + CMP_IO(dci(0x4f8421ed), + R(v13), + R(v13, v15, v4)); // smlal2 v13.2d, v15.4s, v4.s[0] + CMP_IO(dci(0x44d64033), + R(v19), + R(v19, v1, v22)); // smlalb z19.d, z1.s, z22.s + CMP_IO(dci(0x44fb80d5), + R(v21), + R(v21, v6, v11)); // smlalb z21.d, z6.s, z11.s[2] + CMP_IO(dci(0x44ba8bdc), + R(v28), + R(v28, v30, v2)); // smlalb z28.s, z30.h, z2.h[7] + CMP_IO(dci(0x44de4571), + R(v17), + R(v17, v11, v30)); // smlalt z17.d, z11.s, z30.s + CMP_IO(dci(0x44fa8573), + R(v19), + R(v19, v11, v10)); // smlalt z19.d, z11.s, z10.s[2] + CMP_IO(dci(0x44bb8f3e), + R(v30), + R(v30, v25, v3)); // smlalt z30.s, z25.h, z3.h[7] + CMP_IO(dci(0x0eb4a277), + R(v23), + R(v23, v19, v20)); // smlsl v23.2d, v19.2s, v20.2s + CMP_IO(dci(0x0f596132), + R(v18), + R(v18, v9, v9)); // smlsl v18.4s, v9.4h, v9.h[1] + CMP_IO(dci(0x445e5315), + R(v21), + R(v21, v24, v30)); // smlslb z21.h, z24.b, z30.b + CMP_IO(dci(0x44fbab17), + R(v23), + R(v23, v24, v11)); // smlslb z23.d, z24.s, z11.s[3] + CMP_IO(dci(0x44bba19a), + R(v26), + R(v26, v12, v3)); // smlslb z26.s, z12.h, z3.h[6] + CMP_IO(dci(0x449d57b3), + R(v19), + R(v19, v29, v29)); // smlslt z19.s, z29.h, z29.h + CMP_IO(dci(0x44fba731), + R(v17), + R(v17, v25, v11)); // smlslt z17.d, z25.s, z11.s[2] + CMP_IO(dci(0x44bbad80), + R(v0), + R(v0, v12, v3)); // smlslt z0.s, z12.h, z3.h[7] + CMP_IO(dci(0x4e9ba679), + R(v25), + R(v25, v19, v27)); // smmla v25.4s, v19.16b, v27.16b + CMP_IO(dci(0x45199b8e), + R(v14), + R(v14, v28, v25)); // smmla z14.s, z28.b, z25.b + CMP_IO(dci(0x0e1b2cae), R(x14), R(v5)); // smov w14, v5.b[13] + CMP_IO(dci(0x4e142c5a), R(x26), R(v2)); // smov x26, v2.s[2] + CMP_IO(dci(0x9b3d9a1c), R(x28), R(x16, x29, x6)); // smsubl x28, w16, w29, x6 + CMP_IO(dci(0x9b5a106d), R(x13), R(x3, x26)); // smulh x13, x3, x26 + CMP_IO(dci(0x0452182a), + R(v10), + R(p6, v10, v1)); // smulh z10.h, p6/m, z10.h, z1.h + CMP_IO(dci(0x043e689f), R(v31), R(v4, v30)); // smulh z31.b, z4.b, z30.b + + CLEANUP(); +} + +TEST(group_56) { + SETUP(); + + CMP_IO(dci(0x4e39c2bc), + R(v28), + R(v21, v25)); // smull2 v28.8h, v21.16b, v25.16b + CMP_IO(dci(0x4f9aaba8), + R(v8), + R(v29, v26)); // smull2 v8.2d, v29.4s, v26.s[2] + CMP_IO(dci(0x45d972c9), R(v9), R(v22, v25)); // smullb z9.d, z22.s, z25.s + CMP_IO(dci(0x44fdc86b), R(v11), R(v3, v13)); // smullb z11.d, z3.s, z13.s[3] + CMP_IO(dci(0x44bcc116), R(v22), R(v8, v4)); // smullb z22.s, z8.h, z4.h[6] + CMP_IO(dci(0x45ce754b), R(v11), R(v10, v14)); // smullt z11.d, z10.s, z14.s + CMP_IO(dci(0x44fccead), + R(v13), + R(v21, v12)); // smullt z13.d, z21.s, z12.s[3] + CMP_IO(dci(0x44bdc6d4), R(v20), R(v22, v5)); // smullt z20.s, z22.h, z5.h[6] + CMP_IO(dci(0x052d994c), + R(v12), + R(p6, v10, v11)); // splice z12.b, p6, {z10.b, z11.b} + CMP_IO(dci(0x052c92bc), + R(v28), + R(p4, v28, v21)); // splice z28.b, p4, z28.b, z21.b + CMP_IO(dci(0x4ee0780f), R(v15), R(v0)); // sqabs v15.2d, v0.2d + CMP_IO(dci(0x5e207abc), R(v28), R(v21)); // sqabs b28, b21 + CMP_IO(dci(0x4408bf17), R(v23), R(v23, p7, v24)); // sqabs z23.b, p7/m, z24.b + CMP_IO(dci(0x0e7d0c85), R(v5), R(v4, v29)); // sqadd v5.4h, v4.4h, v29.4h + CMP_IO(dci(0x5ebe0d8b), R(v11), R(v12, v30)); // sqadd s11, s12, s30 + CMP_IO(dci(0x44d89516), + R(v22), + R(v22, p5, v22, v8)); // sqadd z22.d, p5/m, z22.d, z8.d + CMP_IO(dci(0x2564ebda), R(v26), R(v26)); // sqadd z26.h, z26.h, #94, lsl #8 + CMP_IO(dci(0x04bd13b3), R(v19), R(v29, v29)); // sqadd z19.s, z29.s, z29.s + CMP_IO(dci(0x4541ddea), + R(v10), + R(v10, v15)); // sqcadd z10.h, z10.h, z15.h, #270 + CMP_IO(dci(0x042dfa0f), R(x15), R(x15)); // sqdecb x15, w15, #0x10, mul #14 + CMP_IO(dci(0x043bfbf6), R(x22), R(x22)); // sqdecb x22, all, mul #12 + CMP_IO(dci(0x04edfb99), R(x25), R(x25)); // sqdecd x25, w25, #0x1c, mul #14 + CMP_IO(dci(0x04fbfb24), R(x4), R(x4)); // sqdecd x4, #0x19, mul #12 + CMP_IO(dci(0x04eac86d), R(v13), R(v13)); // sqdecd z13.d, vl3, mul #11 + CMP_IO(dci(0x046cf9f5), R(x21), R(x21)); // sqdech x21, w21, #0xf, mul #13 + CMP_IO(dci(0x047bf980), R(x0), R(x0)); // sqdech x0, vl128, mul #12 + CMP_IO(dci(0x0469cb81), R(v1), R(v1)); // sqdech z1.h, #0x1c, mul #10 + CMP_IO(dci(0x25ea8811), R(x17), R(p0, x17)); // sqdecp x17, p0.d, w17 + CMP_IO(dci(0x252a8c1c), R(x28), R(x28, p0)); // sqdecp x28, p0.b + CMP_IO(dci(0x256a8165), R(v5), R(v5, p11)); // sqdecp z5.h, p11 + CMP_IO(dci(0x04acf844), R(x4), R(x4)); // sqdecw x4, w4, vl2, mul #13 + CMP_IO(dci(0x04bbfa79), R(x25), R(x25)); // sqdecw x25, #0x13, mul #12 + + CLEANUP(); +} + +TEST(group_57) { + SETUP(); + + CMP_IO(dci(0x04aaca38), R(v24), R(v24)); // sqdecw z24.s, #0x11, mul #11 + CMP_IO(dci(0x0eb99053), + R(v19), + R(v19, v2, v25)); // sqdmlal v19.2d, v2.2s, v25.2s + CMP_IO(dci(0x4f4231fb), + R(v27), + R(v27, v15, v2)); // sqdmlal2 v27.4s, v15.8h, v2.h[0] + CMP_IO(dci(0x5e7d9085), R(v5), R(v5, v4, v29)); // sqdmlal s5, h4, h29 + CMP_IO(dci(0x5f583b65), R(v5), R(v5, v27, v8)); // sqdmlal s5, h27, v8.h[5] + CMP_IO(dci(0x44826164), R(v4), R(v4, v11, v2)); // sqdmlalb z4.s, z11.h, z2.h + CMP_IO(dci(0x44fa2b0a), + R(v10), + R(v24, v10)); // sqdmlalb z10.d, z24.s, z10.s[3] + CMP_IO(dci(0x44bb21a7), + R(v7), + R(v7, v13, v3)); // sqdmlalb z7.s, z13.h, z3.h[6] + CMP_IO(dci(0x44990860), + R(v0), + R(v0, v3, v25)); // sqdmlalbt z0.s, z3.h, z25.h + CMP_IO(dci(0x44dd66ee), + R(v14), + R(v14, v23, v29)); // sqdmlalt z14.d, z23.s, z29.s + CMP_IO(dci(0x44fb2410), + R(v16), + R(v16, v0, v11)); // sqdmlalt z16.d, z0.s, z11.s[2] + CMP_IO(dci(0x44ba24a1), + R(v1), + R(v1, v5, v2)); // sqdmlalt z1.s, z5.h, z2.h[6] + CMP_IO(dci(0x4e78b365), + R(v5), + R(v5, v27, v24)); // sqdmlsl2 v5.4s, v27.8h, v24.8h + CMP_IO(dci(0x4f7a72fd), + R(v29), + R(v29, v23, v10)); // sqdmlsl2 v29.4s, v23.8h, v10.h[3] + CMP_IO(dci(0x5ea2b383), R(v3), R(v3, v28, v2)); // sqdmlsl d3, s28, s2 + CMP_IO(dci(0x5fb97853), + R(v19), + R(v19, v2, v25)); // sqdmlsl d19, s2, v25.s[3] + CMP_IO(dci(0x445d694a), R(v10), R(v10, v29)); // sqdmlslb z10.h, z10.b, z29.b + CMP_IO(dci(0x44fb326c), + R(v12), + R(v12, v19, v11)); // sqdmlslb z12.d, z19.s, z11.s[2] + CMP_IO(dci(0x44bb3a45), + R(v5), + R(v5, v18, v3)); // sqdmlslb z5.s, z18.h, z3.h[7] + CMP_IO(dci(0x44da0e1e), + R(v30), + R(v30, v16, v26)); // sqdmlslbt z30.d, z16.s, z26.s + CMP_IO(dci(0x449e6e50), + R(v16), + R(v16, v18, v30)); // sqdmlslt z16.s, z18.h, z30.h + CMP_IO(dci(0x44fb34ae), + R(v14), + R(v14, v5, v11)); // sqdmlslt z14.d, z5.s, z11.s[2] + CMP_IO(dci(0x44bb3c03), R(v3), R(v0, v3)); // sqdmlslt z3.s, z0.h, z3.h[7] + CMP_IO(dci(0x0fabc015), + R(v21), + R(v0, v11)); // sqdmulh v21.2s, v0.2s, v11.s[1] + CMP_IO(dci(0x0ea1b66f), R(v15), R(v19, v1)); // sqdmulh v15.2s, v19.2s, v1.2s + CMP_IO(dci(0x5f65c176), R(v22), R(v11, v5)); // sqdmulh h22, h11, v5.h[2] + CMP_IO(dci(0x5e7fb538), R(v24), R(v9, v31)); // sqdmulh h24, h9, h31 + CMP_IO(dci(0x043e73f4), R(v20), R(v31, v30)); // sqdmulh z20.b, z31.b, z30.b + CMP_IO(dci(0x44fbf252), + R(v18), + R(v18, v11)); // sqdmulh z18.d, z18.d, z11.d[1] + CMP_IO(dci(0x447bf0ae), R(v14), R(v5, v3)); // sqdmulh z14.h, z5.h, z3.h[7] + CMP_IO(dci(0x44bcf0ef), R(v15), R(v7, v4)); // sqdmulh z15.s, z7.s, z4.s[3] + CMP_IO(dci(0x4eb8d3a3), + R(v3), + R(v29, v24)); // sqdmull2 v3.2d, v29.4s, v24.4s + + CLEANUP(); +} + +TEST(group_58) { + SETUP(); + + CMP_IO(dci(0x0fbab22b), + R(v11), + R(v17, v26)); // sqdmull v11.2d, v17.2s, v26.s[1] + CMP_IO(dci(0x5e61d345), R(v5), R(v26, v1)); // sqdmull s5, h26, h1 + CMP_IO(dci(0x5f79b925), R(v5), R(v9, v9)); // sqdmull s5, h9, v9.h[7] + CMP_IO(dci(0x45da6166), R(v6), R(v11, v26)); // sqdmullb z6.d, z11.s, z26.s + CMP_IO(dci(0x44fce9e8), + R(v8), + R(v15, v12)); // sqdmullb z8.d, z15.s, z12.s[3] + CMP_IO(dci(0x44bde399), + R(v25), + R(v28, v5)); // sqdmullb z25.s, z28.h, z5.h[6] + CMP_IO(dci(0x459e64dd), R(v29), R(v6, v30)); // sqdmullt z29.s, z6.h, z30.h + CMP_IO(dci(0x44fde602), + R(v2), + R(v16, v13)); // sqdmullt z2.d, z16.s, z13.s[2] + CMP_IO(dci(0x44bcef7f), + R(v31), + R(v27, v4)); // sqdmullt z31.s, z27.h, z4.h[7] + CMP_IO(dci(0x042df399), R(x25), R(x25)); // sqincb x25, w25, #0x1c, mul #14 + CMP_IO(dci(0x043bf324), R(x4), R(x4)); // sqincb x4, #0x19, mul #12 + CMP_IO(dci(0x04edf20f), R(x15), R(x15)); // sqincd x15, w15, #0x10, mul #14 + CMP_IO(dci(0x04fbf3f6), R(x22), R(x22)); // sqincd x22, all, mul #12 + CMP_IO(dci(0x04e9c39b), R(v27), R(v27)); // sqincd z27.d, #0x1c, mul #10 + CMP_IO(dci(0x046cf123), R(x3), R(x3)); // sqinch x3, w3, vl16, mul #13 + CMP_IO(dci(0x047af30a), R(x10), R(x10)); // sqinch x10, #0x18, mul #11 + CMP_IO(dci(0x0469c1f7), R(v23), R(v23)); // sqinch z23.h, #0xf, mul #10 + CMP_IO(dci(0x25288887), R(x7), R(p4, x7)); // sqincp x7, p4.b, w7 + CMP_IO(dci(0x25e88cee), R(x14), R(x14, p7)); // sqincp x14, p7.d + CMP_IO(dci(0x25a88093), R(v19), R(v19, p4)); // sqincp z19.s, p4 + CMP_IO(dci(0x04acf116), R(x22), R(x22)); // sqincw x22, w22, vl8, mul #13 + CMP_IO(dci(0x04bcf0ef), R(x15), R(x15)); // sqincw x15, vl7, mul #13 + CMP_IO(dci(0x04aac3c2), R(v2), R(v2)); // sqincw z2.s, mul3, mul #11 + CMP_IO(dci(0x6e6079ea), R(v10), R(v15)); // sqneg v10.8h, v15.8h + CMP_IO(dci(0x7ea07a38), R(v24), R(v17)); // sqneg s24, s17 + CMP_IO(dci(0x4489af4b), R(v11), R(v11, p3, v26)); // sqneg z11.s, p3/m, z26.s + CMP_IO(dci(0x44593d25), + R(v5), + R(v5, v9, v25)); // sqrdcmlah z5.h, z9.h, z25.h, #270 + CMP_IO(dci(0x44bd7c6b), + R(v11), + R(v11, v3, v5)); // sqrdcmlah z11.h, z3.h, z5.h[3], #270 + CMP_IO(dci(0x44fc782a), + R(v10), + R(v10, v1, v12)); // sqrdcmlah z10.s, z1.s, z12.s[1], #180 + CMP_IO(dci(0x6f84dbe8), + R(v8), + R(v8, v31, v4)); // sqrdmlah v8.4s, v31.4s, v4.s[2] + CMP_IO(dci(0x2e5b8652), + R(v18), + R(v18, v18, v27)); // sqrdmlah v18.4h, v18.4h, v27.4h + CMP_IO(dci(0x7fb8d0ed), + R(v13), + R(v13, v7, v24)); // sqrdmlah s13, s7, v24.s[1] + + CLEANUP(); +} + +TEST(group_59) { + SETUP(); + + CMP_IO(dci(0x7e9b8410), R(v16), R(v16, v0, v27)); // sqrdmlah s16, s0, s27 + CMP_IO(dci(0x449d73c0), + R(v0), + R(v0, v30, v29)); // sqrdmlah z0.s, z30.s, z29.s + CMP_IO(dci(0x44fb133e), + R(v30), + R(v30, v25, v11)); // sqrdmlah z30.d, z25.d, z11.d[1] + CMP_IO(dci(0x447b10e2), + R(v2), + R(v2, v7, v3)); // sqrdmlah z2.h, z7.h, z3.h[7] + CMP_IO(dci(0x44ba1173), + R(v19), + R(v19, v11, v2)); // sqrdmlah z19.s, z11.s, z2.s[3] + CMP_IO(dci(0x6f7efb15), + R(v21), + R(v21, v24, v14)); // sqrdmlsh v21.8h, v24.8h, v14.h[7] + CMP_IO(dci(0x6e1b8db4), + R(v20), + R(v20, v13, v27)); // sqrdmlsh v20.16b, v13.16b, v27.16b + CMP_IO(dci(0x7fbdf2fb), + R(v27), + R(v27, v23, v29)); // sqrdmlsh s27, s23, v29.s[1] + CMP_IO(dci(0x7edb8cae), R(v14), R(v14, v5, v27)); // sqrdmlsh d14, d5, d27 + CMP_IO(dci(0x44de757e), + R(v30), + R(v30, v11, v30)); // sqrdmlsh z30.d, z11.d, z30.d + CMP_IO(dci(0x44fb1580), + R(v0), + R(v0, v12, v11)); // sqrdmlsh z0.d, z12.d, z11.d[1] + CMP_IO(dci(0x443b1724), + R(v4), + R(v4, v25, v3)); // sqrdmlsh z4.h, z25.h, z3.h[3] + CMP_IO(dci(0x44bb1731), + R(v17), + R(v17, v25, v3)); // sqrdmlsh z17.s, z25.s, z3.s[3] + CMP_IO(dci(0x0fbed243), + R(v3), + R(v18, v30)); // sqrdmulh v3.2s, v18.2s, v30.s[1] + CMP_IO(dci(0x6ebab7a8), + R(v8), + R(v29, v26)); // sqrdmulh v8.4s, v29.4s, v26.4s + CMP_IO(dci(0x5f7dd3cd), R(v13), R(v30, v13)); // sqrdmulh h13, h30, v13.h[3] + CMP_IO(dci(0x7e7ab47a), R(v26), R(v3, v26)); // sqrdmulh h26, h3, h26 + CMP_IO(dci(0x04797532), R(v18), R(v9, v25)); // sqrdmulh z18.h, z9.h, z25.h + CMP_IO(dci(0x44fdf6d4), + R(v20), + R(v22, v13)); // sqrdmulh z20.d, z22.d, z13.d[1] + CMP_IO(dci(0x443df530), R(v16), R(v9, v5)); // sqrdmulh z16.h, z9.h, z5.h[3] + CMP_IO(dci(0x44bcf6ad), + R(v13), + R(v21, v4)); // sqrdmulh z13.s, z21.s, z4.s[3] + CMP_IO(dci(0x0eab5c15), R(v21), R(v0, v11)); // sqrshl v21.2s, v0.2s, v11.2s + CMP_IO(dci(0x5e3a5fcf), R(v15), R(v30, v26)); // sqrshl b15, b30, b26 + CMP_IO(dci(0x444a9e52), + R(v18), + R(p7, v18, v18)); // sqrshl z18.h, p7/m, z18.h, z18.h + CMP_IO(dci(0x440e86d4), + R(v20), + R(p1, v20, v22)); // sqrshlr z20.b, p1/m, z20.b, z22.b + CMP_IO(dci(0x0f119c01), R(v1), R(v0)); // sqrshrn v1.4h, v0.4s, #15 + CMP_IO(dci(0x5f109c02), R(v2), R(v0)); // sqrshrn h0, s0, #16 + CMP_IO(dci(0x45392860), R(v0), R(v3)); // sqrshrnb z0.h, z3.s, #7 + CMP_IO(dci(0x457a2c7a), R(v26), R(v26, v3)); // sqrshrnt z26.s, z3.d, #6 + CMP_IO(dci(0x2f118c22), R(v2), R(v1)); // sqrshrun v2.4h, v1.4s, #15 + CMP_IO(dci(0x7f398df7), R(v23), R(v15)); // sqrshrun s23, d15, #7 + CMP_IO(dci(0x453e0a43), R(v3), R(v18)); // sqrshrunb z3.h, z18.s, #2 + + CLEANUP(); +} + +TEST(group_60) { + SETUP(); + + CMP_IO(dci(0x457d0c85), R(v5), R(v5, v4)); // sqrshrunt z5.s, z4.d, #3 + CMP_IO(dci(0x0ebe4e43), R(v3), R(v18, v30)); // sqshl v3.2s, v18.2s, v30.2s + CMP_IO(dci(0x4f7e74ac), R(v12), R(v5)); // sqshl v12.2d, v5.2d, #62 + CMP_IO(dci(0x5e7d4fcd), R(v13), R(v30, v29)); // sqshl h13, h30, h29 + CMP_IO(dci(0x5f667636), R(v22), R(v17)); // sqshl d22, d17, #38 + CMP_IO(dci(0x04c68109), R(v9), R(p0, v9)); // sqshl z9.d, p0/m, z9.d, #40 + CMP_IO(dci(0x440886d4), + R(v20), + R(p1, v20, v22)); // sqshl z20.b, p1/m, z20.b, z22.b + CMP_IO(dci(0x444c9e52), + R(v18), + R(p7, v18, v18)); // sqshlr z18.h, p7/m, z18.h, z18.h + CMP_IO(dci(0x6f5965f7), R(v23), R(v15)); // sqshlu v23.2d, v15.2d, #25 + CMP_IO(dci(0x7f326559), R(v25), R(v10)); // sqshlu s25, s10, #18 + CMP_IO(dci(0x04cf8e86), R(v6), R(p3, v6)); // sqshlu z6.d, p3/m, z6.d, #52 + CMP_IO(dci(0x0f329638), R(v24), R(v17)); // sqshrn v24.2s, v17.2d, #14 + CMP_IO(dci(0x5f339445), R(v5), R(v2)); // sqshrn s5, d2, #13 + CMP_IO(dci(0x457e217e), R(v30), R(v11)); // sqshrnb z30.s, z11.d, #2 + CMP_IO(dci(0x453d261c), R(v28), R(v28, v16)); // sqshrnt z28.h, z16.s, #3 + CMP_IO(dci(0x6f3d86fb), R(v27), R(v23)); // sqshrun2 v27.4s, v23.2d, #3 + CMP_IO(dci(0x7f2e8715), R(v21), R(v24)); // sqshrun s21, d24, #18 + CMP_IO(dci(0x45790381), R(v1), R(v28)); // sqshrunb z1.s, z28.d, #7 + CMP_IO(dci(0x453a0487), R(v7), R(v7, v4)); // sqshrunt z7.h, z4.s, #6 + CMP_IO(dci(0x0e7d2d4a), R(v10), R(v10, v29)); // sqsub v10.4h, v10.4h, v29.4h + CMP_IO(dci(0x5ebe2d98), R(v24), R(v12, v30)); // sqsub s24, s12, s30 + CMP_IO(dci(0x44da8109), + R(v9), + R(p0, v9, v8)); // sqsub z9.d, p0/m, z9.d, z8.d + CMP_IO(dci(0x2566cb15), R(v21), R(v21)); // sqsub z21.h, z21.h, #88 + CMP_IO(dci(0x04bd1bc0), R(v0), R(v30, v29)); // sqsub z0.s, z30.s, z29.s + CMP_IO(dci(0x449e8f4b), + R(v11), + R(p3, v11, v26)); // sqsubr z11.s, p3/m, z11.s, z26.s + CMP_IO(dci(0x0e21494c), R(v12), R(v10)); // sqxtn v12.8b, v10.8h + CMP_IO(dci(0x5e214946), R(v6), R(v10)); // sqxtn b6, h10 + CMP_IO(dci(0x45304258), R(v24), R(v18)); // sqxtnb z24.h, z18.s + CMP_IO(dci(0x452846ee), R(v14), R(v14, v23)); // sqxtnt z14.b, z23.h + CMP_IO(dci(0x2e212957), R(v23), R(v10)); // sqxtun v23.8b, v10.8h + CMP_IO(dci(0x7ea128ed), R(v13), R(v7)); // sqxtun s13, d7 + CMP_IO(dci(0x456051f5), R(v21), R(v15)); // sqxtunb z21.s, z15.d + + CLEANUP(); +} + +TEST(group_61) { + SETUP(); + + CMP_IO(dci(0x453057f5), R(v21), R(v21, v31)); // sqxtunt z21.h, z31.s + CMP_IO(dci(0x4eba17a8), R(v8), R(v29, v26)); // srhadd v8.4s, v29.4s, v26.4s + CMP_IO(dci(0x44149f17), + R(v23), + R(p7, v23, v24)); // srhadd z23.b, p7/m, z23.b, z24.b + CMP_IO(dci(0x6f66449f), R(v31), R(v31, v4)); // sri v31.2d, v4.2d, #26 + CMP_IO(dci(0x7f514489), R(v9), R(v9, v4)); // sri d9, d4, #47 + CMP_IO(dci(0x45d9f381), R(v1), R(v1, v28)); // sri z1.d, z28.d, #7 + CMP_IO(dci(0x4e7e57da), R(v26), R(v30)); // srshl v26.8h, v30.8h, v30.8h + CMP_IO(dci(0x5efc5418), R(v24), R(v0, v28)); // srshl d24, d0, d28 + CMP_IO(dci(0x44c28799), + R(v25), + R(p1, v25, v28)); // srshl z25.d, p1/m, z25.d, z28.d + CMP_IO(dci(0x448688bb), + R(v27), + R(p2, v27, v5)); // srshlr z27.s, p2/m, z27.s, z5.s + CMP_IO(dci(0x4f66249f), R(v31), R(v4)); // srshr v31.2d, v4.2d, #26 + CMP_IO(dci(0x5f762571), R(v17), R(v11)); // srshr d17, d11, #10 + CMP_IO(dci(0x04cc885e), R(v30), R(p2, v30)); // srshr z30.d, p2/m, z30.d, #30 + CMP_IO(dci(0x4f4537c0), R(v0), R(v0, v30)); // srsra v0.2d, v30.2d, #59 + CMP_IO(dci(0x5f4034eb), R(v11), R(v11, v7)); // srsra d11, d7, #64 + CMP_IO(dci(0x451ee8ac), R(v12), R(v12, v5)); // srsra z12.h, z5.h, #2 + CMP_IO(dci(0x4e3946bc), + R(v28), + R(v21, v25)); // sshl v28.16b, v21.16b, v25.16b + CMP_IO(dci(0x5efa4566), R(v6), R(v11, v26)); // sshl d6, d11, d26 + CMP_IO(dci(0x0f28a4ee), R(v14), R(v7)); // sshll v14.2d, v7.2s, #8 + CMP_IO(dci(0x455aa159), R(v25), R(v10)); // sshllb z25.d, z10.s, #26 + CMP_IO(dci(0x451aa53f), R(v31), R(v9)); // sshllt z31.s, z9.h, #10 + CMP_IO(dci(0x4f6206fd), R(v29), R(v23)); // sshr v29.2d, v23.2d, #30 + CMP_IO(dci(0x5f410453), R(v19), R(v2)); // sshr d19, d2, #63 + CMP_IO(dci(0x4f5e16a2), R(v2), R(v2, v21)); // ssra v2.2d, v21.2d, #34 + CMP_IO(dci(0x5f421604), R(v4), R(v4, v16)); // ssra d4, d16, #62 + CMP_IO(dci(0x4559e1ea), R(v10), R(v10, v15)); // ssra z10.s, z15.s, #7 + CMP_IO(dci(0x0e3a214c), R(v12), R(v10, v26)); // ssubl v12.8h, v10.8b, v26.8b + CMP_IO(dci(0x45da1159), R(v25), R(v10, v26)); // ssublb z25.d, z10.s, z26.s + CMP_IO(dci(0x455d8bcd), R(v13), R(v30, v29)); // ssublbt z13.h, z30.b, z29.b + CMP_IO(dci(0x454215fb), R(v27), R(v15, v2)); // ssublt z27.h, z15.b, z2.b + CMP_IO(dci(0x455d8fcd), R(v13), R(v30, v29)); // ssubltb z13.h, z30.b, z29.b + CMP_IO(dci(0x0e3a314c), R(v12), R(v10, v26)); // ssubw v12.8h, v10.8h, v26.8b + + CLEANUP(); +} + +TEST(group_62) { + SETUP(); + + CMP_IO(dci(0x45cc5234), R(v20), R(v17, v12)); // ssubwb z20.d, z17.d, z12.s + CMP_IO(dci(0x45da561e), R(v30), R(v16, v26)); // ssubwt z30.d, z16.d, z26.s + CMP_IO(dci(0x0c007381), R(), R(v1, x28)); // st1 {v1.8b}, [x28] + CMP_IO(dci(0x0c00a381), R(), R(v1, v2, x28)); // st1 {v1.8b, v2.8b}, [x28] + CMP_IO(dci(0x0c006381), + R(), + R(v1, v2, v3, x28)); // st1 {v1.8b, v2.8b, v3.8b}, [x28] + CMP_IO(dci(0x0c002381), + R(), + R(v1, v2, v3, v4, x28)); // st1 {v1.8b, v2.8b, v3.8b, v4.8b}, [x28] + CMP_IO(dci(0x4c9f7b15), R(x24), R(v21, x24)); // st1 {v21.4s}, [x24], #16 + CMP_IO(dci(0x4c9fab15), + R(x24), + R(v21, v22, x24)); // st1 {v21.4s, v22.4s}, [x24], #32 + CMP_IO(dci(0x4c9f6b15), + R(x24), + R(v21, v22, v23, x24)); // st1 {v21.4s, v22.4s, v23.4s}, [x24], #48 + CMP_IO(dci(0x4c9f2b15), + R(x24), + R(v21, + v22, + v23, + v24, + x24)); // st1 {v21.4s, v22.4s, v23.4s, v24.4s}, [x24], #64 + CMP_IO(dci(0x4c827b15), R(x24), R(v21, x24, x2)); // st1 {v21.4s}, [x24], x2 + CMP_IO(dci(0x4c9bab15), + R(x24), + R(v21, v22, x24, x27)); // st1 {v21.4s, v22.4s}, [x24], x27 + CMP_IO(dci(0x4c8f6b15), + R(x24), + R(v21, + v22, + v23, + x24, + x15)); // st1 {v21.4s, v22.4s, v23.4s}, [x24], x15 + CMP_IO(dci(0x4c882b15), R(x24), R(v21, v22, v23, v24, x24, x8)); // st1 + // {v21.4s, + // v22.4s, + // v23.4s, + // v24.4s}, + // [x24], x8 + CMP_IO(dci(0x0d00053f), R(), R(v31, x9)); // st1 {v31.b}[1], [x9] + CMP_IO(dci(0x0d00853f), R(), R(v31, x9)); // st1 {v31.d}[0], [x9] + CMP_IO(dci(0x0d00413f), R(), R(v31, x9)); // st1 {v31.h}[0], [x9] + CMP_IO(dci(0x0d00813f), R(), R(v31, x9)); // st1 {v31.s}[0], [x9] + CMP_IO(dci(0x4d9f02f0), R(x23), R(v16, x23)); // st1 {v16.b}[8], [x23], #1 + CMP_IO(dci(0x4d860b15), + R(x24), + R(v21, x24, x6)); // st1 {v21.b}[10], [x24], x6 + CMP_IO(dci(0x4d9f86f0), R(x23), R(v16, x23)); // st1 {v16.d}[1], [x23], #8 + CMP_IO(dci(0x4d8f8715), + R(x24), + R(v21, x24, x15)); // st1 {v21.d}[1], [x24], x15 + CMP_IO(dci(0x4d9f42f0), R(x23), R(v16, x23)); // st1 {v16.h}[4], [x23], #2 + CMP_IO(dci(0x4d864b15), + R(x24), + R(v21, x24, x6)); // st1 {v21.h}[5], [x24], x6 + CMP_IO(dci(0x4d9f82f0), R(x23), R(v16, x23)); // st1 {v16.s}[2], [x23], #4 + CMP_IO(dci(0x4d9b8315), + R(x24), + R(v21, x24, x27)); // st1 {v21.s}[2], [x24], x27 + CMP_IO(dci(0xe45cab72), + R(), + R(v18, p2, v27)); // st1b {z18.d}, p2, [z27.d, #28] + CMP_IO(dci(0xe47da60f), + R(), + R(v15, p1, v16)); // st1b {z15.s}, p1, [z16.s, #29] + CMP_IO(dci(0xe44eebda), + R(), + R(v26, p2, x30)); // st1b {z26.s}, p2, [x30, #-2, mul vl] + CMP_IO(dci(0xe43d42fb), + R(), + R(v27, p0, x23, x29)); // st1b {z27.h}, p0, [x23, x29] + CMP_IO(dci(0xe41db13d), + R(), + R(v29, p4, x9, v29)); // st1b {z29.d}, p4, [x9, z29.d] + CMP_IO(dci(0xe41b8980), + R(), + R(v0, p2, x12, v27)); // st1b {z0.d}, p2, [x12, z27.d, uxtw] + + CLEANUP(); +} + +TEST(group_63) { + SETUP(); + + CMP_IO(dci(0xe45b8731), + R(), + R(v17, p1, x25, v27)); // st1b {z17.s}, p1, [x25, z27.s, uxtw] + CMP_IO(dci(0xe5dca9e8), + R(), + R(v8, p2, v15)); // st1d {z8.d}, p2, [z15.d, #224] + CMP_IO(dci(0xe58eea50), + R(), + R(v16, p2, x18)); // st1d {z16.b}, p2, [x18, #-2, mul vl] + CMP_IO(dci(0xe5fd57cd), + R(), + R(v13, p5, x30, x29)); // st1d {z13.d}, p5, [x30, x29, lsl #3] + CMP_IO(dci(0xe5bcb82a), + R(), + R(v10, p6, x1, v28)); // st1d {z10.d}, p6, [x1, z28.d, lsl #3] + CMP_IO(dci(0xe59dbc6b), + R(), + R(v11, p7, x3, v29)); // st1d {z11.d}, p7, [x3, z29.d] + CMP_IO(dci(0xe5bbcf4b), + R(), + R(v11, p3, x26, v27)); // st1d {z11.d}, p3, [x26, z27.d, sxtw #3] + CMP_IO(dci(0xe59acb0a), + R(), + R(v10, p2, x24, v26)); // st1d {z10.d}, p2, [x24, z26.d, sxtw] + CMP_IO(dci(0xe4dcacfc), + R(), + R(v28, p3, v7)); // st1h {z28.d}, p3, [z7.d, #56] + CMP_IO(dci(0xe4fcbdf5), + R(), + R(v21, p7, v15)); // st1h {z21.s}, p7, [z15.s, #56] + CMP_IO(dci(0xe48ef3f4), + R(), + R(v20, p4, sp)); // st1h {z20.b}, p4, [sp, #-2, mul vl] + CMP_IO(dci(0xe4fd5ae1), + R(), + R(v1, p6, x23, x29)); // st1h {z1.d}, p6, [x23, x29, lsl #1] + CMP_IO(dci(0xe4bcb516), + R(), + R(v22, p5, x8, v28)); // st1h {z22.d}, p5, [x8, z28.d, lsl #1] + CMP_IO(dci(0xe49db2c7), + R(), + R(v7, p4, x22, v29)); // st1h {z7.d}, p4, [x22, z29.d] + CMP_IO(dci(0xe4bbc5a7), + R(), + R(v7, p1, x13, v27)); // st1h {z7.d}, p1, [x13, z27.d, sxtw #1] + CMP_IO(dci(0xe49bc7f6), + R(), + R(v22, p1, sp, v27)); // st1h {z22.d}, p1, [sp, z27.d, sxtw] + CMP_IO(dci(0xe4facb0a), + R(), + R(v10, p2, x24, v26)); // st1h {z10.s}, p2, [x24, z26.s, sxtw #1] + CMP_IO(dci(0xe4dbcf4b), + R(), + R(v11, p3, x26, v27)); // st1h {z11.s}, p3, [x26, z27.s, sxtw] + CMP_IO(dci(0xe55db13d), + R(), + R(v29, p4, v9)); // st1w {z29.d}, p4, [z9.d, #116] + CMP_IO(dci(0xe57ca044), R(), R(v4, p0, v2)); // st1w {z4.s}, p0, [z2.s, #112] + CMP_IO(dci(0xe56de485), + R(), + R(v5, p1, x4)); // st1w {z5.d}, p1, [x4, #-3, mul vl] + CMP_IO(dci(0xe51e5d98), + R(), + R(v24, p7, x12, x30)); // st1w {z24.b}, p7, [x12, x30, lsl #2] + CMP_IO(dci(0xe53ca923), + R(), + R(v3, p2, x9, v28)); // st1w {z3.d}, p2, [x9, z28.d, lsl #2] + CMP_IO(dci(0xe51cab72), + R(), + R(v18, p2, x27, v28)); // st1w {z18.d}, p2, [x27, z28.d] + CMP_IO(dci(0xe53b9e52), + R(), + R(v18, p7, x18, v27)); // st1w {z18.d}, p7, [x18, z27.d, uxtw #2] + CMP_IO(dci(0xe51b9c03), + R(), + R(v3, p7, x0, v27)); // st1w {z3.d}, p7, [x0, z27.d, uxtw] + CMP_IO(dci(0xe57c98ef), + R(), + R(v15, p6, x7, v28)); // st1w {z15.s}, p6, [x7, z28.s, uxtw #2] + CMP_IO(dci(0xe55b94ae), + R(), + R(v14, p5, x5, v27)); // st1w {z14.s}, p5, [x5, z27.s, uxtw] + CMP_IO(dci(0x4c00810d), + R(), + R(v13, v14, x8)); // st2 {v13.16b, v14.16b}, [x8] + CMP_IO(dci(0x4c9f81ce), + R(x14), + R(v14, v15, x14)); // st2 {v14.16b, v15.16b}, [x14], #32 + CMP_IO(dci(0x4c9b81ce), + R(x14), + R(v14, v15, x14, x27)); // st2 {v14.16b, v15.16b}, [x14], x27 + CMP_IO(dci(0x4d201ad6), + R(), + R(v22, v23, x22)); // st2 {v22.b, v23.b}[14], [x22] + + CLEANUP(); +} + +TEST(group_64) { + SETUP(); + + CMP_IO(dci(0x4d2086d6), + R(), + R(v22, v23, x22)); // st2 {v22.d, v23.d}[1], [x22] + CMP_IO(dci(0x4d205ad6), + R(), + R(v22, v23, x22)); // st2 {v22.h, v23.h}[7], [x22] + CMP_IO(dci(0x4d2092d6), + R(), + R(v22, v23, x22)); // st2 {v22.s, v23.s}[3], [x22] + CMP_IO(dci(0x4dbf03b5), + R(x29), + R(v21, v22, x29)); // st2 {v21.b, v22.b}[8], [x29], #2 + CMP_IO(dci(0x0dba0a50), + R(x18), + R(v16, v17, x18, x26)); // st2 {v16.b, v17.b}[2], [x18], x26 + CMP_IO(dci(0x4dbf87b5), + R(x29), + R(v21, v22, x29)); // st2 {v21.d, v22.d}[1], [x29], #16 + CMP_IO(dci(0x0db98650), + R(x18), + R(v16, v17, x18, x25)); // st2 {v16.d, v17.d}[0], [x18], x25 + CMP_IO(dci(0x4dbf43b5), + R(x29), + R(v21, v22, x29)); // st2 {v21.h, v22.h}[4], [x29], #4 + CMP_IO(dci(0x0db34a50), + R(x18), + R(v16, v17, x18, x19)); // st2 {v16.h, v17.h}[1], [x18], x19 + CMP_IO(dci(0x4dbf83b5), + R(x29), + R(v21, v22, x29)); // st2 {v21.s, v22.s}[2], [x29], #8 + CMP_IO(dci(0x0dbb8250), + R(x18), + R(v16, v17, x18, x27)); // st2 {v16.s, v17.s}[0], [x18], x27 + CMP_IO(dci(0xe43bfe52), + R(), + R(v18, v19, p7, x18)); // st2b {z18.b, z19.b}, p7, [x18, #-10, mul vl] + CMP_IO(dci(0xe43b7c03), + R(), + R(v3, v4, p7, x0, x27)); // st2b {z3.b, z4.b}, p7, [x0, x27] + CMP_IO(dci(0xe5bbfcc8), + R(), + R(v8, v9, p7, x6)); // st2d {z8.d, z9.d}, p7, [x6, #-10, mul vl] + CMP_IO(dci(0xe5bb70d5), R(), R(v21, v22, p4, x6, x27)); // st2d {z21.d, + // z22.d}, p4, [x6, + // x27, lsl #3] + CMP_IO(dci(0xd9bd4ad4), R(), R(x20, x22)); // st2g x20, [x22, #-704] + CMP_IO(dci(0xd9bcb77f), R(x27), R(sp, x27)); // st2g sp, [x27], #-848 + CMP_IO(dci(0xd9bb9d9a), R(x12), R(x26, x12)); // st2g x26, [x12, #-1136]! + CMP_IO(dci(0xe4baffdc), + R(), + R(v28, v29, p7, x30)); // st2h {z28.h, z29.h}, p7, [x30, #-12, mul vl] + CMP_IO(dci(0xe4bb7a79), R(), R(v25, v26, p6, x19, x27)); // st2h {z25.h, + // z26.h}, p6, [x19, + // x27, lsl #1] + CMP_IO(dci(0xe53ce41d), + R(), + R(v29, v30, p1, x0)); // st2w {z29.s, z30.s}, p1, [x0, #-8, mul vl] + CMP_IO(dci(0xe53b6980), + R(), + R(v0, v1, p2, x12, x27)); // st2w {z0.s, z1.s}, p2, [x12, x27, lsl #2] + CMP_IO(dci(0x4c00410d), + R(), + R(v13, v14, v15, x8)); // st3 {v13.16b, v14.16b, v15.16b}, [x8] + CMP_IO(dci(0x4c9f41ce), + R(x14), + R(v14, v15, v16, x14)); // st3 {v14.16b, v15.16b, v16.16b}, [x14], #48 + CMP_IO(dci(0x4c8a41ce), + R(x14), + R(v14, + v15, + v16, + x14, + x10)); // st3 {v14.16b, v15.16b, v16.16b}, [x14], x10 + CMP_IO(dci(0x0d00306d), + R(), + R(v13, v14, v15, x3)); // st3 {v13.b, v14.b, v15.b}[4], [x3] + CMP_IO(dci(0x0d00a46d), + R(), + R(v13, v14, v15, x3)); // st3 {v13.d, v14.d, v15.d}[0], [x3] + CMP_IO(dci(0x0d00706d), + R(), + R(v13, v14, v15, x3)); // st3 {v13.h, v14.h, v15.h}[2], [x3] + CMP_IO(dci(0x0d00b06d), + R(), + R(v13, v14, v15, x3)); // st3 {v13.s, v14.s, v15.s}[1], [x3] + CMP_IO(dci(0x0d9f2e1e), + R(x16), + R(v30, v31, v0, x16)); // st3 {v30.b, v31.b, v0.b}[3], [x16], #3 + CMP_IO(dci(0x4d9a3fe7), + R(sp), + R(v7, v8, v9, sp, x26)); // st3 {v7.b, v8.b, v9.b}[15], [sp], x26 + CMP_IO(dci(0x0d9fa61e), + R(x16), + R(v30, v31, v0, x16)); // st3 {v30.d, v31.d, v0.d}[0], [x16], #24 + + CLEANUP(); +} + +TEST(group_65) { + SETUP(); + + CMP_IO(dci(0x4d94a7e7), + R(sp), + R(v7, v8, v9, sp, x20)); // st3 {v7.d, v8.d, v9.d}[1], [sp], x20 + CMP_IO(dci(0x0d9f6a1e), + R(x16), + R(v30, v31, v0, x16)); // st3 {v30.h, v31.h, v0.h}[1], [x16], #6 + CMP_IO(dci(0x4d897be7), + R(sp), + R(v7, v8, v9, sp, x9)); // st3 {v7.h, v8.h, v9.h}[7], [sp], x9 + CMP_IO(dci(0x0d9fa21e), + R(x16), + R(v30, v31, v0, x16)); // st3 {v30.s, v31.s, v0.s}[0], [x16], #12 + CMP_IO(dci(0x4d9eb3e7), + R(sp), + R(v7, v8, v9, sp, x30)); // st3 {v7.s, v8.s, v9.s}[3], [sp], x30 + CMP_IO(dci(0xe45bf3e9), R(), R(v9, v10, v11, p4, sp)); // st3b {z9.b, z10.b, + // z11.b}, p4, [sp, + // #-15, mul vl] + CMP_IO(dci(0xe45b666c), R(), R(v12, v13, v14, p1, x19, x27)); // st3b {z12.b, + // z13.b, + // z14.b}, p1, + // [x19, x27] + CMP_IO(dci(0xe5dbf25f), R(), R(v31, v0, v1, p4, x18)); // st3d {z31.d, z0.d, + // z1.d}, p4, [x18, + // #-15, mul vl] + CMP_IO(dci(0xe5db7b3e), R(), R(v30, v31, v0, p6, x25, x27)); // st3d {z30.d, + // z31.d, z0.d}, + // p6, [x25, + // x27, lsl #3] + CMP_IO(dci(0xe4daf573), + R(), + R(v19, + v20, + v21, + p5, + x11)); // st3h {z19.h, z20.h, z21.h}, p5, [x11, #-18, mul vl] + CMP_IO(dci(0xe4db64e2), R(), R(v2, v3, v4, p1, x7, x27)); // st3h {z2.h, + // z3.h, z4.h}, p1, + // [x7, x27, lsl + // #1] + CMP_IO(dci(0xe55cee86), R(), R(v6, v7, v8, p3, x20)); // st3w {z6.s, z7.s, + // z8.s}, p3, [x20, + // #-12, mul vl] + CMP_IO(dci(0xe55b7f17), R(), R(v23, v24, v25, p7, x24, x27)); // st3w {z23.s, + // z24.s, + // z25.s}, p7, + // [x24, x27, + // lsl #2] + CMP_IO(dci(0x4c00010d), R(), R(v13, v14, v15, v16, x8)); // st4 {v13.16b, + // v14.16b, v15.16b, + // v16.16b}, [x8] + CMP_IO(dci(0x4c9f01ce), + R(x14), + R(v14, + v15, + v16, + v17, + x14)); // st4 {v14.16b, v15.16b, v16.16b, v17.16b}, [x14], #64 + CMP_IO(dci(0x4c9901ce), + R(x14), + R(v14, v15, v16, v17, x14, x25)); // st4 {v14.16b, v15.16b, v16.16b, + // v17.16b}, [x14], x25 + CMP_IO(dci(0x0d202604), + R(), + R(v4, v5, v6, v7, x16)); // st4 {v4.b, v5.b, v6.b, v7.b}[1], [x16] + CMP_IO(dci(0x0d20a604), + R(), + R(v4, v5, v6, v7, x16)); // st4 {v4.d, v5.d, v6.d, v7.d}[0], [x16] + CMP_IO(dci(0x0d206204), + R(), + R(v4, v5, v6, v7, x16)); // st4 {v4.h, v5.h, v6.h, v7.h}[0], [x16] + CMP_IO(dci(0x0d20a204), + R(), + R(v4, v5, v6, v7, x16)); // st4 {v4.s, v5.s, v6.s, v7.s}[0], [x16] + CMP_IO(dci(0x4dbf2ee3), R(x23), R(v3, v4, v5, v6, x23)); // st4 {v3.b, v4.b, + // v5.b, v6.b}[11], + // [x23], #4 + CMP_IO(dci(0x4db12bda), + R(x30), + R(v26, v27, v28, v29, x30, x17)); // st4 {v26.b, v27.b, v28.b, + // v29.b}[10], [x30], x17 + CMP_IO(dci(0x4dbfa6e3), R(x23), R(v3, v4, v5, v6, x23)); // st4 {v3.d, v4.d, + // v5.d, v6.d}[1], + // [x23], #32 + CMP_IO(dci(0x4db2a7da), + R(x30), + R(v26, v27, v28, v29, x30, x18)); // st4 {v26.d, v27.d, v28.d, + // v29.d}[1], [x30], x18 + CMP_IO(dci(0x4dbf6ae3), + R(x23), + R(v3, v4, v5, v6, x23)); // st4 {v3.h, v4.h, v5.h, v6.h}[5], [x23], #8 + CMP_IO(dci(0x4daa6bda), + R(x30), + R(v26, v27, v28, v29, x30, x10)); // st4 {v26.h, v27.h, v28.h, + // v29.h}[5], [x30], x10 + CMP_IO(dci(0x4dbfa2e3), R(x23), R(v3, v4, v5, v6, x23)); // st4 {v3.s, v4.s, + // v5.s, v6.s}[2], + // [x23], #16 + CMP_IO(dci(0x4da2a3da), + R(x30), + R(v26, v27, v28, v29, x30, x2)); // st4 {v26.s, v27.s, v28.s, + // v29.s}[2], [x30], x2 + CMP_IO(dci(0xe47bfcc8), R(), R(v8, v9, v10, v11, p7, x6)); // st4b {z8.b, + // z9.b, z10.b, + // z11.b}, p7, + // [x6, #-20, mul + // vl] + CMP_IO(dci(0xe47b70d5), + R(), + R(v21, v22, v23, v24, p4, x6, x27)); // st4b {z21.b, z22.b, z23.b, + // z24.b}, p4, [x6, x27] + CMP_IO(dci(0xe5fbfe52), R(), R(v18, v19, v20, v21, p7, x18)); // st4d {z18.d, + // z19.d, + // z20.d, + // z21.d}, p7, + // [x18, #-20, + // mul vl] + CMP_IO(dci(0xe5fb7c03), R(), R(v3, v4, v5, v6, p7, x0, x27)); // st4d {z3.d, + // z4.d, z5.d, + // z6.d}, p7, + // [x0, x27, + // lsl #3] + + CLEANUP(); +} + +TEST(group_66) { + SETUP(); + + CMP_IO(dci(0xe4fbf4ae), R(), R(v14, v15, v16, v17, p5, x5)); // st4h {z14.h, + // z15.h, z16.h, + // z17.h}, p5, + // [x5, #-20, + // mul vl] + CMP_IO(dci(0xe4fc78ef), + R(), + R(v15, v16, v17, v18, p6, x7, x28)); // st4h {z15.h, z16.h, z17.h, + // z18.h}, p6, [x7, x28, lsl #1] + CMP_IO(dci(0xe57bef4b), R(), R(v11, v12, v13, v14, p3, x26)); // st4w {z11.s, + // z12.s, + // z13.s, + // z14.s}, p3, + // [x26, #-20, + // mul vl] + CMP_IO(dci(0xe57a6b0a), + R(), + R(v10, v11, v12, v13, p2, x24, x26)); // st4w {z10.s, z11.s, z12.s, + // z13.s}, p2, [x24, x26, lsl + // #2] + CMP_IO(dci(0xd93dd892), R(), R(x18, x4)); // stg x18, [x4, #-560] + CMP_IO(dci(0xd93e965d), R(x18), R(x29, x18)); // stg x29, [x18], #-368 + CMP_IO(dci(0xd939bebc), R(x21), R(x28, x21)); // stg x28, [x21, #-1616]! + CMP_IO(dci(0x693d513d), R(), R(x29, x20, x9)); // stgp x29, x20, [x9, #-96] + CMP_IO(dci(0x689b5324), + R(x25), + R(x4, x20, x25)); // stgp x4, x20, [x25], #864 + CMP_IO(dci(0x69bcfdf5), R(x15), R(x21, x15)); // stgp x21, xzr, [x15, #-112]! + CMP_IO(dci(0x889a1ad7), R(), R(x23, x22)); // stllr w23, [x22] + CMP_IO(dci(0xc89a253f), R(), R(x9)); // stllr xzr, [x9] + CMP_IO(dci(0x089e1708), R(), R(x8, x24)); // stllrb w8, [x24] + CMP_IO(dci(0x489d2eee), R(), R(x14, x23)); // stllrh w14, [x23] + CMP_IO(dci(0x889d854a), R(), R(x10)); // stlr w10, [x10] + CMP_IO(dci(0xc89d8fb3), R(), R(x19, x29)); // stlr x19, [x29] + CMP_IO(dci(0x0899b2bc), R(), R(x28, x21)); // stlrb w28, [x21] + CMP_IO(dci(0x4899f132), R(), R(x18, x9)); // stlrh w18, [x9] + CMP_IO(dci(0x991c001d), R(), R(x29, x0)); // stlur w29, [x0, #-64] + CMP_IO(dci(0xd91c2358), R(), R(x24, x26)); // stlur x24, [x26, #-62] + CMP_IO(dci(0x191d620f), R(), R(x15, x16)); // stlurb w15, [x16, #-42] + CMP_IO(dci(0x591cf1f5), R(), R(x21, x15)); // stlurh w21, [x15, #-49] + CMP_IO(dci(0x8839dc60), R(x25), R(x0, x23, x3)); // stlxp w25, w0, w23, [x3] + CMP_IO(dci(0xc839bd25), R(x25), R(x5, x15, x9)); // stlxp w25, x5, x15, [x9] + CMP_IO(dci(0x8819dc60), R(x25), R(x0, x3)); // stlxr w25, w0, [x3] + CMP_IO(dci(0xc819bd25), R(x25), R(x5, x9)); // stlxr w25, x5, [x9] + CMP_IO(dci(0x081daeee), R(x29), R(x14, x23)); // stlxrb w29, w14, [x23] + CMP_IO(dci(0x481e9708), R(x30), R(x8, x24)); // stlxrh w30, w8, [x24] + CMP_IO(dci(0x283b48bb), R(), R(x27, x18, x5)); // stnp w27, w18, [x5, #-40] + CMP_IO(dci(0xa81b3e52), R(), R(x18, x15, x18)); // stnp x18, x15, [x18, #432] + CMP_IO(dci(0x6c1cc9e8), R(), R(v8, v18, x15)); // stnp d8, d18, [x15, #456] + CMP_IO(dci(0xac3d3c6b), R(), R(v11, v15, x3)); // stnp q11, q15, [x3, #-96] + + CLEANUP(); +} + +TEST(group_67) { + SETUP(); + + CMP_IO(dci(0x2c3d2799), R(), R(v25, v9, x28)); // stnp s25, s9, [x28, #-24] + CMP_IO(dci(0xe41c3516), + R(), + R(v22, p5, v8, x28)); // stnt1b {z22.d}, p5, [z8.d, x28] + CMP_IO(dci(0xe45a2b0a), + R(), + R(v10, p2, v24, x26)); // stnt1b {z10.s}, p2, [z24.s, x26] + CMP_IO(dci(0xe41be731), + R(), + R(v17, p1, x25)); // stnt1b {z17.b}, p1, [x25, #-5, mul vl] + CMP_IO(dci(0xe41b7324), + R(), + R(v4, p4, x25, x27)); // stnt1b {z4.b}, p4, [x25, x27] + CMP_IO(dci(0xe59c2044), + R(), + R(v4, p0, v2, x28)); // stnt1d {z4.d}, p0, [z2.d, x28] + CMP_IO(dci(0xe59be5a7), + R(), + R(v7, p1, x13)); // stnt1d {z7.d}, p1, [x13, #-5, mul vl] + CMP_IO(dci(0xe59b67f6), + R(), + R(v22, p1, sp, x27)); // stnt1d {z22.d}, p1, [sp, x27, lsl #3] + CMP_IO(dci(0xe49c36a0), + R(), + R(v0, p5, v21, x28)); // stnt1h {z0.d}, p5, [z21.d, x28] + CMP_IO(dci(0xe4db3324), + R(), + R(v4, p4, v25, x27)); // stnt1h {z4.s}, p4, [z25.s, x27] + CMP_IO(dci(0xe49bef4b), + R(), + R(v11, p3, x26)); // stnt1h {z11.h}, p3, [x26, #-5, mul vl] + CMP_IO(dci(0xe49a6b0a), + R(), + R(v10, p2, x24, x26)); // stnt1h {z10.h}, p2, [x24, x26, lsl #1] + CMP_IO(dci(0xe51d2799), + R(), + R(v25, p1, v28, x29)); // stnt1w {z25.d}, p1, [z28.d, x29] + CMP_IO(dci(0xe55b30d5), + R(), + R(v21, p4, v6, x27)); // stnt1w {z21.s}, p4, [z6.s, x27] + CMP_IO(dci(0xe51bf4ae), + R(), + R(v14, p5, x5)); // stnt1w {z14.s}, p5, [x5, #-5, mul vl] + CMP_IO(dci(0xe51c78ef), + R(), + R(v15, p6, x7, x28)); // stnt1w {z15.s}, p6, [x7, x28, lsl #2] + CMP_IO(dci(0x293bda79), R(), R(x25, x22, x19)); // stp w25, w22, [x19, #-36] + CMP_IO(dci(0x289cc9e8), R(x15), R(x8, x18, x15)); // stp w8, w18, [x15], #228 + CMP_IO(dci(0x29bb8731), + R(x25), + R(x17, x1, x25)); // stp w17, w1, [x25, #-36]! + CMP_IO(dci(0xa91bf9b4), R(), R(x20, x30, x13)); // stp x20, x30, [x13, #440] + CMP_IO(dci(0xa8bcaaad), + R(x21), + R(x13, x10, x21)); // stp x13, x10, [x21], #-56 + CMP_IO(dci(0xa99ba66c), + R(x19), + R(x12, x9, x19)); // stp x12, x9, [x19, #440]! + CMP_IO(dci(0x6d1d5ba6), R(), R(v6, v22, x29)); // stp d6, d22, [x29, #464] + CMP_IO(dci(0x6cbb48bb), R(x5), R(v27, v18, x5)); // stp d27, d18, [x5], #-80 + CMP_IO(dci(0x6d9d085e), R(x2), R(v30, v2, x2)); // stp d30, d2, [x2, #464]! + CMP_IO(dci(0xad3c8109), R(), R(v9, v0, x8)); // stp q9, q0, [x8, #-112] + CMP_IO(dci(0xac9c2358), R(x26), R(v24, v8, x26)); // stp q24, q8, [x26], #896 + CMP_IO(dci(0xadbc2dc1), + R(x14), + R(v1, v11, x14)); // stp q1, q11, [x14, #-128]! + CMP_IO(dci(0x2d3c95db), R(), R(v27, v5, x14)); // stp s27, s5, [x14, #-28] + CMP_IO(dci(0x2c9c0e86), R(x20), R(v6, v3, x20)); // stp s6, s3, [x20], #224 + CMP_IO(dci(0x2dbc4293), + R(x20), + R(v19, v16, x20)); // stp s19, s16, [x20, #-32]! + CMP_IO(dci(0xb81b765f), R(x18), R(x18)); // str wzr, [x18], #-73 + + CLEANUP(); +} + +TEST(group_68) { + SETUP(); + + CMP_IO(dci(0xb81cdeba), R(x21), R(x26, x21)); // str w26, [x21, #-51]! + CMP_IO(dci(0xb91ba66c), R(), R(x12, x19)); // str w12, [x19, #7076] + CMP_IO(dci(0xb83c29c1), + R(), + R(x1, x14, x28)); // str w1, [x14, x28, undefined] + CMP_IO(dci(0xf81b67f6), R(sp), R(x22, sp)); // str x22, [sp], #-74 + CMP_IO(dci(0xf81ced23), R(x9), R(x3, x9)); // str x3, [x9, #-50]! + CMP_IO(dci(0xf93b8731), R(), R(x17, x25)); // str x17, [x25, #30472] + CMP_IO(dci(0xf83c48fc), R(), R(x7, x28)); // str x28, [x7, w28, uxtw] + CMP_IO(dci(0x3c1cb516), R(x8), R(v22, x8)); // str b22, [x8], #-53 + CMP_IO(dci(0x3c1b9c03), R(x0), R(v3, x0)); // str b3, [x0, #-71]! + CMP_IO(dci(0x3d3cd451), R(), R(v17, x2)); // str b17, [x2, #3893] + CMP_IO(dci(0x3c3a3bdc), + R(), + R(v28, x30, x26)); // str b28, [x30, x26, undefined #0] + CMP_IO(dci(0x3c3c69e8), R(), R(v8, x15, x28)); // str b8, [x15, x28] + CMP_IO(dci(0xfc1ca444), R(x2), R(v4, x2)); // str d4, [x2], #-54 + CMP_IO(dci(0xfc1bbcd5), R(x6), R(v21, x6)); // str d21, [x6, #-69]! + CMP_IO(dci(0xfd3d12c7), R(), R(v7, x22)); // str d7, [x22, #31264] + CMP_IO(dci(0xfc3b18ae), + R(), + R(v14, x5, x27)); // str d14, [x5, x27, undefined #3] + CMP_IO(dci(0x7c1c76a0), R(x21), R(v0, x21)); // str h0, [x21], #-57 + CMP_IO(dci(0x7c1bde79), R(x19), R(v25, x19)); // str h25, [x19, #-67]! + CMP_IO(dci(0x7d3d3c6b), R(), R(v11, x3)); // str h11, [x3, #7838] + CMP_IO(dci(0x7c3b3a52), + R(), + R(v18, x18, x27)); // str h18, [x18, x27, undefined #1] + CMP_IO(dci(0xe59e156e), R(), R(p14, x11)); // str p14, [x11, #245, mul vl] + CMP_IO(dci(0x3c9d660f), R(x16), R(v15, x16)); // str q15, [x16], #-42 + CMP_IO(dci(0x3c9aef0a), R(x24), R(v10, x24)); // str q10, [x24, #-82]! + CMP_IO(dci(0x3d9c4cfc), R(), R(v28, x7)); // str q28, [x7, #28976] + CMP_IO(dci(0x3cbb8b31), + R(), + R(v17, x25, x27)); // str q17, [x25, x27, undefined] + CMP_IO(dci(0xbc1d553d), R(x9), R(v29, x9)); // str s29, [x9], #-43 + CMP_IO(dci(0xbc1affdc), R(x30), R(v28, x30)); // str s28, [x30, #-81]! + CMP_IO(dci(0xbd1c382a), R(), R(v10, x1)); // str s10, [x1, #7224] + CMP_IO(dci(0xbc3b9803), + R(), + R(v3, x0, x27)); // str s3, [x0, x27, undefined #2] + CMP_IO(dci(0xe59e5d98), R(), R(v24, x12)); // str z24, [x12, #247, mul vl] + CMP_IO(dci(0x381ca6ad), R(x21), R(x13, x21)); // strb w13, [x21], #-54 + CMP_IO(dci(0x381bae6c), R(x19), R(x12, x19)); // strb w12, [x19, #-70]! + + CLEANUP(); +} + +TEST(group_69) { + SETUP(); + + CMP_IO(dci(0x391cdeba), R(), R(x26, x21)); // strb w26, [x21, #1847] + CMP_IO(dci(0x383ca9c1), + R(), + R(x1, x14, x28)); // strb w1, [x14, x28, undefined] + CMP_IO(dci(0x383b798d), + R(), + R(x13, x12, x27)); // strb w13, [x12, x27, lsl #0] + CMP_IO(dci(0x781c6437), R(x1), R(x23, x1)); // strh w23, [x1], #-58 + CMP_IO(dci(0x781bece2), R(x7), R(x2, x7)); // strh w2, [x7, #-66]! + CMP_IO(dci(0x791d46d4), R(), R(x20, x22)); // strh w20, [x22, #3746] + CMP_IO(dci(0x783b3be9), + R(), + R(x9, sp, x27)); // strh w9, [sp, x27, undefined #1] + CMP_IO(dci(0xb81b63f6), R(), R(x22, sp)); // stur w22, [sp, #-74] + CMP_IO(dci(0xf81b725f), R(), R(x18)); // stur xzr, [x18, #-73] + CMP_IO(dci(0x3c1cb37f), R(), R(v31, x27)); // stur b31, [x27, #-53] + CMP_IO(dci(0xfc1c8109), R(), R(v9, x8)); // stur d9, [x8, #-56] + CMP_IO(dci(0x7c1c5365), R(), R(v5, x27)); // stur h5, [x27, #-59] + CMP_IO(dci(0x3c9d53a6), R(), R(v6, x29)); // stur q6, [x29, #-43] + CMP_IO(dci(0xbc1d7078), R(), R(v24, x3)); // stur s24, [x3, #-41] + CMP_IO(dci(0x381cc1e8), R(), R(x8, x15)); // sturb w8, [x15, #-52] + CMP_IO(dci(0x781c61ce), R(), R(x14)); // sturh w14, [x14, #-58] + CMP_IO(dci(0x883d6d64), R(x29), R(x4, x27, x11)); // stxp w29, w4, w27, [x11] + CMP_IO(dci(0xc83d4e29), R(x29), R(x9, x19, x17)); // stxp w29, x9, x19, [x17] + CMP_IO(dci(0x881d6d64), R(x29), R(x4, x11)); // stxr w29, w4, [x11] + CMP_IO(dci(0xc81d4e29), R(x29), R(x9, x17)); // stxr w29, x9, [x17] + CMP_IO(dci(0x08197132), R(x25), R(x18, x9)); // stxrb w25, w18, [x9] + CMP_IO(dci(0x481932bc), R(x25), R(x28, x21)); // stxrh w25, w28, [x21] + CMP_IO(dci(0xd9faeb0a), R(), R(x10, x24)); // stz2g x10, [x24, #-1312] + CMP_IO(dci(0xd9fbb4d5), R(x6), R(x21, x6)); // stz2g x21, [x6], #-1104 + CMP_IO(dci(0xd9fcac44), R(x2), R(x4, x2)); // stz2g x4, [x2, #-864]! + CMP_IO(dci(0xd97a594c), R(), R(x12, x10)); // stzg x12, [x10, #-1456] + CMP_IO(dci(0xd979d5f7), R(x15), R(x23, x15)); // stzg x23, [x15], #-1584 + CMP_IO(dci(0xd97e7f22), R(x25), R(x2, x25)); // stzg x2, [x25, #-400]! + CMP_IO(dci(0x4b3b63f6), R(x22), R(sp, x27)); // sub w22, wsp, x27 + CMP_IO(dci(0x515b67f6), R(x22), R(sp)); // sub w22, wsp, #0x6d9000 (7180288) + CMP_IO(dci(0x4b1b0a45), R(x5), R(x18, x27)); // sub w5, w18, w27, lsl #2 + CMP_IO(dci(0xcb3b6a5f), R(sp), R(x18, x27)); // sub sp, x18, x27, lsl #2 + + CLEANUP(); +} + +TEST(group_70) { + SETUP(); + + CMP_IO(dci(0xd13b725f), R(sp), R(x18)); // sub sp, x18, #0xedc (3804) + CMP_IO(dci(0xcb5b2980), R(x0), R(x12, x27)); // sub x0, x12, x27, lsr #10 + CMP_IO(dci(0x2e3d861c), R(v28), R(v16, v29)); // sub v28.8b, v16.8b, v29.8b + CMP_IO(dci(0x7efe84c6), R(v6), R(v6, v30)); // sub d6, d6, d30 + CMP_IO(dci(0x048115db), + R(v27), + R(p5, v27, v14)); // sub z27.s, p5/m, z27.s, z14.s + CMP_IO(dci(0x2521dfe7), R(v7), R(v7)); // sub z7.b, z7.b, #255 + CMP_IO(dci(0x04fd06ee), R(v14), R(v23, v29)); // sub z14.d, z23.d, z29.d + CMP_IO(dci(0xd1bc8109), R(x9), R(x8)); // subg x9, x8, #960, #0 + CMP_IO(dci(0x0e2161bd), R(v29), R(v13, v1)); // subhn v29.8b, v13.8h, v1.8h + CMP_IO(dci(0x457971ea), R(v10), R(v15, v25)); // subhnb z10.b, z15.h, z25.h + CMP_IO(dci(0x45ba76f0), + R(v16), + R(v16, v23, v26)); // subhnt z16.h, z23.s, z26.s + CMP_IO(dci(0x9ad9038e), R(x14), R(x28, x25)); // subp x14, x28, x25 + CMP_IO(dci(0xbade03e7), R(x7), R(sp, x30)); // subps x7, sp, x30 + CMP_IO(dci(0x04c31a79), + R(v25), + R(p6, v25, v19)); // subr z25.d, p6/m, z25.d, z19.d + CMP_IO(dci(0x2563fd25), R(v5), R(v5)); // subr z5.h, z5.h, #233, lsl #8 + CMP_IO(dci(0x6b5d1d30), R(x16), R(x9, x29)); // subs w16, w9, w29, lsr #7 + CMP_IO(dci(0x6b3b67f6), R(x22), R(sp, x27)); // subs w22, wsp, x27, lsl #1 + CMP_IO(dci(0x715b67f6), R(x22), R(sp)); // subs w22, wsp, #0x6d9000 (7180288) + CMP_IO(dci(0xeb5cfdf5), R(x21), R(x15, x28)); // subs x21, x15, x28, lsr #63 + CMP_IO(dci(0xeb3b725f), R(), R(x18, x27)); // cmp x18, x27, lsl #4 + CMP_IO(dci(0xf13b725f), R(), R(x18)); // cmp x18, #0xedc (3804) + CMP_IO(dci(0x0f1afa1e), + R(v30), + R(v30, v16, v26)); // sudot v30.2s, v16.8b, v26.4b[2] + CMP_IO(dci(0x44bc1ea0), R(v0), R(v0, v21, v4)); // sudot z0.s, z21.b, z4.b[3] + CMP_IO(dci(0x05713932), R(v18), R(v9)); // sunpkhi z18.h, z9.b + CMP_IO(dci(0x05b038dd), R(v29), R(v6)); // sunpklo z29.s, z6.h + CMP_IO(dci(0x0e603b22), R(v2), R(v25)); // suqadd v2.4h, v25.4h + CMP_IO(dci(0x5ea03bc0), R(v0), R(v30)); // suqadd s0, s30 + CMP_IO(dci(0x44dc9a79), + R(v25), + R(p6, v25, v19)); // suqadd z25.d, p6/m, z25.d, z19.d + CMP_IO(dci(0xb83e8315), R(x21), R(x30, x24)); // swp w30, w21, [x24] + CMP_IO(dci(0xf83e8250), R(x16), R(x30, x18)); // swp x30, x16, [x18] + CMP_IO(dci(0xb8ba821e), R(x30), R(x26, x16)); // swpa w26, w30, [x16] + CMP_IO(dci(0xf8ba8087), R(x7), R(x26, x4)); // swpa x26, x7, [x4] + + CLEANUP(); +} + +TEST(group_71) { + SETUP(); + + CMP_IO(dci(0x38be8250), R(x16), R(x30, x18)); // swpab w30, w16, [x18] + CMP_IO(dci(0x78be80c6), R(x6), R(x30, x6)); // swpah w30, w6, [x6] + CMP_IO(dci(0xb8fe8322), R(x2), R(x30, x25)); // swpal w30, w2, [x25] + CMP_IO(dci(0xf8fe818b), R(x11), R(x30, x12)); // swpal x30, x11, [x12] + CMP_IO(dci(0x38fa8094), R(x20), R(x26, x4)); // swpalb w26, w20, [x4] + CMP_IO(dci(0x78fa807a), R(x26), R(x26, x3)); // swpalh w26, w26, [x3] + CMP_IO(dci(0x383a8087), R(x7), R(x26, x4)); // swpb w26, w7, [x4] + CMP_IO(dci(0x783a82fd), R(x29), R(x26, x23)); // swph w26, w29, [x23] + CMP_IO(dci(0xb87a8159), R(x25), R(x26, x10)); // swpl w26, w25, [x10] + CMP_IO(dci(0xf87a8094), R(x20), R(x26, x4)); // swpl x26, x20, [x4] + CMP_IO(dci(0x387e818b), R(x11), R(x30, x12)); // swplb w30, w11, [x12] + CMP_IO(dci(0x787e8171), R(x17), R(x30, x11)); // swplh w30, w17, [x11] + CMP_IO(dci(0x0450ab72), R(v18), R(v18, p2, v27)); // sxtb z18.h, p2/m, z27.h + CMP_IO(dci(0x0492b8cf), R(v15), R(v15, p6, v6)); // sxth z15.s, p6/m, z6.s + CMP_IO(dci(0x04d4b93e), R(v30), R(v30, p6, v9)); // sxtw z30.d, p6/m, z9.d + CMP_IO(dci(0x0e1b034b), + R(v11), + R(v26, v27)); // tbl v11.8b, {v26.16b}, v27.8b + CMP_IO(dci(0x0e1b234b), + R(v11), + R(v26, v27, v27)); // tbl v11.8b, {v26.16b, v27.16b}, v27.8b + CMP_IO(dci(0x0e1b434b), + R(v11), + R(v26, + v27, + v28, + v27)); // tbl v11.8b, {v26.16b, v27.16b, v28.16b}, v27.8b + CMP_IO(dci(0x0e1b634b), + R(v11), + R(v26, + v27, + v28, + v29, + v27)); // tbl v11.8b, {v26.16b, v27.16b, v28.16b, v29.16b}, v27.8b + CMP_IO(dci(0x05fa321e), R(v30), R(v16, v26)); // tbl z30.d, {z16.d}, z26.d + CMP_IO(dci(0x053a2887), + R(v7), + R(v4, v5, v26)); // tbl z7.b, {z4.b, z5.b}, z26.b + CMP_IO(dci(0xb79e1708), R(), R(x8)); // tbnz x8, #51, #-0x3d20 + CMP_IO(dci(0x0e1b125f), + R(v31), + R(v31, v18, v27)); // tbx v31.8b, {v18.16b}, v27.8b + CMP_IO(dci(0x0e1b325f), + R(v31), + R(v31, v18, v19, v27)); // tbx v31.8b, {v18.16b, v19.16b}, v27.8b + CMP_IO(dci(0x0e1b525f), + R(v31), + R(v31, + v18, + v19, + v20, + v27)); // tbx v31.8b, {v18.16b, v19.16b, v20.16b}, v27.8b + CMP_IO(dci(0x0e1b725f), + R(v31), + R(v31, v18, v19, v20, v21, v27)); // tbx v31.8b, {v18.16b, v19.16b, + // v20.16b, v21.16b}, v27.8b + CMP_IO(dci(0x05be2f08), R(v8), R(v8, v24, v30)); // tbx z8.s, z24.s, z30.s + CMP_IO(dci(0x36599dea), R(), R(x10)); // tbz w10, #11, #+0x33bc + CMP_IO(dci(0x0e1c2b7f), R(v31), R(v27, v28)); // trn1 v31.8b, v27.8b, v28.8b + CMP_IO(dci(0x05ac5123), R(p3), R(p9, p12)); // trn1 p3.s, p9.s, p12.s + CMP_IO(dci(0x05fd7399), R(v25), R(v28, v29)); // trn1 z25.d, z28.d, z29.d + CMP_IO(dci(0x4ec86a86), R(v6), R(v20, v8)); // trn2 v6.2d, v20.2d, v8.2d + + CLEANUP(); +} + +TEST(group_72) { + SETUP(); + + CMP_IO(dci(0x056c54aa), R(p10), R(p5, p12)); // trn2 p10.h, p5.h, p12.h + CMP_IO(dci(0x053d76d4), R(v20), R(v22, v29)); // trn2 z20.b, z22.b, z29.b + CMP_IO(dci(0x6e787f65), + R(v5), + R(v5, v27, v24)); // uaba v5.8h, v27.8h, v24.8h + CMP_IO(dci(0x455dffcd), + R(v13), + R(v13, v30, v29)); // uaba z13.h, z30.h, z29.h + CMP_IO(dci(0x2e3a514c), + R(v12), + R(v12, v10, v26)); // uabal v12.8h, v10.8b, v26.8b + CMP_IO(dci(0x459dcbb3), + R(v19), + R(v19, v29, v29)); // uabalb z19.s, z29.h, z29.h + CMP_IO(dci(0x455ecf15), + R(v21), + R(v21, v24, v30)); // uabalt z21.h, z24.b, z30.b + CMP_IO(dci(0x2ead76ee), R(v14), R(v23, v13)); // uabd v14.2s, v23.2s, v13.2s + CMP_IO(dci(0x044d041d), + R(v29), + R(v29, p1, v29, v0)); // uabd z29.h, p1/m, z29.h, z0.h + CMP_IO(dci(0x6e3a7087), R(v7), R(v4, v26)); // uabdl2 v7.8h, v4.16b, v26.16b + CMP_IO(dci(0x45da3966), R(v6), R(v11, v26)); // uabdlb z6.d, z11.s, z26.s + CMP_IO(dci(0x459e3cdd), R(v29), R(v6, v30)); // uabdlt z29.s, z6.h, z30.h + CMP_IO(dci(0x6ea06bf5), R(v21), R(v21, v31)); // uadalp v21.2d, v31.4s + CMP_IO(dci(0x4445b202), R(v2), R(v2, p4, v16)); // uadalp z2.h, p4/m, z16.b + CMP_IO(dci(0x6e780365), R(v5), R(v27, v24)); // uaddl2 v5.4s, v27.8h, v24.8h + CMP_IO(dci(0x45ce0b2c), R(v12), R(v25, v14)); // uaddlb z12.d, z25.s, z14.s + CMP_IO(dci(0x6e6028d7), R(v23), R(v6)); // uaddlp v23.4s, v6.8h + CMP_IO(dci(0x45da0ed6), R(v22), R(v22, v26)); // uaddlt z22.d, z22.s, z26.s + CMP_IO(dci(0x6e7038af), R(v15), R(v5)); // uaddlv s15, v5.8h + CMP_IO(dci(0x040138ef), R(v15), R(p6, v7)); // uaddv d15, p6, z7.b + CMP_IO(dci(0x6e781365), R(v5), R(v27, v24)); // uaddw2 v5.4s, v27.4s, v24.8h + CMP_IO(dci(0x45d94b81), R(v1), R(v28, v25)); // uaddwb z1.d, z28.d, z25.s + CMP_IO(dci(0x45984fa3), R(v3), R(v29, v24)); // uaddwt z3.s, z29.s, z24.h + CMP_IO(dci(0x53111bde), R(x30), R(x30)); // ubfiz w30, w30, #15, #7 + CMP_IO(dci(0xd35a6e1e), R(x30), R(x16)); // ubfx x30, x16, #26, #2 + CMP_IO(dci(0x6e61d80f), R(v15), R(v0)); // ucvtf v15.2d, v0.2d + CMP_IO(dci(0x2e79d86d), R(v13), R(v3)); // ucvtf v13.4h, v3.4h + CMP_IO(dci(0x6f45e6ee), R(v14), R(v23)); // ucvtf v14.2d, v23.2d, #59 + CMP_IO(dci(0x7e21dabc), R(v28), R(v21)); // ucvtf s28, s21 + CMP_IO(dci(0x7e79dae3), R(v3), R(v23)); // ucvtf h3, h23 + CMP_IO(dci(0x7f5ee7f4), R(v20), R(v31)); // ucvtf d20, d31, #34 + CMP_IO(dci(0x1e43b202), R(v2), R(x16)); // ucvtf d2, w16, #20 + + CLEANUP(); +} + +TEST(group_73) { + SETUP(); + + CMP_IO(dci(0x1e6303a6), R(v6), R(x29)); // ucvtf d6, w29 + CMP_IO(dci(0x9e433c6b), R(v11), R(x3)); // ucvtf d11, x3, #49 + CMP_IO(dci(0x9e63020f), R(v15), R(x16)); // ucvtf d15, x16 + CMP_IO(dci(0x1ec3885e), R(v30), R(x2)); // ucvtf h30, w2, #30 + CMP_IO(dci(0x1ee302ba), R(v26), R(x21)); // ucvtf h26, w21 + CMP_IO(dci(0x9ec312c7), R(v7), R(x22)); // ucvtf h7, x22, #60 + CMP_IO(dci(0x9ee30123), R(v3), R(x9)); // ucvtf h3, x9 + CMP_IO(dci(0x1e03bf7f), R(v31), R(x27)); // ucvtf s31, w27, #17 + CMP_IO(dci(0x1e2301db), R(v27), R(x14)); // ucvtf s27, w14 + CMP_IO(dci(0x9e03b516), R(v22), R(x8)); // ucvtf s22, x8, #19 + CMP_IO(dci(0x9e230372), R(v18), R(x27)); // ucvtf s18, x27 + CMP_IO(dci(0x6553bc03), R(v3), R(v3, p7, v0)); // ucvtf z3.h, p7/m, z0.h + CMP_IO(dci(0x65d1a799), R(v25), R(v25, p1, v28)); // ucvtf z25.d, p1/m, z28.s + CMP_IO(dci(0x6555a7f6), R(v22), R(v22, p1, v31)); // ucvtf z22.h, p1/m, z31.s + CMP_IO(dci(0x6595a9e8), R(v8), R(v8, p2, v15)); // ucvtf z8.s, p2/m, z15.s + CMP_IO(dci(0x65d7bd30), R(v16), R(v16, p7, v9)); // ucvtf z16.d, p7/m, z9.d + CMP_IO(dci(0x6557b573), R(v19), R(v19, p5, v11)); // ucvtf z19.h, p5/m, z11.d + CMP_IO(dci(0x65d5adc1), R(v1), R(v1, p3, v14)); // ucvtf z1.s, p3/m, z14.d + CMP_IO(dci(0x0000919a), R(), R()); // udf #0x919a + CMP_IO(dci(0x1ade0b08), R(x8), R(x24, x30)); // udiv w8, w24, w30 + CMP_IO(dci(0x9add0bcd), R(x13), R(x30, x29)); // udiv x13, x30, x29 + CMP_IO(dci(0x04d500a1), R(v1), R(p0, v1, v5)); // udiv z1.d, p0/m, z1.d, z5.d + CMP_IO(dci(0x04970923), + R(v3), + R(p2, v3, v9)); // udivr z3.s, p2/m, z3.s, z9.s + CMP_IO(dci(0x2f3de957), + R(v23), + R(v23, v10, v29)); // udot v23.2s, v10.8b, v29.4b[3] + CMP_IO(dci(0x6e9c95e8), + R(v8), + R(v8, v15, v28)); // udot v8.4s, v15.16b, v28.16b + CMP_IO(dci(0x448d04ce), R(v14), R(v14, v6, v13)); // udot z14.s, z6.b, z13.b + CMP_IO(dci(0x44fa07dc), + R(v28), + R(v28, v30, v10)); // udot z28.d, z30.h, z10.h[1] + CMP_IO(dci(0x44bb04d5), R(v21), R(v21, v6, v3)); // udot z21.s, z6.b, z3.b[3] + CMP_IO(dci(0x6e3e07f4), + R(v20), + R(v31, v30)); // uhadd v20.16b, v31.16b, v30.16b + CMP_IO(dci(0x44918923), + R(v3), + R(p2, v3, v9)); // uhadd z3.s, p2/m, z3.s, z9.s + CMP_IO(dci(0x2e3e272f), R(v15), R(v25, v30)); // uhsub v15.8b, v25.8b, v30.8b + CMP_IO(dci(0x44939d30), + R(v16), + R(p7, v16, v9)); // uhsub z16.s, p7/m, z16.s, z9.s + + CLEANUP(); +} + +TEST(group_74) { + SETUP(); + + CMP_IO(dci(0x44d794ae), + R(v14), + R(p5, v14, v5)); // uhsubr z14.d, p5/m, z14.d, z5.d + CMP_IO(dci(0x9bbd7ae1), R(x1), R(x23, x29, x30)); // umaddl x1, w23, w29, x30 + CMP_IO(dci(0x6e3965f7), + R(v23), + R(v15, v25)); // umax v23.16b, v15.16b, v25.16b + CMP_IO(dci(0x04891cc8), R(v8), R(p7, v8, v6)); // umax z8.s, p7/m, z8.s, z6.s + CMP_IO(dci(0x2529d94c), R(v12), R(v12)); // umax z12.b, z12.b, #202 + CMP_IO(dci(0x6e3ea7e7), + R(v7), + R(v31, v30)); // umaxp v7.16b, v31.16b, v30.16b + CMP_IO(dci(0x4495b078), + R(v24), + R(p4, v24, v3)); // umaxp z24.s, p4/m, z24.s, z3.s + CMP_IO(dci(0x2e30aa04), R(v4), R(v16)); // umaxv b4, v16.8b + CMP_IO(dci(0x04093324), R(v4), R(p4, v25)); // umaxv b4, p4, z25.b + CMP_IO(dci(0x6eae6d0d), R(v13), R(v8, v14)); // umin v13.4s, v8.4s, v14.4s + CMP_IO(dci(0x044b119a), + R(v26), + R(p4, v26, v12)); // umin z26.h, p4/m, z26.h, z12.h + CMP_IO(dci(0x25ebdad6), R(v22), R(v22)); // umin z22.d, z22.d, #214 + CMP_IO(dci(0x6e2bad9d), + R(v29), + R(v12, v11)); // uminp v29.16b, v12.16b, v11.16b + CMP_IO(dci(0x4457b82a), + R(v10), + R(p6, v10, v1)); // uminp z10.h, p6/m, z10.h, z1.h + CMP_IO(dci(0x2e71ab87), R(v7), R(v28)); // uminv h7, v28.4h + CMP_IO(dci(0x04cb3b3e), R(v30), R(p6, v25)); // uminv d30, p6, z25.d + CMP_IO(dci(0x2e7a807b), + R(v27), + R(v27, v3, v26)); // umlal v27.4s, v3.4h, v26.4h + CMP_IO(dci(0x2f822b1a), + R(v26), + R(v26, v24, v2)); // umlal v26.2d, v24.2s, v2.s[2] + CMP_IO(dci(0x44dd4ae1), R(v1), R(v1, v23, v29)); // umlalb z1.d, z23.s, z29.s + CMP_IO(dci(0x44fb9803), + R(v3), + R(v3, v0, v11)); // umlalb z3.d, z0.s, z11.s[3] + CMP_IO(dci(0x44bb90ae), + R(v14), + R(v14, v5, v3)); // umlalb z14.s, z5.h, z3.h[6] + CMP_IO(dci(0x44824f83), R(v3), R(v3, v28, v2)); // umlalt z3.s, z28.h, z2.h + CMP_IO(dci(0x44fb9e45), + R(v5), + R(v5, v18, v11)); // umlalt z5.d, z18.s, z11.s[3] + CMP_IO(dci(0x44bb966c), + R(v12), + R(v12, v19, v3)); // umlalt z12.s, z19.h, z3.h[6] + CMP_IO(dci(0x6e39a2bc), + R(v28), + R(v28, v21, v25)); // umlsl2 v28.8h, v21.16b, v25.16b + CMP_IO(dci(0x6f9a6ba8), + R(v8), + R(v8, v29, v26)); // umlsl2 v8.2d, v29.4s, v26.s[2] + CMP_IO(dci(0x449e5a43), R(v3), R(v3, v18, v30)); // umlslb z3.s, z18.h, z30.h + CMP_IO(dci(0x44fab0a1), + R(v1), + R(v1, v5, v10)); // umlslb z1.d, z5.s, z10.s[2] + CMP_IO(dci(0x44bbb010), + R(v16), + R(v16, v0, v3)); // umlslb z16.s, z0.h, z3.h[6] + CMP_IO(dci(0x445d5c85), R(v5), R(v5, v4, v29)); // umlslt z5.h, z4.b, z29.b + CMP_IO(dci(0x44fbb5a7), + R(v7), + R(v7, v13, v11)); // umlslt z7.d, z13.s, z11.s[2] + CMP_IO(dci(0x44babf0a), + R(v10), + R(v10, v24, v2)); // umlslt z10.s, z24.h, z2.h[7] + + CLEANUP(); +} + +TEST(group_75) { + SETUP(); + + CMP_IO(dci(0x6e9ca4ef), + R(v15), + R(v15, v7, v28)); // ummla v15.4s, v7.16b, v28.16b + CMP_IO(dci(0x45d99abc), + R(v28), + R(v28, v21, v25)); // ummla z28.s, z21.b, z25.b + CMP_IO(dci(0x0e1b3fdc), R(x28), R(v30)); // umov w28, v30.b[13] + CMP_IO(dci(0x4e183fdc), R(x28), R(v30)); // mov x28, v30.d[1] + CMP_IO(dci(0x9bbdaeee), + R(x14), + R(x23, x29, x11)); // umsubl x14, w23, w29, x11 + CMP_IO(dci(0x9bd97b9b), R(x27), R(x28, x25)); // umulh x27, x28, x25 + CMP_IO(dci(0x049316a0), + R(v0), + R(p5, v0, v21)); // umulh z0.s, p5/m, z0.s, z21.s + CMP_IO(dci(0x04fd6e29), R(v9), R(v17, v29)); // umulh z9.d, z17.d, z29.d + CMP_IO(dci(0x2eb4c277), R(v23), R(v19, v20)); // umull v23.2d, v19.2s, v20.2s + CMP_IO(dci(0x2f59a132), R(v18), R(v9, v9)); // umull v18.4s, v9.4h, v9.h[1] + CMP_IO(dci(0x454279fb), R(v27), R(v15, v2)); // umullb z27.h, z15.b, z2.b + CMP_IO(dci(0x44fdd13d), R(v29), R(v9, v13)); // umullb z29.d, z9.s, z13.s[2] + CMP_IO(dci(0x44bcd044), R(v4), R(v2, v4)); // umullb z4.s, z2.h, z4.h[6] + CMP_IO(dci(0x45da7d59), R(v25), R(v10, v26)); // umullt z25.d, z10.s, z26.s + CMP_IO(dci(0x44fcd5db), + R(v27), + R(v14, v12)); // umullt z27.d, z14.s, z12.s[2] + CMP_IO(dci(0x44bddfa6), R(v6), R(v29, v5)); // umullt z6.s, z29.h, z5.h[7] + CMP_IO(dci(0x6ebd0fb3), R(v19), R(v29, v29)); // uqadd v19.4s, v29.4s, v29.4s + CMP_IO(dci(0x7e7e0e5d), R(v29), R(v18, v30)); // uqadd h29, h18, h30 + CMP_IO(dci(0x44198044), + R(v4), + R(p0, v4, v2)); // uqadd z4.b, p0/m, z4.b, z2.b + CMP_IO(dci(0x25a5ea50), R(v16), R(v16)); // uqadd z16.s, z16.s, #82, lsl #8 + CMP_IO(dci(0x047d1485), R(v5), R(v4, v29)); // uqadd z5.h, z4.h, z29.h + CMP_IO(dci(0x042cfeba), R(x26), R(x26)); // uqdecb w26, #0x15, mul #13 + CMP_IO(dci(0x043bff24), R(x4), R(x4)); // uqdecb x4, #0x19, mul #12 + CMP_IO(dci(0x04edfd30), R(x16), R(x16)); // uqdecd w16, vl16, mul #14 + CMP_IO(dci(0x04fbfff6), R(x22), R(x22)); // uqdecd x22, all, mul #12 + CMP_IO(dci(0x04e9cf9b), R(v27), R(v27)); // uqdecd z27.d, #0x1c, mul #10 + CMP_IO(dci(0x046dfed4), R(x20), R(x20)); // uqdech w20, #0x16, mul #14 + CMP_IO(dci(0x047aff0a), R(x10), R(x10)); // uqdech x10, #0x18, mul #11 + CMP_IO(dci(0x0469cdf7), R(v23), R(v23)); // uqdech z23.h, #0xf, mul #10 + CMP_IO(dci(0x25ab8838), R(x24), R(x24, p1)); // uqdecp w24, p1.s + CMP_IO(dci(0x25eb8cee), R(x14), R(x14, p7)); // uqdecp x14, p7.d + CMP_IO(dci(0x25ab8093), R(v19), R(v19, p4)); // uqdecp z19.s, p4 + + CLEANUP(); +} + +TEST(group_76) { + SETUP(); + + CMP_IO(dci(0x04acff65), R(x5), R(x5)); // uqdecw w5, #0x1b, mul #13 + CMP_IO(dci(0x04bcfcef), R(x15), R(x15)); // uqdecw x15, vl7, mul #13 + CMP_IO(dci(0x04aacfc2), R(v2), R(v2)); // uqdecw z2.s, mul3, mul #11 + CMP_IO(dci(0x042df530), R(x16), R(x16)); // uqincb w16, vl16, mul #14 + CMP_IO(dci(0x043bf7f6), R(x22), R(x22)); // uqincb x22, all, mul #12 + CMP_IO(dci(0x04ecf6ba), R(x26), R(x26)); // uqincd w26, #0x15, mul #13 + CMP_IO(dci(0x04fbf724), R(x4), R(x4)); // uqincd x4, #0x19, mul #12 + CMP_IO(dci(0x04eac46d), R(v13), R(v13)); // uqincd z13.d, vl3, mul #11 + CMP_IO(dci(0x046df7a6), R(x6), R(x6)); // uqinch w6, mul4, mul #14 + CMP_IO(dci(0x047bf580), R(x0), R(x0)); // uqinch x0, vl128, mul #12 + CMP_IO(dci(0x0469c781), R(v1), R(v1)); // uqinch z1.h, #0x1c, mul #10 + CMP_IO(dci(0x256989c2), R(x2), R(x2, p14)); // uqincp w2, p14.h + CMP_IO(dci(0x25298c1c), R(x28), R(x28, p0)); // uqincp x28, p0.b + CMP_IO(dci(0x25698165), R(v5), R(v5, p11)); // uqincp z5.h, p11 + CMP_IO(dci(0x04acf693), R(x19), R(x19)); // uqincw w19, #0x14, mul #13 + CMP_IO(dci(0x04bbf679), R(x25), R(x25)); // uqincw x25, #0x13, mul #12 + CMP_IO(dci(0x04aac638), R(v24), R(v24)); // uqincw z24.s, #0x11, mul #11 + CMP_IO(dci(0x6e395df7), + R(v23), + R(v15, v25)); // uqrshl v23.16b, v15.16b, v25.16b + CMP_IO(dci(0x7efa5d59), R(v25), R(v10, v26)); // uqrshl d25, d10, d26 + CMP_IO(dci(0x448b9cc8), + R(v8), + R(p7, v8, v6)); // uqrshl z8.s, p7/m, z8.s, z6.s + CMP_IO(dci(0x44cf9ba6), + R(v6), + R(p6, v6, v29)); // uqrshlr z6.d, p6/m, z6.d, z29.d + CMP_IO(dci(0x2f259d64), R(v4), R(v11)); // uqrshrn v4.2s, v11.2d, #27 + CMP_IO(dci(0x7f3e9d7e), R(v30), R(v11)); // uqrshrn s30, d11, #2 + CMP_IO(dci(0x457939ea), R(v10), R(v15)); // uqrshrnb z10.s, z15.d, #7 + CMP_IO(dci(0x453a3ef0), R(v16), R(v16, v23)); // uqrshrnt z16.h, z23.s, #6 + CMP_IO(dci(0x6e7e4f15), R(v21), R(v24, v30)); // uqshl v21.8h, v24.8h, v30.8h + CMP_IO(dci(0x6f4f76ce), R(v14), R(v22)); // uqshl v14.2d, v22.2d, #15 + CMP_IO(dci(0x7ebd4efb), R(v27), R(v23, v29)); // uqshl s27, s23, s29 + CMP_IO(dci(0x7f5d7564), R(v4), R(v11)); // uqshl d4, d11, #29 + CMP_IO(dci(0x04079f7f), R(v31), R(p7, v31)); // uqshl z31.h, p7/m, z31.h, #11 + CMP_IO(dci(0x44c99ba6), + R(v6), + R(p6, v6, v29)); // uqshl z6.d, p6/m, z6.d, z29.d + CMP_IO(dci(0x448d9cc8), + R(v8), + R(p7, v8, v6)); // uqshlr z8.s, p7/m, z8.s, z6.s + + CLEANUP(); +} + +TEST(group_77) { + SETUP(); + + CMP_IO(dci(0x6f3a97c2), R(v2), R(v30)); // uqshrn2 v2.4s, v30.2d, #6 + CMP_IO(dci(0x7f199460), R(v0), R(v3)); // uqshrn h0, s3, #7 + CMP_IO(dci(0x453e30ac), R(v12), R(v5)); // uqshrnb z12.h, z5.s, #2 + CMP_IO(dci(0x457d36ee), R(v14), R(v14, v23)); // uqshrnt z14.s, z23.d, #3 + CMP_IO(dci(0x6ebd2fc0), R(v0), R(v30, v29)); // uqsub v0.4s, v30.4s, v29.4s + CMP_IO(dci(0x7e7e2f22), R(v2), R(v25, v30)); // uqsub h2, h25, h30 + CMP_IO(dci(0x441b9f7f), + R(v31), + R(p7, v31, v27)); // uqsub z31.b, p7/m, z31.b, z27.b + CMP_IO(dci(0x25a7f643), R(v3), R(v3)); // uqsub z3.s, z3.s, #178, lsl #8 + CMP_IO(dci(0x047d1d4a), R(v10), R(v10, v29)); // uqsub z10.h, z10.h, z29.h + CMP_IO(dci(0x445f841d), + R(v29), + R(p1, v29, v0)); // uqsubr z29.h, p1/m, z29.h, z0.h + CMP_IO(dci(0x2ea14aee), R(v14), R(v23)); // uqxtn v14.2s, v23.2d + CMP_IO(dci(0x7e214a04), R(v4), R(v16)); // uqxtn b4, h16 + CMP_IO(dci(0x45604b9e), R(v30), R(v28)); // uqxtnb z30.s, z28.d + CMP_IO(dci(0x45304ed0), R(v16), R(v16, v22)); // uqxtnt z16.h, z22.s + CMP_IO(dci(0x4ea1cbf4), R(v20), R(v31)); // urecpe v20.4s, v31.4s + CMP_IO(dci(0x4480a225), R(v5), R(v5, p0, v17)); // urecpe z5.s, p0/m, z17.s + CMP_IO(dci(0x2e791532), R(v18), R(v9, v25)); // urhadd v18.4h, v9.4h, v25.4h + CMP_IO(dci(0x44d580a1), + R(v1), + R(p0, v1, v5)); // urhadd z1.d, p0/m, z1.d, z5.d + CMP_IO(dci(0x2ebe5650), R(v16), R(v18, v30)); // urshl v16.2s, v18.2s, v30.2s + CMP_IO(dci(0x7ef557e6), R(v6), R(v31, v21)); // urshl d6, d31, d21 + CMP_IO(dci(0x4403860f), + R(v15), + R(p1, v15, v16)); // urshl z15.b, p1/m, z15.b, z16.b + CMP_IO(dci(0x44479d8d), + R(v13), + R(p7, v13, v12)); // urshlr z13.h, p7/m, z13.h, z12.h + CMP_IO(dci(0x6f4b259d), R(v29), R(v12)); // urshr v29.2d, v12.2d, #53 + CMP_IO(dci(0x7f4824bb), R(v27), R(v5)); // urshr d27, d5, #56 + CMP_IO(dci(0x040d938c), R(v12), R(p4, v12)); // urshr z12.h, p4/m, z12.h, #4 + CMP_IO(dci(0x2ea1ca72), R(v18), R(v19)); // ursqrte v18.2s, v19.2s + CMP_IO(dci(0x4481bc03), R(v3), R(v3, p7, v0)); // ursqrte z3.s, p7/m, z0.s + CMP_IO(dci(0x6f6434be), R(v30), R(v30, v5)); // ursra v30.2d, v5.2d, #28 + CMP_IO(dci(0x7f6e3598), R(v24), R(v24, v12)); // ursra d24, d12, #18 + CMP_IO(dci(0x45deed7e), R(v30), R(v30, v11)); // ursra z30.d, z11.d, #2 + CMP_IO(dci(0x0f9afa1e), + R(v30), + R(v30, v16, v26)); // usdot v30.2s, v16.8b, v26.4b[2] + CMP_IO(dci(0x0e9c9c1d), + R(v29), + R(v29, v0, v28)); // usdot v29.2s, v0.8b, v28.8b + + CLEANUP(); +} + +TEST(group_78) { + SETUP(); + + CMP_IO(dci(0x449b7a5f), + R(v31), + R(v31, v18, v27)); // usdot z31.s, z18.b, z27.b + CMP_IO(dci(0x44bc1aa0), R(v0), R(v0, v21, v4)); // usdot z0.s, z21.b, z4.b[3] + CMP_IO(dci(0x6ef9478e), R(v14), R(v28, v25)); // ushl v14.2d, v28.2d, v25.2d + CMP_IO(dci(0x7eee472c), R(v12), R(v25, v14)); // ushl d12, d25, d14 + CMP_IO(dci(0x2f38a5cc), R(v12), R(v14)); // ushll v12.2d, v14.2s, #24 + CMP_IO(dci(0x451aabcf), R(v15), R(v30)); // ushllb z15.s, z30.h, #10 + CMP_IO(dci(0x4559aec9), R(v9), R(v22)); // ushllt z9.d, z22.s, #25 + CMP_IO(dci(0x6f430677), R(v23), R(v19)); // ushr v23.2d, v19.2d, #61 + CMP_IO(dci(0x7f610525), R(v5), R(v9)); // ushr d5, d9, #31 + CMP_IO(dci(0x4e9cad16), + R(v22), + R(v22, v8, v28)); // usmmla v22.4s, v8.16b, v28.16b + CMP_IO(dci(0x459e9971), + R(v17), + R(v17, v11, v30)); // usmmla z17.s, z11.b, z30.b + CMP_IO(dci(0x2e603b22), R(v2), R(v25)); // usqadd v2.4h, v25.4h + CMP_IO(dci(0x7ea03bc0), R(v0), R(v30)); // usqadd s0, s30 + CMP_IO(dci(0x44dd9a79), + R(v25), + R(p6, v25, v19)); // usqadd z25.d, p6/m, z25.d, z19.d + CMP_IO(dci(0x6f4b1628), R(v8), R(v8, v17)); // usra v8.2d, v17.2d, #53 + CMP_IO(dci(0x7f4a1439), R(v25), R(v25, v1)); // usra d25, d1, #54 + CMP_IO(dci(0x4599e460), R(v0), R(v0, v3)); // usra z0.d, z3.d, #39 + CMP_IO(dci(0x2ead22ee), R(v14), R(v23, v13)); // usubl v14.2d, v23.2s, v13.2s + CMP_IO(dci(0x45ce194b), R(v11), R(v10, v14)); // usublb z11.d, z10.s, z14.s + CMP_IO(dci(0x45d91ec9), R(v9), R(v22, v25)); // usublt z9.d, z22.s, z25.s + CMP_IO(dci(0x2ead32ee), R(v14), R(v23, v13)); // usubw v14.2d, v23.2d, v13.2s + CMP_IO(dci(0x45d95b8e), R(v14), R(v28, v25)); // usubwb z14.d, z28.d, z25.s + CMP_IO(dci(0x45585d84), R(v4), R(v12, v24)); // usubwt z4.h, z12.h, z24.b + CMP_IO(dci(0x05b33ba8), R(v8), R(v29)); // uunpkhi z8.s, z29.h + CMP_IO(dci(0x05f23ad6), R(v22), R(v22)); // uunpklo z22.d, z22.s + CMP_IO(dci(0x0491a9e8), R(v8), R(v8, p2, v15)); // uxtb z8.s, p2/m, z15.s + CMP_IO(dci(0x04d3a1ce), R(v14), R(p0, v14)); // uxth z14.d, p0/m, z14.d + CMP_IO(dci(0x04d5bdb3), R(v19), R(v19, p7, v13)); // uxtw z19.d, p7/m, z13.d + CMP_IO(dci(0x4e5d1a02), R(v2), R(v16, v29)); // uzp1 v2.8h, v16.8h, v29.8h + CMP_IO(dci(0x05ec49ce), R(p14), R(p14, p12)); // uzp1 p14.d, p14.d, p12.d + CMP_IO(dci(0x05bc69e8), R(v8), R(v15, v28)); // uzp1 z8.s, z15.s, z28.s + CMP_IO(dci(0x0e9d586b), R(v11), R(v3, v29)); // uzp2 v11.2s, v3.2s, v29.2s + + CLEANUP(); +} + +TEST(group_79) { + SETUP(); + + CMP_IO(dci(0x052c4c27), R(p7), R(p1, p12)); // uzp2 p7.b, p1.b, p12.b + CMP_IO(dci(0x057c6ead), R(v13), R(v21, v28)); // uzp2 z13.h, z21.h, z28.h + CMP_IO(dci(0x257d1202), R(p2), R(x16, x29)); // whilege p2.h, x16, x29 + CMP_IO(dci(0x25fc0119), R(p9), R(x8, x28)); // whilegt p9.d, w8, w28 + CMP_IO(dci(0x25bd187b), R(p11), R(x3, x29)); // whilehi p11.s, x3, x29 + CMP_IO(dci(0x25fc09c1), R(p1), R(x14, x28)); // whilehs p1.d, w14, w28 + CMP_IO(dci(0x25bc0533), R(p3), R(x9, x28)); // whilele p3.s, w9, w28 + CMP_IO(dci(0x25fd0f89), R(p9), R(x28, x29)); // whilelo p9.d, w28, w29 + CMP_IO(dci(0x257c1f75), R(p5), R(x27, x28)); // whilels p5.h, x27, x28 + CMP_IO(dci(0x253c04ec), R(p12), R(x7, x28)); // whilelt p12.b, w7, w28 + CMP_IO(dci(0x257e33da), R(p10), R(x30, x30)); // whilerw p10.h, x30, x30 + CMP_IO(dci(0x257e33ca), R(p10), R(x30, x30)); // whilewr p10.h, x30, x30 + CMP_IO(dci(0x25289020), R(), R(p1)); // wrffr p1.b + CMP_IO(dci(0xd5004d3f), R(), R()); // xaflag + CMP_IO(dci(0x043936bc), R(v28), R(v28, v21)); // xar z28.h, z28.h, z21.h, #7 + CMP_IO(dci(0xdac147fe), R(x30), R(x30)); // xpacd x30 + CMP_IO(dci(0xdac143f9), R(x25), R(x25)); // xpaci x25 + CMP_IO(dci(0xd50320ff), R(x30), R(x30)); // xpaclri + CMP_IO(dci(0x0e61287a), R(v26), R(v3)); // xtn v26.4h, v3.4s + CMP_IO(dci(0xd503203f), R(), R()); // yield + CMP_IO(dci(0x4edc39ce), R(v14), R(v14, v28)); // zip1 v14.2d, v14.2d, v28.2d + CMP_IO(dci(0x056d4002), R(p2), R(p0, p13)); // zip1 p2.h, p0.h, p13.h + CMP_IO(dci(0x053c638c), R(v12), R(v28, v28)); // zip1 z12.b, z28.b, z28.b + CMP_IO(dci(0x0e1c7837), R(v23), R(v1, v28)); // zip2 v23.8b, v1.8b, v28.8b + CMP_IO(dci(0x05ad446b), R(p11), R(p3, p13)); // zip2 p11.s, p3.s, p13.s + CMP_IO(dci(0x05fc6451), R(v17), R(v2, v28)); // zip2 z17.d, z2.d, z28.d + + CLEANUP(); +} + +TEST(group_80) { + SETUP(); + + CMP_IO(dci(0x98123456), + R(x22), + R()); // ldrsw x22, pc+149128 (addr 0x7fff098dd6e4) + CMP_IO(dci(0x585555cc), + R(x12), + R()); // ldr x12, pc+699064 (addr 0x7fffeede4be4) + CMP_IO(dci(0x18aaaaee), + R(x14), + R()); // ldr w14, pc-699044 (addr 0x7ffcd56d4478) + CMP_IO(dci(0x1c564747), + R(v7), + R()); // ldr s7, pc+706792 (addr 0x7ffee374dd54) + CMP_IO(dci(0x5c676fef), + R(v15), + R()); // ldr d15, pc+847356 (addr 0x7ffc51e91c68) + CMP_IO(dci(0x9cedcaa2), + R(v2), + R()); // ldr q2, pc-149164 (addr 0x7ffd852c53f0) + CMP_IO(dci(0xd8ed8700), + R(), + R()); // prfm pldl1keep, pc-151328 (addr 0x7ffd6bf2eb9c) + + CLEANUP(); +} +#undef R + +} // namespace aarch64 +} // namespace vixl diff --git a/test/aarch64/test-ior-aarch64.h b/test/aarch64/test-ior-aarch64.h new file mode 100644 index 00000000..7d2b6860 --- /dev/null +++ b/test/aarch64/test-ior-aarch64.h @@ -0,0 +1,86 @@ +// Copyright 2022, VIXL authors +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// * Neither the name of ARM Limited nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND +// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#define TEST(name) TEST_(AARCH64_IOR_##name) + +#define SETUP() \ + MacroAssembler masm; \ + masm.GetCPUFeatures()->Combine(CPUFeatures::All()); \ + masm.SetGenerateSimulatorCode(true); \ + Decoder decoder; \ + Disassembler disasm; \ + IOReporter ior; \ + decoder.AppendVisitor(&disasm); \ + decoder.AppendVisitor(&ior) + +#define CLEANUP() + +#define CMP_IO(ASM, DST, SRC) \ + do { \ + masm.Reset(); \ + ior.Reset(); \ + { \ + ExactAssemblyScope guard(&masm, kInstructionSize); \ + masm.ASM; \ + } \ + masm.FinalizeCode(); \ + decoder.Decode(masm.GetBuffer()->GetStartAddress()); \ + std::unordered_set dst = ior.GetDestinationRegisters(); \ + std::unordered_set dst_expected(DST); \ + std::unordered_set src = ior.GetSourceRegisters(); \ + std::unordered_set src_expected(SRC); \ + if ((dst != dst_expected) || (src != src_expected)) { \ + uint32_t encoding = *masm.GetBuffer()->GetStartAddress(); \ + printf("\nInstruction: %s (0x%08" PRIx32 ")\n", \ + disasm.GetOutput(), \ + encoding); \ + if (dst != dst_expected) { \ + printf( \ + "Mismatched destination registers.\n" \ + "Expected: %s\nFound: %s\n", \ + UnorderedSetAsString(dst_expected).c_str(), \ + UnorderedSetAsString(dst).c_str()); \ + } \ + if (src != src_expected) { \ + printf( \ + "Mismatched source registers.\n" \ + "Expected: %s\nFound: %s\n", \ + UnorderedSetAsString(src_expected).c_str(), \ + UnorderedSetAsString(src).c_str()); \ + } \ + abort(); \ + } \ + } while (0) + +static std::string UnorderedSetAsString( + const std::unordered_set& s) { + std::string result; + for (const vixl::aarch64::CPURegister& i : s) { + result += i.GetArchitecturalName(); + result += " "; + } + return result; +}