From 8f38e52564a339d7fd3e2fd75b19e435765bba0c Mon Sep 17 00:00:00 2001 From: Denis Drakhnia Date: Mon, 29 Jan 2024 07:34:49 +0200 Subject: [PATCH] disas/e2k: use OpenE2K disassembler --- disas/e2k-dis.c | 2113 ++++++++++++++++++++++++++++++++++ disas/e2k-opc.c | 2396 +++++++++++++++++++++++++++++++++++++++ disas/e2k.h | 603 ++++++++++ disas/meson.build | 4 + include/disas/dis-asm.h | 25 +- target/e2k/cpu.c | 1 + 6 files changed, 5125 insertions(+), 17 deletions(-) create mode 100644 disas/e2k-dis.c create mode 100644 disas/e2k-opc.c create mode 100644 disas/e2k.h diff --git a/disas/e2k-dis.c b/disas/e2k-dis.c new file mode 100644 index 0000000000..37bd2e6e50 --- /dev/null +++ b/disas/e2k-dis.c @@ -0,0 +1,2113 @@ +/* E2K disassembler + Copyright (C) 2022 Free Software Foundation, Inc. + + This file is part of the GNU opcodes library. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + You should have received a copy of the GNU General Public License + along with this program; see the file COPYING3. If not, + see . */ + +#include "qemu/osdep.h" +#include "qemu/bitops.h" +#include "libiberty.h" +#include "disas/dis-asm.h" +#include "disas/e2k.h" + +#include + +enum ctpr_type +{ + CTPR_NONE, + CTPR_DISP, + CTPR_APB, + CTPR_SYS, + CTPR_RET, + CTPR_MOVTD, +}; + +struct ctpr_info +{ + bfd_vma target; + enum ctpr_type type; +}; + +struct syllable +{ + const char *name; + short index; + bool is_half; +}; + +struct e2k_private_data +{ + struct ctpr_info ctpr[4]; + + struct syllable syll[32]; + short syll_cur; + short syll_len; + + bool debug; + bool aliases; + bool show_syllables; + bool show_literal_loc; + bool show_gpr_size; + bool show_pair; + + /* Set if controll transfer was decoded. */ + bool ct_decoded; + + unsigned short version; + int lines; +}; + +#define implement_me(c) assert((c) && "implement me"); + +#define print_styled(info, style, ...) \ + (*info->fprintf_func) (info->stream, __VA_ARGS__) + +#define print_text(info, ...) \ + print_styled (info, dis_style_text, __VA_ARGS__) + +#define print_mnemonic(info, ...) \ + print_styled (info, dis_style_mnemonic, __VA_ARGS__) + +#define print_align(info) \ + print_text (info, "\t") + +#define print_aligned_text(info, ...) \ + print_align (info); \ + print_styled (info, dis_style_text, __VA_ARGS__) + +#define print_aligned_mnemonic(info, ...) \ + print_align (info); \ + print_styled (info, dis_style_mnemonic, __VA_ARGS__) + +#define print_operand_alignment(info, width) \ + print_text (info, "%c", width < 8 ? '\t' : ' '); + +#define print_sub_mnemonic(info, ...) \ + print_styled (info, dis_style_sub_mnemonic, __VA_ARGS__) + +#define print_asm_directive(info, ...) \ + print_styled (info, dis_style_assembler_directive, __VA_ARGS__) + +#define print_register(info, ...) \ + print_styled (info, dis_style_register, __VA_ARGS__) + +#define print_immediate(info, ...) \ + print_styled (info, dis_style_immediate, __VA_ARGS__) + +#define print_address(info, ...) \ + print_styled (info, dis_style_address, __VA_ARGS__) + +#define print_address_offset(info, ...) \ + print_styled (info, dis_style_address_offset, __VA_ARGS__) + +#define print_symbol(info, ...) \ + print_styled (info, dis_style_symbol, __VA_ARGS__) + +#define print_comment(info, ...) \ + print_styled (info, dis_style_comment_start, __VA_ARGS__) + +#define print_uimm(info, value) \ + print_immediate (info, "%u", (unsigned int) value) + +#define print_hex(info, value) \ + print_immediate (info, "%#x", (unsigned int) (value)) + +#define print_hex64(info, value) \ + print_immediate (info, "%#lx", (uint64_t) (value)) + +#define print_named_assign(info, name) \ + print_register (info, "%s", name); \ + print_text (info, "="); + +#define print_named_uimm(info, name, value) \ + print_named_assign (info, name); \ + print_uimm (info, value) + +#define print_named_hex(info, name, value) \ + print_named_assign (info, name); \ + print_hex (info, value) + +#define print_aad(info, index) \ + print_register (info, "%s", e2k_reg_names_aad[index]) + +#define print_aasti(info, index) \ + print_register (info, "%s", e2k_reg_names_aasti[index]) + +#define print_aaind(info, index) \ + print_register (info, "%s", e2k_reg_names_aaind[index]) + +#define print_aaincr(info, index) \ + print_register (info, "%s", e2k_reg_names_aaincr[index]); + +#define print_ctpr(info, index) \ + print_register (info, "%s", e2k_reg_names_ctpr[index]) + +#define print_cmp(info, index) \ + print_register (info, "%s", e2k_reg_names_cmp[index]) + +#define print_ipr(info, index) \ + print_register (info, "%s", e2k_reg_names_ipr[index]) + +#define print_not(info) \ + print_text (info, "~") + +#define print_preg(info, index) \ + print_register (info, "%s", e2k_reg_names_preg[index]) + +#define print_pcnt(info, index) \ + print_register (info, "%s", e2k_reg_names_pcnt[index]) + +#define print_lpred(info, index) \ + print_register (info, "%s", e2k_reg_names_lpred[index]) + +#define print_rndpred(info, index) \ + print_register (info, "%s", e2k_reg_names_rndpred[index]) + +#define print_not_preg(info, index) \ + print_not (info); \ + print_preg (info, index) + +#define print_loop_end(info) \ + print_register (info, "loop_end") + +#define print_not_loop_end(info) \ + print_not (info); \ + print_loop_end (info) + +#define print_or(info) \ + print_text (info, " || ") + +#define print_and(info) \ + print_text (info, " && ") + +static void +print_state_register (struct disassemble_info *info, uint8_t value) +{ + const char *name = e2k_reg_names_sr[value]; + + if (name) + print_register (info, "%s", name); + else + { + print_text (info, "", value); + implement_me(0); + } +} + +static bool +print_gpr (struct disassemble_info *info, uint8_t value, enum gpr_size size) +{ + struct e2k_private_data *pd = info->private_data; + + if (value >= 0xc0 && value < 0xe0) + return false; + + if (pd->show_gpr_size) + switch (size) + { + case GS_NONE: + case GS_S: + print_register (info, "%s", e2k_reg_names_gpr[value]); + break; + case GS_D: + print_register (info, "%s", e2k_reg_names_gpr_d[value]); + break; + case GS_X: + print_register (info, "%s", e2k_reg_names_gpr_x[value]); + break; + case GS_Q: + print_register (info, "%s", e2k_reg_names_gpr_q[value]); + break; + case GS_P: + print_register (info, "%s", e2k_reg_names_gpr_qp[value]); + break; + } + else + print_register (info, "%s", e2k_reg_names_gpr[value]); + + return true; +} + +static void +print_dst (struct disassemble_info *info, uint8_t value, enum gpr_size size) +{ + if (print_gpr (info, value, size)) + return; + else if (value == 0xdf || value == 0xde) + print_text (info, "_"); + else + { + print_text (info, "", value); + implement_me(0); + } +} + +static bool +print_literal (struct disassemble_info *info, uint8_t value, + struct e2k_unpacked_bundle *bundle, bool is_label) +{ + struct e2k_private_data *pd = info->private_data; + unsigned int loc = value & 3; + + if (value >= 0xdc && value <= 0xde) + { + uint64_t lit; + + if (!bundle->lts_present[loc] || + !bundle->lts_present[loc + 1]) + goto err; + + lit = ((uint64_t) bundle->lts[loc + 1] << 32) | bundle->lts[loc]; + + if (is_label) + (*info->print_address_func)(lit, info); + else + print_hex64 (info, lit); + + if (pd->show_literal_loc) + { + print_mnemonic (info, " as i64"); + print_text (info, "@%u", loc); + } + } + else if (value >= 0xd8 && value <= 0xdb) + { + if (!bundle->lts_present[loc]) + goto err; + + if (is_label) + (*info->print_address_func)(bundle->lts[loc], info); + else + print_hex (info, bundle->lts[loc]); + + if (pd->show_literal_loc) + { + print_mnemonic (info, " as i32"); + print_text (info, "@%u", loc); + } + } + else if (value >= 0xd0 && value <= 0xd5) + { + uint16_t lit; + + if (!bundle->lts_present[loc]) + goto err; + + lit = bundle->lts[loc] >> (value & 4 ? 16 : 0); + + if (is_label) + (*info->print_address_func)(lit, info); + else + print_hex (info, lit); + + if (pd->show_literal_loc) + { + print_mnemonic (info, " as i16"); + print_text (info, "@%u%c", loc, value & 4 ? 'h' : 'l'); + } + } + else + return false; + return true; + +err: + print_text (info, ""); + return true; +} + +static void +print_psrc (struct disassemble_info *info, uint8_t psrc, bool rndpred) +{ + if (psrc == 0) + print_register (info, "lcntex"); + else if ((psrc & 0xe0) == 0) + { + unsigned int i; + + print_register (info, "spred"); + for (i = 0; i < 6; ++i) + if (psrc & (1 << i)) + print_register (info, "%d", i); + } + else if ((psrc & 0xe0) == 0x40) + { + if (rndpred) + print_rndpred (info, psrc & 0x1f); + else + print_pcnt (info, psrc & 0x1f); + } + else if ((psrc & 0xe0) == 0x60) + print_preg (info, psrc & 0x1f); + else + { + print_text (info, "", psrc); + implement_me(0); + } +} + +static void +print_rlp (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle, unsigned int ch) +{ + uint32_t cds = 0; + uint16_t rlp; + unsigned int count, index, i; + bool first = true; + + count = HS_DECODE_CDS_COUNT (bundle->hs) * 2; + index = ch < 3 ? ch : ch - 3; + for (i = 0; i < count; ++i) + { + if (i & 1) + rlp = cds >> 16; + else + rlp = cds = bundle->cds[i / 2]; + + if ((rlp & RLP_MRGC) || + ((ch < 3) == ((rlp & RLP_CLUSTER) != 0)) || + (!RLP_DECODE_ALC (rlp, index))) + continue; + + print_text (info, " %s ", first ? "?" : "&&"); + if (RLP_DECODE_INV (rlp, index)) + print_not (info); + print_psrc (info, RLP_DECODE_PSRC (rlp), false); + first = false; + } +} + +static bool +print_merge_condition (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle, unsigned int ch) +{ + uint32_t cds = 0; + uint16_t rlp; + unsigned int count, index, i; + + count = HS_DECODE_CDS_COUNT (bundle->hs) * 2; + index = ch < 3 ? ch : ch - 3; + for (i = 0; i < count; ++i) + { + if (i & 1) + rlp = cds >> 16; + else + rlp = cds = bundle->cds[i / 2]; + + if (((rlp & (RLP_MRGC | RLP_AM)) != RLP_MRGC) || + ((ch < 3) == ((rlp & RLP_CLUSTER) != 0)) || + (!RLP_DECODE_ALC (rlp, index))) + continue; + + if (RLP_DECODE_INV (rlp, index)) + print_not (info); + print_psrc (info, RLP_DECODE_PSRC (rlp), false); + return true; + } + + return false; +} + +static void +print_am (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle, unsigned int ch) +{ + uint32_t cds = 0; + uint16_t rlp; + unsigned int count, index, i; + + count = HS_DECODE_CDS_COUNT (bundle->hs) * 2; + index = ch < 3 ? ch : ch - 3; + for (i = 0; i < count; ++i) + { + if (i & 1) + rlp = cds >> 16; + else + rlp = cds = bundle->cds[i / 2]; + + if (((rlp & (RLP_MRGC | RLP_AM)) != RLP_AM) || + ((ch < 3) == ((rlp & RLP_CLUSTER) != 0))) + continue; + + print_text (info, " ? "); + if (RLP_DECODE_INV (rlp, index)) + print_not (info); + print_psrc (info, RLP_DECODE_PSRC (rlp), false); + return; + } +} + +static void +set_default_e2k_dis_options (struct e2k_private_data *pd) +{ + pd->debug = false; + pd->aliases = true; + pd->show_syllables = false; /* TODO: depends on objdump.c:show_raw_insn */ + pd->show_literal_loc = false; + pd->show_gpr_size = true; + pd->show_pair = false; +} + +static void +set_isa_version (struct e2k_private_data *pd, unsigned long mach) +{ + pd->version = mach ? mach : bfd_mach_e2k_v7; +} + +static void push_syllable(struct e2k_private_data *pd, const char *name, + unsigned short index, bool is_half) +{ + if (pd->show_syllables) + { + pd->syll[pd->syll_len].name = name; + pd->syll[pd->syll_len].index = index; + pd->syll[pd->syll_len].is_half = is_half; + pd->syll_len += 1; + } +} + +static void +print_syllable_impl (struct disassemble_info *info) +{ + struct e2k_private_data *pd = info->private_data; + const struct syllable *syll; + char buf[64] = { 0 }, *p; + unsigned int i; + + if (pd->syll_cur >= pd->syll_len) + { + print_text (info, "%20c", ' '); + return; + } + + syll = pd->syll + pd->syll_cur++; + p = buf; + p += sprintf (p, "%s", syll->name); + if (syll->index != -1) + p += sprintf (p, "%d", syll->index); + + if (syll->is_half) + { + syll = pd->syll + pd->syll_cur++; + + p += sprintf (p, " %s", syll->name); + if (syll->index != -1) + p += sprintf (p, "%d", syll->index); + } + + for (i = p - buf; i < 16; ++i) + *p++ = ' '; + *p = '\0'; + + print_text (info, "%s", buf); +} + +#define print_syllable(pd, info) \ + if (pd->show_syllables) \ + print_syllable_impl (info) + +static bool +bundle_unpack (struct e2k_private_data *pd, bfd_byte *packet, + unsigned int len, struct e2k_unpacked_bundle *bundle) +{ + bfd_byte *p, *m, *e; + unsigned int i, j, h, cds_count, pls_count, lts_count; + + p = packet; + bundle->hs = bfd_getl32 (p); + p += 4; + m = p + HS_DECODE_HOFF (bundle->hs); + e = packet + len; + + if (m > e) + return false; + + push_syllable (pd, "HS", -1, false); + + if (HS_DECODE_SS (bundle->hs)) + { + if ((p + 4) > e) + return false; + + push_syllable (pd, "SS", -1, false); + bundle->ss_present = true; + bundle->ss = bfd_getl32 (p); + p += 4; + } + + for (i = 0; i < ALC_COUNT; ++i) + { + if (!HS_DECODE_ALS (bundle->hs, i)) + continue; + + if ((p + 4) > e) + return false; + + push_syllable (pd, "ALS", i, false); + bundle->als_present[i] = true; + bundle->als[i] = bfd_getl32 (p); + p += 4; + } + + if (HS_DECODE_CS (bundle->hs, 0)) + { + if ((p + 4) > e) + return false; + + push_syllable (pd, "CS", 0, false); + bundle->cs_present[0] = true; + bundle->cs[0] = bfd_getl32 (p); + p += 4; + } + + if ((p + (HS_DECODE_CS (bundle->hs, 1) ? 8 : 4)) == m) + { + if ((p + 4) > e) + return false; + + push_syllable (pd, "ALES", 2, true); + push_syllable (pd, "ALES", 5, true); + for (j = 0; j < 2; ++j) + { + i = j == 0 ? 5 : 2; + bundle->ales_present[i] = ALES_ALLOCATED; + bundle->ales[i] = bfd_getl16 (p); + p += 2; + } + } + + if (HS_DECODE_CS (bundle->hs, 1)) + { + if ((p + 4) > e) + return false; + + push_syllable (pd, "CS", 1, false); + bundle->cs_present[1] = true; + bundle->cs[1] = bfd_getl32 (p); + p += 4; + } + + if (p != m) + return false; + + /* XXX: stupid order of half-syllables. */ + h = 0; + for (i = 0; i < ALC_COUNT; ++i) + { + if (!HS_DECODE_ALES (bundle->hs, i)) + continue; + + bundle->ales_present[i] |= ALES_PRESENT; + if (i != 2 && i != 5) + { + push_syllable (pd, "ALES", i, true); + bundle->ales[i] = bfd_getl16 (h & 1 ? p - 2 : p + 2); + p += 2; + ++h; + } + else if ((bundle->ales_present[i] & ALES_ALLOCATED) == 0) + bundle->ales[i] = 0x01c0; + } + + if (bundle->ss_present && SS_DECODE_FORMAT (bundle->ss) == 0) + { + for (i = 0; i < 4; ++i) + if (SS_DECODE_AAS (bundle->ss, i)) + { + bundle->aas_present[i / 2] = true; + bundle->aas_present[i + 2] = true; + } + + for (i = 0; i < 6; ++i) + if (bundle->aas_present[i]) + { + push_syllable (pd, "AAS", i, true); + bundle->aas[i] = bfd_getl16 (h & 1 ? p - 2 : p + 2); + p += 2; + ++h; + } + } + + /* Align to next syllable. */ + if (h & 1) + { + push_syllable (pd, " ", -1, true); + p += 2; + ++h; + } + + cds_count = HS_DECODE_CDS_COUNT (bundle->hs); + pls_count = HS_DECODE_PLS_COUNT (bundle->hs); + lts_count = (e - p) / 4; + + e -= (cds_count + pls_count) * 4; + if (e < p) + return false; + + lts_count = (e - p) / 4; + if (lts_count > 4) + lts_count = 4; + e -= lts_count * 4; + + while (p < e) + { + push_syllable (pd, "gap", -1, false); + p += 4; + } + + for (i = lts_count; i--;) + { + push_syllable (pd, "LTS", i, false); + bundle->lts_present[i] = true; + bundle->lts[i] = bfd_getl32 (e); + e += 4; + } + + for (i = pls_count; i--;) + { + push_syllable (pd, "PLS", i, false); + bundle->pls_present[i] = true; + bundle->pls[i] = bfd_getl32 (e); + e += 4; + } + + for (i = cds_count; i--;) + { + push_syllable (pd, "CDS", i, false); + bundle->cds_present[i] = true; + bundle->cds[i] = bfd_getl32 (e); + e += 4; + } + + return true; +} + +static void +print_nl (struct disassemble_info *info) +{ + struct e2k_private_data *pd = info->private_data; + print_styled (info, dis_style_comment_stop, "\n\t"); + print_syllable (pd, info); + ++pd->lines; +} + +static void +print_ss_advance (struct disassemble_info *info, const char *name, + unsigned int x, const char* l, const char* h) +{ + if (!x) + return; + print_aligned_mnemonic (info, "%s.", name); + if (x & 1) + print_sub_mnemonic (info, "%s", l); + if (x & 2) + print_sub_mnemonic (info, "%s", h); + print_nl (info); +} + +static void +print_sf1 (struct disassemble_info *info, uint32_t ss) +{ + print_ss_advance (info, "alc", SS_DECODE_ALC (ss), "t", "f"); + print_ss_advance (info, "abp", SS_DECODE_ABP (ss), "t", "f"); + print_ss_advance (info, "abn", SS_DECODE_ABN (ss), "t", "f"); + print_ss_advance (info, "abg", SS_DECODE_ABG (ss), "d", "i"); + + if (SS_DECODE_BAP (ss)) + { + print_aligned_mnemonic (info, "bap"); + print_nl (info); + } + + if (SS_DECODE_EAP (ss)) + { + print_aligned_mnemonic (info, "eap"); + print_nl (info); + } +} + +static void +decode_ss (struct disassemble_info *info, uint32_t ss) +{ + if (SS_DECODE_FORMAT (ss) == 0) + print_sf1 (info, ss); + else + { + if (ss & SS_TYPE1_MASK) + { + print_aligned_mnemonic (info, "SS"); + print_text (info, "(%08x)", ss); + print_nl (info); + implement_me(0); + } + } +} + +static void +decode_hs (struct disassemble_info *info, uint32_t hs) +{ + if (HS_DECODE_LOOP (hs)) + { + print_aligned_mnemonic (info, "loop_mode"); + print_nl (info); + } + + /* XXX: unknown bit */ + if (HS_DECODE_SIM (hs)) + { + print_aligned_text (info, ""); + print_nl (info); + implement_me(0); + } + + /* XXX: unknown bit */ + if (HS_DECODE_MDL (hs)) + { + print_aligned_text (info, ""); + print_nl (info); + implement_me(0); + } +} + +static void +decode_nop (struct disassemble_info *info, uint32_t hs) +{ + struct e2k_private_data *pd = info->private_data; + unsigned int nop = HS_DECODE_NOP (hs); + + if (nop > 1 || pd->lines == 0) + { + print_aligned_mnemonic (info, "nop "); + print_uimm (info, nop); + print_nl (info); + } +} + +static void +decode_aau (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + unsigned int i; + + for (i = 0; i < 4; ++i) + { + const char *name = NULL; + uint16_t aas, aas_dst; + enum gpr_size size = GS_D; + int width; + + if (!bundle->aas_present[i + 2]) + continue; + + aas = bundle->aas[i + 2]; + aas_dst = bundle->aas[i / 2]; + + switch (aas & MOVA_OPC_MASK) + { + case MOVA_NONE: + continue; + case MOVAB: + name = "movab"; + break; + case MOVAH: + name = "movah"; + break; + case MOVAW: + name = "movaw"; + break; + case MOVAD: + name = "movad"; + break; + case MOVAQ: + name = "movaq"; + size = GS_Q; + break; + case MOVAQP: + name = "movaqp"; + size = GS_P; + break; + default: + print_text (info, "AAS@%d(%04x) AAS@%d(%04x)", i + 2, aas, i / 2, aas_dst); + print_nl (info); + continue; + } + width = strlen (name); + + print_text (info, "apb%d ", i); + print_mnemonic (info, "%s", name); + if (aas & MOVA_BE) + { + print_sub_mnemonic (info, ".be"); + width += 3; + } + if (aas & MOVA_AM) + { + print_sub_mnemonic (info, ".am"); + width += 3; + } + print_operand_alignment (info, width); + print_dst (info, (aas_dst >> (i & 1 ? 0 : 8)) & 0xff, size); + print_text (info, ", "); + print_named_uimm (info, "area", MOVA_DECODE_AREA (aas)); + print_text (info, ", "); + print_named_uimm (info, "index", MOVA_DECODE_IND (aas)); + print_nl (info); + } +} + +static void +decode_pls (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + unsigned int i, count, used[8] = { 0 }; + + count = HS_DECODE_PLS_COUNT (bundle->hs); + + for (i = count; i--;) + if ((bundle->pls[i] & LP_WRITE_PREG) || used[i + 4]) + { + used[i + 4] += 1; + used[LP_DECODE_LPSRC (bundle->pls[i], 0)] += 1; + used[LP_DECODE_LPSRC (bundle->pls[i], 1)] += 1; + } + + for (i = 0; i < count; ++i) + { + uint32_t pls = bundle->pls[i]; + unsigned int j; + + if (!used[i + 4]) + continue; + + print_text (info, "plu%d\t", i); + switch (pls & LP_OPC_MASK) + { + case LP_ANDP: + print_mnemonic (info, "andp"); + print_operand_alignment (info, 4); + break; + case LP_LANDP: + print_mnemonic (info, "landp"); + print_operand_alignment (info, 5); + break; + case LP_MOVEP: + print_mnemonic (info, "movep"); + print_operand_alignment (info, 5); + break; + default: + print_mnemonic (info, "invalid_clp"); + print_operand_alignment (info, 11); + implement_me(0); + break; + } + + if (pls & LP_WRITE_PREG) + print_preg (info, LP_DECODE_PREG (pls)); + else + print_text (info, "_"); + + for (j = 0; j < 2; ++j) + { + unsigned int lp; + + print_text (info, ", "); + if (LP_DECODE_LPSRC_INV (pls, j)) + print_not (info); + lp = LP_DECODE_LPSRC (pls, j); + if (lp < 4) + print_psrc (info, ELP_DECODE (bundle->pls[lp / 2], lp & 1), true); + else + print_register (info, "plu%u", lp - 4); + } + print_nl (info); + } +} + +static void +print_ct_cond (struct disassemble_info *info, unsigned int cond, unsigned int pred) +{ + if (cond != CT_COND_ALWAYS) + print_text (info, " ? "); + + switch (cond) + { + case CT_COND_NONE: + abort (); /* unreachable */ + case CT_COND_ALWAYS: + break; + case CT_COND_PREG: + print_preg (info, pred); + break; + case CT_COND_NOT_PREG: + print_not_preg (info, pred); + break; + case CT_COND_LOOP_END: + print_loop_end (info); + break; + case CT_COND_NOT_LOOP_END: + print_not_loop_end (info); + break; + case CT_COND_PREG_OR_LOOP_END: + print_preg (info, pred); + print_or (info); + print_loop_end (info); + break; + case CT_COND_NOT_PREG_AND_NOT_LOOP_END: + print_not_preg (info, pred); + print_and (info); + print_not_loop_end (info); + break; + case CT_COND_MLOCK_OR_DTAL: + print_register (info, "mlock"); + if (pred) + { + char buf[8] = { 0 }; + char *p = buf; + unsigned int i; + + for (i = 0; i < 4; ++i) + if (pred & (1 << i)) + *p++ = '0' + (i > 1 ? i + 1 : i); + + print_text (info, " || "); + print_register (info, "dt_al%s", buf); + } + break; + case CT_COND_MLOCK_OR_CMP: + print_register (info, "mlock"); + print_or (info); + + if ((pred & 0x18) == 0x00) + { + if (pred & 1) + print_not (info); + print_cmp (info, EXTRACT_BITS (pred, 1, 2)); + } + else if ((pred & 0x18) == 0x08) + { + unsigned int index = pred & 4 ? 3 : 0; + + if (pred & 2) + print_not (info); + print_register (info, "alc%u", index); + print_or (info); + if (pred & 1) + print_not (info); + print_register (info, "alc%u", index + 1); + } + else if ((pred & 0x18) == 0x10) + { + if (pred & 1) + print_not (info); + + if ((pred & 0x6) == 0) + print_register (info, "plu0"); + else if ((pred & 0x6) == 2) + print_register (info, "plu1"); + else if ((pred & 0x6) == 4) + print_register (info, "plu2"); + else + goto cmp_pred_err; + } + else +cmp_pred_err: + print_text (info, "", pred); + break; + case CT_COND_CMP_CLP: + if (pred & 1) + print_not (info); + + if (pred & 0x10) + { + int plu = EXTRACT_BITS(pred, 1, 3); + + print_register (info, "plu%d", plu); + implement_me(plu <= 3); + } + else + { + int alc; + + switch (EXTRACT_BITS(pred, 1, 3)) + { + case 0: alc = 0; break; + case 1: alc = 1; break; + case 2: alc = 3; break; + case 3: alc = 4; break; + default: alc = -1; break; + } + + print_register (info, "alc%d", alc); + implement_me(alc != -1); + } + break; + case CT_COND_NOT_PREG_OR_LOOP_END: + print_not_preg (info, pred); + print_or (info); + print_loop_end (info); + break; + case CT_COND_PREG_AND_NOT_LOOP_END: + print_not_preg (info, pred); + print_and (info); + print_loop_end (info); + break; + default: + print_text (info, "", cond); + implement_me(0); + break; + } +} + +/* XXX: when it should be printed? */ +static void +print_ipd (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + unsigned int ipd; + + if (bundle->ss_present && (ipd = SS_DECODE_IPD (bundle->ss))) + { + print_aligned_mnemonic (info, "ipd "); + print_uimm (info, ipd); + print_nl (info); + } +} + +static void +decode_ct (bfd_vma memaddr, struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + struct e2k_private_data *pd = info->private_data; + enum ct_cond cond; + unsigned int ctpr; + bool hint_target = false; + + if (!bundle->ss_present || SS_DECODE_FORMAT (bundle->ss) != 0 || + pd->ct_decoded) + return; + + cond = SS_DECODE_CT_COND (bundle->ss); + if (cond == CT_COND_NONE) + return; + + pd->ct_decoded = true; + info->insn_info_valid = 1; + info->target = 0; + info->insn_type = cond == CT_COND_ALWAYS ? dis_branch : dis_condbranch; + + ctpr = SS_DECODE_CTPR (bundle->ss); + if (ctpr > 0) + { + if (bundle->cs_present[1] && + TEST_OPCODE (bundle->cs[1], CALL_OPCODE_CS1, CALL_OPCODE_MASK_CS1)) + { + hint_target = true; + info->insn_type = cond == CT_COND_ALWAYS ? dis_jsr : dis_condjsr; + print_aligned_mnemonic (info, "call"); + print_operand_alignment (info, 4); + print_uimm (info, CALL_DECODE_WBS_CS1 (bundle->cs[1])); + print_text (info, ", "); + print_ctpr (info, ctpr); + } + else + { + hint_target = true; + print_aligned_mnemonic (info, "ct"); + print_operand_alignment (info, 2); + print_ctpr (info, ctpr); + if (pd->ctpr[ctpr].type == CTPR_DISP) + info->target = pd->ctpr[ctpr].target; + } + } + else if (bundle->cs_present[0] && + TEST_OPCODE (bundle->cs[0], IBRANCH_OPCODE_CS0, IBRANCH_OPCODE_MASK_CS0)) + { + int32_t disp = IBRANCH_DECODE_DISP_CS0 (bundle->cs[0]); + + info->insn_type = cond == CT_COND_ALWAYS ? dis_jsr : dis_condjsr; + info->target = memaddr + disp; + print_ipd (info, bundle); + if (bundle->cs_present[1] && + TEST_OPCODE (bundle->cs[1], ICALL_OPCODE_CS1, ICALL_OPCODE_MASK_CS1)) + { + print_aligned_mnemonic (info, "icall"); + print_operand_alignment (info, 5); + print_uimm (info, CALL_DECODE_WBS_CS1 (bundle->cs[1])); + print_text (info, ", "); + } + else + { + print_aligned_mnemonic (info, "ibranch"); + print_operand_alignment (info, 7); + } + (*info->print_address_func)(info->target, info); + } + else if (bundle->cs_present[0] && + TEST_OPCODE (bundle->cs[0], DONE_OPCODE_CS0, DONE_OPCODE_MASK_CS0)) + { + unsigned int type = DONE_DECODE_TYPE_CS0 (bundle->cs[0]); + + switch (type) + { + case DONE_TYPE_DONE: + print_aligned_mnemonic (info, "done"); + print_operand_alignment (info, 4); + + /* XXX: deprecated? */ + if (bundle->cs[0] & DONE_FDAM_CS0) + print_mnemonic (info, "fdam"); + + /* XXX: deprecated? */ + if (bundle->cs[0] & DONE_TRAR_CS0) + { + if (bundle->cs[0] & DONE_FDAM_CS0) + print_text (info, ","); + print_mnemonic (info, " trar"); + } + break; + case DONE_TYPE_IRET: + print_aligned_mnemonic (info, "iret"); + break; + case DONE_TYPE_HRET: + print_aligned_mnemonic (info, "hret"); + break; + case DONE_TYPE_GLAUNCH: + print_aligned_mnemonic (info, "glaunch"); + break; + default: + print_text (info, "CS0(%08x)", bundle->cs[0]); + implement_me(0); + break; + } + } + else + { + print_text (info, "invalid ct: SS(%08x)", bundle->ss); + implement_me(0); + print_nl (info); + return; + } + + print_ct_cond (info, cond, SS_DECODE_CT_PRED (bundle->ss)); + + if (hint_target) + switch (pd->ctpr[ctpr].type) + { + case CTPR_DISP: + if (pd->ctpr[ctpr].target) + { + print_comment (info, " # "); + (*info->print_address_func)(pd->ctpr[ctpr].target, info); + } + break; + case CTPR_SYS: + print_comment (info, " # syscall %#lx", pd->ctpr[ctpr].target); + break; + case CTPR_RET: + print_comment (info, " # return"); + break; + case CTPR_MOVTD: + print_comment (info, " # movtd at %#lx", pd->ctpr[ctpr].target); + break; + default: + break; + } + + print_nl (info); +} + +static int +print_hint_call (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + if (bundle->ss_present && + SS_DECODE_FORMAT(bundle->ss) && + SS_DECODE_PREP_CALL_HINT (bundle->ss)) + { + print_sub_mnemonic (info, ".call"); + return 5; + } + return 0; +} + +static void +print_prep (struct disassemble_info *info, struct e2k_unpacked_bundle *bundle, + const char *sub, unsigned int ctpr, int32_t disp ATTRIBUTE_UNUSED, + bfd_vma target) +{ + int width = 4; + print_aligned_mnemonic (info, "prep"); + + if (sub) + { + print_sub_mnemonic (info, "%s", sub); + width += strlen (sub); + } + else + width += print_hint_call (info, bundle); + + print_operand_alignment (info, width); + print_ctpr (info, ctpr); + print_text (info, ", "); + (*info->print_address_func)(target, info); + + print_nl (info); +} + +static void +decode_cs0 (bfd_vma memaddr, struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + struct e2k_private_data *pd = info->private_data; + uint32_t cs0; + unsigned int ctpr; + + if (!bundle->cs_present[0]) + return; + + cs0 = bundle->cs[0]; + ctpr = CS0_DECODE_CTPR (cs0); + + if (ctpr != 0) + { + if (TEST_OPCODE (cs0, PREP_OPCODE_CS0, PREP_OPCODE_MASK_CS0)) + { + int32_t disp = PREP_DECODE_DISP_CS0 (cs0); + bfd_vma target = memaddr + disp; + + pd->ctpr[ctpr].target = target; + pd->ctpr[ctpr].type = CTPR_DISP; + + print_ipd (info, bundle); + print_prep (info, bundle, NULL, ctpr, disp, target); + } + else if (TEST_OPCODE (cs0, PREP_APB_OPCODE_CS0, PREP_APB_OPCODE_MASK_CS0)) + { + int32_t disp = PREP_APB_DECODE_DISP_CS0 (cs0); + bfd_vma target = memaddr + disp; + + pd->ctpr[ctpr].target = target; + pd->ctpr[ctpr].type = CTPR_APB; + + print_ipd (info, bundle); + print_prep (info, bundle, ".apb", ctpr, disp, target); + } + else if (TEST_OPCODE (cs0, PREP_SYS_OPCODE_CS0, PREP_SYS_OPCODE_MASK_CS0)) + { + uint32_t target = PREP_SYS_DECODE_DISP_CS0 (cs0); + + pd->ctpr[ctpr].type = CTPR_SYS; + pd->ctpr[ctpr].target = target; + + print_ipd (info, bundle); + print_aligned_mnemonic (info, "prep"); + print_sub_mnemonic (info, ".sys"); + print_operand_alignment (info, 8); + print_ctpr (info, ctpr); + print_text (info, ", "); + print_hex (info, target); + print_nl (info); + } + else if (TEST_OPCODE (cs0, PREP_RET_OPCODE_CS0, PREP_RET_OPCODE_MASK_CS0)) + { + pd->ctpr[ctpr].type = CTPR_RET; + pd->ctpr[ctpr].target = 0; + + print_ipd (info, bundle); + print_aligned_mnemonic (info, "prep"); + print_sub_mnemonic (info, ".ret"); + print_operand_alignment (info, 8); + print_ctpr (info, ctpr); + print_nl (info); + } + else if (TEST_OPCODE (cs0, GETTSD_OPCODE_CS0, GETTSD_OPCODE_MASK_CS0)) + { + print_aligned_mnemonic (info, "gettsd"); + print_operand_alignment (info, 6); + print_ctpr (info, ctpr); + print_nl (info); + } + else + goto err; + } + else if (TEST_OPCODE (cs0, IBRANCH_OPCODE_CS0, IBRANCH_OPCODE_MASK_CS0) && + pd->ct_decoded) + ; /* ibranch decoded in decode_ct. */ + else if (TEST_OPCODE (cs0, DONE_OPCODE_CS0, DONE_OPCODE_MASK_CS0)) + ; /* done decoded in decode_ct. */ + else if (TEST_OPCODE (cs0, PREF_OPCODE_CS0, PREF_OPCODE_MASK_CS0)) + { + unsigned int ipr = PREF_DECODE_IPR_CS0 (cs0); + unsigned int disp = PREF_DECODE_DISP_CS0 (cs0); + + print_aligned_mnemonic (info, "pref"); + print_operand_alignment (info, 4); + print_ipr (info, ipr); + print_text (info, ", "); + print_hex (info, disp); + if (cs0 & PREF_IPD_CS0) + { + print_text (info, ", "); + print_aligned_mnemonic (info, "ipd"); + } + print_nl (info); + } + else if (TEST_OPCODE (cs0, PUTTSD_OPCODE_CS0, PUTTSD_OPCODE_MASK_CS0)) + { + int32_t disp = PUTTSD_DECODE_DISP_CS0 (cs0); + + print_aligned_mnemonic (info, "puttsd"); + print_operand_alignment (info, 6); + (*info->print_address_func)(memaddr + disp, info); + print_nl (info); + } + else + { +err: + print_aligned_mnemonic (info, "CS0"); + print_text (info, "(%08x)", cs0); + print_nl (info); + } +} + +static void +print_setwd (struct disassemble_info *info, uint32_t lts0) +{ + int width = 5; + + print_aligned_mnemonic (info, "setwd"); + if (!(lts0 & SETWD_NFX_LTS0)) + { + print_sub_mnemonic (info, ".x"); + width += 2; + } + if (lts0 & SETWD_DBL_LTS0) + { + print_sub_mnemonic (info, ".z"); + width += 2; + } + if (lts0 & SETWD_MCN_LTS0) + { + /* TODO: mode check numeric value (protected mode) */ + print_sub_mnemonic (info, ".mcn"); + width += 4; + } + print_operand_alignment (info, width); + print_uimm (info, SETWD_DECODE_WSZ_LTS0 (lts0)); + print_nl (info); +} + +static void +print_setbn (struct disassemble_info *info, uint32_t cs1) +{ + int rsz, rbs, rcur; + + rsz = SETBN_DECODE_RSZ_CS1 (cs1); + rbs = SETBN_DECODE_RBS_CS1 (cs1); + rcur = SETBN_DECODE_RCUR_CS1 (cs1); + + print_aligned_mnemonic (info, "setbn"); + print_operand_alignment (info, 5); + print_uimm (info, rsz); + print_text (info, ", "); + print_uimm (info, rbs); + if (rcur) + { + print_text (info, ", "); + print_uimm (info, rcur); + } + print_nl (info); +} + +static void +print_setbp (struct disassemble_info *info, uint32_t cs1) +{ + print_aligned_mnemonic (info, "setbp"); + print_operand_alignment (info, 5); + print_uimm (info, SETBP_DECODE_PSZ_CS1 (cs1)); + print_nl (info); +} + +static void +decode_cs1 (struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle) +{ + struct e2k_private_data *pd = info->private_data; + uint32_t cs1; + + if (!bundle->cs_present[1]) + return; + + cs1 = bundle->cs[1]; + + if (TEST_OPCODE (cs1, CALL_OPCODE_CS1, CALL_OPCODE_MASK_CS1) && + pd->ct_decoded) + ; /* call decoded in decode_ct. */ + else if (TEST_OPCODE (cs1, SETWD_OPCODE_CS1, SETWD_OPCODE_MASK_CS1) && + bundle->lts_present[0] && + TEST_OPCODE (bundle->lts[0], SETWD_OPCODE_LTS0, SETWD_OPCODE_MASK_LTS0)) + { + if (cs1 & SETWD_VFRPSZ_CS1) + { + print_aligned_mnemonic (info, "vfrpsz"); + print_operand_alignment (info, 6); + print_named_hex (info, "rpsz", VFRPSZ_DECODE_RPSZ_LTS0 (bundle->lts[0])); + print_nl (info); + } + + print_setwd (info, bundle->lts[0]); + + if (cs1 & SETWD_SETBN_CS1) + print_setbn (info, cs1); + + if (cs1 & SETWD_SETBP_CS1) + print_setbp (info, cs1); + + if (cs1 & SETWD_SETTR_CS1) + { + print_aligned_mnemonic (info, "settr"); + print_operand_alignment (info, 5); + print_named_hex (info, "type", VFRPSZ_DECODE_RPSZ_LTS0 (bundle->lts[0])); + print_nl (info); + } + } + else if (TEST_OPCODE (cs1, SETBN_SETBP_OPCODE_CS1, SETBN_SETBP_OPCODE_MASK_CS1)) + { + if (cs1 & SETWD_SETBN_CS1) + print_setbn (info, cs1); + + if (cs1 & SETWD_SETBP_CS1) + print_setbp (info, cs1); + } + else if (TEST_OPCODE (cs1, SETEI_OPCODE_CS1, SETEI_OPCODE_MASK_CS1)) + { + print_aligned_mnemonic (info, "setei"); + print_operand_alignment (info, 5); + print_hex (info, SETEI_DECODE_VALUE_CS1 (cs1)); + print_nl (info); + } + else if (TEST_OPCODE (cs1, SETSFT_CS1_OPCODE, SETSFT_CS1_OPCODE_MASK)) + { + print_aligned_mnemonic (info, "setsft"); + print_operand_alignment (info, 6); + print_nl (info); + } + else if (TEST_OPCODE (cs1, WAIT_OPCODE_CS1, WAIT_OPCODE_MASK_CS1)) + { + static const struct { + const char *name; + unsigned int bit; + } fields[] = + { + {"sas", WAIT_SAS_CS1}, + {"sal", WAIT_SAL_CS1}, + {"trap", WAIT_TRAP_CS1}, + {"ma_c", WAIT_MA_C_CS1}, + {"fl_c", WAIT_FL_C_CS1}, + {"ld_c", WAIT_LD_C_CS1}, + {"st_c", WAIT_ST_C_CS1}, + {"all_e", WAIT_ALL_E_CS1}, + {"all_c", WAIT_ALL_C_CS1} + }; + unsigned int i; + bool first = true; + + print_aligned_mnemonic (info, "wait"); + print_operand_alignment (info, 4); + for (i = 0; i < ARRAY_SIZE (fields); ++i) + { + if ((cs1 & fields[i].bit) == 0) + continue; + + if (first) + { + print_text (info, " %s", fields[i].name); + first = false; + } + else + print_text (info, ", %s", fields[i].name); + } + print_nl (info); + } + else if (TEST_OPCODE (cs1, SETMAS_OPCODE_CS1, SETMAS_OPCODE_MASK_CS1)) + { + if (pd->debug) + { + print_aligned_mnemonic (info, "setmas"); + print_operand_alignment (info, 6); + print_hex (info, SETMAS_DECODE_CS1 (cs1, 0)); + print_text (info, ", "); + print_hex (info, SETMAS_DECODE_CS1 (cs1, 2)); + print_text (info, ", "); + print_hex (info, SETMAS_DECODE_CS1 (cs1, 3)); + print_text (info, ", "); + print_hex (info, SETMAS_DECODE_CS1 (cs1, 5)); + print_nl (info); + } + } + else if (TEST_OPCODE (cs1, FLUSH_CS1_OPCODE, FLUSH_CS1_OPCODE_MASK)) + { + if (cs1 & FLUSH_R_CS1) + { + print_aligned_mnemonic (info, "flushr"); + print_operand_alignment (info, 6); + print_nl (info); + } + if (cs1 & FLUSH_C_CS1) + { + print_aligned_mnemonic (info, "flushc"); + print_operand_alignment (info, 6); + print_nl (info); + } + } + else if (TEST_OPCODE (cs1, VFBG_OPCODE_CS1, VFBG_OPCODE_MASK_CS1)) + { + print_aligned_mnemonic (info, "vfbg"); + print_operand_alignment (info, 4); + print_named_hex (info, "umask", VFBG_DECODE_UMASK_CS1 (cs1)); + print_text (info, ", "); + print_named_hex (info, "dmask", VFBG_DECODE_DMASK_CS1 (cs1)); + if (cs1 & VFBG_CHKM4_CS1) + { + print_text (info, ", chkm4"); + } + print_nl (info); + } + else + { + print_aligned_mnemonic (info, "CS1"); + print_text (info, "(%08x)", cs1); + print_nl (info); + } +} + +#define AL_HASH(als, ales) ((((ales) >> 1) & 0xf80) | (((als) >> 24) & 0x7f)) + +static const struct al_opcode * +al_lookup (struct e2k_private_data *pd, struct e2k_unpacked_bundle *bundle, + unsigned int ch, uint32_t als, uint16_t ales, enum al_flags flags) +{ + static uint16_t al_hash[1 << (5 + 7)]; + static bool initialized = false; + uint8_t opc1 = (als >> 24) & 0x7f; + uint8_t opc2 = ales >> 8; + uint16_t hash; + unsigned int i; + + if (!initialized) + { + const struct al_opcode *p = al_opcodes; + + memset (al_hash, 0xff, sizeof(al_hash)); + for (i = 0; p->name; ++i, ++p) + { + if (((p->flags & AF_REMOVED_IN_V2) && pd->version >= 2) || + ((p->flags & AF_REMOVED_IN_V3) && pd->version >= 3)) + continue; + + hash = AL_HASH (p->als, p->ales); + if (al_hash[hash] == 0xffff) + al_hash[hash] = i; + } + initialized = true; + } + + /* Hack for plog and qplog instructions. */ + if (opc2 >= 0x10 && opc2 <= 0x13) + hash = AL_HASH (0, ales | 0x0100); + else + hash = AL_HASH (als, ales); + + i = al_hash[hash]; + if (i == 0xffff) + return NULL; + + for (; al_opcodes[i].name; ++i) + { + const struct al_opcode *p = &al_opcodes[i]; + const struct al_format_info *format_info = &al_format_info[p->format]; + + if (flags && (p->flags & flags) == 0) + continue; + + /* Skip deleted instructions. */ + if (((p->flags & AF_REMOVED_IN_V2) && pd->version >= 2) || + ((p->flags & AF_REMOVED_IN_V3) && pd->version >= 3)) + continue; + + /* Hack for plog and qplog instructions. */ + if (!(opc2 >= 0x10 && opc2 <= 0x13) && opc1 != (p->als >> 24)) + break; + + /* Additional matching for specific formats. */ + switch (p->format) + { + case AAURR: + case AAURW: + if (!HAS_SETMAS (bundle) || SETMAS_DECODE_CS1 (bundle->cs[1], ch) != 0x3f) + continue; + break; + default: + break; + } + + if ((als & format_info->als_mask) == p->als && + (ales & format_info->ales_mask) == p->ales && + (p->version[ch] && p->version[ch] <= pd->version)) + return p; + } + + return NULL; +} + +static const struct al_opcode * +al_find (struct e2k_private_data *pd, struct e2k_unpacked_bundle *bundle, + unsigned int ch, uint32_t als, uint16_t ales) +{ + const struct al_opcode *opcode; + + opcode = al_lookup (pd, bundle, ch, als, ales, 0); + /* Hack for stupid encoding. */ + if (!opcode && ALES_DECODE_OPC (ales) == 0x02) + { + if (ch == 2 || ch == 5) + opcode = al_lookup (pd, bundle, ch, als, 0, AF_EXPLICIT_ALES25); + else if (ch == 0 || ch == 3) + { + ales = 0x0100 | ALES_DECODE_SRC3 (ales); + opcode = al_lookup (pd, bundle, ch, als, ales, AF_ALT_ALES03); + } + } + return opcode; +} + +static void +decode_al (bfd_vma memaddr, struct disassemble_info *info, + struct e2k_unpacked_bundle *bundle, unsigned int ch) +{ + struct e2k_private_data *pd = info->private_data; + const struct al_opcode *opcode; + const struct al_format_info *format_info; + uint32_t als; + uint16_t ales; + const char *operand; + unsigned int width; + bool is_ctpr_dst; + + als = bundle->als[ch]; + ales = (bundle->ales_present[ch] & ALES_PRESENT) ? bundle->ales[ch] : 0; + opcode = al_find (pd, bundle, ch, als, ales); + + if (!opcode) + { + print_aligned_mnemonic (info, "als%d", ch); + print_text (info, "(%08x)", als); + if (bundle->ales_present[ch]) + { + print_mnemonic (info, " ales%d", ch); + print_text (info, "(%04x)", ales); + } + print_nl (info); + return; + } + + format_info = &al_format_info[opcode->format]; + + if (opcode->flags & AF_PAIR) + { + unsigned int pair = format_info->pair[ch]; + + /* TODO: check pair instruction */ + + if (!pd->show_pair && pair < ch) + return; + } + + print_text (info, "alc%d", ch); + if (ALS_DECODE_SM (als)) + print_sub_mnemonic (info, ".sm"); + print_text (info, "\t"); + print_mnemonic (info, "%s", opcode->name); + width = strlen (opcode->name); + + is_ctpr_dst = ch == 0 && ALS_IS_DST_CTPR (ALS_DECODE_DST (als)) && + (opcode->format == ALF2_MOVTD || + (opcode->format == ALF2 && strcmp (opcode->name, "getpl") == 0)); + + if (is_ctpr_dst) + width += print_hint_call (info, bundle); + + operand = al_format_info[opcode->format].operands; + if (*operand != '\0') + print_operand_alignment (info, width); + + for (; *operand; ++operand) + { + unsigned int value; + + switch (*operand) + { + case ',': + print_text (info, ", "); + break; + case 'D': + value = ALS_DECODE_DST (als); + if (is_ctpr_dst) + { + unsigned int ctpr = value & 3; + + pd->ctpr[ctpr].type = CTPR_MOVTD; + pd->ctpr[ctpr].target = memaddr; + print_ctpr (info, ctpr); + } + else + print_dst (info, value, opcode->dst); + break; + case '4': + value = ALS_DECODE_SRC4 (als); + if (!print_gpr (info, value, opcode->dst)) + { + print_text (info, "", value); + implement_me(0); + } + break; + case 'P': + value = ALS_DECODE_CMP_DST (als); + print_preg (info, value); + break; + case 'S': + value = ALS_DECODE_DST (als); + print_state_register (info, value); + break; + case '1': + value = ALS_DECODE_SRC1 (als); + if (!print_gpr (info, value, opcode->src1)) + print_uimm (info, value - 0xc0); + break; + case '2': + value = ALS_DECODE_SRC2 (als); + if (print_gpr (info, value, opcode->src2)) + ; + else if (value >= 0xc0 && value < 0xd0) + print_uimm (info, value - 0xc0); + else if (!print_literal (info, value, bundle, is_ctpr_dst)) + { + print_text (info, "", value); + implement_me(0); + } + break; + case '3': + value = ALES_DECODE_SRC3 (ales); + if (!print_gpr (info, value, opcode->src3)) + { + print_text (info, "", value); + implement_me(0); + } + break; + case 'L': + value = ALES_DECODE_SRC3 (ales); + if (print_gpr (info, value, opcode->src2)) + ; + else if (pd->version < bfd_mach_e2k_v7 || !print_literal (info, value, bundle, is_ctpr_dst)) + { + print_text (info, "", value); + implement_me(0); + } + break; + case 'p': + if (!print_merge_condition (info, bundle, ch)) + { + print_text (info, ""); + implement_me(0); + } + break; + case 's': + value = ALS_DECODE_SRC1 (als); + print_state_register (info, value); + break; + case 'i': + value = ALES_DECODE_SRC3 (ales); + print_hex (info, value); + break; + case 'a': + value = ALS_DECODE_AA_AAD (als); + print_aad (info, value); + break; + case 'A': + value = ALS_DECODE_AA_INDEX (als); + print_aasti (info, value); + break; + case 'l': + value = ALS_DECODE_AA_LTS (als); + if (value == 0) + break; + + print_text (info, ", "); + --value; + if (bundle->lts_present[value]) + print_hex (info, bundle->lts[value]); + else + print_text (info, ""); + break; + case 'U': + case 'u': + switch (ALS_DECODE_AA_MODE (als)) + { + case STAA_MODE_AAD: + print_aad (info, ALS_DECODE_AA_AAD (als)); + break; + case STAA_MODE_AASTI: + print_aasti (info, ALS_DECODE_AA_INDEX (als)); + break; + case STAA_MODE_AAIND: + print_aaind (info, ALS_DECODE_AA_INDEX (als)); + break; + case STAA_MODE_AAINCR: + print_aaincr (info, ALS_DECODE_AA_INCR (als)); + break; + default: + print_text (info, ""); + implement_me(0); + break; + } + break; + case 't': + print_hex (info, ((ales >> 1) & 0x80) | ALS_DECODE_OPC (als)); + break; + case 'm': + if (bundle->cs_present[1] && + TEST_OPCODE (bundle->cs[1], SETMAS_OPCODE_CS1, SETMAS_OPCODE_MASK_CS1)) + { + unsigned int mas = SETMAS_DECODE_CS1 (bundle->cs[1], ch); + + if (mas) + { + print_text (info, ", mas="); + print_hex (info, mas); + } + } + break; + case 'w': + print_uimm (info, ALS_DECODE_SRC1 (als) * 2); + break; + case '?': + print_rlp (info, bundle, ch); + break; + case 'c': + { + unsigned int cond, ctpr; + + /* Prevent decoding in decode_ct. */ + pd->ct_decoded = true; + + if (!bundle->ss_present || SS_DECODE_FORMAT (bundle->ss) != 0) + { + print_text (info, " "); + implement_me(0); + return; + } + + cond = SS_DECODE_CT_COND (bundle->ss); + if (cond == CT_COND_NONE) + { + print_text (info, " "); + implement_me(0); + return; + } + ctpr = SS_DECODE_CTPR (bundle->ss); + if (cond == CT_COND_NONE || ctpr != 0) + { + print_text (info, " "); + implement_me(0); + return; + } + + print_ct_cond (info, cond, SS_DECODE_CT_PRED (bundle->ss)); + break; + } + default: + implement_me(0); + } + } + + print_nl (info); + + /* Special case for staa instructions. */ + if (opcode->format == ALF10_MAS && ALS_DECODE_AA_INC (als)) + { + print_text (info, "alc%d\t", ch); + print_mnemonic (info, "incr"); + print_operand_alignment (info, 4); + print_aaincr (info, ALS_DECODE_AA_INCR (als)); + print_am (info, bundle, ch); + print_nl (info); + } +} + +static void +print_apb (struct disassemble_info *info, unsigned int ch, uint32_t apb, + uint32_t disp) +{ + print_mnemonic (info, "apb"); + print_text (info, "@%d ", ch); + print_named_uimm (info, ch == 0 ? "ct" : "dpl", (apb & FAPB_CT) != 0); + print_text (info, ", "); + print_named_uimm (info, "dcd", FAPB_DECODE_DCD (apb)); + print_text (info, ", "); + print_named_uimm (info, "fmt", FAPB_DECODE_FMT (apb)); + print_text (info, ", "); + print_named_uimm (info, "mrng", FAPB_DECODE_MRNG (apb)); + print_text (info, ", "); + print_aad (info, FAPB_DECODE_AAD (apb)); + print_text (info, ", "); + print_aaincr (info, FAPB_DECODE_INCR (apb)); + print_text (info, ", "); + print_aaind (info, FAPB_DECODE_INDEX (apb)); + print_text (info, ", "); + print_named_uimm (info, "asz", FAPB_DECODE_ASZ (apb)); + print_text (info, ", "); + print_named_uimm (info, "abs", FAPB_DECODE_ABS (apb)); + print_text (info, ", "); + print_named_hex (info, "disp", disp); + print_nl (info); +} + +static int +print_bundle (bfd_vma memaddr, struct disassemble_info *info) +{ + struct e2k_private_data *pd = info->private_data; + struct e2k_unpacked_bundle bundle = { 0 }; + bfd_byte packet[64]; + int status; + unsigned int len, i; + + info->bytes_per_line = pd->show_syllables ? 4 : 8; + info->bytes_per_chunk = 4; + info->display_endian = BFD_ENDIAN_LITTLE; + //info->flags |= MULTILINE_OUTPUT; + info->insn_type = dis_nonbranch; + + /* Read the first byte to check the length of bundle. */ + status = (*info->read_memory_func) (memaddr, packet, 1, info); + if (status != 0) + { + (*info->memory_error_func) (status, memaddr, info); + return status; + } + + print_text (info, "\n\t"); + len = HS_DECODE_BSZ (packet[0]); + status = (*info->read_memory_func) (memaddr, packet, len, info); + if (status != 0 || !bundle_unpack (pd, packet, len, &bundle)) + { + unsigned int j; + + len = 16; + status = (*info->read_memory_func) (memaddr, packet, len, info); + if (status != 0) + { + (*info->memory_error_func) (status, memaddr, info); + return status; + } + + pd->lines = 0; + pd->syll_cur = 0; + pd->syll_len = 0; + + for (j = 0; j < 2; ++j) + { + push_syllable (pd, "FAPB", j, false); + push_syllable (pd, "DISP", j, false); + } + print_syllable (pd, info); + + for (j = 0; j < 2; ++j) + { + uint32_t apb, disp; + + apb = bfd_getl32 (packet + j * 8); + disp = bfd_getl32 (packet + j * 8 + 4); + print_apb (info, j, apb, disp); + } + } + else + { + print_syllable (pd, info); + decode_hs (info, bundle.hs); + + if (bundle.ss_present) + decode_ss (info, bundle.ss); + + decode_cs1 (info, &bundle); + + for (i = 0; i < ALC_COUNT; ++i) + if (bundle.als_present[i]) + decode_al (memaddr, info, &bundle, i); + + decode_aau (info, &bundle); + decode_pls (info, &bundle); + decode_ct (memaddr, info, &bundle); + decode_cs0 (memaddr, info, &bundle); + + if (info->insn_type == dis_branch || + info->insn_type == dis_jsr || + info->insn_type == dis_condjsr) + memset (pd->ctpr, 0, sizeof (pd->ctpr)); + + decode_nop (info, bundle.hs); + } + + //print_aligned_text (info, "--"); + + /* Force print tail syllables. */ + if (pd->show_syllables) + { + int syll_count = (int) len / info->bytes_per_line - 1; + + while (pd->lines < syll_count) + print_nl (info); + } + + return len; +} + +int +print_insn_e2k (bfd_vma memaddr, struct disassemble_info *info) +{ + struct e2k_private_data *pd; + + if (info->private_data == NULL) + info->private_data = calloc (1, sizeof (struct e2k_private_data)); + + pd = info->private_data; + + if (info->disassembler_options != NULL) + { + set_isa_version (pd, info->mach); + info->disassembler_options = NULL; + } + else if (pd->version == 0) + { + set_default_e2k_dis_options (pd); + set_isa_version (pd, info->mach); + } + + pd->ct_decoded = false; + pd->lines = 0; + pd->syll_cur = 0; + pd->syll_len = 0; + + return print_bundle (memaddr, info); +} diff --git a/disas/e2k-opc.c b/disas/e2k-opc.c new file mode 100644 index 0000000000..50e0f2068c --- /dev/null +++ b/disas/e2k-opc.c @@ -0,0 +1,2396 @@ +/* E2K opcode list + Copyright (C) 2022 Free Software Foundation, Inc. + + This file is part of the GNU opcodes library. + + This library is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3, or (at your option) + any later version. + + It is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public + License for more details. + + You should have received a copy of the GNU General Public License + along with this program; see the file COPYING3. If not, + see . */ + +#include "qemu/osdep.h" +#include "e2k.h" + +const char e2k_reg_names_gpr[NGPR][8] = +{ + "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", + "b8", "b9", "b10", "b11", "b12", "b13", "b14", "b15", + "b16", "b17", "b18", "b19", "b20", "b21", "b22", "b23", + "b24", "b25", "b26", "b27", "b28", "b29", "b30", "b31", + "b32", "b33", "b34", "b35", "b36", "b37", "b38", "b39", + "b40", "b41", "b42", "b43", "b44", "b45", "b46", "b47", + "b48", "b49", "b50", "b51", "b52", "b53", "b54", "b55", + "b56", "b57", "b58", "b59", "b60", "b61", "b62", "b63", + "b64", "b65", "b66", "b67", "b68", "b69", "b70", "b71", + "b72", "b73", "b74", "b75", "b76", "b77", "b78", "b79", + "b80", "b81", "b82", "b83", "b84", "b85", "b86", "b87", + "b88", "b89", "b90", "b91", "b92", "b93", "b94", "b95", + "b96", "b97", "b98", "b99", "b100", "b101", "b102", "b103", + "b104", "b105", "b106", "b107", "b108", "b109", "b110", "b111", + "b112", "b113", "b114", "b115", "b116", "b117", "b118", "b119", + "b120", "b121", "b122", "b123", "b124", "b125", "b126", "b127", + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", + "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", + "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", + "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31", + "r32", "r33", "r34", "r35", "r36", "r37", "r38", "r39", + "r40", "r41", "r42", "r43", "r44", "r45", "r46", "r47", + "r48", "r49", "r50", "r51", "r52", "r53", "r54", "r55", + "r56", "r57", "r58", "r59", "r60", "r61", "r62", "r63", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", + "g8", "g9", "g10", "g11", "g12", "g13", "g14", "g15", + "g16", "g17", "g18", "g19", "g20", "g21", "g22", "g23", + "g24", "g25", "g26", "g27", "g28", "g29", "g30", "g31", +}; + +const char e2k_reg_names_gpr_d[NGPR][8] = +{ + "db0", "db1", "db2", "db3", "db4", "db5", "db6", "db7", + "db8", "db9", "db10", "db11", "db12", "db13", "db14", "db15", + "db16", "db17", "db18", "db19", "db20", "db21", "db22", "db23", + "db24", "db25", "db26", "db27", "db28", "db29", "db30", "db31", + "db32", "db33", "db34", "db35", "db36", "db37", "db38", "db39", + "db40", "db41", "db42", "db43", "db44", "db45", "db46", "db47", + "db48", "db49", "db50", "db51", "db52", "db53", "db54", "db55", + "db56", "db57", "db58", "db59", "db60", "db61", "db62", "db63", + "db64", "db65", "db66", "db67", "db68", "db69", "db70", "db71", + "db72", "db73", "db74", "db75", "db76", "db77", "db78", "db79", + "db80", "db81", "db82", "db83", "db84", "db85", "db86", "db87", + "db88", "db89", "db90", "db91", "db92", "db93", "db94", "db95", + "db96", "db97", "db98", "db99", "db100", "db101", "db102", "db103", + "db104", "db105", "db106", "db107", "db108", "db109", "db110", "db111", + "db112", "db113", "db114", "db115", "db116", "db117", "db118", "db119", + "db120", "db121", "db122", "db123", "db124", "db125", "db126", "db127", + "dr0", "dr1", "dr2", "dr3", "dr4", "dr5", "dr6", "dr7", + "dr8", "dr9", "dr10", "dr11", "dr12", "dr13", "dr14", "dr15", + "dr16", "dr17", "dr18", "dr19", "dr20", "dr21", "dr22", "dr23", + "dr24", "dr25", "dr26", "dr27", "dr28", "dr29", "dr30", "dr31", + "dr32", "dr33", "dr34", "dr35", "dr36", "dr37", "dr38", "dr39", + "dr40", "dr41", "dr42", "dr43", "dr44", "dr45", "dr46", "dr47", + "dr48", "dr49", "dr50", "dr51", "dr52", "dr53", "dr54", "dr55", + "dr56", "dr57", "dr58", "dr59", "dr60", "dr61", "dr62", "dr63", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "dg0", "dg1", "dg2", "dg3", "dg4", "dg5", "dg6", "dg7", + "dg8", "dg9", "dg10", "dg11", "dg12", "dg13", "dg14", "dg15", + "dg16", "dg17", "dg18", "dg19", "dg20", "dg21", "dg22", "dg23", + "dg24", "dg25", "dg26", "dg27", "dg28", "dg29", "dg30", "dg31", +}; + +const char e2k_reg_names_gpr_x[NGPR][8] = +{ + "xb0", "xb1", "xb2", "xb3", "xb4", "xb5", "xb6", "xb7", + "xb8", "xb9", "xb10", "xb11", "xb12", "xb13", "xb14", "xb15", + "xb16", "xb17", "xb18", "xb19", "xb20", "xb21", "xb22", "xb23", + "xb24", "xb25", "xb26", "xb27", "xb28", "xb29", "xb30", "xb31", + "xb32", "xb33", "xb34", "xb35", "xb36", "xb37", "xb38", "xb39", + "xb40", "xb41", "xb42", "xb43", "xb44", "xb45", "xb46", "xb47", + "xb48", "xb49", "xb50", "xb51", "xb52", "xb53", "xb54", "xb55", + "xb56", "xb57", "xb58", "xb59", "xb60", "xb61", "xb62", "xb63", + "xb64", "xb65", "xb66", "xb67", "xb68", "xb69", "xb70", "xb71", + "xb72", "xb73", "xb74", "xb75", "xb76", "xb77", "xb78", "xb79", + "xb80", "xb81", "xb82", "xb83", "xb84", "xb85", "xb86", "xb87", + "xb88", "xb89", "xb90", "xb91", "xb92", "xb93", "xb94", "xb95", + "xb96", "xb97", "xb98", "xb99", "xb100", "xb101", "xb102", "xb103", + "xb104", "xb105", "xb106", "xb107", "xb108", "xb109", "xb110", "xb111", + "xb112", "xb113", "xb114", "xb115", "xb116", "xb117", "xb118", "xb119", + "xb120", "xb121", "xb122", "xb123", "xb124", "xb125", "xb126", "xb127", + "xr0", "xr1", "xr2", "xr3", "xr4", "xr5", "xr6", "xr7", + "xr8", "xr9", "xr10", "xr11", "xr12", "xr13", "xr14", "xr15", + "xr16", "xr17", "xr18", "xr19", "xr20", "xr21", "xr22", "xr23", + "xr24", "xr25", "xr26", "xr27", "xr28", "xr29", "xr30", "xr31", + "xr32", "xr33", "xr34", "xr35", "xr36", "xr37", "xr38", "xr39", + "xr40", "xr41", "xr42", "xr43", "xr44", "xr45", "xr46", "xr47", + "xr48", "xr49", "xr50", "xr51", "xr52", "xr53", "xr54", "xr55", + "xr56", "xr57", "xr58", "xr59", "xr60", "xr61", "xr62", "xr63", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "xg0", "xg1", "xg2", "xg3", "xg4", "xg5", "xg6", "xg7", + "xg8", "xg9", "xg10", "xg11", "xg12", "xg13", "xg14", "xg15", + "xg16", "xg17", "xg18", "xg19", "xg20", "xg21", "xg22", "xg23", + "xg24", "xg25", "xg26", "xg27", "xg28", "xg29", "xg30", "xg31", +}; + +const char e2k_reg_names_gpr_q[NGPR][8] = +{ + "qb0", "qb1", "qb2", "qb3", "qb4", "qb5", "qb6", "qb7", + "qb8", "qb9", "qb10", "qb11", "qb12", "qb13", "qb14", "qb15", + "qb16", "qb17", "qb18", "qb19", "qb20", "qb21", "qb22", "qb23", + "qb24", "qb25", "qb26", "qb27", "qb28", "qb29", "qb30", "qb31", + "qb32", "qb33", "qb34", "qb35", "qb36", "qb37", "qb38", "qb39", + "qb40", "qb41", "qb42", "qb43", "qb44", "qb45", "qb46", "qb47", + "qb48", "qb49", "qb50", "qb51", "qb52", "qb53", "qb54", "qb55", + "qb56", "qb57", "qb58", "qb59", "qb60", "qb61", "qb62", "qb63", + "qb64", "qb65", "qb66", "qb67", "qb68", "qb69", "qb70", "qb71", + "qb72", "qb73", "qb74", "qb75", "qb76", "qb77", "qb78", "qb79", + "qb80", "qb81", "qb82", "qb83", "qb84", "qb85", "qb86", "qb87", + "qb88", "qb89", "qb90", "qb91", "qb92", "qb93", "qb94", "qb95", + "qb96", "qb97", "qb98", "qb99", "qb100", "qb101", "qb102", "qb103", + "qb104", "qb105", "qb106", "qb107", "qb108", "qb109", "qb110", "qb111", + "qb112", "qb113", "qb114", "qb115", "qb116", "qb117", "qb118", "qb119", + "qb120", "qb121", "qb122", "qb123", "qb124", "qb125", "qb126", "qb127", + "qr0", "qr1", "qr2", "qr3", "qr4", "qr5", "qr6", "qr7", + "qr8", "qr9", "qr10", "qr11", "qr12", "qr13", "qr14", "qr15", + "qr16", "qr17", "qr18", "qr19", "qr20", "qr21", "qr22", "qr23", + "qr24", "qr25", "qr26", "qr27", "qr28", "qr29", "qr30", "qr31", + "qr32", "qr33", "qr34", "qr35", "qr36", "qr37", "qr38", "qr39", + "qr40", "qr41", "qr42", "qr43", "qr44", "qr45", "qr46", "qr47", + "qr48", "qr49", "qr50", "qr51", "qr52", "qr53", "qr54", "qr55", + "qr56", "qr57", "qr58", "qr59", "qr60", "qr61", "qr62", "qr63", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "qg0", "qg1", "qg2", "qg3", "qg4", "qg5", "qg6", "qg7", + "qg8", "qg9", "qg10", "qg11", "qg12", "qg13", "qg14", "qg15", + "qg16", "qg17", "qg18", "qg19", "qg20", "qg21", "qg22", "qg23", + "qg24", "qg25", "qg26", "qg27", "qg28", "qg29", "qg30", "qg31", +}; + +const char e2k_reg_names_gpr_qp[NGPR][8] = +{ + "qpb0", "qpb1", "qpb2", "qpb3", "qpb4", "qpb5", "qpb6", "qpb7", + "qpb8", "qpb9", "qpb10", "qpb11", "qpb12", "qpb13", "qpb14", "qpb15", + "qpb16", "qpb17", "qpb18", "qpb19", "qpb20", "qpb21", "qpb22", "qpb23", + "qpb24", "qpb25", "qpb26", "qpb27", "qpb28", "qpb29", "qpb30", "qpb31", + "qpb32", "qpb33", "qpb34", "qpb35", "qpb36", "qpb37", "qpb38", "qpb39", + "qpb40", "qpb41", "qpb42", "qpb43", "qpb44", "qpb45", "qpb46", "qpb47", + "qpb48", "qpb49", "qpb50", "qpb51", "qpb52", "qpb53", "qpb54", "qpb55", + "qpb56", "qpb57", "qpb58", "qpb59", "qpb60", "qpb61", "qpb62", "qpb63", + "qpb64", "qpb65", "qpb66", "qpb67", "qpb68", "qpb69", "qpb70", "qpb71", + "qpb72", "qpb73", "qpb74", "qpb75", "qpb76", "qpb77", "qpb78", "qpb79", + "qpb80", "qpb81", "qpb82", "qpb83", "qpb84", "qpb85", "qpb86", "qpb87", + "qpb88", "qpb89", "qpb90", "qpb91", "qpb92", "qpb93", "qpb94", "qpb95", + "qpb96", "qpb97", "qpb98", "qpb99", "qpb100", "qpb101", "qpb102", "qpb103", + "qpb104", "qpb105", "qpb106", "qpb107", "qpb108", "qpb109", "qpb110", "qpb111", + "qpb112", "qpb113", "qpb114", "qpb115", "qpb116", "qpb117", "qpb118", "qpb119", + "qpb120", "qpb121", "qpb122", "qpb123", "qpb124", "qpb125", "qpb126", "qpb127", + "qpr0", "qpr1", "qpr2", "qpr3", "qpr4", "qpr5", "qpr6", "qpr7", + "qpr8", "qpr9", "qpr10", "qpr11", "qpr12", "qpr13", "qpr14", "qpr15", + "qpr16", "qpr17", "qpr18", "qpr19", "qpr20", "qpr21", "qpr22", "qpr23", + "qpr24", "qpr25", "qpr26", "qpr27", "qpr28", "qpr29", "qpr30", "qpr31", + "qpr32", "qpr33", "qpr34", "qpr35", "qpr36", "qpr37", "qpr38", "qpr39", + "qpr40", "qpr41", "qpr42", "qpr43", "qpr44", "qpr45", "qpr46", "qpr47", + "qpr48", "qpr49", "qpr50", "qpr51", "qpr52", "qpr53", "qpr54", "qpr55", + "qpr56", "qpr57", "qpr58", "qpr59", "qpr60", "qpr61", "qpr62", "qpr63", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", + "qpg0", "qpg1", "qpg2", "qpg3", "qpg4", "qpg5", "qpg6", "qpg7", + "qpg8", "qpg9", "qpg10", "qpg11", "qpg12", "qpg13", "qpg14", "qpg15", + "qpg16", "qpg17", "qpg18", "qpg19", "qpg20", "qpg21", "qpg22", "qpg23", + "qpg24", "qpg25", "qpg26", "qpg27", "qpg28", "qpg29", "qpg30", "qpg31", +}; + +const char e2k_reg_names_preg[NPREG][4] = +{ + "p0", "p1", "p2", "p3", "p4", "p5", "p6", "p7", + "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15", + "p16", "p17", "p18", "p19", "p20", "p21", "p22", "p23", + "p24", "p25", "p26", "p27", "p28", "p29", "p30", "p31" +}; + +const char e2k_reg_names_lpred[NLPRED][4] = +{ + "lp0", "lp1", "lp2", "lp3", "lp4", "lp5", "lp6" +}; + +const char e2k_reg_names_cmp[NCMP][8] = +{ + "cmp0", "cmp1", "cmp3", "cmp4" +}; + +const char e2k_reg_names_pcnt[NPCNT][8] = +{ + "pcnt0", "pcnt1", "pcnt2", "pcnt3", + "pcnt4", "pcnt5", "pcnt6", "pcnt7", + "pcnt8", "pcnt9", "pcnt10", "pcnt11", + "pcnt12", "pcnt13", "pcnt14", "pcnt15", + "pcnt16", "pcnt17", "pcnt18", "pcnt19", + "pcnt20", "pcnt21", "pcnt22", "pcnt23", + "pcnt24", "pcnt25", "pcnt26", "pcnt27", + "pcnt28", "pcnt29", "pcnt30", "pcnt31" +}; + +const char e2k_reg_names_ctpr[NCTPR][8] = +{ + "ctpr0", "ctpr1", "ctpr2", "ctpr3" +}; + +const char e2k_reg_names_ipr[NIPR][8] = +{ + "ipr0", "ipr1", "ipr2", "ipr3", "ipr4", "ipr5", "ipr6", "ipr7" +}; + +const char e2k_reg_names_aad[NAAD][8] = +{ + "aad0", "aad1", "aad2", "aad3", "aad4", "aad5", "aad6", "aad7", + "aad8", "aad9", "aad10", "aad11", "aad12", "aad13", "aad14", "aad15", + "aad16", "aad17", "aad18", "aad19", "aad20", "aad21", "aad22", "aad23", + "aad24", "aad25", "aad26", "aad27", "aad28", "aad29", "aad30", "aad31" +}; + +const char e2k_reg_names_aasti[NAASTI][8] = +{ + "aasti0", "aasti1", "aasti2", "aasti3", + "aasti4", "aasti5", "aasti6", "aasti7", + "aasti8", "aasti9", "aasti10", "aasti11", + "aasti12", "aasti13", "aasti14", "aasti15" +}; + +const char e2k_reg_names_aaind[NAAIND][8] = +{ + "aaind0", "aaind1", "aaind2", "aaind3", + "aaind4", "aaind5", "aaind6", "aaind7", + "aaind8", "aaind9", "aaind10", "aaind11", + "aaind12", "aaind13", "aaind14", "aaind15" +}; + +const char e2k_reg_names_aaincr[NAAINCR][8] = +{ + "aaincr0", "aaincr1", "aaincr2", "aaincr3", + "aaincr4", "aaincr5", "aaincr6", "aaincr7" +}; + +const char *e2k_reg_names_rndpred[NRNDPRED] = +{ + "bgrpred", "rndpred1", "rndpred2", "rndpred3", + "rndpred4", "rndpred5", "rndpred6", "rndpred7", + "rndpred8", "rndpred9", "rndpred10", "rndpred11", + "rndpred12", "rndpred13", "rndpred14", "rndpred15", + "rndpred16", "rndpred17", "rndpred18", "rndpred19", + "rndpred20", "rndpred21", "rndpred22", "rndpred23", + "rndpred24", "rndpred25", "rndpred26", "rndpred27", + "rndpred28", "rndpred29", "rndpred30", "rndpred31" +}; + +const char *e2k_reg_names_sr[NSR] = +{ + /* 0x00 */ "psr", + /* 0x01 */ "wd", + /* 0x02 */ NULL, + /* 0x03 */ NULL, + /* 0x04 */ "core_mode", + /* 0x05 */ NULL, + /* 0x06 */ "cwd", + /* 0x07 */ "psp.hi", + /* 0x08 */ NULL, + /* 0x09 */ "psp.lo", + /* 0x0a */ NULL, + /* 0x0b */ "pshtp", + /* 0x0c */ NULL, + /* 0x0d */ "pcsp.hi", + /* 0x0e */ NULL, + /* 0x0f */ "pcsp.lo", + /* 0x10 */ NULL, + /* 0x11 */ NULL, + /* 0x12 */ NULL, + /* 0x13 */ "pcshtp", + /* 0x14 */ NULL, + /* 0x15 */ "ctpr1", + /* 0x16 */ "ctpr2", + /* 0x17 */ "ctpr3", + /* 0x18 */ NULL, + /* 0x19 */ NULL, + /* 0x1a */ NULL, + /* 0x1b */ NULL, + /* 0x1c */ NULL, + /* 0x1d */ NULL, + /* 0x1e */ "sbr", + /* 0x1f */ NULL, + /* 0x10 */ NULL, + /* 0x21 */ "cutd", + /* 0x22 */ NULL, + /* 0x23 */ "eir", + /* 0x24 */ "tsd", /* deprecated */ + /* 0x25 */ "cuir", + /* 0x26 */ "oscud.hi", + /* 0x27 */ "oscud.lo", + /* 0x28 */ "osgd.hi", + /* 0x29 */ "osgd.lo", + /* 0x2a */ "osem", + /* 0x2b */ NULL, + /* 0x2c */ "usd.hi", + /* 0x2d */ "usd.lo", + /* 0x2e */ "tr", /* deprecated */ + /* 0x2f */ "osr0", + /* 0x30 */ "cud.hi", + /* 0x31 */ "cud.lo", + /* 0x32 */ "gd.hi", + /* 0x33 */ "gd.lo", + /* 0x34 */ "cs.hi", + /* 0x35 */ "cs.lo", + /* 0x36 */ "ds.hi", + /* 0x37 */ "ds.lo", + /* 0x38 */ "es.hi", + /* 0x39 */ "es.lo", + /* 0x3a */ "fs.hi", + /* 0x3b */ "fs.lo", + /* 0x3c */ "gs.hi", + /* 0x3d */ "gs.lo", + /* 0x3e */ "ss.hi", + /* 0x3f */ "ss.lo", + /* 0x40 */ "dibcr", + /* 0x41 */ "dimcr", + /* 0x42 */ "dibsr", + /* 0x43 */ "dtcr", + /* 0x44 */ NULL, + /* 0x45 */ NULL, + /* 0x46 */ NULL, + /* 0x47 */ NULL, + /* 0x48 */ "dibar0", + /* 0x49 */ "dibar1", + /* 0x4a */ "dibar2", + /* 0x4b */ "dibar3", + /* 0x4c */ "dimar0", + /* 0x4d */ "dimar1", + /* 0x4e */ "dtarf", + /* 0x4f */ "dtart", + /* 0x50 */ NULL, + /* 0x51 */ "cr0.hi", + /* 0x52 */ NULL, + /* 0x53 */ "cr0.lo", + /* 0x54 */ NULL, + /* 0x55 */ "cr1.hi", + /* 0x56 */ NULL, + /* 0x57 */ "cr1.lo", + /* 0x58 */ NULL, + /* 0x59 */ NULL, + /* 0x5a */ NULL, + /* 0x5b */ NULL, + /* 0x5c */ NULL, + /* 0x5d */ NULL, + /* 0x5e */ NULL, + /* 0x5f */ NULL, + /* 0x60 */ NULL, + /* 0x61 */ NULL, + /* 0x62 */ NULL, + /* 0x63 */ NULL, + /* 0x64 */ NULL, + /* 0x65 */ NULL, + /* 0x66 */ NULL, + /* 0x67 */ NULL, + /* 0x68 */ NULL, + /* 0x69 */ NULL, + /* 0x6a */ NULL, + /* 0x6b */ NULL, + /* 0x6c */ NULL, + /* 0x6d */ NULL, + /* 0x6e */ NULL, + /* 0x6f */ NULL, + /* 0x70 */ "sclkm1", + /* 0x71 */ "sclkm2", + /* 0x72 */ NULL, + /* 0x73 */ NULL, + /* 0x74 */ NULL, + /* 0x75 */ NULL, + /* 0x76 */ NULL, + /* 0x77 */ NULL, + /* 0x78 */ "cu_hw0", + /* 0x79 */ NULL, + /* 0x7a */ NULL, + /* 0x7b */ NULL, + /* 0x7c */ NULL, + /* 0x7d */ NULL, + /* 0x7e */ NULL, + /* 0x7f */ NULL, + /* 0x80 */ "upsr", + /* 0x81 */ "ip", + /* 0x82 */ "nip", + /* 0x83 */ "lsr", + /* 0x84 */ "pfpfr", + /* 0x85 */ "fpcr", + /* 0x86 */ "fpsr", + /* 0x87 */ "ilcr", + /* 0x88 */ "br", + /* 0x89 */ "bgr", + /* 0x8a */ "idr", + /* 0x8b */ NULL, + /* 0x8c */ NULL, + /* 0x8d */ NULL, + /* 0x8e */ NULL, + /* 0x8f */ NULL, + /* 0x90 */ "clkr", + /* 0x91 */ "rndpr", + /* 0x92 */ "sclkr", + /* 0x93 */ NULL, + /* 0x94 */ NULL, + /* 0x95 */ NULL, + /* 0x96 */ NULL, + /* 0x97 */ NULL, + /* 0x98 */ NULL, + /* 0x99 */ NULL, + /* 0x9a */ NULL, + /* 0x9b */ NULL, + /* 0x9c */ "tir.hi", + /* 0x9d */ "tir.lo", + /* 0x9e */ NULL, + /* 0x9f */ NULL, + /* 0xa0 */ "rpr", + /* 0xa1 */ "sbbp", + /* 0xa2 */ "rpr.hi", + /* 0xa3 */ NULL, + /* 0xa4 */ NULL, + /* 0xa5 */ NULL, + /* 0xa6 */ NULL, + /* 0xa7 */ NULL, + /* 0xa8 */ NULL, + /* 0xa9 */ NULL, + /* 0xaa */ NULL, + /* 0xab */ NULL, + /* 0xac */ NULL, + /* 0xad */ NULL, + /* 0xae */ NULL, + /* 0xaf */ NULL, + /* 0xb0 */ NULL, + /* 0xb1 */ NULL, + /* 0xb2 */ NULL, + /* 0xb3 */ NULL, + /* 0xb4 */ NULL, + /* 0xb5 */ NULL, + /* 0xb6 */ NULL, + /* 0xb7 */ NULL, + /* 0xb8 */ NULL, + /* 0xb9 */ NULL, + /* 0xba */ NULL, + /* 0xbb */ NULL, + /* 0xbc */ NULL, + /* 0xbd */ NULL, + /* 0xbe */ NULL, + /* 0xbf */ NULL, + /* 0xc0 */ "upsrm", + /* 0xc1 */ NULL, + /* 0xc2 */ NULL, + /* 0xc3 */ "lsr1", /* v5+ */ + /* 0xc4 */ NULL, + /* 0xc5 */ NULL, + /* 0xc6 */ NULL, + /* 0xc7 */ "ilcr1", /* v5+ */ + /* 0xc8 */ NULL, + /* 0xc9 */ NULL, + /* 0xca */ NULL, + /* 0xcb */ NULL, + /* 0xcc */ NULL, + /* 0xcd */ NULL, + /* 0xce */ NULL, + /* 0xcf */ NULL, + /* 0xd0 */ NULL, + /* 0xd1 */ NULL, + /* 0xd2 */ NULL, + /* 0xd3 */ NULL, + /* 0xd4 */ NULL, + /* 0xd5 */ NULL, + /* 0xd6 */ NULL, + /* 0xd7 */ NULL, + /* 0xd8 */ NULL, + /* 0xd9 */ NULL, + /* 0xda */ NULL, + /* 0xdb */ NULL, + /* 0xdc */ NULL, + /* 0xdd */ NULL, + /* 0xde */ NULL, + /* 0xdf */ NULL, + /* 0xe0 */ NULL, + /* 0xe1 */ NULL, + /* 0xe2 */ NULL, + /* 0xe3 */ NULL, + /* 0xe4 */ NULL, + /* 0xe5 */ NULL, + /* 0xe6 */ NULL, + /* 0xe7 */ NULL, + /* 0xe8 */ NULL, + /* 0xe9 */ NULL, + /* 0xea */ NULL, + /* 0xeb */ NULL, + /* 0xec */ NULL, + /* 0xed */ NULL, + /* 0xee */ NULL, + /* 0xef */ NULL, + /* 0xf0 */ NULL, + /* 0xf1 */ NULL, + /* 0xf2 */ NULL, + /* 0xf3 */ NULL, + /* 0xf4 */ NULL, + /* 0xf5 */ NULL, + /* 0xf6 */ NULL, + /* 0xf7 */ NULL, + /* 0xf8 */ NULL, + /* 0xf9 */ NULL, + /* 0xfa */ NULL, + /* 0xfb */ NULL, + /* 0xfc */ NULL, + /* 0xfd */ NULL, + /* 0xfe */ NULL, + /* 0xff */ NULL +}; + +const uint8_t e2k_reg_version_sr[NSR] = /* TODO */ +{ + /* 0x00 */ 0, + /* 0x01 */ 0, + /* 0x02 */ 0, + /* 0x03 */ 0, + /* 0x04 */ 0, + /* 0x05 */ 0, + /* 0x06 */ 0, + /* 0x07 */ 0, + /* 0x08 */ 0, + /* 0x09 */ 0, + /* 0x0a */ 0, + /* 0x0b */ 0, + /* 0x0c */ 0, + /* 0x0d */ 0, + /* 0x0e */ 0, + /* 0x0f */ 0, + /* 0x10 */ 0, + /* 0x11 */ 0, + /* 0x12 */ 0, + /* 0x13 */ 0, + /* 0x14 */ 0, + /* 0x15 */ 0, + /* 0x16 */ 0, + /* 0x17 */ 0, + /* 0x18 */ 0, + /* 0x19 */ 0, + /* 0x1a */ 0, + /* 0x1b */ 0, + /* 0x1c */ 0, + /* 0x1d */ 0, + /* 0x1e */ 0, + /* 0x1f */ 0, + /* 0x10 */ 0, + /* 0x21 */ 0, + /* 0x22 */ 0, + /* 0x23 */ 0, + /* 0x24 */ 0, + /* 0x25 */ 0, + /* 0x26 */ 0, + /* 0x27 */ 0, + /* 0x28 */ 0, + /* 0x29 */ 0, + /* 0x2a */ 0, + /* 0x2b */ 0, + /* 0x2c */ 0, + /* 0x2d */ 0, + /* 0x2e */ 0, + /* 0x2f */ 0, + /* 0x30 */ 0, + /* 0x31 */ 0, + /* 0x32 */ 0, + /* 0x33 */ 0, + /* 0x34 */ 0, + /* 0x35 */ 0, + /* 0x36 */ 0, + /* 0x37 */ 0, + /* 0x38 */ 0, + /* 0x39 */ 0, + /* 0x3a */ 0, + /* 0x3b */ 0, + /* 0x3c */ 0, + /* 0x3d */ 0, + /* 0x3e */ 0, + /* 0x3f */ 0, + /* 0x40 */ 0, + /* 0x41 */ 0, + /* 0x42 */ 0, + /* 0x43 */ 0, + /* 0x44 */ 0, + /* 0x45 */ 0, + /* 0x46 */ 0, + /* 0x47 */ 0, + /* 0x48 */ 0, + /* 0x49 */ 0, + /* 0x4a */ 0, + /* 0x4b */ 0, + /* 0x4c */ 0, + /* 0x4d */ 0, + /* 0x4e */ 0, + /* 0x4f */ 0, + /* 0x50 */ 0, + /* 0x51 */ 0, + /* 0x52 */ 0, + /* 0x53 */ 0, + /* 0x54 */ 0, + /* 0x55 */ 0, + /* 0x56 */ 0, + /* 0x57 */ 0, + /* 0x58 */ 0, + /* 0x59 */ 0, + /* 0x5a */ 0, + /* 0x5b */ 0, + /* 0x5c */ 0, + /* 0x5d */ 0, + /* 0x5e */ 0, + /* 0x5f */ 0, + /* 0x60 */ 0, + /* 0x61 */ 0, + /* 0x62 */ 0, + /* 0x63 */ 0, + /* 0x64 */ 0, + /* 0x65 */ 0, + /* 0x66 */ 0, + /* 0x67 */ 0, + /* 0x68 */ 0, + /* 0x69 */ 0, + /* 0x6a */ 0, + /* 0x6b */ 0, + /* 0x6c */ 0, + /* 0x6d */ 0, + /* 0x6e */ 0, + /* 0x6f */ 0, + /* 0x70 */ 0, + /* 0x71 */ 0, + /* 0x72 */ 0, + /* 0x73 */ 0, + /* 0x74 */ 0, + /* 0x75 */ 0, + /* 0x76 */ 0, + /* 0x77 */ 0, + /* 0x78 */ 0, + /* 0x79 */ 0, + /* 0x7a */ 0, + /* 0x7b */ 0, + /* 0x7c */ 0, + /* 0x7d */ 0, + /* 0x7e */ 0, + /* 0x7f */ 0, + /* 0x80 */ 0, + /* 0x81 */ 0, + /* 0x82 */ 0, + /* 0x83 */ 0, + /* 0x84 */ 0, + /* 0x85 */ 0, + /* 0x86 */ 0, + /* 0x87 */ 0, + /* 0x88 */ 0, + /* 0x89 */ 0, + /* 0x8a */ 0, + /* 0x8b */ 0, + /* 0x8c */ 0, + /* 0x8d */ 0, + /* 0x8e */ 0, + /* 0x8f */ 0, + /* 0x90 */ 0, + /* 0x91 */ 0, + /* 0x92 */ 0, + /* 0x93 */ 0, + /* 0x94 */ 0, + /* 0x95 */ 0, + /* 0x96 */ 0, + /* 0x97 */ 0, + /* 0x98 */ 0, + /* 0x99 */ 0, + /* 0x9a */ 0, + /* 0x9b */ 0, + /* 0x9c */ 0, + /* 0x9d */ 0, + /* 0x9e */ 0, + /* 0x9f */ 0, + /* 0xa0 */ 0, + /* 0xa1 */ 0, + /* 0xa2 */ 0, + /* 0xa3 */ 0, + /* 0xa4 */ 0, + /* 0xa5 */ 0, + /* 0xa6 */ 0, + /* 0xa7 */ 0, + /* 0xa8 */ 0, + /* 0xa9 */ 0, + /* 0xaa */ 0, + /* 0xab */ 0, + /* 0xac */ 0, + /* 0xad */ 0, + /* 0xae */ 0, + /* 0xaf */ 0, + /* 0xb0 */ 0, + /* 0xb1 */ 0, + /* 0xb2 */ 0, + /* 0xb3 */ 0, + /* 0xb4 */ 0, + /* 0xb5 */ 0, + /* 0xb6 */ 0, + /* 0xb7 */ 0, + /* 0xb8 */ 0, + /* 0xb9 */ 0, + /* 0xba */ 0, + /* 0xbb */ 0, + /* 0xbc */ 0, + /* 0xbd */ 0, + /* 0xbe */ 0, + /* 0xbf */ 0, + /* 0xc0 */ 0, + /* 0xc1 */ 0, + /* 0xc2 */ 0, + /* 0xc3 */ 5, /* lsr1 */ + /* 0xc4 */ 0, + /* 0xc5 */ 0, + /* 0xc6 */ 0, + /* 0xc7 */ 5, /* ilcr1 */ + /* 0xc8 */ 0, + /* 0xc9 */ 0, + /* 0xca */ 0, + /* 0xcb */ 0, + /* 0xcc */ 0, + /* 0xcd */ 0, + /* 0xce */ 0, + /* 0xcf */ 0, + /* 0xd0 */ 0, + /* 0xd1 */ 0, + /* 0xd2 */ 0, + /* 0xd3 */ 0, + /* 0xd4 */ 0, + /* 0xd5 */ 0, + /* 0xd6 */ 0, + /* 0xd7 */ 0, + /* 0xd8 */ 0, + /* 0xd9 */ 0, + /* 0xda */ 0, + /* 0xdb */ 0, + /* 0xdc */ 0, + /* 0xdd */ 0, + /* 0xde */ 0, + /* 0xdf */ 0, + /* 0xe0 */ 0, + /* 0xe1 */ 0, + /* 0xe2 */ 0, + /* 0xe3 */ 0, + /* 0xe4 */ 0, + /* 0xe5 */ 0, + /* 0xe6 */ 0, + /* 0xe7 */ 0, + /* 0xe8 */ 0, + /* 0xe9 */ 0, + /* 0xea */ 0, + /* 0xeb */ 0, + /* 0xec */ 0, + /* 0xed */ 0, + /* 0xee */ 0, + /* 0xef */ 0, + /* 0xf0 */ 0, + /* 0xf1 */ 0, + /* 0xf2 */ 0, + /* 0xf3 */ 0, + /* 0xf4 */ 0, + /* 0xf5 */ 0, + /* 0xf6 */ 0, + /* 0xf7 */ 0, + /* 0xf8 */ 0, + /* 0xf9 */ 0, + /* 0xfa */ 0, + /* 0xfb */ 0, + /* 0xfc */ 0, + /* 0xfd */ 0, + /* 0xfe */ 0, + /* 0xff */ 0 +}; + +/* D - destination GPR register or empty result + * P - destination predicate register + * S - destination state register + * U - destination AAU register + * 1 - GPR register or uimm5 + * 2 - GPR register, uimm4 or literal + * 3 - GPR register + * L - GPR register or 32-bit literal + * 4 - GPR register + * p - predicate in MRGC + * m - optional MAS + * ? - optional predicate for conditional execution + * c - optional predicate for control transfer + * i - uimm8 in ales[7:0] + * t - uimm8 in ales[8] and als[30:24] + * s - state register + * u - AAU register + * w - wbs for icalld + * a - aad register + * A - aasti register + * l - 32-bit literal + */ +const struct al_format_info al_format_info[ALF_MAX] = +{ +#define U -1 +/* als| ales| pair channel| operands */ +/* ALF1 */ {0x7f000000, 0xffff, {U,U,U,U,U,U}, "D,1,2?"}, +/* ALF1_MERGE */ {0x7f000000, 0xffff, {U,U,U,U,U,U}, "D,1,2,p?"}, +/* ALF1_MAS */ {0x7f000000, 0xffff, {U,U,U,U,U,U}, "D,1,2m?"}, +/* ALF2 */ {0x7fff0000, 0xffff, {1,0,U,4,3,U}, "D,2?"}, +/* ALF2_MOVTD */ {0x7fff0000, 0xffff, {U,U,U,U,U,U}, "D,2?"}, +/* ALF3_MAS */ {0x7f000000, 0xffff, {U,U,5,U,U,2}, "4,1,2m?"}, +/* ALF7 */ {0x7f0000e0, 0xffff, {U,U,U,U,U,U}, "P,1,2?"}, +/* ALF8 */ {0x7fff00e0, 0xffff, {U,U,U,U,U,U}, "P,2?"}, +/* ALF10_MAS */ {0x7f000000, 0xffff, {U,U,5,U,U,2}, "D,a,Alm?"}, +/* ALF11 */ {0x7f000000, 0xffff, {1,0,U,4,3,U}, "D,1,2?"}, +/* ALF11_LIT8 */ {0x7f000000, 0xff00, {U,U,U,U,U,U}, "D,1,2,i?"}, +/* ALF11_MERGE */ {0x7f000000, 0xffff, {U,U,U,U,U,U}, "D,1,2,p?"}, +/* ALF11_MAS */ {0x7f000000, 0xffff, {2,U,0,5,U,3}, "D,1,2m?"}, +/* ALF12 */ {0x7fff0000, 0xffff, {U,U,U,U,U,U}, "D,2?"}, +/* ALF12_IBRANCHD */ {0x7fff0000, 0xffff, {U,U,U,U,U,U}, "D,2c"}, +/* ALF12_ICALLD */ {0x7f000000, 0xffff, {U,U,U,U,U,U}, "D,w,2c"}, +/* ALF12_PSHUFH */ {0x7fff0000, 0xff00, {U,U,U,U,U,U}, "D,2,i?"}, +/* ALF13_MAS */ {0x7f000000, 0xffff, {U,U,5,U,U,2}, "4,1,2m?"}, +/* ALF15 */ {0x7fff0000, 0xffff, {U,U,U,U,U,U}, "S,2?"}, +/* ALF16 */ {0x7f00ff00, 0xffff, {U,U,U,U,U,U}, "D,s?"}, +/* ALF17 */ {0x7f000000, 0xffff, {U,U,U,U,U,U}, "P,1,2?"}, +/* ALF21 */ {0x7f000000, 0xff00, {U,U,U,U,U,U}, "D,1,2,3?"}, +/* ALF21_LT3 */ {0x7f000000, 0xff00, {U,U,U,U,U,U}, "D,1,2,L?"}, +/* ALF21_MERGE */ {0x7f000000, 0xff00, {U,U,U,U,U,U}, "D,1,2,3,p?"}, +/* ALF21_LOG */ {0x00000000, 0xfe00, {U,U,U,U,U,U}, "D,t,1,2,3?"}, +/* ALF21_LOG_LT3 */ {0x00000000, 0xfe00, {U,U,U,U,U,U}, "D,l,1,2,L?"}, +/* ALF22 */ {0x7fff0000, 0xffff, {1,0,U,4,3,U}, "D,2?"}, +/* AAURR */ {0x7f000000, 0xffff, {U,U,5,U,U,2}, "D,u?"}, +/* AAURW */ {0x7f000000, 0xffff, {U,U,5,U,U,2}, "U,4?"}, +#undef U +}; + +#define S GS_S +#define D GS_D +#define X GS_X +#define Q GS_Q +#define P GS_P + +/* MUST be sorted by ales, als. */ +const struct al_opcode al_opcodes[] = +{ +/* instruction | encoding| versions |operands| | additional */ +/* mnemonic | als ales| c0 c1 c2 c3 c4 c5 | sizes| FMT| flags */ +{"andw", 0x00000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"andd", 0x01000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"andnw", 0x02000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"andnd", 0x03000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"orw", 0x04000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"ord", 0x05000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"ornw", 0x06000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"ornd", 0x07000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"xorw", 0x08000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"xord", 0x09000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"xornw", 0x0a000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"xornd", 0x0b000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"sxtb", 0x0cc00000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,0,S,0, ALF2, AF_ALIAS}, +{"sxth", 0x0cc10000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,0,S,0, ALF2, AF_ALIAS}, +{"sxtw", 0x0cc20000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,0,S,0, ALF2, AF_ALIAS}, +{"zxtb", 0x0cc40000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,0,S,0, ALF2, AF_ALIAS}, +{"zxth", 0x0cc50000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,0,S,0, ALF2, AF_ALIAS}, +{"zxtw", 0x0cc60000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,0,S,0, ALF2, AF_ALIAS}, +{"sxt", 0x0c000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,S,S,0, ALF1, 0}, +{"mergew", 0x0e000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1_MERGE, 0}, +{"merged", 0x0f000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1_MERGE, 0}, +{"addw", 0x10000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"addd", 0x11000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"negw", 0x12c00000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF2, AF_ALIAS}, +{"subs", 0x12000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"negd", 0x13c00000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF2, AF_ALIAS}, +{"subd", 0x13000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"sclw", 0x14000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"scld", 0x15000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"scrw", 0x16000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"scrd", 0x17000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"shlw", 0x18000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"shld", 0x19000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"shrw", 0x1a000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"shrd", 0x1b000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"sarw", 0x1c000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"sard", 0x1d000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"getfw", 0x1e000000, 0x0000, { 1, 1, 1, 1, 1, 1}, S,S,S,0, ALF1, 0}, +{"getfd", 0x1f000000, 0x0000, { 1, 1, 1, 1, 1, 1}, D,D,D,0, ALF1, 0}, +{"cmpowb", 0x20000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpbwb", 0x20000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpewb", 0x20000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpbewb", 0x20000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpswb", 0x20000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmppwb", 0x200000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmplwb", 0x200000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmplewb", 0x200000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpodb", 0x21000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpbdb", 0x21000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpedb", 0x21000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpbedb", 0x21000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpsdb", 0x21000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmppdb", 0x210000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpldb", 0x210000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpledb", 0x210000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpandewb", 0x22000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpandswb", 0x22000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpandpwb", 0x220000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpandlewb", 0x220000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"cmpandedb", 0x23000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpandsdb", 0x23000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpandpdb", 0x230000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cmpandledb", 0x230000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"cctopo", 0x24c00000, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"stb", 0x24000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,D,D,0, ALF3_MAS, 0}, +{"cctopb", 0x24c00020, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"cctope", 0x24c00040, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"cctopbe", 0x24c00060, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"cctops", 0x24c00080, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"cctopp", 0x24c000a0, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"cctopl", 0x24c000c0, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"cctople", 0x24c000e0, 0x0000, { 1, 0, 0, 1, 0, 0}, 0,0,S,0, ALF8, 0}, +{"sth", 0x25000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,D,D,0, ALF3_MAS, 0}, +{"stw", 0x26000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,D,D,0, ALF3_MAS, 0}, +{"bitrevw", 0x26c00000, 0x0000, { 2, 2, 0, 2, 2, 0}, S,0,S,0, ALF2, 0}, +{"std", 0x27000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,D,D,0, ALF3_MAS, 0}, +{"bitrevd", 0x27c00000, 0x0000, { 2, 2, 0, 2, 2, 0}, D,0,D,0, ALF2, 0}, +{"fxcmpeqsb", 0x28000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"stcsb", 0x28000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fxcmpltsb", 0x28000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmplesb", 0x28000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmpuodsb", 0x28000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmpneqsb", 0x28000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmpnltsb", 0x280000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmpnlesb", 0x280000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmpodsb", 0x280000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,S,0, ALF7, 0}, +{"fxcmpeqdb", 0x29000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"stcsh", 0x29000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fxcmpltdb", 0x29000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"fxcmpledb", 0x29000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"fxcmpuoddb", 0x29000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"fxcmpneqdb", 0x29000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"fxcmpnltdb", 0x290000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"fxcmpnledb", 0x290000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"fxcmpoddb", 0x290000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,D,0, ALF7, 0}, +{"stcsw", 0x2a000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fxcmpeqxb", 0x2b000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"stcsd", 0x2b000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF3_MAS, 0}, +{"fxcmpltxb", 0x2b000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"fxcmplexb", 0x2b000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"fxcmpuodxb", 0x2b000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"fxcmpneqxb", 0x2b000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"fxcmpnltxb", 0x2b0000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"fxcmpnlexb", 0x2b0000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"fxcmpodxb", 0x2b0000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,X,X,0, ALF7, 0}, +{"stdsb", 0x2c000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"stdsh", 0x2d000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fcmpeqsb", 0x2e000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"stdsw", 0x2e000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fcmpltsb", 0x2e000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmplesb", 0x2e000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmpuodsb", 0x2e000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmpneqsb", 0x2e000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmpnltsb", 0x2e0000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmpnlesb", 0x2e0000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmpodsb", 0x2e0000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,S,S,0, ALF7, 0}, +{"fcmpeqdb", 0x2f000000, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"stdsd", 0x2f000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF3_MAS, 0}, +{"fcmpltdb", 0x2f000020, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fcmpledb", 0x2f000040, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fcmpuoddb", 0x2f000060, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fcmpneqdb", 0x2f000080, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fcmpnltdb", 0x2f0000a0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fcmpnledb", 0x2f0000c0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fcmpoddb", 0x2f0000e0, 0x0000, { 1, 1, 0, 1, 1, 0}, 0,D,D,0, ALF7, 0}, +{"fadds", 0x30000000, 0x0000, { 1, 1, 4, 1, 1, 4}, S,S,S,0, ALF1, AF_EXPLICIT_ALES25}, +{"stesb", 0x30000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"faddd", 0x31000000, 0x0000, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF1, AF_EXPLICIT_ALES25}, +{"stesh", 0x31000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fsubs", 0x32000000, 0x0000, { 1, 1, 4, 1, 1, 4}, S,S,S,0, ALF1, AF_EXPLICIT_ALES25}, +{"stesw", 0x32000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fsubd", 0x33000000, 0x0000, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF1, AF_EXPLICIT_ALES25}, +{"stesd", 0x33000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF3_MAS, 0}, +{"fmins", 0x34000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF1, 0}, +{"stfsb", 0x34000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fmind", 0x35000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF1, 0}, +{"stfsh", 0x35000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fmaxs", 0x36000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF1, 0}, +{"stfsw", 0x36000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fmaxd", 0x37000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF1, 0}, +{"stfsd", 0x37000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF3_MAS, 0}, +{"fmuls", 0x38000000, 0x0000, { 1, 1, 4, 1, 1, 4}, S,S,S,0, ALF1, AF_EXPLICIT_ALES25}, +{"stgsb", 0x38000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fmuld", 0x39000000, 0x0000, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF1, AF_EXPLICIT_ALES25}, +{"stgsh", 0x39000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"stgsw", 0x3a000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"stgsd", 0x3b000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF3_MAS, 0}, +{"stssb", 0x3c000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fstoiw", 0x3cc00000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"fstoiwtr", 0x3cc20000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"iwtofs", 0x3cc40000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"stssh", 0x3d000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fdtoid", 0x3dc00000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2, 0}, +{"fxtoid", 0x3dc10000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,X,0, ALF2, 0}, +{"fdtoidtr", 0x3dc20000, 0x0000, { 2, 2, 0, 2, 2, 0}, D,0,D,0, ALF2, 0}, +{"fxtoidtr", 0x3dc30000, 0x0000, { 2, 2, 0, 2, 2, 0}, D,0,X,0, ALF2, 0}, +{"idtofd", 0x3dc40000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2, 0}, +{"idtofx", 0x3dc50000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,0,D,0, ALF2, 0}, +{"fxtofd", 0x3dc60000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,X,0, ALF2, 0}, +{"fdtofx", 0x3dc70000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,0,D,0, ALF2, 0}, +{"pfstoiw", 0x3dc80000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2, 0}, +{"pfstoiwtr", 0x3dca0000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2, 0}, +{"piwtofs", 0x3dcc0000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2, 0}, +{"stssw", 0x3e000000, 0x0000, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF3_MAS, 0}, +{"fstoid", 0x3ec00000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,S,0, ALF2, 0}, +{"fstoidtr", 0x3ec20000, 0x0000, { 2, 2, 0, 2, 2, 0}, D,0,S,0, ALF2, 0}, +{"iwtofd", 0x3ec40000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,S,0, ALF2, 0}, +{"iwtofx", 0x3ec50000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,0,S,0, ALF2, 0}, +{"fstofd", 0x3ec60000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,S,0, ALF2, 0}, +{"fstofx", 0x3ec70000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,0,S,0, ALF2, 0}, +{"pfstofd", 0x3ece0000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,S,0, ALF2, 0}, +{"stssd", 0x3f000000, 0x0000, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF3_MAS, 0}, +{"fdtoiw", 0x3fc00000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"fxtoiw", 0x3fc10000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,X,0, ALF2, 0}, +{"fdtoiwtr", 0x3fc20000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"fxtoiwtr", 0x3fc30000, 0x0000, { 2, 2, 0, 2, 2, 0}, S,0,X,0, ALF2, 0}, +{"idtofs", 0x3fc40000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"fdtofs", 0x3fc60000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"fxtofs", 0x3fc70000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,X,0, ALF2, 0}, +{"pfdtoiw", 0x3fc80000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"pfdtoiwtr", 0x3fca0000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"pfdtofs", 0x3fce0000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,D,0, ALF2, 0}, +{"fxaddss", 0x40000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,S,0, ALF1, 0}, +{"udivw", 0x40000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,S,S,0, ALF1, 0}, +{"fxadddd", 0x41000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,D,0, ALF1, 0}, +{"udivd", 0x41000000, 0x0000, { 0, 0, 0, 0, 0, 1}, D,D,D,0, ALF1, 0}, +{"fxaddsx", 0x42000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,S,0, ALF1, 0}, +{"sdivw", 0x42000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,S,S,0, ALF1, 0}, +{"fxadddx", 0x43000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,D,0, ALF1, 0}, +{"sdivd", 0x43000000, 0x0000, { 0, 0, 0, 0, 0, 1}, D,D,D,0, ALF1, 0}, +{"fxaddxs", 0x44000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF1, 0}, +{"udivx", 0x44000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,D,S,0, ALF1, 0}, +{"fxaddxd", 0x45000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,X,0, ALF1, 0}, +{"umodx", 0x45000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,D,S,0, ALF1, 0}, +{"sdivx", 0x46000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,D,S,0, ALF1, 0}, +{"fxaddxx", 0x47000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,X,0, ALF1, 0}, +{"smodx", 0x47000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,D,S,0, ALF1, 0}, +{"fxdivss", 0x48000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,X,S,0, ALF1, 0}, +{"fxsubss", 0x48000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,S,0, ALF1, 0}, +{"fxdivdd", 0x49000000, 0x0000, { 0, 0, 0, 0, 0, 1}, D,X,D,0, ALF1, 0}, +{"fxsubdd", 0x49000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,D,0, ALF1, 0}, +{"fxdivsx", 0x4a000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,S,0, ALF1, 0}, +{"fxsubsx", 0x4a000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,S,0, ALF1, 0}, +{"fxdivdx", 0x4b000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,D,0, ALF1, 0}, +{"fxsubdx", 0x4b000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,D,0, ALF1, 0}, +{"fxdivxs", 0x4c000000, 0x0000, { 0, 0, 0, 0, 0, 1}, S,X,X,0, ALF1, 0}, +{"fxsubxs", 0x4c000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF1, 0}, +{"fxdivxd", 0x4d000000, 0x0000, { 0, 0, 0, 0, 0, 1}, D,X,X,0, ALF1, 0}, +{"fxsubxd", 0x4d000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,X,0, ALF1, 0}, +{"fxdivxx", 0x4f000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,X,0, ALF1, 0}, +{"fxsubxx", 0x4f000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,X,0, ALF1, 0}, +{"fxmulss", 0x50000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,S,0, ALF1, 0}, +{"fxmuldd", 0x51000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,D,0, ALF1, 0}, +{"fxmulsx", 0x52000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,S,0, ALF1, 0}, +{"fxsqrtisx", 0x52c00000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,0,S,0, ALF2, 0}, +{"fxmuldx", 0x53000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,D,0, ALF1, 0}, +{"fxsqrtidx", 0x53c00000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,0,D,0, ALF2, 0}, +{"fxmulxs", 0x54000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF1, 0}, +{"fxmulxd", 0x55000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,X,0, ALF1, 0}, +{"fxmulxx", 0x57000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,X,0, ALF1, 0}, +{"fxsqrtixx", 0x57c00000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,0,X,0, ALF2, 0}, +{"fxrsubss", 0x58000000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,X,S,0, ALF1, 0}, +{"fxrsubdd", 0x59000000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,X,D,0, ALF1, 0}, +{"fxsqrtuxx", 0x59000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,X,0, ALF1, 0}, +{"fxrsubsx", 0x5a000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,S,0, ALF1, 0}, +{"fxsqrtusx", 0x5a000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,S,0, ALF1, 0}, +{"fxrsubdx", 0x5b000000, 0x0000, { 1, 1, 0, 1, 1, 0}, X,X,D,0, ALF1, 0}, +{"fxsqrtudx", 0x5b000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,D,0, ALF1, 0}, +{"movfi", 0x5cc00000, 0x0000, { 2, 1, 0, 2, 1, 0}, S,0,X,0, ALF2, 0}, +{"fxsqrttxx", 0x5d000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,X,0, ALF1, 0}, +{"fxsqrttsx", 0x5e000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,S,0, ALF1, 0}, +{"movif", 0x5e000000, 0x0000, { 2, 1, 0, 2, 1, 0}, X,D,S,0, ALF1, 0}, +{"fxsqrttdx", 0x5f000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,D,0, ALF1, 0}, +{"movx", 0x5fc00000, 0x0000, { 2, 2, 0, 2, 2, 0}, X,0,X,0, ALF2, 0}, +{"movxa", 0x5fc10000, 0x0000, { 2, 2, 0, 2, 2, 0}, X,0,X,0, ALF2, 0}, +{"movxc", 0x5fc20000, 0x0000, { 2, 2, 0, 2, 2, 0}, X,0,X,0, ALF2, 0}, +{"fxdivtss", 0x60000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,S,S,0, ALF1, 0}, +{"movts", 0x60c00000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"movtcs", 0x60c10000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"movtrs", 0x60c20000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"movtrcs", 0x60c30000, 0x0000, { 1, 1, 0, 1, 1, 0}, S,0,S,0, ALF2, 0}, +{"fxdivtdd", 0x61000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,D,D,0, ALF1, 0}, +{"movtd", 0x61c00000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2_MOVTD, 0}, +{"movtcd", 0x61c10000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2_MOVTD, 0}, +{"movtrd", 0x61c20000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2_MOVTD, 0}, +{"movtrcd", 0x61c30000, 0x0000, { 1, 1, 0, 1, 1, 0}, D,0,D,0, ALF2_MOVTD, 0}, +{"fxdivtsx", 0x62000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,S,0, ALF1, 0}, +{"getsap", 0x62ec0000, 0x0000, { 1, 1, 0, 0, 0, 0}, Q,0,S,0, ALF2, AF_PAIR}, +{"cudtoap", 0x62f00000, 0x0000, { 1, 1, 0, 1, 1, 0}, Q,0,S,0, ALF2, AF_PAIR}, +{"gdtoap", 0x62f20000, 0x0000, { 1, 1, 0, 1, 1, 0}, Q,0,S,0, ALF2, AF_PAIR}, +{"fxdivtdx", 0x63000000, 0x0000, { 0, 0, 0, 0, 0, 1}, X,X,D,0, ALF1, 0}, +{"vfsi", 0x63000000, 0x0000, { 0, 1, 0, 0, 1, 0}, D,S,D,0, ALF1, 0}, +{"getpl", 0x63f00000, 0x0000, { 1, 0, 0, 1, 0, 0}, D,0,S,0, ALF2, 0}, +{"ldb", 0x64000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,D,D,0, ALF1_MAS, 0}, +{"lzcnts", 0x64c00000, 0x0000, { 0, 2, 0, 0, 2, 0}, S,0,S,0, ALF2, 0}, +{"ldh", 0x65000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,D,D,0, ALF1_MAS, 0}, +{"lzcntd", 0x65c00000, 0x0000, { 0, 2, 0, 0, 2, 0}, D,0,D,0, ALF2, 0}, +{"ldw", 0x66000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,D,D,0, ALF1_MAS, 0}, +{"popcnts", 0x66c00000, 0x0000, { 0, 2, 0, 0, 2, 0}, S,0,S,0, ALF2, 0}, +{"ldd", 0x67000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,D,D,0, ALF1_MAS, 0}, +{"popcntd", 0x67c00000, 0x0000, { 0, 2, 0, 0, 2, 0}, D,0,D,0, ALF2, 0}, +{"ldcsb", 0x68000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"vfbgv", 0x68000000, 0x0000, { 0, 6, 0, 0, 6, 0}, S,S,S,0, ALF1, 0}, +{"ldcsh", 0x69000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"modbgv", 0x69c00000, 0x0000, { 0, 6, 0, 0, 6, 0}, S,0,S,0, ALF2, 0}, +{"ldcsw", 0x6a000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"mkfsw", 0x6a000000, 0x0000, { 0, 6, 0, 0, 6, 0}, D,S,S,0, ALF1, 0}, +{"ldcsd", 0x6b000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"lddsb", 0x6c000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"lddsh", 0x6d000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"lddsw", 0x6e000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"lddsd", 0x6f000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldesb", 0x70000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldesh", 0x71000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldesw", 0x72000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldesd", 0x73000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldfsb", 0x74000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldfsh", 0x75000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldfsw", 0x76000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldfsd", 0x77000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldgsb", 0x78000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldgsh", 0x79000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldgsw", 0x7a000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldgsd", 0x7b000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldssb", 0x7c000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldssh", 0x7d000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldssw", 0x7e000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"ldssd", 0x7f000000, 0x0000, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF1_MAS, 0}, +{"pminub", 0x00000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"punpckhbh", 0x00000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"pminsh", 0x01000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"punpcklbh", 0x01000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stq", 0x01000000, 0x01c0, { 0, 0, 5, 0, 0, 5}, Q,D,D,0, ALF13_MAS, AF_PAIR}, +{"pmaxub", 0x02000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"punpckhhw", 0x02000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stcsq", 0x02000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"pmaxsh", 0x03000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"punpcklhw", 0x03000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stdsq", 0x03000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"pminsb", 0x04000000, 0x01c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"punpckhwd", 0x04000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stesq", 0x04000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"pminuh", 0x05000000, 0x01c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"punpcklwd", 0x05000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stfsq", 0x05000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"pmaxsb", 0x06000000, 0x01c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmovmskps", 0x06000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stgsq", 0x06000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"pmaxuh", 0x07000000, 0x01c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmovmskpd", 0x07000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"stssq", 0x07000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"packsshb", 0x08000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"paddb", 0x08000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"gettags", 0x08c00000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,S,0, ALF12, 0}, +{"packushb", 0x09000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"paddh", 0x09000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"gettagd", 0x09c00000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,D,0, ALF12, 0}, +{"packsswh", 0x0a000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"paddsb", 0x0a000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"puttags", 0x0a000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF11_MAS, 0}, +{"paddsh", 0x0b000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmovmskb", 0x0b000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"puttagd", 0x0b000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,D,S,0, ALF11_MAS, 0}, +{"psrlqh", 0x0c000000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11_LIT8, 0}, +{"paddusb", 0x0c000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psrlql", 0x0d000000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11_LIT8, 0}, +{"paddush", 0x0d000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psllqh", 0x0e000000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11_LIT8, 0}, +{"paddw", 0x0e000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psllql", 0x0f000000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11_LIT8, 0}, +{"paddd", 0x0f000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psrlw", 0x10000000, 0x01c0, { 3, 1, 0, 3, 1, 0}, D,D,D,0, ALF11, AF_ALT_ALES03}, +{"psubb", 0x10000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psrlh", 0x11000000, 0x01c0, { 3, 1, 0, 3, 1, 0}, D,D,D,0, ALF11, AF_ALT_ALES03}, +{"psubh", 0x11000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psraw", 0x12000000, 0x01c0, { 3, 1, 0, 3, 1, 0}, D,D,D,0, ALF11, AF_ALT_ALES03}, +{"psubsb", 0x12000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psrah", 0x13000000, 0x01c0, { 3, 1, 0, 3, 1, 0}, D,D,D,0, ALF11, AF_ALT_ALES03}, +{"psubsh", 0x13000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psllw", 0x14000000, 0x01c0, { 3, 1, 0, 3, 1, 0}, D,D,D,0, ALF11, AF_ALT_ALES03}, +{"psubusb", 0x14000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psllh", 0x15000000, 0x01c0, { 3, 1, 0, 3, 1, 0}, D,D,D,0, ALF11, AF_ALT_ALES03}, +{"psubush", 0x15000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pshufw", 0x16000000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11_LIT8, 0}, +{"psubw", 0x16000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psubd", 0x17000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pshufh", 0x17c00000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,0,D,0, ALF12_PSHUFH, 0}, +{"pcmpeqb", 0x18000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmulhh", 0x18000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"pcmpeqh", 0x19000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmullh", 0x19000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"pcmpeqw", 0x1a000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmaddh", 0x1a000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"pcmpgtb", 0x1b000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmulhuh", 0x1b000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"strd", 0x1b000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,D,D,0, ALF13_MAS, 0}, +{"staab", 0x1c000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,0,0, ALF10_MAS, 0}, +{"pcmpgth", 0x1c000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"psadbw", 0x1c000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"staah", 0x1d000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,0,0, ALF10_MAS, 0}, +{"pcmpgtw", 0x1d000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"pmulubhh", 0x1d000000, 0x01c0, { 0, 2, 0, 0, 2, 0}, D,D,D,0, ALF11, 0}, +{"aaurww", 0x1e000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,0,0, AAURW, 0}, +{"staaw", 0x1e000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,0,0, ALF10_MAS, 0}, +{"pextrh", 0x1e000000, 0x0100, { 0, 1, 0, 0, 1, 0}, S,D,D,0, ALF11_LIT8, 0}, +{"pavgusb", 0x1e000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"aaurwd", 0x1f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,0,0,0, AAURW, 0}, +{"staad", 0x1f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,0,0,0, ALF10_MAS, 0}, +{"pinsh", 0x1f000000, 0x0100, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11_LIT8, 0}, +{"pavgush", 0x1f000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,D,D,0, ALF11, 0}, +{"mulw", 0x20000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"muld", 0x21000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"umulx", 0x22000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,S,S,0, ALF11, 0}, +{"smulx", 0x23000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,S,S,0, ALF11, 0}, +{"fscales", 0x24000000, 0x01c0, { 0, 4, 0, 0, 4, 0}, S,S,S,0, ALF11, 0}, +{"stgdb", 0x24000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF13_MAS, 0}, +{"gettc", 0x24c00000, 0x01c0, { 1, 0, 0, 0, 0, 0}, D,0,S,0, ALF12, 0}, +{"fscaled", 0x25000000, 0x01c0, { 0, 4, 0, 0, 4, 0}, D,S,D,0, ALF11, 0}, +{"puttc", 0x25000000, 0x01c0, { 1, 0, 0, 0, 0, 0}, D,D,D,0, ALF11, 0}, +{"stgdh", 0x25000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF13_MAS, 0}, +{"puttst", 0x25c00000, 0x01c0, { 0, 0, 0, 3, 0, 0}, D,0,D,0, ALF12, 0}, +{"pmullw", 0x26000000, 0x01c0, { 0, 5, 0, 0, 5, 0}, D,D,D,0, ALF11, 0}, +{"stgdw", 0x26000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,S,S,0, ALF13_MAS, 0}, +{"invtc", 0x26c00000, 0x01c0, { 1, 0, 0, 0, 0, 0}, D,0,S,0, ALF12, 0}, +{"qpmgme", 0x27000000, 0x0100, { 7, 0, 0, 0, 0, 0}, P,P,P,P, ALF21, 0}, +{"fxscalesx", 0x27000000, 0x01c0, { 0, 4, 0, 0, 4, 0}, X,X,S,0, ALF11, 0}, +{"stgdd", 0x27000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,S,S,0, ALF13_MAS, 0}, +{"stapb", 0x28000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, 0}, +{"fxcmpudsf", 0x28000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF11, 0}, +{"fxcmpodsf", 0x28000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF11, 0}, +{"staph", 0x29000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, 0}, +{"fxcmpuddf", 0x29000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF11, 0}, +{"fxcmpoddf", 0x29000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF11, 0}, +{"stapw", 0x2a000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, 0}, +{"stapd", 0x2b000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,Q,S,0, ALF13_MAS, 0}, +{"fxcmpudxf", 0x2b000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF11, 0}, +{"fxcmpodxf", 0x2b000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, S,X,X,0, ALF11, 0}, +{"fcmpeqs", 0x2c000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"stodrb", 0x2c000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"fcmplts", 0x2c000000, 0x01c1, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmples", 0x2c000000, 0x01c2, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpuods", 0x2c000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpneqs", 0x2c000000, 0x01c4, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpnlts", 0x2c000000, 0x01c5, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpnles", 0x2c000000, 0x01c6, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpods", 0x2c000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpeqd", 0x2d000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodrh", 0x2d000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"fcmpltd", 0x2d000000, 0x01c1, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fcmpled", 0x2d000000, 0x01c2, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fcmpuodd", 0x2d000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fcmpneqd", 0x2d000000, 0x01c4, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fcmpnltd", 0x2d000000, 0x01c5, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fcmpnled", 0x2d000000, 0x01c6, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fcmpodd", 0x2d000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodrw", 0x2e000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"fcmpudsf", 0x2e000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"fcmpodsf", 0x2e000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, S,S,S,0, ALF11, 0}, +{"stodrd", 0x2f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"fcmpuddf", 0x2f000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, S,D,D,0, ALF11, 0}, +{"fcmpoddf", 0x2f000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, S,D,D,0, ALF11, 0}, +{"pfadds", 0x30000000, 0x01c0, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF11, 0}, +{"stodwb", 0x30000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfaddd", 0x31000000, 0x01c0, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF11, 0}, +{"stodwh", 0x31000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfsubs", 0x32000000, 0x01c0, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF11, 0}, +{"stodww", 0x32000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfsubd", 0x33000000, 0x01c0, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF11, 0}, +{"stodwd", 0x33000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfmins", 0x34000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodpb", 0x34000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfmind", 0x35000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodph", 0x35000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfmaxs", 0x36000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodpw", 0x36000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfmaxd", 0x37000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodpd", 0x37000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,Q,S,0, ALF13_MAS, AF_REMOVED_IN_V3}, +{"pfmuls", 0x38000000, 0x01c0, { 1, 1, 4, 1, 1, 4}, D,D,D,0, ALF11, 0}, +{"pfmuld", 0x39000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stgdq", 0x39000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,S,S,0, ALF13_MAS, AF_PAIR}, +{"pfcmpeqs", 0x3a000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stapq", 0x3a000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,Q,S,0, ALF13_MAS, AF_PAIR}, +{"pfcmplts", 0x3a000000, 0x01c1, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmples", 0x3a000000, 0x01c2, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpuods", 0x3a000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpneqs", 0x3a000000, 0x01c4, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpnlts", 0x3a000000, 0x01c5, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpnles", 0x3a000000, 0x01c6, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpods", 0x3a000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpeqd", 0x3b000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodrq", 0x3b000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,Q,S,0, ALF13_MAS, AF_PAIR | AF_REMOVED_IN_V3}, +{"pfcmpltd", 0x3b000000, 0x01c1, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpled", 0x3b000000, 0x01c2, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpuodd", 0x3b000000, 0x01c3, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpneqd", 0x3b000000, 0x01c4, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpnltd", 0x3b000000, 0x01c5, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpnled", 0x3b000000, 0x01c6, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfcmpodd", 0x3b000000, 0x01c7, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"stodwq", 0x3c000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,Q,S,0, ALF13_MAS, AF_PAIR | AF_REMOVED_IN_V3}, +{"rww", 0x3cc00000, 0x01c0, { 1, 0, 0, 0, 0, 0}, 0,0,S,0, ALF15, 0}, +{"stodpq", 0x3d000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,Q,S,0, ALF13_MAS, AF_PAIR | AF_REMOVED_IN_V3}, +{"rwd", 0x3dc00000, 0x01c0, { 1, 0, 0, 0, 0, 0}, 0,0,D,0, ALF15, 0}, +{"rrs", 0x3e00c000, 0x01c0, { 1, 0, 0, 0, 0, 0}, S,0,0,0, ALF16, 0}, +{"aaurwq", 0x3f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,0,0,0, AAURW, AF_PAIR}, +{"staaq", 0x3f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,0,0,0, ALF10_MAS, AF_PAIR}, +{"rrd", 0x3f00c000, 0x01c0, { 1, 0, 0, 0, 0, 0}, D,0,0,0, ALF16, 0}, +{"pmrgp", 0x40000000, 0x01c0, { 6, 6, 0, 6, 6, 0}, D,D,D,0, ALF11_MERGE, 0}, +{"ldq", 0x41000000, 0x01c0, { 5, 0, 5, 5, 0, 5}, Q,D,D,0, ALF11_MAS, AF_PAIR}, +{"ldfsq", 0x45000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,D,D,0, ALF11_MAS, AF_PAIR}, +{"ldgsq", 0x46000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,D,D,0, ALF11_MAS, AF_PAIR}, +{"ldssq", 0x47000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,D,D,0, ALF11_MAS, AF_PAIR}, +{"fdivs", 0x48000000, 0x01c0, { 0, 0, 0, 0, 0, 1}, S,S,S,0, ALF11, 0}, +{"pandd", 0x48000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"fdivd", 0x49000000, 0x01c0, { 0, 0, 0, 0, 0, 1}, D,D,D,0, ALF11, 0}, +{"pandnd", 0x49000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfdivs", 0x4a000000, 0x01c0, { 0, 0, 0, 0, 0, 1}, S,S,S,0, ALF11, 0}, +{"pord", 0x4a000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfdivd", 0x4b000000, 0x01c0, { 0, 0, 0, 0, 0, 1}, D,D,D,0, ALF11, 0}, +{"pxord", 0x4b000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, 0}, +{"psrld", 0x4c000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"fsqrts", 0x4cc00000, 0x01c0, { 0, 0, 0, 0, 0, 1}, S,0,S,0, ALF12, 0}, +{"pcmpeqd", 0x4d000000, 0x01c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"fsqrtid", 0x4dc00000, 0x01c0, { 0, 0, 0, 0, 0, 1}, D,0,D,0, ALF12, 0}, +{"pslld", 0x4e000000, 0x01c0, { 0, 1, 0, 0, 1, 0}, D,D,D,0, ALF11, 0}, +{"pfsqrts", 0x4ec00000, 0x01c0, { 0, 0, 0, 0, 0, 1}, S,0,S,0, ALF12, 0}, +{"pcmpgtd", 0x4f000000, 0x01c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"aptoap", 0x50000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,Q,S,0, ALF11, AF_PAIR}, +{"frcps", 0x50c00000, 0x01c0, { 0, 0, 0, 0, 0, 1}, S,0,S,0, ALF12, 0}, +{"fsqrttd", 0x51000000, 0x01c0, { 0, 0, 0, 0, 0, 1}, D,D,D,0, ALF11, 0}, +{"getva", 0x52000000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,Q,S,0, ALF11, 0}, +{"pfsqrttd", 0x53000000, 0x01c0, { 0, 0, 0, 0, 0, 1}, D,D,D,0, ALF11, 0}, +{"tdtomp", 0x53000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, D,D,D,0, ALF11, AF_REMOVED_IN_V3}, +{"ibranchd", 0x53c00000, 0x01c0, { 6, 0, 0, 0, 0, 0}, D,0,D,0, ALF12_IBRANCHD, 0}, +{"odtoap", 0x54000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,Q,D,0, ALF11, AF_REMOVED_IN_V3}, +{"frsqrts", 0x54c00000, 0x01c0, { 0, 0, 0, 0, 0, 1}, S,0,S,0, ALF12, 0}, +{"icalld", 0x54000000, 0x01c0, { 6, 0, 0, 0, 0, 0}, D,0,D,0, ALF12_ICALLD, 0}, +{"cast", 0x55000000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,Q,Q,0, ALF11, AF_REMOVED_IN_V3}, +{"gettd", 0x56c00000, 0x01c0, { 1, 0, 0, 1, 0, 0}, D,0,D,0, ALF12, AF_REMOVED_IN_V3}, +{"movtq", 0x57c00000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,0,Q,0, ALF22, AF_PAIR}, +{"movtcq", 0x57c10000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,0,Q,0, ALF22, AF_PAIR}, +{"movtrq", 0x57c20000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,0,Q,0, ALF22, AF_PAIR}, +{"movtrcq", 0x57c30000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,0,Q,0, ALF22, AF_PAIR}, +{"mpsadbh", 0x58000000, 0x01c0, { 0, 3, 0, 0, 3, 0}, D,D,D,0, ALF11, 0}, +{"getsp", 0x58ec0000, 0x01c0, { 1, 0, 0, 0, 0, 0}, D,0,S,0, ALF12, 0}, +{"getsod", 0x5aec0000, 0x01c0, { 1, 1, 0, 1, 1, 0}, Q,0,Q,0, ALF12, AF_REMOVED_IN_V3}, +{"ldrd", 0x5b000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,D,D,0, ALF11, 0}, +{"aaurrw", 0x5e000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, S,0,0,0, AAURR, 0}, +{"aaurrd", 0x5f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, D,0,0,0, AAURR, 0}, +{"addcd", 0x60000000, 0x0100, { 0, 5, 0, 0, 5, 0}, D,D,D,S, ALF21, 0}, +{"ldcudb", 0x60000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"addcd_c", 0x61000000, 0x0100, { 0, 5, 0, 0, 5, 0}, D,D,D,S, ALF21, 0}, +{"ldcudh", 0x61000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"subcd", 0x62000000, 0x0100, { 0, 5, 0, 0, 5, 0}, D,D,D,S, ALF21, 0}, +{"ldcudw", 0x62000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"subcd_c", 0x63000000, 0x0100, { 0, 5, 0, 0, 5, 0}, D,D,D,S, ALF21, 0}, +{"ldcudd", 0x63000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"ldgdb", 0x64000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"ldgdh", 0x65000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"ldgdw", 0x66000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"ldgdd", 0x67000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,S,S,0, ALF11_MAS, 0}, +{"ldapb", 0x68000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, 0}, +{"pmaddubsh", 0x68000000, 0x01c0, { 0, 3, 0, 0, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldaph", 0x69000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, 0}, +{"pmulhrsh", 0x69000000, 0x01c0, { 0, 3, 0, 0, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldapw", 0x6a000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, 0}, +{"phminposuh", 0x6a000000, 0x01c0, { 0, 3, 0, 0, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldapd", 0x6b000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, 0}, +{"packuswh", 0x6b000000, 0x01c0, { 0, 3, 0, 0, 3, 0}, D,D,D,0, ALF11, 0}, +{"fstoifs", 0x6c000000, 0x01c0, { 3, 3, 0, 3, 3, 0}, S,S,S,0, ALF11, 0}, +{"ldodrb", 0x6c000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"fdtoifd", 0x6d000000, 0x01c0, { 3, 3, 0, 3, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldodrh", 0x6d000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"ldodrw", 0x6e000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"pfstoifs", 0x6e000000, 0x01c0, { 3, 3, 0, 3, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldodrd", 0x6f000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"pfdtoifd", 0x6f000000, 0x01c0, { 3, 3, 0, 3, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldodwb", 0x70000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"umulhd", 0x70000000, 0x01c0, { 3, 3, 0, 3, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldodwh", 0x71000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"smulhd", 0x71000000, 0x01c0, { 3, 3, 0, 3, 3, 0}, D,D,D,0, ALF11, 0}, +{"ldodww", 0x72000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"pfhadds", 0x72000000, 0x01c0, { 3, 3, 4, 3, 3, 4}, D,D,D,0, ALF11, 0}, +{"ldodwd", 0x73000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"pfhsubs", 0x73000000, 0x01c0, { 3, 3, 4, 3, 3, 4}, D,D,D,0, ALF11, 0}, +{"getfzs", 0x74000000, 0x01c0, { 5, 5, 5, 5, 5, 5}, S,S,S,0, ALF11, 0}, +{"ldodpb", 0x74000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"getfzd", 0x75000000, 0x01c0, { 5, 5, 5, 5, 5, 5}, D,D,D,0, ALF11, 0}, +{"ldodph", 0x75000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"ldodpw", 0x76000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"ldodpd", 0x77000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, D,Q,S,0, ALF11_MAS, AF_REMOVED_IN_V3}, +{"pfaddsubs", 0x77000000, 0x01c0, { 3, 3, 4, 3, 3, 4}, D,D,D,0, ALF11, 0}, +{"ldcudq", 0x78000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,S,S,0, ALF11_MAS, AF_PAIR}, +{"ldgdq", 0x79000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,S,S,0, ALF11_MAS, AF_PAIR}, +{"ldapq", 0x7a000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,Q,S,0, ALF11_MAS, AF_PAIR}, +{"ldodrq", 0x7b000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,Q,S,0, ALF11_MAS, AF_PAIR | AF_REMOVED_IN_V3}, +{"ldodwq", 0x7c000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,Q,S,0, ALF11_MAS, AF_PAIR | AF_REMOVED_IN_V3}, +{"ldodpq", 0x7d000000, 0x01c0, { 1, 0, 1, 1, 0, 1}, Q,Q,S,0, ALF11_MAS, AF_PAIR | AF_REMOVED_IN_V3}, +{"aaurrq", 0x7f000000, 0x01c0, { 0, 0, 1, 0, 0, 1}, Q,0,0,0, AAURR, AF_PAIR}, +{"qpsrlw", 0x00000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpsrlh", 0x01000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpsraw", 0x02000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpsrah", 0x03000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpsllw", 0x04000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpsllh", 0x05000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpsrld", 0x06000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpslld", 0x07000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,D,0, ALF11, 0}, +{"qpand", 0x08000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpandn", 0x09000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpor", 0x0a000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpxor", 0x0b000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpminuw", 0x0c000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpminsw", 0x0d000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaxuw", 0x0e000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaxsw", 0x0f000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"stmqp", 0x11000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"stcsmqp", 0x12000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"stdsmqp", 0x13000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"stesmqp", 0x14000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"stfsmqp", 0x15000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"psrcw", 0x16000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, D,D,D,0, ALF11, 0}, +{"stgsmqp", 0x16000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"psrcd", 0x17000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, D,D,D,0, ALF11, 0}, +{"stssmqp", 0x17000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"qpcmpeqd", 0x18000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qphaddh", 0x19000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"stgdmqp", 0x19000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,S,S,0, ALF13_MAS, 0}, +{"qphaddw", 0x1a000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"stapmqp", 0x1a000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,Q,S,0, ALF13_MAS, 0}, +{"qphaddsh", 0x1b000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpgtd", 0x1c000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qphsubh", 0x1d000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qphsubw", 0x1e000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qphsubsh", 0x1f000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"pminuw", 0x20000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"staaqp", 0x20000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,0,0,0, ALF10_MAS, 0}, +{"pminsw", 0x21000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"stqp", 0x21000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"pmaxuw", 0x22000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"stcsqp", 0x22000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"pmaxsw", 0x23000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"stdsqp", 0x23000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"stesqp", 0x24000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"qpsrad", 0x25000000, 0x02c0, { 6, 6, 0, 6, 6, 0}, P,D,P,0, ALF11, 0}, +{"stfsqp", 0x25000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"qpsrcw", 0x26000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,D,P,0, ALF11, 0}, +{"stgsqp", 0x26000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"qpsrcd", 0x27000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,D,P,0, ALF11, 0}, +{"stssqp", 0x27000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"pcmpeqbop", 0x28000000, 0x02c0, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqhop", 0x28000000, 0x02c1, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqwop", 0x28000000, 0x02c2, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqdop", 0x28000000, 0x02c3, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgtbop", 0x28000000, 0x02c4, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgthop", 0x28000000, 0x02c5, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgtwop", 0x28000000, 0x02c6, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgtdop", 0x28000000, 0x02c7, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqbap", 0x28000000, 0x02c8, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqhap", 0x28000000, 0x02c9, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqwap", 0x28000000, 0x02ca, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpeqdap", 0x28000000, 0x02cb, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgtbap", 0x28000000, 0x02cc, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgthap", 0x28000000, 0x02cd, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgtwap", 0x28000000, 0x02ce, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"pcmpgtdap", 0x28000000, 0x02cf, { 6, 0, 0, 6, 0, 0}, 0,D,D,0, ALF17, 0}, +{"phaddh", 0x29000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"stgdqp", 0x29000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,S,S,0, ALF13_MAS, 0}, +{"phaddw", 0x2a000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"stapqp", 0x2a000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,Q,S,0, ALF13_MAS, 0}, +{"phaddsh", 0x2b000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"strqp", 0x2b000000, 0x02c0, { 0, 0, 5, 0, 0, 5}, P,D,D,0, ALF13_MAS, 0}, +{"qpcmpeqbop", 0x2c000000, 0x02c0, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqhop", 0x2c000000, 0x02c1, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqwop", 0x2c000000, 0x02c2, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqdop", 0x2c000000, 0x02c3, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgtbop", 0x2c000000, 0x02c4, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgthop", 0x2c000000, 0x02c5, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgtwop", 0x2c000000, 0x02c6, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgtdop", 0x2c000000, 0x02c7, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqbap", 0x2c000000, 0x02c8, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqhap", 0x2c000000, 0x02c9, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqwap", 0x2c000000, 0x02ca, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpeqdap", 0x2c000000, 0x02cb, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgtbap", 0x2c000000, 0x02cc, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgthap", 0x2c000000, 0x02cd, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgtwap", 0x2c000000, 0x02ce, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"qpcmpgtdap", 0x2c000000, 0x02cf, { 6, 0, 0, 6, 0, 0}, 0,P,P,0, ALF17, 0}, +{"phsubh", 0x2d000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"phsubw", 0x2e000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"phsubsh", 0x2f000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"psignb", 0x30000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"qpaesltr", 0x30000000, 0x0200, { 0, 7, 0, 0, 0, 0}, P,P,P,P, ALF21, 0}, +{"psignh", 0x31000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"qpaesiltr", 0x31000000, 0x0200, { 0, 7, 0, 0, 0, 0}, P,P,P,P, ALF21, 0}, +{"psignw", 0x32000000, 0x02c0, { 3, 0, 0, 3, 0, 0}, D,D,D,0, ALF11, 0}, +{"qpkuzltr", 0x32c00000, 0x02c0, { 0, 7, 0, 0, 0, 0}, P,0,P,0, ALF12, 0}, +{"qpsbgltrlo", 0x33000000, 0x02c0, { 0, 7, 0, 0, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsbgltrhi", 0x33000000, 0x02c1, { 0, 7, 0, 0, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmsk2sgnb", 0x34000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,S,0, ALF11, 0}, +{"qpaesebgn", 0x34000000, 0x0200, { 0, 0, 7, 0, 0, 0}, P,P,P,P, ALF21, 0}, +{"qpcext_0x00", 0x35c00000, 0x02c0, { 6, 6, 0, 6, 6, 0}, P,0,D,0, ALF12, 0}, +{"qpcext_0x7f", 0x35c00000, 0x02c2, { 6, 6, 0, 6, 6, 0}, P,0,D,0, ALF12, 0}, +{"qpcext_0x80", 0x35c00000, 0x02c4, { 6, 6, 0, 6, 6, 0}, P,0,D,0, ALF12, 0}, +{"qpcext_0xff", 0x35c00000, 0x02c6, { 6, 6, 0, 6, 6, 0}, P,0,D,0, ALF12, 0}, +{"qpaesdbgn", 0x35000000, 0x0200, { 0, 0, 7, 0, 0, 0}, P,P,P,P, ALF21, 0}, +{"qpcm2b", 0x36c00000, 0x02c0, { 7, 7, 0, 7, 7, 0}, P,0,S,0, ALF12, 0}, +{"qpcm2h", 0x36c00000, 0x02c1, { 7, 7, 0, 7, 7, 0}, P,0,S,0, ALF12, 0}, +{"qpcm2w", 0x36c00000, 0x02c2, { 7, 7, 0, 7, 7, 0}, P,0,S,0, ALF12, 0}, +{"qpcm2d", 0x36c00000, 0x02c3, { 7, 7, 0, 7, 7, 0}, P,0,S,0, ALF12, 0}, +{"qpkuzebgn", 0x36000000, 0x0200, { 0, 0, 7, 0, 0, 0}, P,P,P,P, ALF21, 0}, +{"qps2cmh", 0x37000000, 0x02c1, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qps2cmw", 0x37000000, 0x02c2, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qps2cmd", 0x37000000, 0x02c3, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qpsignb", 0x38000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsignh", 0x39000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsignw", 0x3a000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsgn2mskb", 0x3cc00000, 0x02c0, { 5, 5, 0, 5, 5, 0}, S,0,P,0, ALF12, 0}, +{"qps2mb", 0x3c000000, 0x02c0, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qps2mh", 0x3c000000, 0x02c1, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qps2mw", 0x3c000000, 0x02c2, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qps2md", 0x3c000000, 0x02c3, { 7, 7, 0, 7, 7, 0}, S,P,P,0, ALF11, 0}, +{"qppackdl", 0x3d000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,D,D,0, ALF11, 0}, +{"qpswitchw", 0x3ec00000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpswitchd", 0x3fc00000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpminub", 0x40000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpminsh", 0x41000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaxub", 0x42000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaxsh", 0x43000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpminsb", 0x44000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpminuh", 0x45000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaxsb", 0x46000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaxuh", 0x47000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpacksshb", 0x48000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpaddb", 0x48000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpackushb", 0x49000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpaddh", 0x49000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpacksswh", 0x4a000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpaddsb", 0x4a000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpackuswh", 0x4b000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpaddsh", 0x4b000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpaddusb", 0x4c000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpaddush", 0x4d000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpaddw", 0x4e000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpaddd", 0x4f000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubb", 0x50000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubh", 0x51000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubsb", 0x52000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubsh", 0x53000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubusb", 0x54000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubush", 0x55000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubw", 0x56000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsubd", 0x57000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpeqb", 0x58000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmulhh", 0x58000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpeqh", 0x59000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmullh", 0x59000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpeqw", 0x5a000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmaddh", 0x5a000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpgtb", 0x5b000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmulhuh", 0x5b000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpgth", 0x5c000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpsadbw", 0x5c000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpcmpgtw", 0x5d000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmulubhh", 0x5d000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpavgusb", 0x5e000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmullw", 0x5e000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpavgush", 0x5f000000, 0x02c0, { 5, 0, 0, 5, 0, 0}, P,P,P,0, ALF11, 0}, +{"qpmrgp", 0x60000000, 0x02c0, { 6, 6, 0, 6, 6, 0}, P,P,P,0, ALF11_MERGE, 0}, +{"ldqp", 0x61000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"ldcsqp", 0x62000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"lddsqp", 0x63000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"ldesqp", 0x64000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"ldfsqp", 0x65000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"ldgsqp", 0x66000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"ldssqp", 0x67000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"ldcudqp", 0x68000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"qpmaddubsh", 0x68000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"ldgdqp", 0x69000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"qpmulhrsh", 0x69000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"ldapqp", 0x6a000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"qphminposuh", 0x6a000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"ldrqp", 0x6b000000, 0x02c0, { 5, 0, 5, 5, 0, 5}, P,D,D,0, ALF11_MAS, 0}, +{"qpmpsadbh", 0x6b000000, 0x02c0, { 0, 5, 0, 0, 5, 0}, P,P,P,0, ALF11, 0}, +{"puttagqp", 0x6c000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,S,0, ALF11, 0}, +{"qpfstois", 0x6dc80000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpfstoistr", 0x6dca0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpistofs", 0x6dcc0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpfstoid", 0x6dd80000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,D,0, ALF12, 0}, +{"qpfstoidtr", 0x6dda0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,D,0, ALF12, 0}, +{"qpistofd", 0x6ddc0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,D,0, ALF12, 0}, +{"qpfstofd", 0x6dde0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,D,0, ALF12, 0}, +{"qpfdtois", 0x6de80000, 0x02c0, { 5, 5, 0, 5, 5, 0}, D,0,P,0, ALF12, 0}, +{"qpfdtoistr", 0x6dea0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, D,0,P,0, ALF12, 0}, +{"qpidtofs", 0x6dec0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, D,0,P,0, ALF12, 0}, +{"qpfdtofs", 0x6dee0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, D,0,P,0, ALF12, 0}, +{"qpfdtoid", 0x6df80000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpfdtoidtr", 0x6dfa0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpidtofd", 0x6dfc0000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,0,P,0, ALF12, 0}, +{"qpfstoifs", 0x6e000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,D,P,0, ALF11, 0}, +{"qpfdtoifd", 0x6f000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,D,P,0, ALF11, 0}, +{"qpfadds", 0x70000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfaddd", 0x71000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfsubs", 0x72000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfsubd", 0x73000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfmins", 0x74000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfmind", 0x75000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfmaxs", 0x76000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfmaxd", 0x77000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfmuls", 0x78000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfmuld", 0x79000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfcmpeqs", 0x7a000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmplts", 0x7a000000, 0x02c1, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmples", 0x7a000000, 0x02c2, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpuods", 0x7a000000, 0x02c3, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpneqs", 0x7a000000, 0x02c4, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpnlts", 0x7a000000, 0x02c5, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpnles", 0x7a000000, 0x02c6, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpods", 0x7a000000, 0x02c7, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpeqd", 0x7b000000, 0x02c0, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpltd", 0x7b000000, 0x02c1, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpled", 0x7b000000, 0x02c2, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpuodd", 0x7b000000, 0x02c3, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpneqd", 0x7b000000, 0x02c4, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpnltd", 0x7b000000, 0x02c5, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpnled", 0x7b000000, 0x02c6, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfcmpodd", 0x7b000000, 0x02c7, { 5, 5, 0, 5, 5, 0}, P,P,P,0, ALF11, 0}, +{"qpfhadds", 0x7c000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfhsubs", 0x7d000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfaddsubs", 0x7e000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"qpfaddsubd", 0x7f000000, 0x02c0, { 5, 5, 5, 5, 5, 5}, P,P,P,0, ALF11, 0}, +{"fmas", 0x00000000, 0x0300, { 6, 6, 6, 6, 6, 6}, S,S,S,S, ALF21, 0}, +{"fmad", 0x01000000, 0x0300, { 6, 6, 6, 6, 6, 6}, D,D,D,D, ALF21, 0}, +{"fmss", 0x02000000, 0x0300, { 6, 6, 6, 6, 6, 6}, S,S,S,S, ALF21, 0}, +{"fmsd", 0x03000000, 0x0300, { 6, 6, 6, 6, 6, 6}, D,D,D,D, ALF21, 0}, +{"fnmas", 0x04000000, 0x0300, { 6, 6, 6, 6, 6, 6}, S,S,S,S, ALF21, 0}, +{"fnmad", 0x05000000, 0x0300, { 6, 6, 6, 6, 6, 6}, D,D,D,D, ALF21, 0}, +{"fnmss", 0x06000000, 0x0300, { 6, 6, 6, 6, 6, 6}, S,S,S,S, ALF21, 0}, +{"fnmsd", 0x07000000, 0x0300, { 6, 6, 6, 6, 6, 6}, D,D,D,D, ALF21, 0}, +{"qpfmas", 0x08000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmad", 0x09000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmss", 0x0a000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmsd", 0x0b000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfnmas", 0x0c000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfnmad", 0x0d000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfnmss", 0x0e000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfnmsd", 0x0f000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmass", 0x10000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmasd", 0x11000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmsas", 0x12000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"qpfmsad", 0x13000000, 0x0300, { 6, 6, 6, 6, 6, 6}, P,P,P,P, ALF21, 0}, +{"clmull", 0x14000000, 0x03c0, { 6, 6, 0, 6, 6, 0}, D,D,D,0, ALF11, 0}, +{"clmulh", 0x15000000, 0x03c0, { 6, 6, 0, 6, 6, 0}, D,D,D,0, ALF11, 0}, +{"qpackhbss", 0x16000000, 0x03c0, { 7, 7, 0, 7, 7, 0}, P,P,P,0, ALF11, 0}, +{"qpackhbus", 0x16000000, 0x03c1, { 7, 7, 0, 7, 7, 0}, P,P,P,0, ALF11, 0}, +{"qpackwhss", 0x16000000, 0x03c2, { 7, 7, 0, 7, 7, 0}, P,P,P,0, ALF11, 0}, +{"qpackwhus", 0x16000000, 0x03c3, { 7, 7, 0, 7, 7, 0}, P,P,P,0, ALF11, 0}, +{"qpfstobf", 0x17000000, 0x03ce, { 7, 7, 0, 7, 7, 0}, P,P,P,0, ALF11, 0}, +{"qpidotsbwss", 0x18000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qpidotsbwus", 0x19000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qpidotsbwuu", 0x1a000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qpidotshwss", 0x1c000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qpbfdots", 0x20000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_0", 0x28000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_1", 0x29000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_2", 0x2a000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_3", 0x2b000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_4", 0x2c000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_5", 0x2d000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_6", 0x2e000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"qptbl_7", 0x2f000000, 0x0300, { 7, 7, 0, 7, 7, 0}, P,P,P,P, ALF21, 0}, +{"andw_fb", 0x00000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"andnw_fb", 0x02000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"orw_fb", 0x04000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"ornw_fb", 0x06000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"xorw_fb", 0x08000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"xornw_fb", 0x0a000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"addw_fb", 0x10000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"subw_fb", 0x12000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"sclw_fb", 0x14000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"scrw_fb", 0x16000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"shlw_fb", 0x18000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"shrw_fb", 0x1a000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"sarw_fb", 0x1c000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"umulx_fb", 0x22000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"smulx_fb", 0x23000000, 0x04c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"incw_fb", 0x30000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"decw_fb", 0x32000000, 0x0400, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"andw_fh", 0x00000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"andnw_fh", 0x02000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"orw_fh", 0x04000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"ornw_fh", 0x06000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"xorw_fh", 0x08000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"xornw_fh", 0x0a000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"addw_fh", 0x10000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"subw_fh", 0x12000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"sclw_fh", 0x14000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"scrw_fh", 0x16000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"shlw_fh", 0x18000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"shrw_fh", 0x1a000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"sarw_fh", 0x1c000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"umulx_fh", 0x22000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"smulx_fh", 0x23000000, 0x05c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"incw_fh", 0x30000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"decw_fh", 0x32000000, 0x0500, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"andw_fw", 0x00000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"andnw_fw", 0x02000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"orw_fw", 0x04000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"ornw_fw", 0x06000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"xorw_fw", 0x08000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"xornw_fw", 0x0a000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"addw_fw", 0x10000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"subw_fw", 0x12000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"sclw_fw", 0x14000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"scrw_fw", 0x16000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"shlw_fw", 0x18000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"shrw_fw", 0x1a000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"sarw_fw", 0x1c000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"umulx_fw", 0x22000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"smulx_fw", 0x23000000, 0x06c0, { 1, 0, 0, 1, 0, 0}, S,S,S,0, ALF11, 0}, +{"incw_fw", 0x30000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"decw_fw", 0x32000000, 0x0600, { 1, 0, 0, 1, 0, 0}, S,S,S,S, ALF21, 0}, +{"andd_fd", 0x01000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"andnd_fd", 0x03000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"ord_fd", 0x05000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"ornd_fd", 0x07000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"xord_fd", 0x09000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"xornd_fd", 0x0b000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"addd_fd", 0x11000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"subd_fd", 0x13000000, 0x07c0, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF11, 0}, +{"scld_fd", 0x15000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"scrd_fd", 0x17000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"shld_fd", 0x19000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"shrd_fd", 0x1b000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"sard_fd", 0x1d000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"incd_fd", 0x31000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"decd_fd", 0x33000000, 0x0700, { 3, 0, 0, 3, 0, 0}, S,D,D,0, ALF21, 0}, +{"and_andw", 0x00000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_andd", 0x01000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_andw", 0x02000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_andd", 0x03000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_andw", 0x04000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_andd", 0x05000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_andw", 0x06000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_andd", 0x07000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_andw", 0x08000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_andd", 0x09000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_andw", 0x0a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_andd", 0x0b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_andw", 0x0e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_andd", 0x0f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_andw", 0x10000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_andd", 0x11000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_andw", 0x12000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_andd", 0x13000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_andw", 0x14000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_andd", 0x15000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_andw", 0x16000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_andd", 0x17000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_andw", 0x18000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_andd", 0x19000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_andw", 0x1a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_andd", 0x1b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_andw", 0x1c000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_andd", 0x1d000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_andw", 0x1e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_andd", 0x1f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_andnw", 0x20000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_andnd", 0x21000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_andnw", 0x22000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_andnd", 0x23000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_andnw", 0x24000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_andnd", 0x25000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_andnw", 0x26000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_andnd", 0x27000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_andnw", 0x28000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_andnd", 0x29000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_andnw", 0x2a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_andnd", 0x2b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_andnw", 0x2e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_andnd", 0x2f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_andnw", 0x30000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_andnd", 0x31000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_andnw", 0x32000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_andnd", 0x33000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_andnw", 0x34000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_andnd", 0x35000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_andnw", 0x36000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_andnd", 0x37000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_andnw", 0x38000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_andnd", 0x39000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_andnw", 0x3a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_andnd", 0x3b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_andnw", 0x3c000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_andnd", 0x3d000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_andnw", 0x3e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_andnd", 0x3f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_orw", 0x40000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_ord", 0x41000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_orw", 0x42000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_ord", 0x43000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_orw", 0x44000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_ord", 0x45000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_orw", 0x46000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_ord", 0x47000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_orw", 0x48000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_ord", 0x49000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_orw", 0x4a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_ord", 0x4b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_orw", 0x4e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_ord", 0x4f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_orw", 0x50000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_ord", 0x51000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_orw", 0x52000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_ord", 0x53000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_orw", 0x54000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_ord", 0x55000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_orw", 0x56000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_ord", 0x57000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_orw", 0x58000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_ord", 0x59000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_orw", 0x5a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_ord", 0x5b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_orw", 0x5c000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_ord", 0x5d000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_orw", 0x5e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_ord", 0x5f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_ornw", 0x60000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_ornd", 0x61000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_ornw", 0x62000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_ornd", 0x63000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_ornw", 0x64000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_ornd", 0x65000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_ornw", 0x66000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_ornd", 0x67000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_ornw", 0x68000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_ornd", 0x69000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_ornw", 0x6a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_ornd", 0x6b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_ornw", 0x6e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_ornd", 0x6f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_ornw", 0x70000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_ornd", 0x71000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_ornw", 0x72000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_ornd", 0x73000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_ornw", 0x74000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_ornd", 0x75000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_ornw", 0x76000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_ornd", 0x77000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_ornw", 0x78000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_ornd", 0x79000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_ornw", 0x7a000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_ornd", 0x7b000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_ornw", 0x7c000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_ornd", 0x7d000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_ornw", 0x7e000000, 0x0800, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_ornd", 0x7f000000, 0x0800, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_xorw", 0x00000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_xord", 0x01000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_xorw", 0x02000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_xord", 0x03000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_xorw", 0x04000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_xord", 0x05000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_xorw", 0x06000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_xord", 0x07000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_xorw", 0x08000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_xord", 0x09000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_xorw", 0x0a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_xord", 0x0b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_xorw", 0x0e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_xord", 0x0f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_xorw", 0x10000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_xord", 0x11000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_xorw", 0x12000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_xord", 0x13000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_xorw", 0x14000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_xord", 0x15000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_xorw", 0x16000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_xord", 0x17000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_xorw", 0x18000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_xord", 0x19000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_xorw", 0x1a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_xord", 0x1b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_xorw", 0x1c000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_xord", 0x1d000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_xorw", 0x1e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_xord", 0x1f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_xornw", 0x20000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_xornd", 0x21000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_xornw", 0x22000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_xornd", 0x23000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_xornw", 0x24000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_xornd", 0x25000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_xornw", 0x26000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_xornd", 0x27000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_xornw", 0x28000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_xornd", 0x29000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_xornw", 0x2a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_xornd", 0x2b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_xornw", 0x2e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_xornd", 0x2f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_xornw", 0x30000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_xornd", 0x31000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_xornw", 0x32000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_xornd", 0x33000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_xornw", 0x34000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_xornd", 0x35000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_xornw", 0x36000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_xornd", 0x37000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_xornw", 0x38000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_xornd", 0x39000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_xornw", 0x3a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_xornd", 0x3b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_xornw", 0x3c000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_xornd", 0x3d000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_xornw", 0x3e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_xornd", 0x3f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_rsubw", 0x40000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_rsubd", 0x41000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_rsubw", 0x42000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_rsubd", 0x43000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_rsubw", 0x44000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_rsubd", 0x45000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_rsubw", 0x46000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_rsubd", 0x47000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_rsubw", 0x48000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_rsubd", 0x49000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_rsubw", 0x4a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_rsubd", 0x4b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_rsubw", 0x4e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_rsubd", 0x4f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_rsubw", 0x50000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_rsubd", 0x51000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_rsubw", 0x52000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_rsubd", 0x53000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_rsubw", 0x54000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_rsubd", 0x55000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_rsubw", 0x56000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_rsubd", 0x57000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_rsubw", 0x58000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_rsubd", 0x59000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_rsubw", 0x5a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_rsubd", 0x5b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_rsubw", 0x5c000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_rsubd", 0x5d000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_rsubw", 0x5e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_rsubd", 0x5f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_mergew", 0x60000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"and_merged", 0x61000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"andn_mergew", 0x62000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"andn_merged", 0x63000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"or_mergew", 0x64000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"or_merged", 0x65000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"orn_mergew", 0x66000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"orn_merged", 0x67000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"xor_mergew", 0x68000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"xor_merged", 0x69000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"xorn_mergew", 0x6a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"xorn_merged", 0x6b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_mergew", 0x6e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_merged", 0x6f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_mergew", 0x70000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_merged", 0x71000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"sub_mergew", 0x72000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"sub_merged", 0x73000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"scl_mergew", 0x74000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"scl_merged", 0x75000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"scr_mergew", 0x76000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"scr_merged", 0x77000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"shl_mergew", 0x78000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"shl_merged", 0x79000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"shr_mergew", 0x7a000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"shr_merged", 0x7b000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"sar_mergew", 0x7c000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"sar_merged", 0x7d000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"getf_mergew", 0x7e000000, 0x0900, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"getf_merged", 0x7f000000, 0x0900, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"and_addw", 0x00000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_addd", 0x01000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_addw", 0x02000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_addd", 0x03000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_addw", 0x04000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_addd", 0x05000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_addw", 0x06000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_addd", 0x07000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_addw", 0x08000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_addd", 0x09000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_addw", 0x0a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_addd", 0x0b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_addw", 0x0e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_addd", 0x0f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_addw", 0x10000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_addd", 0x11000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_addw", 0x12000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_addd", 0x13000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_addw", 0x14000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_addd", 0x15000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_addw", 0x16000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_addd", 0x17000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_addw", 0x18000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_addd", 0x19000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_addw", 0x1a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_addd", 0x1b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_addw", 0x1c000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_addd", 0x1d000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_addw", 0x1e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_addd", 0x1f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_subw", 0x20000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"and_subd", 0x21000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"andn_subw", 0x22000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"andn_subd", 0x23000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"or_subw", 0x24000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"or_subd", 0x25000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"orn_subw", 0x26000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"orn_subd", 0x27000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xor_subw", 0x28000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xor_subd", 0x29000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"xorn_subw", 0x2a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"xorn_subd", 0x2b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_subw", 0x2e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, 0}, +{"merge_subd", 0x2f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"add_subw", 0x30000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"add_subd", 0x31000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sub_subw", 0x32000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sub_subd", 0x33000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scl_subw", 0x34000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scl_subd", 0x35000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"scr_subw", 0x36000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"scr_subd", 0x37000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shl_subw", 0x38000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shl_subd", 0x39000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"shr_subw", 0x3a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"shr_subd", 0x3b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"sar_subw", 0x3c000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"sar_subd", 0x3d000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"getf_subw", 0x3e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, 0}, +{"getf_subd", 0x3f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, 0}, +{"and_sclw", 0x40000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"and_scld", 0x41000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"andn_sclw", 0x42000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"andn_scld", 0x43000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"or_sclw", 0x44000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"or_scld", 0x45000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"orn_sclw", 0x46000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"orn_scld", 0x47000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xor_sclw", 0x48000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xor_scld", 0x49000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xorn_sclw", 0x4a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xorn_scld", 0x4b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"merge_sclw", 0x4e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_scld", 0x4f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_sclw", 0x50000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"add_scld", 0x51000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sub_sclw", 0x52000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sub_scld", 0x53000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scl_sclw", 0x54000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scl_scld", 0x55000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scr_sclw", 0x56000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scr_scld", 0x57000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shl_sclw", 0x58000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shl_scld", 0x59000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shr_sclw", 0x5a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shr_scld", 0x5b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sar_sclw", 0x5c000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sar_scld", 0x5d000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"getf_sclw", 0x5e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"getf_scld", 0x5f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"and_scrw", 0x60000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"and_scrd", 0x61000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"andn_scrw", 0x62000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"andn_scrd", 0x63000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"or_scrw", 0x64000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"or_scrd", 0x65000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"orn_scrw", 0x66000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"orn_scrd", 0x67000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xor_scrw", 0x68000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xor_scrd", 0x69000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xorn_scrw", 0x6a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xorn_scrd", 0x6b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"merge_scrw", 0x6e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_scrd", 0x6f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_scrw", 0x70000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"add_scrd", 0x71000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sub_scrw", 0x72000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sub_scrd", 0x73000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scl_scrw", 0x74000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scl_scrd", 0x75000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scr_scrw", 0x76000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scr_scrd", 0x77000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shl_scrw", 0x78000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shl_scrd", 0x79000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shr_scrw", 0x7a000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shr_scrd", 0x7b000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sar_scrw", 0x7c000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sar_scrd", 0x7d000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"getf_scrw", 0x7e000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"getf_scrd", 0x7f000000, 0x0a00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"and_shlw", 0x00000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"and_shld", 0x01000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"andn_shlw", 0x02000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"andn_shld", 0x03000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"or_shlw", 0x04000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"or_shld", 0x05000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"orn_shlw", 0x06000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"orn_shld", 0x07000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xor_shlw", 0x08000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xor_shld", 0x09000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xorn_shlw", 0x0a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xorn_shld", 0x0b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"merge_shlw", 0x0e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_shld", 0x0f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_shlw", 0x10000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"add_shld", 0x11000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sub_shlw", 0x12000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sub_shld", 0x13000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scl_shlw", 0x14000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scl_shld", 0x15000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scr_shlw", 0x16000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scr_shld", 0x17000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shl_shlw", 0x18000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shl_shld", 0x19000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shr_shlw", 0x1a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shr_shld", 0x1b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sar_shlw", 0x1c000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sar_shld", 0x1d000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"getf_shlw", 0x1e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"getf_shld", 0x1f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"and_shrw", 0x20000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"and_shrd", 0x21000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"andn_shrw", 0x22000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"andn_shrd", 0x23000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"or_shrw", 0x24000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"or_shrd", 0x25000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"orn_shrw", 0x26000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"orn_shrd", 0x27000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xor_shrw", 0x28000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xor_shrd", 0x29000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xorn_shrw", 0x2a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xorn_shrd", 0x2b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"merge_shrw", 0x2e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_shrd", 0x2f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_shrw", 0x30000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"add_shrd", 0x31000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sub_shrw", 0x32000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sub_shrd", 0x33000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scl_shrw", 0x34000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scl_shrd", 0x35000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scr_shrw", 0x36000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scr_shrd", 0x37000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shl_shrw", 0x38000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shl_shrd", 0x39000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shr_shrw", 0x3a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shr_shrd", 0x3b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sar_shrw", 0x3c000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sar_shrd", 0x3d000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"getf_shrw", 0x3e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"getf_shrd", 0x3f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"and_sarw", 0x40000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"and_sard", 0x41000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"andn_sarw", 0x42000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"andn_sard", 0x43000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"or_sarw", 0x44000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"or_sard", 0x45000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"orn_sarw", 0x46000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"orn_sard", 0x47000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xor_sarw", 0x48000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xor_sard", 0x49000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xorn_sarw", 0x4a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xorn_sard", 0x4b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"merge_sarw", 0x4e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_sard", 0x4f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_sarw", 0x50000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"add_sard", 0x51000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sub_sarw", 0x52000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sub_sard", 0x53000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scl_sarw", 0x54000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scl_sard", 0x55000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scr_sarw", 0x56000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scr_sard", 0x57000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shl_sarw", 0x58000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shl_sard", 0x59000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shr_sarw", 0x5a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shr_sard", 0x5b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sar_sarw", 0x5c000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sar_sard", 0x5d000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"getf_sarw", 0x5e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"getf_sard", 0x5f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"and_getfw", 0x60000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"and_getfd", 0x61000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"andn_getfw", 0x62000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"andn_getfd", 0x63000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"or_getfw", 0x64000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"or_getfd", 0x65000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"orn_getfw", 0x66000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"orn_getfd", 0x67000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xor_getfw", 0x68000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xor_getfd", 0x69000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"xorn_getfw", 0x6a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"xorn_getfd", 0x6b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"insfw", 0x6c000000, 0x0b00, { 1, 1, 0, 1, 1, 0}, S,S,S,S, ALF21, 0}, +{"insfd", 0x6d000000, 0x0b00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, 0}, +{"merge_getfw", 0x6e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"merge_getfd", 0x6f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21_MERGE, AF_REMOVED_IN_V2}, +{"add_getfw", 0x70000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"add_getfd", 0x71000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sub_getfw", 0x72000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sub_getfd", 0x73000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scl_getfw", 0x74000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scl_getfd", 0x75000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"scr_getfw", 0x76000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"scr_getfd", 0x77000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shl_getfw", 0x78000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shl_getfd", 0x79000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"shr_getfw", 0x7a000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"shr_getfd", 0x7b000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"sar_getfw", 0x7c000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"sar_getfd", 0x7d000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"getf_getfw", 0x7e000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"getf_getfd", 0x7f000000, 0x0b00, { 0, 1, 0, 0, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"fadd_adds", 0x00000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, S,S,S,S, ALF21, 0}, +{"fadd_addd", 0x01000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"fsub_adds", 0x02000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, S,S,S,S, ALF21, 0}, +{"fsub_addd", 0x03000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"fmul_adds", 0x08000000, 0x0c00, { 1, 1, 4, 1, 1, 4}, S,S,S,S, ALF21, 0}, +{"fmul_addd", 0x09000000, 0x0c00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"fadd_subs", 0x20000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, S,S,S,S, ALF21, 0}, +{"fadd_subd", 0x21000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"fsub_subs", 0x22000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, S,S,S,S, ALF21, 0}, +{"fsub_subd", 0x23000000, 0x0c00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"fmul_subs", 0x28000000, 0x0c00, { 1, 1, 4, 1, 1, 4}, S,S,S,S, ALF21, 0}, +{"fmul_subd", 0x29000000, 0x0c00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"fadd_muls", 0x00000000, 0x0d00, { 1, 1, 0, 1, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"fadd_muld", 0x01000000, 0x0d00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"fsub_muls", 0x02000000, 0x0d00, { 1, 1, 0, 1, 1, 0}, S,S,S,S, ALF21, AF_REMOVED_IN_V2}, +{"fsub_muld", 0x03000000, 0x0d00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"fadd_rsubs", 0x20000000, 0x0d00, { 2, 2, 4, 2, 2, 4}, S,S,S,S, ALF21, 0}, +{"fadd_rsubd", 0x21000000, 0x0d00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"fsub_rsubs", 0x22000000, 0x0d00, { 2, 2, 4, 2, 2, 4}, S,S,S,S, ALF21, 0}, +{"fsub_rsubd", 0x23000000, 0x0d00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"fmul_rsubs", 0x28000000, 0x0d00, { 1, 1, 4, 1, 1, 4}, S,S,S,S, ALF21, 0}, +{"fmul_rsubd", 0x29000000, 0x0d00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_adds", 0x00000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_addd", 0x01000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_adds", 0x02000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_addd", 0x03000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfhadd_adds", 0x04000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhsub_adds", 0x06000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_adds", 0x08000000, 0x0e00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_addd", 0x09000000, 0x0e00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfaddsub_adds", 0x0e000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_subs", 0x20000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_subd", 0x21000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_subs", 0x22000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_subd", 0x23000000, 0x0e00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfhadd_subs", 0x24000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhsub_subs", 0x26000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_subs", 0x28000000, 0x0e00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_subd", 0x29000000, 0x0e00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfaddsub_subs", 0x2e000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_hadds", 0x40000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_hadds", 0x42000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhadd_hadds", 0x44000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhsub_hadds", 0x46000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_hadds", 0x48000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfaddsub_hadds", 0x4e000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_hsubs", 0x60000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_hsubs", 0x62000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhadd_hsubs", 0x64000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhsub_hsubs", 0x66000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_hsubs", 0x68000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfaddsub_hsubs", 0x6e000000, 0x0e00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_muls", 0x00000000, 0x0f00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"pfadd_muld", 0x01000000, 0x0f00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"pfsub_muls", 0x02000000, 0x0f00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"pfsub_muld", 0x03000000, 0x0f00, { 1, 1, 0, 1, 1, 0}, D,D,D,D, ALF21, AF_REMOVED_IN_V2}, +{"pfadd_rsubs", 0x20000000, 0x0f00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfadd_rsubd", 0x21000000, 0x0f00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_rsubs", 0x22000000, 0x0f00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_rsubd", 0x23000000, 0x0f00, { 2, 2, 4, 2, 2, 4}, D,D,D,D, ALF21, 0}, +{"pfhadd_rsubs", 0x24000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhsub_rsubs", 0x26000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_rsubs", 0x28000000, 0x0f00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_rsubd", 0x29000000, 0x0f00, { 1, 1, 4, 1, 1, 4}, D,D,D,D, ALF21, 0}, +{"pfaddsub_rsubs", 0x2e000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pshufb", 0x4d000000, 0x0f00, { 2, 2, 0, 2, 2, 0}, D,D,D,D, ALF21, 0}, +{"pfadd_addsubs", 0x60000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfsub_addsubs", 0x62000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhadd_addsubs", 0x64000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfhsub_addsubs", 0x66000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pfmul_addsubs", 0x68000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, 0}, +{"pmerge", 0x6d000000, 0x0f00, { 2, 2, 0, 2, 2, 0}, D,D,D,D, ALF21_MERGE, 0}, +{"pfaddsub_addsubs", 0x6e000000, 0x0f00, { 3, 3, 4, 3, 3, 4}, D,D,D,D, ALF21, AF_ALIAS}, +{"plog_and", 0x00000000, 0x1100, { 5, 5, 0, 5, 5, 0}, D,D,D,D, ALF21, AF_ALIAS}, +{"plog_xor", 0x16000000, 0x1100, { 5, 5, 0, 5, 5, 0}, D,D,D,D, ALF21, AF_ALIAS}, +{"plog_sel3", 0x58000000, 0x1100, { 5, 5, 0, 5, 5, 0}, D,D,D,D, ALF21, AF_ALIAS}, +{"plog_mjr", 0x68000000, 0x1100, { 5, 5, 0, 5, 5, 0}, D,D,D,D, ALF21, AF_ALIAS}, +{"plog_or", 0x7e000000, 0x1100, { 5, 5, 0, 5, 5, 0}, D,D,D,D, ALF21, AF_ALIAS}, +{"plog", 0x00000000, 0x1000, { 5, 5, 0, 5, 5, 0}, D,D,D,D, ALF21_LOG, 0}, +{"qplog_and", 0x00000000, 0x1300, { 5, 5, 7, 5, 5, 7}, P,P,P,P, ALF21_LT3, AF_ALIAS}, +{"qplog_xor", 0x16000000, 0x1300, { 5, 5, 7, 5, 5, 7}, P,P,P,P, ALF21_LT3, AF_ALIAS}, +{"qplog_sel3", 0x58000000, 0x1300, { 5, 5, 7, 5, 5, 7}, P,P,P,P, ALF21_LT3, AF_ALIAS}, +{"qplog_mjr", 0x68000000, 0x1300, { 5, 5, 7, 5, 5, 7}, P,P,P,P, ALF21_LT3, AF_ALIAS}, +{"qplog_or", 0x7e000000, 0x1300, { 5, 5, 7, 5, 5, 7}, P,P,P,P, ALF21_LT3, AF_ALIAS}, +{"qplog", 0x00000000, 0x1200, { 5, 5, 7, 5, 5, 7}, P,P,P,P, ALF21_LOG_LT3, 0}, +{"qpfadd_adds", 0x00000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_addd", 0x01000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_adds", 0x02000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_addd", 0x03000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhadd_adds", 0x04000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhsub_adds", 0x06000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_adds", 0x08000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_addd", 0x09000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_adds", 0x0e000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_addd", 0x0f000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_subs", 0x20000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_subd", 0x21000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_subs", 0x22000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_subd", 0x23000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhadd_subs", 0x24000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhsub_subs", 0x26000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_subs", 0x28000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_subd", 0x29000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_subs", 0x2e000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_subd", 0x2f000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_hadds", 0x40000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_hadds", 0x42000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhadd_hadds", 0x44000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhsub_hadds", 0x46000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_hadds", 0x48000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_hadds", 0x4e000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_hsubs", 0x60000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_hsubs", 0x62000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhadd_hsubs", 0x64000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhsub_hsubs", 0x66000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_hsubs", 0x68000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_hsubs", 0x6e000000, 0x1600, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qppermb", 0x0d000000, 0x1700, { 5, 5, 0, 5, 5, 0}, P,P,P,P, ALF21_LT3, 0}, +{"qpfadd_rsubs", 0x20000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_rsubd", 0x21000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_rsubs", 0x22000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_rsubd", 0x23000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhadd_rsubs", 0x24000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhsub_rsubs", 0x26000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_rsubs", 0x28000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_rsubd", 0x29000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpinss", 0x2c000000, 0x1700, { 7, 7, 0, 7, 7, 0}, P,P,S,P, ALF21_LT3, 0}, +{"qpinsd", 0x2d000000, 0x1700, { 7, 7, 0, 7, 7, 0}, P,P,D,P, ALF21_LT3, 0}, +{"qpfaddsub_rsubs", 0x2e000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_rsubd", 0x2f000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpshufb", 0x4d000000, 0x1700, { 5, 5, 0, 5, 5, 0}, P,P,P,P, ALF21, 0}, +{"qpfadd_addsubs", 0x60000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfadd_addsubd", 0x61000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_addsubs", 0x62000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfsub_addsubd", 0x63000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhadd_addsubs", 0x64000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfhsub_addsubs", 0x66000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_addsubs", 0x68000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfmul_addsubd", 0x69000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpmerge", 0x6d000000, 0x1700, { 5, 5, 0, 5, 5, 0}, P,P,P,P, ALF21_MERGE, 0}, +{"qpfaddsub_addsubs", 0x6e000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, +{"qpfaddsub_addsubd", 0x6f000000, 0x1700, { 5, 5, 5, 5, 5, 5}, P,P,P,P, ALF21, 0}, + +/* Terminate the list. */ +{NULL, 0, 0, {0,0,0,0,0,0}, 0,0,0,0, 0, 0} +}; diff --git a/disas/e2k.h b/disas/e2k.h new file mode 100644 index 0000000000..d058933e71 --- /dev/null +++ b/disas/e2k.h @@ -0,0 +1,603 @@ +/* e2k.h. E2K opcode list for GDB, the GNU debugger. + Copyright (C) 2022 Free Software Foundation, Inc. + + This file is part of GDB, GAS, and the GNU binutils. + + GDB, GAS, and the GNU binutils are free software; you can redistribute + them and/or modify them under the terms of the GNU General Public + License as published by the Free Software Foundation; either version + 3, or (at your option) any later version. + + GDB, GAS, and the GNU binutils are distributed in the hope that they + will be useful, but WITHOUT ANY WARRANTY; without even the implied + warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + the GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; see the file COPYING3. If not, + see . */ + +#ifndef _E2K_H_ +#define _E2K_H_ + +#include +#include +#include + +#define SIGN_EXTEND(x, n) \ + ((long long) (x) << (sizeof (long long) - (n)) >> (sizeof (long long) - (n))) +#define EXTRACT_BITS(x, s, n) (((x) >> (s)) & ((1 << (n)) - 1)) +#define SEXTRACT_BITS(x, s, n) SIGN_EXTEND (EXTRACT_BITS (x, s, n), n) +#define CLEAR_BITS(x, s, n) ((x) & ~(((1 << (n)) - 1) << (s))) +#define ENCODE_BITS(x, s, n) (((x) & ((1 << (n)) - 1)) << (s)) +#define DEPOSIT_BITS(x, s, n, v) (CLEAR_BITS (x, s, n) | ENCODE_BITS (v, s, n)) +#define DEPOSIT_FIELD(x, s0, n, v, s1) \ + DEPOSIT_BITS (x, s0, n, EXTRACT_BITS (v, s1, n)) + +#define NGPR 256 +#define NPREG 32 +#define NLPRED 7 +#define NCMP 4 +#define NPCNT 32 +#define NCTPR 4 +#define NIPR 8 +#define NAAD 32 +#define NAAINCR 8 +#define NAASTI 16 +#define NAAIND 16 +#define NRNDPRED 32 +#define NSR 256 + +extern const char e2k_reg_names_gpr[NGPR][8]; +extern const char e2k_reg_names_gpr_d[NGPR][8]; +extern const char e2k_reg_names_gpr_x[NGPR][8]; +extern const char e2k_reg_names_gpr_q[NGPR][8]; +extern const char e2k_reg_names_gpr_qp[NGPR][8]; +extern const char e2k_reg_names_preg[NPREG][4]; +extern const char e2k_reg_names_lpred[NLPRED][4]; +extern const char e2k_reg_names_cmp[NCMP][8]; +extern const char e2k_reg_names_pcnt[NPCNT][8]; +extern const char e2k_reg_names_ctpr[NCTPR][8]; +extern const char e2k_reg_names_ipr[NIPR][8]; +extern const char e2k_reg_names_aad[NAAD][8]; +extern const char e2k_reg_names_aaincr[NAAINCR][8]; +extern const char e2k_reg_names_aasti[NAASTI][8]; +extern const char e2k_reg_names_aaind[NAAIND][8]; +extern const char *e2k_reg_names_rndpred[NRNDPRED]; +extern const char *e2k_reg_names_sr[NSR]; +extern const uint8_t e2k_reg_version_sr[NSR]; + +#define GPR_NAME_SIZE sizeof(*e2k_reg_names_gpr) +#define GPR_D_NAME_SIZE sizeof(*e2k_reg_names_gpr_d) +#define GPR_X_NAME_SIZE sizeof(*e2k_reg_names_gpr_x) +#define GPR_Q_NAME_SIZE sizeof(*e2k_reg_names_gpr_q) +#define GPR_QP_NAME_SIZE sizeof(*e2k_reg_names_gpr_qp) +#define PREG_NAME_SIZE sizeof(*e2k_reg_names_preg) +#define LPRED_NAME_SIZE sizeof(*e2k_reg_names_lpred) +#define CMP_NAME_SIZE sizeof(*e2k_reg_names_cmp) +#define PCNT_NAME_SIZE sizeof(*e2k_reg_names_pcnt) +#define CTPR_NAME_SIZE sizeof(*e2k_reg_names_ctpr) +#define IPR_NAME_SIZE sizeof(*e2k_reg_names_ipr) +#define AAD_NAME_SIZE sizeof(*e2k_reg_names_aad) +#define AAINCR_NAME_SIZE sizeof(*e2k_reg_names_aaincr) +#define AASTI_NAME_SIZE sizeof(*e2k_reg_names_aasti) +#define AAIND_NAME_SIZE sizeof(*e2k_reg_names_aaind) + +#define ALC_COUNT 6 + +enum ales_present +{ + ALES_NONE, + ALES_ALLOCATED, + ALES_PRESENT, +}; + +struct e2k_unpacked_bundle +{ + uint32_t hs; + uint32_t ss; + uint32_t als[ALC_COUNT]; + uint32_t cs[2]; + uint32_t lts[4]; + uint32_t pls[3]; + uint32_t cds[3]; + uint16_t ales[6]; + uint16_t aas[6]; + bool ss_present; + bool als_present[ALC_COUNT]; + bool cs_present[2]; + enum ales_present ales_present[ALC_COUNT]; + bool aas_present[6]; + bool lts_present[4]; + bool pls_present[3]; + bool cds_present[3]; +}; + +/* Keep in sync with al_format_info. */ +enum al_format +{ + ALF1, /* dst, src1, src2 */ + ALF1_MERGE, /* dst, src1, src2, mrgc */ + ALF1_MAS, /* dst, src1, src2[, mas=u7] */ + ALF2, /* dst, src2 */ + ALF2_MOVTD, /* dst|ctpr_in_alc0, src2 */ + ALF3_MAS, /* src4, src1, src2[, mas=u7] */ + ALF7, /* dst_preg, src1, src2 */ + ALF8, /* dst_preg, src2 */ + ALF10_MAS, /* dst, aad, aasti[, lit32][, mas=u7] */ + ALF11, /* dst, src1, src2 */ + ALF11_LIT8, /* dst, src1, src2, u8 */ + ALF11_MERGE, /* dst, src1, src2, mrgc */ + ALF11_MAS, /* dst, src1, src2[, mas=u7] */ + ALF12, /* dst, src2 */ + ALF12_IBRANCHD, /* dst, src2 */ + ALF12_ICALLD, /* dst, wbs, src2 */ + ALF12_PSHUFH, /* dst, src2, u8 */ + ALF13_MAS, /* src4, src1, src2[, mas=u7] */ + ALF15, /* dst, sr */ + ALF16, /* dst_sr, src2 */ + ALF17, /* dst_preg, src1, src2 */ + ALF21, /* dst, src1, src2, src3 */ + ALF21_LT3, /* dst, src1, src2, src3|lit32 */ + ALF21_MERGE, /* dst, src1, src2, src3, mrgc */ + ALF21_LOG, /* dst, imm8, src1, src2, src3 */ + ALF21_LOG_LT3, /* dst, imm8, src1, src2, src3|lit32 */ + ALF22, /* dst, src2 */ + AAURR, /* dst, aau */ + AAURW, /* dst_aau, src2 */ + ALF_MAX, +}; + +struct al_format_info +{ + uint32_t als_mask; + uint16_t ales_mask; + uint8_t pair[6]; + const char *operands; +}; + +enum al_flags +{ + AF_ALIAS = 0x01, + AF_PAIR = 0x02, + AF_ALT_ALES03 = 0x04, /* ales.opc = 0x02 */ + AF_EXPLICIT_ALES25 = 0x08, /* ales.opc = 0x02, force ales for >=v4 */ + AF_REMOVED_IN_V2 = 0x10, + AF_REMOVED_IN_V3 = 0x20, +}; + +enum gpr_size +{ + GS_NONE, + GS_S, /* 32-bit */ + GS_D, /* 64-bit */ + GS_X, /* 80-bit */ + GS_Q, /* 128-bit, even/odd pair of two 64-bit */ + GS_P, /* 128-bit */ +}; + +struct al_opcode +{ + const char *name; + uint32_t als; + uint16_t ales; + uint8_t version[6]; +#ifdef __GNUC__ + enum gpr_size dst : 4; + enum gpr_size src1 : 4; + enum gpr_size src2 : 4; + enum gpr_size src3 : 4; + enum al_format format : 8; + enum al_flags flags : 8; +#else + uint8_t dst : 4; + uint8_t src1 : 4; + uint8_t src2 : 4; + uint8_t src3 : 4; + uint8_t format; + uint8_t flags; +#endif +}; + +extern const struct al_format_info al_format_info[ALF_MAX]; +extern const struct al_opcode al_opcodes[]; + +#define TEST_OPCODE(x, o, m) (((x) & (m)) == (o)) + +/* HS */ + +#define HS_ENCODE_HOFF(x) ENCODE_BITS ((x) / 4, 0, 4) +#define HS_ENCODE_BSZ(x) ENCODE_BITS ((x) / 8 - 1, 4, 3) +#define HS_ENCODE_NOP(x) ENCODE_BITS ((x) - 1, 7, 3) +#define HS_ENCODE_LOOP(x) ENCODE_BITS (x, 10, 1) +#define HS_ENCODE_SIM(x) ENCODE_BITS (x, 11, 1) +#define HS_ENCODE_SS(x) ENCODE_BITS (x, 12, 1) +#define HS_ENCODE_MDL(x) ENCODE_BITS (x, 13, 1) +#define HS_ENCODE_CS_MASK(x) ENCODE_BITS (x, 14, 2) +#define HS_ENCODE_CS(x, i) ENCODE_BITS (x, 14 + (i), 2) +#define HS_ENCODE_CDS_COUNT(x) ENCODE_BITS (x, 16, 2) +#define HS_ENCODE_PLS_COUNT(x) ENCODE_BITS (x, 18, 2) +#define HS_ENCODE_ALES_MASK(x) ENCODE_BITS (x, 20, 6) +#define HS_ENCODE_ALES(x, i) ENCODE_BITS (x, 20 + (i), 1) +#define HS_ENCODE_ALS_MASK(x) ENCODE_BITS (x, 26, 6) +#define HS_ENCODE_ALS(x, i) ENCODE_BITS (x, 26 + (i), 1) +#define HS_DECODE_HOFF(x) (EXTRACT_BITS (x, 0, 4) * 4) +#define HS_DECODE_BSZ(x) (EXTRACT_BITS (x, 4, 3) * 8 + 8) +#define HS_DECODE_NOP(x) (EXTRACT_BITS (x, 7, 3) + 1) +#define HS_DECODE_LOOP(x) EXTRACT_BITS (x, 10, 1) +#define HS_DECODE_SIM(x) EXTRACT_BITS (x, 11, 1) +#define HS_DECODE_SS(x) EXTRACT_BITS (x, 12, 1) +#define HS_DECODE_MDL(x) EXTRACT_BITS (x, 13, 1) +#define HS_DECODE_CS_MASK(x) EXTRACT_BITS (x, 14, 2) +#define HS_DECODE_CS(x, i) EXTRACT_BITS (x, 14 + (i), 1) +#define HS_DECODE_CDS_COUNT(x) (int) EXTRACT_BITS (x, 16, 2) +#define HS_DECODE_PLS_COUNT(x) (int) EXTRACT_BITS (x, 18, 2) +#define HS_DECODE_ALES_MASK(x) EXTRACT_BITS (x, 20, 6) +#define HS_DECODE_ALES(x, i) EXTRACT_BITS (x, 20 + (i), 1) +#define HS_DECODE_ALS_MASK(x) EXTRACT_BITS (x, 26, 6) +#define HS_DECODE_ALS(x, i) EXTRACT_BITS (x, 26 + (i), 1) + +/* SS */ + +enum ct_cond +{ + CT_COND_NONE = 0, /* none */ + CT_COND_ALWAYS = 1, /* unconditional */ + CT_COND_PREG = 2, /* pN */ + CT_COND_NOT_PREG = 3, /* ~pN */ + CT_COND_LOOP_END = 4, /* loop_end */ + CT_COND_NOT_LOOP_END = 5, /* ~loop_end */ + CT_COND_PREG_OR_LOOP_END = 6, /* pN || loop_end */ + CT_COND_NOT_PREG_AND_NOT_LOOP_END = 7, /* ~pN && ~loop_end */ + CT_COND_MLOCK_OR_DTAL = 8, /* mlock */ + /* mlock || dt_al0134 */ + CT_COND_MLOCK_OR_CMP = 9, /* mlock || [~]cmpN */ + /* mlock || [~]cmpN || [~]cmpN */ + /* mlock || [~]clpN */ + CT_COND_CMP_CLP = 11, /* {~}{cmp,clp}N */ + CT_COND_NOT_PREG_OR_LOOP_END = 14, /* ~pN || loop_end */ + CT_COND_PREG_AND_NOT_LOOP_END = 15 /* pN && ~loop_end */ +}; + +#define DISP_MIN -1073741824 +#define DISP_MAX 1073741823 + +#define SS_ENCODE_CT_PRED(x) ENCODE_BITS (x, 0, 5) +#define SS_ENCODE_CT_COND(x) ENCODE_BITS (x, 5, 5) +#define SS_ENCODE_CTPR(x) ENCODE_BITS (x, 10, 2) +#define SS_ENCODE_FORMAT(x) ENCODE_BITS (x, 20, 1) +#define SS_ENCODE_IPD(x) ENCODE_BITS (x, 30, 2) + +#define SS_DECODE_CT_PRED(x) EXTRACT_BITS (x, 0, 5) +#define SS_DECODE_CT_COND(x) EXTRACT_BITS (x, 5, 5) +#define SS_DECODE_CTPR(x) EXTRACT_BITS (x, 10, 2) +#define SS_DECODE_FORMAT(x) EXTRACT_BITS (x, 20, 1) +#define SS_DECODE_IPD(x) EXTRACT_BITS (x, 30, 2) + +/* SS type0 */ +#define SS_ENCODE_AAS_MAS(x) ENCODE_BITS (x, 12, 4) +#define SS_ENCODE_AAS(x, i) ENCODE_BITS (x, 12 + (i), 1) +#define SS_ENCODE_ALC(x) ENCODE_BITS (x, 16, 2) +#define SS_ENCODE_ALCT(x) ENCODE_BITS (x, 16, 1) +#define SS_ENCODE_ALCF(x) ENCODE_BITS (x, 17, 1) +#define SS_ENCODE_ABP(x) ENCODE_BITS (x, 18, 2) +#define SS_ENCODE_ABPT(x) ENCODE_BITS (x, 18, 1) +#define SS_ENCODE_ABPF(x) ENCODE_BITS (x, 19, 1) +#define SS_ENCODE_ABN(x) ENCODE_BITS (x, 21, 2) +#define SS_ENCODE_ABNT(x) ENCODE_BITS (x, 21, 1) +#define SS_ENCODE_ABNF(x) ENCODE_BITS (x, 22, 1) +#define SS_ENCODE_ABG(x) ENCODE_BITS (x, 23, 2) +#define SS_ENCODE_ABGD(x) ENCODE_BITS (x, 23, 1) +#define SS_ENCODE_ABGI(x) ENCODE_BITS (x, 24, 1) +#define SS_ENCODE_RP_LO(x) ENCODE_BITS (x, 25, 1) +#define SS_ENCODE_VFDI(x) ENCODE_BITS (x, 26, 1) +#define SS_ENCODE_RP_HI(x) ENCODE_BITS (x, 27, 1) +#define SS_ENCODE_BAP(x) ENCODE_BITS (x, 28, 1) +#define SS_ENCODE_EAP(x) ENCODE_BITS (x, 29, 1) +#define SS_DECODE_AAS_MAS(x) EXTRACT_BITS (x, 12, 4) +#define SS_DECODE_AAS(x, i) EXTRACT_BITS (x, 12 + (i), 1) +#define SS_DECODE_ALC(x) EXTRACT_BITS (x, 16, 2) +#define SS_DECODE_ALCT(x) EXTRACT_BITS (x, 16, 1) +#define SS_DECODE_ALCF(x) EXTRACT_BITS (x, 17, 1) +#define SS_DECODE_ABP(x) EXTRACT_BITS (x, 18, 2) +#define SS_DECODE_ABPT(x) EXTRACT_BITS (x, 18, 1) +#define SS_DECODE_ABPF(x) EXTRACT_BITS (x, 19, 1) +#define SS_DECODE_ABN(x) EXTRACT_BITS (x, 21, 2) +#define SS_DECODE_ABNT(x) EXTRACT_BITS (x, 21, 1) +#define SS_DECODE_ABNF(x) EXTRACT_BITS (x, 22, 1) +#define SS_DECODE_ABG(x) EXTRACT_BITS (x, 23, 2) +#define SS_DECODE_ABGD(x) EXTRACT_BITS (x, 23, 1) +#define SS_DECODE_ABGI(x) EXTRACT_BITS (x, 24, 1) +#define SS_DECODE_RP_LO(x) EXTRACT_BITS (x, 25, 1) +#define SS_DECODE_VFDI(x) EXTRACT_BITS (x, 26, 1) +#define SS_DECODE_RP_HI(x) EXTRACT_BITS (x, 27, 1) +#define SS_DECODE_BAP(x) EXTRACT_BITS (x, 28, 1) +#define SS_DECODE_EAP(x) EXTRACT_BITS (x, 29, 1) + +/* SS type1 */ +#define SS_TYPE1_MASK 0x3fefe000 +#define SS_ENCODE_PREP_CALL_HINT(x) ENCODE_BITS (x, 12, 1) +#define SS_DECODE_PREP_CALL_HINT(x) EXTRACT_BITS (x, 12, 1) + +/* TODO: SS flushts and invts formats. */ + +/* ALS */ + +#define STAA_MODE_AAD 0 +#define STAA_MODE_AASTI 1 +#define STAA_MODE_AAIND 2 +#define STAA_MODE_AAINCR 3 + +#define ALS_IS_DST_CTPR(dst) ((dst) >= 0xd1 && (dst) <= 0xd3) + +#define ALS_ENCODE_DST(x) ENCODE_BITS (x, 0, 8) +#define ALS_ENCODE_SRC4 ALS_ENCODE_DST +#define ALS_ENCODE_SRC2(x) ENCODE_BITS (x, 8, 8) +#define ALS_ENCODE_SRC1(x) ENCODE_BITS (x, 16, 8) +#define ALS_ENCODE_IMM3(x) ENCODE_BITS (x, 24, 3) +#define ALS_ENCODE_OPC(x) ENCODE_BITS (x, 24, 7) +#define ALS_ENCODE_SM(x) ENCODE_BITS (x, 31, 1) +#define ALS_ENCODE_CMP_DST(x) ENCODE_BITS (x, 0, 5) +#define ALS_ENCODE_CMP_OPC(x) ENCODE_BITS (x, 5, 3) +#define ALS_ENCODE_AA_LTS(x) ENCODE_BITS (x, 8, 2) +#define ALS_ENCODE_AA_MODE(x) ENCODE_BITS (x, 10, 2) +#define ALS_ENCODE_AA_INC(x) ENCODE_BITS (x, 10, 1) +#define ALS_ENCODE_AA_S(x) ENCODE_BITS (x, 11, 1) +#define ALS_ENCODE_AA_INCR(x) ENCODE_BITS (x, 12, 3) +#define ALS_ENCODE_AA_INDEX(x) ENCODE_BITS (x, 15, 4) +#define ALS_ENCODE_AA_AAD(x) ENCODE_BITS (x, 19, 5) +#define ALS_DECODE_DST(x) EXTRACT_BITS (x, 0, 8) +#define ALS_DECODE_SRC4 ALS_DECODE_DST +#define ALS_DECODE_SRC2(x) EXTRACT_BITS (x, 8, 8) +#define ALS_DECODE_SRC1(x) EXTRACT_BITS (x, 16, 8) +#define ALS_DECODE_SRC1(x) EXTRACT_BITS (x, 16, 8) +#define ALS_DECODE_IMM3(x) EXTRACT_BITS (x, 24, 3) +#define ALS_DECODE_OPC(x) EXTRACT_BITS (x, 24, 7) +#define ALS_DECODE_SM(x) EXTRACT_BITS (x, 31, 1) +#define ALS_DECODE_CMP_DST(x) EXTRACT_BITS (x, 0, 5) +#define ALS_DECODE_CMP_OPC(x) EXTRACT_BITS (x, 5, 3) +#define ALS_DECODE_AA_LTS(x) EXTRACT_BITS (x, 8, 2) +#define ALS_DECODE_AA_MODE(x) EXTRACT_BITS (x, 10, 2) +#define ALS_DECODE_AA_S(x) EXTRACT_BITS (x, 11, 1) +#define ALS_DECODE_AA_INC(x) EXTRACT_BITS (x, 10, 1) +#define ALS_DECODE_AA_INCR(x) EXTRACT_BITS (x, 12, 3) +#define ALS_DECODE_AA_INDEX(x) EXTRACT_BITS (x, 15, 4) +#define ALS_DECODE_AA_AAD(x) EXTRACT_BITS (x, 19, 5) + +/* ALES */ + +#define ALES_ENCODE_SRC3(x) ENCODE_BITS (x, 0, 8) +#define ALES_ENCODE_OPC(x) ENCODE_BITS (x, 8, 8) +#define ALES_DECODE_SRC3(x) EXTRACT_BITS (x, 0, 8) +#define ALES_DECODE_OPC(x) EXTRACT_BITS (x, 8, 8) + +/* CS0 */ + +#define CS0_ENCODE_DISP_RAW(x) ENCODE_BITS ((x), 0, 28) +#define CS0_ENCODE_DISP(x) ENCODE_BITS ((x) >> 3, 0, 28) +#define CS0_ENCODE_CTPR(x) ENCODE_BITS (x, 30, 2) +#define CS0_DECODE_DISP_RAW(x) EXTRACT_BITS (x, 0, 28) +#define CS0_DECODE_DISP(x) (((int32_t) (EXTRACT_BITS (x, 0, 28) << 4)) >> 1) +#define CS0_DECODE_CTPR(x) EXTRACT_BITS (x, 30, 2) +#define CS0_IS_DISP_VALID(x) \ + (CS0_DECODE_DISP (CS0_ENCODE_DISP (x)) == (int32_t) (x)) + +#define PREP_OPCODE_CS0 0x00000000 +#define PREP_OPCODE_MASK_CS0 0x30000000 +#define PREP_ENCODE_CTPR_CS0 CS0_ENCODE_CTPR +#define PREP_ENCODE_DISP_CS0 CS0_ENCODE_DISP +#define PREP_DECODE_CTPR_CS0 CS0_DECODE_CTPR +#define PREP_DECODE_DISP_CS0 CS0_DECODE_DISP +#define PREP_IS_DISP_VALID_CS0 CS0_IS_DISP_VALID + +#define PREP_APB_OPCODE_CS0 0x90000000 +#define PREP_APB_OPCODE_MASK_CS0 0xf0000000 +#define PREP_APB_ENCODE_DISP_CS0 CS0_ENCODE_DISP +#define PREP_APB_DECODE_DISP_CS0 CS0_DECODE_DISP +#define PREP_APB_IS_DISP_VALID_CS0 CS0_IS_DISP_VALID + +#define PREP_SYS_OPCODE_CS0 0x20000000 +#define PREP_SYS_OPCODE_MASK_CS0 0x30000000 +#define PREP_SYS_ENCODE_CTPR_CS0 CS0_ENCODE_CTPR +#define PREP_SYS_ENCODE_DISP_CS0 CS0_ENCODE_DISP_RAW +#define PREP_SYS_DECODE_CTPR_CS0 CS0_DECODE_CTPR +#define PREP_SYS_DECODE_DISP_CS0 CS0_DECODE_DISP_RAW + +#define PREP_RET_OPCODE_CS0 0xf0000000 +#define PREP_RET_OPCODE_MASK_CS0 0xffffffff + +#define GETTSD_OPCODE_CS0 0x30000001 +#define GETTSD_OPCODE_MASK_CS0 0x3fffffff +#define GETTSD_ENCODE_CTPR_CS0 CS0_ENCODE_CTPR +#define GETTSD_DECODE_CTPR_CS0 CS0_DECODE_CTPR + +#define IBRANCH_OPCODE_CS0 0x00000000 +#define IBRANCH_OPCODE_MASK_CS0 0xf0000000 +#define IBRANCH_ENCODE_DISP_CS0 CS0_ENCODE_DISP +#define IBRANCH_DECODE_DISP_CS0 CS0_DECODE_DISP +#define IBRANCH_IS_DISP_VALID_CS0 CS0_IS_DISP_VALID + +#define PREF_OPCODE_CS0 0x10000000 +#define PREF_OPCODE_MASK_CS0 0xf0000000 +#define PREF_IPD_CS0 (1u << 3) +#define PREF_ENCODE_IPR_CS0(x) ENCODE_BITS (x, 0, 3) +#define PREF_ENCODE_DISP_CS0(x) ENCODE_BITS (x, 4, 24) +#define PREF_DECODE_IPR_CS0(x) EXTRACT_BITS (x, 0, 3) +#define PREF_DECODE_DISP_CS0(x) EXTRACT_BITS (x, 4, 24) + +#define PUTTSD_OPCODE_CS0 0x20000000 +#define PUTTSD_OPCODE_MASK_CS0 0xf0000000 +#define PUTTSD_ENCODE_DISP_CS0 CS0_ENCODE_DISP +#define PUTTSD_DECODE_DISP_CS0 CS0_DECODE_DISP +#define PUTTSD_IS_DISP_VALID_CS0 CS0_IS_DISP_VALID + +#define DONE_OPCODE_CS0 0x30000000 +#define DONE_OPCODE_MASK_CS0 0xf3fffff8 +#define DONE_ENCODE_TYPE_CS0(x) ENCODE_BITS (x, 0, 3) +#define DONE_DECODE_TYPE_CS0(x) EXTRACT_BITS (x, 0, 3) +#define DONE_TYPE_DONE 0 +#define DONE_TYPE_IRET 2 +#define DONE_TYPE_HRET 3 +#define DONE_TYPE_GLAUNCH 4 +#define DONE_FDAM_CS0 (1u << 26) +#define DONE_TRAR_CS0 (1u << 27) + +/* CS1 */ + +#define SETWD_OPCODE_CS1 0x00000000 +#define SETWD_OPCODE_MASK_CS1 0xe1800000 +#define SETWD_OPCODE_LTS0 0x00000000 +#define SETWD_OPCODE_MASK_LTS0 0x00000003 +#define SETWD_SETTR_CS1 0x02000000 +#define SETWD_SETBN_CS1 0x04000000 +#define SETWD_SETBP_CS1 0x08000000 +#define SETWD_VFRPSZ_CS1 0x10000000 + +#define SETTR_ENCODE_TYPE_LTS0(x) ENCODE_BITS (x, 17, 16) +#define SETTR_DECODE_TYPE_LTS0(x) EXTRACT_BITS (x, 17, 16) + +#define VFRPSZ_ENCODE_RPSZ_LTS0(x) ENCODE_BITS (x, 12, 5) +#define VFRPSZ_DECODE_RPSZ_LTS0(x) EXTRACT_BITS (x, 12, 5) + +#define SETWD_MCN_LTS0 0x00000004 +#define SETWD_DBL_LTS0 0x00000008 +#define SETWD_NFX_LTS0 0x00000010 +#define SETWD_ENCODE_WSZ_LTS0(x) ENCODE_BITS ((x) / 2, 5, 7) +#define SETWD_DECODE_WSZ_LTS0(x) (2 * EXTRACT_BITS (x, 5, 7)) + +#define SETBN_ENCODE_RBS_CS1(x) ENCODE_BITS ((x) / 2, 0, 6) +#define SETBN_ENCODE_RSZ_CS1(x) ENCODE_BITS ((x) / 2 - 1, 6, 6) +#define SETBN_ENCODE_RCUR_CS1(x) ENCODE_BITS ((x) / 2, 12, 6) +#define SETBN_DECODE_RBS_CS1(x) (2 * EXTRACT_BITS (x, 0, 6)) +#define SETBN_DECODE_RSZ_CS1(x) (2 + 2 * EXTRACT_BITS (x, 6, 6)) +#define SETBN_DECODE_RCUR_CS1(x) (2 * EXTRACT_BITS (x, 12, 6)) + +#define SETBP_ENCODE_PSZ_CS1(x) ENCODE_BITS (x, 18, 5) +#define SETBP_DECODE_PSZ_CS1(x) EXTRACT_BITS (x, 18, 5) + +#define SETBN_SETBP_OPCODE_CS1 0x40000000 +#define SETBN_SETBP_OPCODE_MASK_CS1 0xe3800000 + +#define SETEI_OPCODE_CS1 0x20000000 +#define SETEI_OPCODE_MASK_CS1 0xf8000000 +#define SETEI_ENCODE_VALUE_CS1(x) ENCODE_BITS (x, 0, 8) +#define SETEI_DECODE_VALUE_CS1(x) EXTRACT_BITS (x, 0, 8) + +#define SETSFT_CS1_OPCODE 0x28000000 +#define SETSFT_CS1_OPCODE_MASK 0xf8000000 + +#define WAIT_OPCODE_CS1 0x30000000 +#define WAIT_OPCODE_MASK_CS1 0xfffffe00 +#define WAIT_ALL_C_CS1 (1u << 0) +#define WAIT_ALL_E_CS1 (1u << 1) +#define WAIT_ST_C_CS1 (1u << 2) +#define WAIT_LD_C_CS1 (1u << 3) +#define WAIT_FL_C_CS1 (1u << 4) +#define WAIT_MA_C_CS1 (1u << 5) +#define WAIT_TRAP_CS1 (1u << 6) +#define WAIT_SAL_CS1 (1u << 7) +#define WAIT_SAS_CS1 (1u << 8) + +#define CALL_OPCODE_CS1 0x50000000 +#define CALL_OPCODE_MASK_CS1 0xffffff80 +#define ICALL_OPCODE_CS1 0x50000080 +#define ICALL_OPCODE_MASK_CS1 0xffffff80 +#define CALL_ENCODE_WBS_CS1(x) ENCODE_BITS ((x) / 2, 0, 7) +#define CALL_DECODE_WBS_CS1(x) (EXTRACT_BITS (x, 0, 7) * 2) + +#define SETMAS_OPCODE_CS1 0x60000000 +#define SETMAS_OPCODE_MASK_CS1 0xf0000000 +#define SETMAS_OFFSET_FROM_CHAN(i) (7 * ((i) == 5 ? (i) - 2 : ((i) >= 2 ? (i) - 1 : (i)))) +#define SETMAS_ENCODE_CS1(x, ch) ENCODE_BITS (x, SETMAS_OFFSET_FROM_CHAN (5 - ch), 7) +#define SETMAS_DECODE_CS1(x, ch) EXTRACT_BITS (x, SETMAS_OFFSET_FROM_CHAN (5 - ch), 7) + +#define HAS_SETMAS(bundle) (bundle->cs_present[1] && \ + TEST_OPCODE (bundle->cs[1], SETMAS_OPCODE_CS1, SETMAS_OPCODE_MASK_CS1)) + +#define FLUSH_CS1_OPCODE 0x70000000 +#define FLUSH_CS1_OPCODE_MASK 0xfffffffc +#define FLUSH_R_CS1 0x00000001 +#define FLUSH_C_CS1 0x00000002 + +#define VFBG_OPCODE_CS1 0x80000000 +#define VFBG_OPCODE_MASK_CS1 0xfffe0000 +#define VFBG_CHKM4_CS1 0x00010000 +#define VFBG_ENCODE_UMASK_CS1(x) ENCODE_BITS (x, 0, 8) +#define VFBG_ENCODE_DMASK_CS1(x) ENCODE_BITS (x, 8, 8) +#define VFBG_DECODE_UMASK_CS1(x) EXTRACT_BITS (x, 0, 8) +#define VFBG_DECODE_DMASK_CS1(x) EXTRACT_BITS (x, 8, 8) + +/* CDS */ + +#define PSRC_PCNT 0x40 +#define PSRC_PREG 0x60 +#define RLP_ENCODE_PSRC(x) ENCODE_BITS (x, 0, 7) +#define RLP_ENCODE_INV(x, i) ENCODE_BITS (x, 7 + (i), 1) +#define RLP_ENCODE_ALC(x, i) ENCODE_BITS (x, 10 + (i), 1) +#define RLP_DECODE_PSRC(x) EXTRACT_BITS (x, 0, 7) +#define RLP_DECODE_INV(x, i) EXTRACT_BITS (x, 7 + (i), 1) +#define RLP_DECODE_ALC(x, i) EXTRACT_BITS (x, 10 + (i), 1) +#define RLP_AM 0x2000 +#define RLP_CLUSTER 0x4000 +#define RLP_MRGC 0x8000 + +/* AAS 2..5 */ + +#define MOVA_ENCODE_IND(x) ENCODE_BITS (x, 1, 5) +#define MOVA_ENCODE_AREA(x) ENCODE_BITS (x, 6, 6) +#define MOVA_DECODE_IND(x) EXTRACT_BITS (x, 1, 5) +#define MOVA_DECODE_AREA(x) EXTRACT_BITS (x, 6, 6) + +#define MOVA_AM 0x0001 +#define MOVA_OPC_MASK 0x7000 +#define MOVA_NONE 0x0000 +#define MOVAB 0x1000 +#define MOVAH 0x2000 +#define MOVAW 0x3000 +#define MOVAD 0x4000 +#define MOVAQ 0x5000 +#define MOVA_UNDEFINED 0x6000 +#define MOVAQP 0x7000 +#define MOVA_BE 0x8000 + +/* PLS */ + +#define ELP_ENCODE(x, i) ENCODE_BITS (x, (i) ? 16 : 24, 8) +#define ELP_DECODE(x, i) EXTRACT_BITS (x, (i) ? 16 : 24, 8) + +#define LP_ENCODE_PREG(x) ENCODE_BITS (x, 0, 5) +#define LP_DECODE_PREG(x) EXTRACT_BITS (x, 0, 5) +#define LP_WRITE_PREG (1u << 5) +#define LP_ENCODE_LPSRC(x, i) ENCODE_BITS (x, (i) ? 6 : 10, 3) +#define LP_DECODE_LPSRC(x, i) EXTRACT_BITS (x, (i) ? 6 : 10, 3) +#define LP_ENCODE_LPSRC_INV(x, i) ENCODE_BITS (x, (i) ? 9 : 13, 1) +#define LP_DECODE_LPSRC_INV(x, i) EXTRACT_BITS (x, (i) ? 9 : 13, 1) +#define LP_ANDP (0u << 14) +#define LP_LANDP (1u << 14) +#define LP_MOVEP (3u << 14) +#define LP_OPC_MASK (3u << 14) + +/* FAPB */ + +#define FAPB_ENCODE_ABS(x) ENCODE_BITS (x, 0, 5) +#define FAPB_ENCODE_ASZ(x) ENCODE_BITS (x, 5, 3) +#define FAPB_ENCODE_INDEX(x) ENCODE_BITS (x, 8, 4) +#define FAPB_ENCODE_INCR(x) ENCODE_BITS (x, 12, 3) +#define FAPB_ENCODE_AAD(x) ENCODE_BITS (x, 15, 5) +#define FAPB_ENCODE_MRNG(x) ENCODE_BITS (x, 20, 5) +#define FAPB_ENCODE_FMT(x) ENCODE_BITS (x, 25, 3) +#define FAPB_ENCODE_DCD(x) ENCODE_BITS (x, 28, 2) +#define FAPB_DECODE_ABS(x) EXTRACT_BITS (x, 0, 5) +#define FAPB_DECODE_ASZ(x) EXTRACT_BITS (x, 5, 3) +#define FAPB_DECODE_INDEX(x) EXTRACT_BITS (x, 8, 4) +#define FAPB_DECODE_INCR(x) EXTRACT_BITS (x, 12, 3) +#define FAPB_DECODE_AAD(x) EXTRACT_BITS (x, 15, 5) +#define FAPB_DECODE_MRNG(x) EXTRACT_BITS (x, 20, 5) +#define FAPB_DECODE_FMT(x) EXTRACT_BITS (x, 25, 3) +#define FAPB_DECODE_DCD(x) EXTRACT_BITS (x, 28, 2) + +#define FAPB_SI (1u << 30) +#define FAPB_CT (1u << 31) +#define FAPB_DPL (1u << 31) + +#endif /* _E2K_H_ */ diff --git a/disas/meson.build b/disas/meson.build index 815523ab85..aedb4947e3 100644 --- a/disas/meson.build +++ b/disas/meson.build @@ -1,5 +1,9 @@ common_ss.add(when: 'CONFIG_ALPHA_DIS', if_true: files('alpha.c')) common_ss.add(when: 'CONFIG_CRIS_DIS', if_true: files('cris.c')) +common_ss.add(when: 'CONFIG_E2K_DIS', if_true: files( + 'e2k-opc.c', + 'e2k-dis.c', +)) common_ss.add(when: 'CONFIG_HEXAGON_DIS', if_true: files('hexagon.c')) common_ss.add(when: 'CONFIG_HPPA_DIS', if_true: files('hppa.c')) common_ss.add(when: 'CONFIG_M68K_DIS', if_true: files('m68k.c')) diff --git a/include/disas/dis-asm.h b/include/disas/dis-asm.h index 7cc3c64850..81cb6960da 100644 --- a/include/disas/dis-asm.h +++ b/include/disas/dis-asm.h @@ -237,23 +237,14 @@ enum bfd_architecture #define bfd_mach_cris_v32 32 #define bfd_mach_cris_v10_v32 1032 bfd_arch_microblaze, /* Xilinx MicroBlaze. */ - bfd_arch_e2k, /* MCST E2K. */ -/* It's crucial that the underlying `bfd_mach_e2k*' have the same values as */ -/* the corresponding `E_E2K_MACH_*'s!!! */ -#define bfd_mach_e2k_generic 0 -#define bfd_mach_e2k_ev1 1 -/* This is interpreted as the common subset of all Elbrus V2 iterations. - Currently it is the same as the common subset of all elbrus-2c+. */ -#define bfd_mach_e2k_ev2 2 -#define bfd_mach_e2k_ev3 3 -#define bfd_mach_e2k_ev4 4 -#define bfd_mach_e2k_ev5 5 -#define bfd_mach_e2k_ev6 6 -/* Values 16, 17 and 18 used to be reserved for the first three iterations - of `elbrus-v2'. See `include/elf/e2k.h' for why they can't be reused right - now. */ -#define bfd_mach_e2k_8c 19 -#define bfd_mach_e2k_1cplus 20 + bfd_arch_e2k, /* MCST E2K. */ +#define bfd_mach_e2k_v1 1 +#define bfd_mach_e2k_v2 2 +#define bfd_mach_e2k_v3 3 +#define bfd_mach_e2k_v4 4 +#define bfd_mach_e2k_v5 5 +#define bfd_mach_e2k_v6 6 +#define bfd_mach_e2k_v7 7 bfd_arch_moxie, /* The Moxie core. */ bfd_arch_ia64, /* HP/Intel ia64 */ #define bfd_mach_ia64_elf64 64 diff --git a/target/e2k/cpu.c b/target/e2k/cpu.c index c0ed9c693b..a386f6dcaa 100644 --- a/target/e2k/cpu.c +++ b/target/e2k/cpu.c @@ -96,6 +96,7 @@ static void e2k_cpu_disas_set_info(CPUState *cs, disassemble_info *info) CPUE2KState *env = &cpu->env; info->mach = env->version * 3; + info->print_insn = print_insn_e2k; } /* https://www.altlinux.org/Модели_процессоров_Эльбрус */