From 7a667b7ba5cd543977fca583b50a5b9ca9d68faa Mon Sep 17 00:00:00 2001 From: Denis Drakhnya Date: Sun, 3 Jan 2021 16:06:18 +0200 Subject: [PATCH] target: e2k: Add short, ext, ext1, ext2 alops table. --- target/e2k/translate.c | 1 + target/e2k/translate.h | 1 + target/e2k/translate/alc.c | 1824 ++++++++++++++++---------------- target/e2k/translate/alops.inc | 1809 +++++++++++++++++++++++++++++++ 4 files changed, 2731 insertions(+), 904 deletions(-) create mode 100644 target/e2k/translate/alops.inc diff --git a/target/e2k/translate.c b/target/e2k/translate.c index b89f6ade6f..831c68aed0 100644 --- a/target/e2k/translate.c +++ b/target/e2k/translate.c @@ -363,6 +363,7 @@ static void e2k_tr_init_disas_context(DisasContextBase *db, CPUState *cs) CPUE2KState *env = &cpu->env; ctx->version = env->version; + e2k_alc_init(ctx); } static void e2k_tr_tb_start(DisasContextBase *db, CPUState *cs) diff --git a/target/e2k/translate.h b/target/e2k/translate.h index ac1b140a23..316d1ef284 100644 --- a/target/e2k/translate.h +++ b/target/e2k/translate.h @@ -559,6 +559,7 @@ void e2k_control_execute(DisasContext *ctx); void e2k_control_window_change(DisasContext *ctx); void e2k_stubs_commit(DisasContext *ctx); +void e2k_alc_init(DisasContext *ctx); void e2k_alc_execute(DisasContext *ctx); void e2k_alc_commit(DisasContext *ctx); diff --git a/target/e2k/translate/alc.c b/target/e2k/translate/alc.c index f54419744d..5333d24032 100644 --- a/target/e2k/translate/alc.c +++ b/target/e2k/translate/alc.c @@ -3,29 +3,9 @@ #include "exec/log.h" #include "translate.h" -#define NO_EXT 0x0 -#define EXT 0x1 -#define EXT1 0x2 -#define EXT2 0x3 -#define FLB 0x4 -#define FLH 0x5 -#define FLW 0x6 -#define FLD 0x7 -#define ICMB0 0x8 -#define ICMB1 0x9 -#define ICMB2 0xA -#define ICMB3 0xB +#include "alops.inc" -#define FCMB0 0xC -#define FCMB1 0xD -#define PFCMB0 0XE -#define PFCMB1 0xF -#define LCMBD0 0x10 -#define LCMBD1 0x11 -#define LCMBQ0 0x12 -#define LCMBQ1 0x13 -#define QPFCMB0 0x16 -#define QPFCMB1 0x17 +static int16_t alops_map[4][128][6] = { { { -1 } } }; typedef struct { TCGv_i32 tag; @@ -1713,7 +1693,7 @@ static void gen_ld(DisasContext *ctx, Instr *instr, MemOp memop) tcg_temp_free_i64(t0); } -static void gen_st_i64(DisasContext *ctx, Instr *instr, MemOp memop) +static void gen_st_ddd(DisasContext *ctx, Instr *instr, MemOp memop) { TCGLabel *l0 = gen_new_label(); Src64 s1 = get_src1_i64(ctx, instr->chan); @@ -1746,7 +1726,7 @@ static void gen_st_i64(DisasContext *ctx, Instr *instr, MemOp memop) tcg_temp_free_i64(t0); } -static void gen_st_i32(DisasContext *ctx, Instr *instr, MemOp memop) +static void gen_st_dds(DisasContext *ctx, Instr *instr, MemOp memop) { TCGLabel *l0 = gen_new_label(); Src64 s1 = get_src1_i64(ctx, instr->chan); @@ -2102,7 +2082,7 @@ static void gen_staa_i32(DisasContext *ctx, Instr *instr, MemOp memop) gen_set_label(l0); } -static void gen_alopf1_i64(DisasContext *ctx, int chan, +static void gen_alopf1_ddd(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_i64, TCGv_i64)) { Src64 s1 = get_src1_i64(ctx, chan); @@ -2115,7 +2095,7 @@ static void gen_alopf1_i64(DisasContext *ctx, int chan, gen_al_result_i64(ctx, chan, dst, tag); } -static void gen_alopf1_i64_env(DisasContext *ctx, int chan, +static void gen_alopf1_dedd(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_env, TCGv_i64, TCGv_i64)) { Src64 s1 = get_src1_i64(ctx, chan); @@ -2128,7 +2108,7 @@ static void gen_alopf1_i64_env(DisasContext *ctx, int chan, gen_al_result_i64(ctx, chan, dst, tag); } -static void gen_alopf1_i32(DisasContext *ctx, int chan, +static void gen_alopf1_sss(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_i32, TCGv_i32)) { Src32 s1 = get_src1_i32(ctx, chan); @@ -2141,7 +2121,7 @@ static void gen_alopf1_i32(DisasContext *ctx, int chan, gen_al_result_i32(ctx, chan, dst, tag); } -static void gen_alopf1_i32_env(DisasContext *ctx, int chan, +static void gen_alopf1_sess(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_env, TCGv_i32, TCGv_i32)) { Src32 s1 = get_src1_i32(ctx, chan); @@ -2154,7 +2134,7 @@ static void gen_alopf1_i32_env(DisasContext *ctx, int chan, gen_al_result_i32(ctx, chan, dst, tag); } -static void gen_alopf1_i32_i64(DisasContext *ctx, int chan, +static void gen_alopf1_dss(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_i32, TCGv_i32)) { Src32 s1 = get_src1_i32(ctx, chan); @@ -2167,7 +2147,7 @@ static void gen_alopf1_i32_i64(DisasContext *ctx, int chan, gen_al_result_i64(ctx, chan, dst, tag); } -static void gen_alopf1_tag_i64(DisasContext *ctx, int chan, +static void gen_alopf1_dttdd(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_i32, TCGv_i32, TCGv_i64, TCGv_i64)) { Src64 s1 = get_src1_i64(ctx, chan); @@ -2180,7 +2160,7 @@ static void gen_alopf1_tag_i64(DisasContext *ctx, int chan, gen_al_result_i64(ctx, chan, dst, tag); } -static void gen_alopf1_tag_i32(DisasContext *ctx, int chan, +static void gen_alopf1_sttss(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_i32, TCGv_i32, TCGv_i32, TCGv_i32)) { Src32 s1 = get_src1_i32(ctx, chan); @@ -2193,7 +2173,7 @@ static void gen_alopf1_tag_i32(DisasContext *ctx, int chan, gen_al_result_i32(ctx, chan, dst, tag); } -static void gen_alopf1_cmp_i64(DisasContext *ctx, Instr *instr, +static void gen_alopf1_cmp_ddb(DisasContext *ctx, Instr *instr, void (*op)(TCGv_i64, int, TCGv_i64, TCGv_i64)) { int chan = instr->chan; @@ -2216,7 +2196,7 @@ static void gen_alopf1_cmp_i64(DisasContext *ctx, Instr *instr, tcg_temp_free_i32(t0); } -static void gen_alopf1_cmp_i32(DisasContext *ctx, Instr *instr, +static void gen_alopf1_cmp_ssb(DisasContext *ctx, Instr *instr, void (*op)(TCGv_i32, int, TCGv_i32, TCGv_i32)) { int chan = instr->chan; @@ -2291,7 +2271,7 @@ static void gen_alopf1_cmp_xs(DisasContext *ctx, Instr *instr) temp_free_src80(&t2); } -static void gen_alopf1_mrgc_i32(DisasContext *ctx, Instr *instr) +static void gen_alopf1_mrgc_sss(DisasContext *ctx, Instr *instr) { Src32 s1 = get_src1_i32(ctx, instr->chan); Src32 s2 = get_src2_i32(ctx, instr->chan); @@ -2310,7 +2290,7 @@ static void gen_alopf1_mrgc_i32(DisasContext *ctx, Instr *instr) tcg_temp_free_i32(t0); } -static void gen_alopf1_mrgc_i64(DisasContext *ctx, Instr *instr) +static void gen_alopf1_mrgc_ddd(DisasContext *ctx, Instr *instr) { Src64 s1 = get_src1_i64(ctx, instr->chan); Src64 s2 = get_src2_i64(ctx, instr->chan); @@ -2357,7 +2337,7 @@ static void gen_alopf21_i32(DisasContext *ctx, Instr *instr, gen_al_result_i32(ctx, instr->chan, dst, tag); } -static void gen_alopf2_i32(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_i32)) +static void gen_alopf2_ss(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_i32)) { Src32 s2 = get_src2_i32(ctx, chan); TCGv_i32 dst = e2k_get_temp_i32(ctx); @@ -2368,7 +2348,7 @@ static void gen_alopf2_i32(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCG gen_al_result_i32(ctx, chan, dst, tag); } -static void gen_alopf2_i64(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_i64)) +static void gen_alopf2_dd(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_i64)) { Src64 s2 = get_src2_i64(ctx, chan); TCGv_i64 dst = e2k_get_temp_i64(ctx); @@ -2379,7 +2359,7 @@ static void gen_alopf2_i64(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCG gen_al_result_i64(ctx, chan, dst, tag); } -static void gen_alopf2_i32_env(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_env, TCGv_i32)) +static void gen_alopf2_ses(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_env, TCGv_i32)) { Src32 s2 = get_src2_i32(ctx, chan); TCGv_i32 dst = e2k_get_temp_i32(ctx); @@ -2390,7 +2370,7 @@ static void gen_alopf2_i32_env(DisasContext *ctx, int chan, void (*op)(TCGv_i32, gen_al_result_i32(ctx, chan, dst, tag); } -static void gen_alopf2_i64_env(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_env, TCGv_i64)) +static void gen_alopf2_ded(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_env, TCGv_i64)) { Src64 s2 = get_src2_i64(ctx, chan); TCGv_i64 dst = e2k_get_temp_i64(ctx); @@ -2401,7 +2381,7 @@ static void gen_alopf2_i64_env(DisasContext *ctx, int chan, void (*op)(TCGv_i64, gen_al_result_i64(ctx, chan, dst, tag); } -static void gen_alopf2_i64_i32_env(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_env, TCGv_i64)) +static void gen_alopf2_sed(DisasContext *ctx, int chan, void (*op)(TCGv_i32, TCGv_env, TCGv_i64)) { Src64 s2 = get_src2_i64(ctx, chan); TCGv_i32 dst = e2k_get_temp_i32(ctx); @@ -2412,7 +2392,7 @@ static void gen_alopf2_i64_i32_env(DisasContext *ctx, int chan, void (*op)(TCGv_ gen_al_result_i32(ctx, chan, dst, tag); } -static void gen_alopf2_i32_i64_env(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_env, TCGv_i32)) +static void gen_alopf2_des(DisasContext *ctx, int chan, void (*op)(TCGv_i64, TCGv_env, TCGv_i32)) { Src32 s2 = get_src2_i32(ctx, chan); TCGv_i64 dst = e2k_get_temp_i64(ctx); @@ -2609,893 +2589,908 @@ static inline void gen_alopf2_dx(DisasContext *ctx, Instr *instr, gen_al_result_i80(ctx, instr, res.lo, res.hi, res.tag); } -static void gen_no_ext(DisasContext *ctx, Instr *instr) +static Alop find_op(Instr *instr) +{ + int16_t index = alops_map[instr->opc2][instr->opc1][instr->chan]; + while (index != -1) { + bool is_match = false; + AlopDesc *desc = &alops[index]; + switch(desc->alopf) { + case ALOPF1: + case ALOPF1_MERGE: + case ALOPF3: + case ALOPF10: + case ALOPF11_LIT8: + case ALOPF12_PSHUFH: + case ALOPF21: + is_match = true; + break; + case ALOPF2: + case ALOPF15: + is_match = desc->extra1 == instr->opce1; + break; + case ALOPF7: + is_match = desc->extra1 == instr->opc_cmp; + break; + case ALOPF8: + is_match = desc->extra1 == instr->opc_cmp && instr->opce1 == 0xc0; + break; + case ALOPF11: + case ALOPF11_MERGE: + case ALOPF13: + case ALOPF17: + is_match = desc->extra1 == instr->opce3; + break; + case ALOPF12: + case ALOPF12_IBRANCHD: + case ALOPF12_ICALLD: + case ALOPF22: + is_match = desc->extra1 == instr->opce1 && desc->extra2 == instr->opce3; + break; + case ALOPF16: + is_match = desc->extra1 == instr->opce2; + break; + } + + if (is_match) { + return desc->op; + } + + index = desc->next[instr->chan]; + } + + return OP_NONE; +} + +static void gen_op(DisasContext *ctx, Instr *instr) { int chan = instr->chan; + Alop op = find_op(instr); - switch(instr->opc1) { - case 0x00: /* ands */ gen_alopf1_i32(ctx, chan, tcg_gen_and_i32); return; - case 0x01: /* andd */ gen_alopf1_i64(ctx, chan, tcg_gen_and_i64); return; - case 0x02: /* andns */ gen_alopf1_i32(ctx, chan, gen_andn_i32); return; - case 0x03: /* andnd */ gen_alopf1_i64(ctx, chan, gen_andn_i64); return; - case 0x04: /* ors */ gen_alopf1_i32(ctx, chan, tcg_gen_or_i32); return; - case 0x05: /* ord */ gen_alopf1_i64(ctx, chan, tcg_gen_or_i64); return; - case 0x06: /* orns */ gen_alopf1_i32(ctx, chan, gen_orn_i32); return; - case 0x07: /* ornd */ gen_alopf1_i64(ctx, chan, gen_orn_i64); return; - case 0x08: /* xors */ gen_alopf1_i32(ctx, chan, tcg_gen_xor_i32); return; - case 0x09: /* xord */ gen_alopf1_i64(ctx, chan, tcg_gen_xor_i64); return; - case 0x0a: /* xorns */ gen_alopf1_i32(ctx, chan, gen_xorn_i32); return; - case 0x0b: /* xornd */ gen_alopf1_i64(ctx, chan, gen_xorn_i64); return; - case 0x0c: /* sxt */ gen_sxt(ctx, chan); return; - case 0x0e: /* merges */ gen_alopf1_mrgc_i32(ctx, instr); return; - case 0x0f: /* merged */ gen_alopf1_mrgc_i64(ctx, instr); return; - case 0x10: /* adds */ gen_alopf1_i32(ctx, chan, tcg_gen_add_i32); return; - case 0x11: /* addd */ gen_alopf1_i64(ctx, chan, tcg_gen_add_i64); return; - case 0x12: /* subs */ gen_alopf1_i32(ctx, chan, tcg_gen_sub_i32); return; - case 0x13: /* subd */ gen_alopf1_i64(ctx, chan, tcg_gen_sub_i64); return; - case 0x14: /* scls */ gen_alopf1_i32(ctx, chan, tcg_gen_rotl_i32); return; - case 0x15: /* scld */ gen_alopf1_i64(ctx, chan, tcg_gen_rotl_i64); return; - case 0x16: /* scrs */ gen_alopf1_i32(ctx, chan, tcg_gen_rotr_i32); return; - case 0x17: /* scrd */ gen_alopf1_i64(ctx, chan, tcg_gen_rotr_i64); return; - case 0x18: /* shls */ gen_alopf1_i32(ctx, chan, tcg_gen_shl_i32); return; - case 0x19: /* shld */ gen_alopf1_i64(ctx, chan, tcg_gen_shl_i64); return; - case 0x1a: /* shrs */ gen_alopf1_i32(ctx, chan, tcg_gen_shr_i32); return; - case 0x1b: /* shrd */ gen_alopf1_i64(ctx, chan, tcg_gen_shr_i64); return; - case 0x1c: /* sars */ gen_alopf1_i32(ctx, chan, tcg_gen_sar_i32); return; - case 0x1d: /* sard */ gen_alopf1_i64(ctx, chan, tcg_gen_sar_i64); return; - case 0x1e: /* getfs */ gen_alopf1_i32(ctx, chan, gen_getfs); return; - case 0x1f: /* getfd */ gen_alopf1_i64(ctx, chan, gen_getfd); return; - case 0x20: - if (is_chan_0134(chan)) { - /* cmp{op}sb */ - gen_alopf1_cmp_i32(ctx, instr, gen_cmp_i32); - return; - } + switch(op) { + case OP_NONE: e2k_tr_gen_exception(ctx, E2K_EXCP_ILLOPC); break; + case OP_ANDS: gen_alopf1_sss(ctx, chan, tcg_gen_and_i32); break; + case OP_ANDD: gen_alopf1_ddd(ctx, chan, tcg_gen_and_i64); break; + case OP_ANDNS: gen_alopf1_sss(ctx, chan, gen_andn_i32); break; + case OP_ANDND: gen_alopf1_ddd(ctx, chan, gen_andn_i64); break; + case OP_ORS: gen_alopf1_sss(ctx, chan, tcg_gen_or_i32); break; + case OP_ORD: gen_alopf1_ddd(ctx, chan, tcg_gen_or_i64); break; + case OP_ORNS: gen_alopf1_sss(ctx, chan, gen_orn_i32); break; + case OP_ORND: gen_alopf1_ddd(ctx, chan, gen_orn_i64); break; + case OP_XORS: gen_alopf1_sss(ctx, chan, tcg_gen_xor_i32); break; + case OP_XORD: gen_alopf1_ddd(ctx, chan, tcg_gen_xor_i64); break; + case OP_XORNS: gen_alopf1_sss(ctx, chan, gen_xorn_i32); break; + case OP_XORND: gen_alopf1_ddd(ctx, chan, gen_xorn_i64); break; + case OP_SXT: gen_sxt(ctx, chan); break; + case OP_ADDS: gen_alopf1_sss(ctx, chan, tcg_gen_add_i32); break; + case OP_ADDD: gen_alopf1_ddd(ctx, chan, tcg_gen_add_i64); break; + case OP_SUBS: gen_alopf1_sss(ctx, chan, tcg_gen_sub_i32); break; + case OP_SUBD: gen_alopf1_ddd(ctx, chan, tcg_gen_sub_i64); break; + case OP_SCLS: gen_alopf1_sss(ctx, chan, tcg_gen_rotl_i32); break; + case OP_SCLD: gen_alopf1_ddd(ctx, chan, tcg_gen_rotl_i64); break; + case OP_SCRS: gen_alopf1_sss(ctx, chan, tcg_gen_rotr_i32); break; + case OP_SCRD: gen_alopf1_ddd(ctx, chan, tcg_gen_rotr_i64); break; + case OP_SHLS: gen_alopf1_sss(ctx, chan, tcg_gen_shl_i32); break; + case OP_SHLD: gen_alopf1_ddd(ctx, chan, tcg_gen_shl_i64); break; + case OP_SHRS: gen_alopf1_sss(ctx, chan, tcg_gen_shr_i32); break; + case OP_SHRD: gen_alopf1_ddd(ctx, chan, tcg_gen_shr_i64); break; + case OP_SARS: gen_alopf1_sss(ctx, chan, tcg_gen_sar_i32); break; + case OP_SARD: gen_alopf1_ddd(ctx, chan, tcg_gen_sar_i64); break; + case OP_GETFS: gen_alopf1_sss(ctx, chan, gen_getfs); break; + case OP_GETFD: gen_alopf1_ddd(ctx, chan, gen_getfd); break; + case OP_MERGES: gen_alopf1_mrgc_sss(ctx, instr); break; + case OP_MERGED: gen_alopf1_mrgc_ddd(ctx, instr); break; + case OP_CMPOSB: + case OP_CMPBSB: + case OP_CMPESB: + case OP_CMPBESB: + case OP_CMPSSB: + case OP_CMPPSB: + case OP_CMPLSB: + case OP_CMPLESB: + gen_alopf1_cmp_ssb(ctx, instr, gen_cmp_i32); break; - case 0x21: - if (is_chan_0134(chan)) { - /* cmp{op}db */ - gen_alopf1_cmp_i64(ctx, instr, gen_cmp_i64); - return; - } + case OP_CMPODB: + case OP_CMPBDB: + case OP_CMPEDB: + case OP_CMPBEDB: + case OP_CMPSDB: + case OP_CMPPDB: + case OP_CMPLDB: + case OP_CMPLEDB: + gen_alopf1_cmp_ddb(ctx, instr, gen_cmp_i64); break; - case 0x22: - if (is_chan_0134(chan)) { - /* cmpand{op}sb */ - gen_alopf1_cmp_i32(ctx, instr, gen_cmpand_i32); - return; - } + case OP_CMPANDESB: + case OP_CMPANDSSB: + case OP_CMPANDPSB: + case OP_CMPANDLESB: + gen_alopf1_cmp_ssb(ctx, instr, gen_cmpand_i32); break; - case 0x23: - if (is_chan_0134(chan)) { - /* cmpand{op}db */ - gen_alopf1_cmp_i64(ctx, instr, gen_cmpand_i64); - return; - } + case OP_CMPANDEDB: + case OP_CMPANDSDB: + case OP_CMPANDPDB: + case OP_CMPANDLEDB: + gen_alopf1_cmp_ddb(ctx, instr, gen_cmpand_i64); break; - case 0x24: { - if (is_chan_25(chan)) { - /* stb */ - gen_st_i32(ctx, instr, MO_UB); + case OP_FCMPEQSB: + case OP_FCMPLTSB: + case OP_FCMPLESB: + case OP_FCMPUODSB: + case OP_FCMPNEQSB: + case OP_FCMPNLTSB: + case OP_FCMPNLESB: + case OP_FCMPODSB: { + void (*f)(TCGv_i32, TCGv_i32, TCGv_i32) = 0; + + GENERATE_FCMP_SWITCH_TABLE(f, instr->opce3, 0xc0, gen_, f, s); + + if(f) { + gen_alopf1_sss(ctx, chan, f); return; } break; } - case 0x25: { - if (is_chan_25(chan)) { - /* sth */ - gen_st_i32(ctx, instr, MO_UW); + case OP_FCMPEQDB: + case OP_FCMPLTDB: + case OP_FCMPLEDB: + case OP_FCMPUODDB: + case OP_FCMPNEQDB: + case OP_FCMPNLTDB: + case OP_FCMPNLEDB: + case OP_FCMPODDB: { + void (*f)(TCGv_i64, TCGv_i64, TCGv_i64) = 0; + + GENERATE_FCMP_SWITCH_TABLE(f, instr->opce3, 0xc0, gen_, f, d); + + if(f) { + gen_alopf1_ddd(ctx, chan, f); return; } break; } - case 0x26: { - if (is_chan_25(chan)) { - /* stw */ - gen_st_i32(ctx, instr, MO_UL); - return; - } else if(instr->opce1 == 0xc0 && ctx->version >= 2) { - /* bitrevs */ - gen_alopf2_i32(ctx, chan, gen_bitrevs); - return; - } + case OP_FXCMPEQSB: + case OP_FXCMPLTSB: + case OP_FXCMPLESB: + case OP_FXCMPUODSB: + case OP_FXCMPNEQSB: + case OP_FXCMPNLTSB: + case OP_FXCMPNLESB: + case OP_FXCMPODSB: + gen_alopf1_cmp_xs(ctx, instr); break; - } - case 0x27: { - if (is_chan_25(chan)) { - /* std */ - gen_st_i64(ctx, instr, MO_Q); - return; - } else if(instr->opce1 == 0xc0 && ctx->version >= 2) { - /* bitrevd */ - gen_alopf2_i64(ctx, chan, gen_bitrevd); - return; - } + case OP_FXCMPEQDB: + case OP_FXCMPLTDB: + case OP_FXCMPLEDB: + case OP_FXCMPUODDB: + case OP_FXCMPNEQDB: + case OP_FXCMPNLTDB: + case OP_FXCMPNLEDB: + case OP_FXCMPODDB: + gen_alopf1_cmp_xd(ctx, instr); break; - } - case 0x28: - if (is_chan_0134(chan)) { - /* fxcmp{op}sb */ - gen_alopf1_cmp_xs(ctx, instr); - return; - } - case 0x29: - if (is_chan_0134(chan)) { - /* fxcmp{op}db */ - gen_alopf1_cmp_xd(ctx, instr); - return; - } - case 0x2b: { - if (is_chan_0134(chan)) { - /* fxcmp{op}xb */ - gen_alopf1_cmp_xx(ctx, instr); - return; - } - } - case 0x2e: { - if (is_chan_0134(chan)) { - /* fcmp{op}sb */ - gen_alopf1_cmp_i32(ctx, instr, gen_fcmp_i32); - return; - } + case OP_FXCMPEQXB: + case OP_FXCMPLTXB: + case OP_FXCMPLEXB: + case OP_FXCMPUODXB: + case OP_FXCMPNEQXB: + case OP_FXCMPNLTXB: + case OP_FXCMPNLEXB: + case OP_FXCMPODXB: + gen_alopf1_cmp_xx(ctx, instr); break; - } - case 0x2f: { - if (is_chan_0134(chan)) { - /* fcmp{op}db */ - gen_alopf1_cmp_i64(ctx, instr, gen_fcmp_i64); - return; - } - break; - } - case 0x30: - if (is_chan_0134(chan)) { - /* fadds */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fadds); - return; - } - break; - case 0x31: - if (is_chan_0134(chan)) { - /* faddd */ - gen_alopf1_i64_env(ctx, chan, gen_helper_faddd); - return; - } - break; - case 0x32: - if (is_chan_0134(chan)) { - /* fsubs */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fsubs); - return; - } - break; - case 0x33: - if (is_chan_0134(chan)) { - /* fsubd */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fsubd); - return; - } - break; - case 0x34: - if (is_chan_0134(chan)) { - /* fmins */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fmins); - return; - } - break; - case 0x35: - if (is_chan_0134(chan)) { - /* fmind */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fmind); - return; - } - break; - case 0x36: - if (is_chan_0134(chan)) { - /* fmaxs */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fmaxs); - return; - } - break; - case 0x37: - if (is_chan_0134(chan)) { - /* fmaxd */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fmaxd); - return; - } - break; - case 0x38: - if (is_chan_0134(chan)) { - /* fmuls */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fmuls); - return; - } - break; - case 0x39: - if (is_chan_0134(chan)) { - /* fmuld */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fmuld); - return; - } - break; - case 0x3c: - if (is_chan_0134(chan)) { - void (*func)(TCGv_i32, TCGv_env, TCGv_i32) = 0; - - switch(instr->opce1) { - case 0xc0: func = gen_helper_fstois; break; - case 0xc2: func = gen_helper_fstoistr; break; - case 0xc4: func = gen_helper_istofs; break; - } - - if (func) { - gen_alopf2_i32_env(ctx, chan, func); - return; - } - } - break; - case 0x3d: - if (is_chan_0134(chan)) { - void (*func)(TCGv_i64, TCGv_env, TCGv_i64) = 0; - - switch(instr->opce1) { - case 0xc0: func = gen_helper_fdtoid; break; - case 0xc2: func = ctx->version >= 2 ? gen_helper_fdtoidtr : 0; break; - case 0xc4: func = gen_helper_idtofd; break; - case 0xc6: gen_alopf2_xd(ctx, instr, gen_fxtofd); return; - case 0xc7: gen_alopf2_dx(ctx, instr, gen_fdtofx); return; - } - - if (func) { - gen_alopf2_i64_env(ctx, chan, func); - return; - } - } - break; - case 0x3e: - if (is_chan_0134(chan)) { - void (*func)(TCGv_i64, TCGv_env, TCGv_i32) = 0; - - switch(instr->opce1) { - case 0xc0: func = gen_helper_fstoid; break; - case 0xc2: func = ctx->version >= 2 ? gen_helper_fstoidtr : 0; break; - case 0xc4: func = gen_helper_istofd; break; - case 0xc6: func = gen_helper_fstofd; break; - case 0xc7: gen_alopf2_sx(ctx, instr, gen_fstofx); return; - } - - if (func) { - gen_alopf2_i32_i64_env(ctx, chan, func); - return; - } - } - break; - case 0x3f: - if (is_chan_0134(chan)) { - void (*func)(TCGv_i32, TCGv_env, TCGv_i64) = 0; - - switch(instr->opce1) { - case 0xc0: func = gen_helper_fdtois; break; - case 0xc2: func = gen_helper_fdtoistr; break; - case 0xc4: func = gen_helper_idtofs; break; - case 0xc6: func = gen_helper_fdtofs; break; - case 0xc7: gen_alopf2_xs(ctx, instr, gen_fxtofs); return; - } - - if (func) { - gen_alopf2_i64_i32_env(ctx, chan, func); - return; - } - } - break; - case 0x40: - if (is_chan_0134(chan)) { - /* fxaddss */ - gen_alopf1_xss(ctx, instr, gen_helper_fxaddxx); - return; - } else if (chan == 5) { + case OP_STB: gen_st_dds(ctx, instr, MO_UB); break; + case OP_STH: gen_st_dds(ctx, instr, MO_UW); break; + case OP_STW: gen_st_dds(ctx, instr, MO_UL); break; + case OP_STD: gen_st_ddd(ctx, instr, MO_Q); break; + case OP_LDB: gen_ld(ctx, instr, MO_UB); break; + case OP_LDH: gen_ld(ctx, instr, MO_UW); break; + case OP_LDW: gen_ld(ctx, instr, MO_UL); break; + case OP_LDD: gen_ld(ctx, instr, MO_Q); break; + case OP_BITREVS: gen_alopf2_ss(ctx, chan, gen_bitrevs); break; + case OP_BITREVD: gen_alopf2_dd(ctx, chan, gen_bitrevd); break; + case OP_LZCNTS: gen_alopf2_ss(ctx, chan, gen_lzcnts); break; + case OP_LZCNTD: gen_alopf2_dd(ctx, chan, gen_lzcntd); break; + case OP_POPCNTS: gen_alopf2_ss(ctx, chan, tcg_gen_ctpop_i32); break; + case OP_POPCNTD: gen_alopf2_dd(ctx, chan, tcg_gen_ctpop_i64); break; + case OP_FADDS: gen_alopf1_sess(ctx, chan, gen_helper_fadds); break; + case OP_FADDD: gen_alopf1_dedd(ctx, chan, gen_helper_faddd); break; + case OP_FSUBS: gen_alopf1_sess(ctx, chan, gen_helper_fsubs); break; + case OP_FSUBD: gen_alopf1_dedd(ctx, chan, gen_helper_fsubd); break; + case OP_FMINS: gen_alopf1_sess(ctx, chan, gen_helper_fmins); break; + case OP_FMIND: gen_alopf1_dedd(ctx, chan, gen_helper_fmind); break; + case OP_FMAXS: gen_alopf1_sess(ctx, chan, gen_helper_fmaxs); break; + case OP_FMAXD: gen_alopf1_dedd(ctx, chan, gen_helper_fmaxd); break; + case OP_FMULS: gen_alopf1_sess(ctx, chan, gen_helper_fmuls); break; + case OP_FMULD: gen_alopf1_dedd(ctx, chan, gen_helper_fmuld); break; + case OP_FSTOIS: gen_alopf2_ses(ctx, chan, gen_helper_fstois); break; + case OP_FSTOISTR: gen_alopf2_ses(ctx, chan, gen_helper_fstoistr); break; + case OP_ISTOFS: gen_alopf2_ses(ctx, chan, gen_helper_istofs); break; + case OP_FDTOID: gen_alopf2_ded(ctx, chan, gen_helper_fdtoid); break; + case OP_IDTOFD: gen_alopf2_ded(ctx, chan, gen_helper_idtofd); break; + case OP_FXTOFD: gen_alopf2_xd(ctx, instr, gen_fxtofd); break; + case OP_FDTOFX: gen_alopf2_dx(ctx, instr, gen_fdtofx); break; + case OP_FSTOID: gen_alopf2_des(ctx, chan, gen_helper_fstoid); break; + case OP_FSTOIDTR: gen_alopf2_des(ctx, chan, gen_helper_fstoidtr); break; + case OP_FDTOIDTR: gen_alopf2_ded(ctx, chan, gen_helper_fdtoidtr); break; + case OP_ISTOFD: gen_alopf2_des(ctx, chan, gen_helper_istofd); break; + case OP_FSTOFD: gen_alopf2_des(ctx, chan, gen_helper_fstofd); break; + case OP_FSTOFX: gen_alopf2_sx(ctx, instr, gen_fstofx); break; + case OP_FDTOISTR: gen_alopf2_sed(ctx, chan, gen_helper_fdtoistr); break; + case OP_FDTOIS: gen_alopf2_sed(ctx, chan, gen_helper_fdtois); break; + case OP_IDTOFS: gen_alopf2_sed(ctx, chan, gen_helper_idtofs); break; + case OP_FDTOFS: gen_alopf2_sed(ctx, chan, gen_helper_fdtofs); break; + case OP_FXTOFS: gen_alopf2_xs(ctx, instr, gen_fxtofs); break; + case OP_UDIVS: + if (instr->src2 == 0xc0) { // FIXME: temp hack - if (instr->src2 == 0xc0) { - e2k_tr_gen_exception_no_spill(ctx, 0); - return; - } - - /* udivs */ - gen_alopf1_tag_i32(ctx, chan, gen_udivs); + e2k_tr_gen_exception_no_spill(ctx, 0); return; } + gen_alopf1_sttss(ctx, chan, gen_udivs); break; - case 0x41: - if (is_chan_0134(chan)) { - /* fxadddd */ - gen_alopf1_xdd(ctx, instr, gen_helper_fxaddxx); - return; - } else if (chan == 5) { - /* udivd */ - gen_alopf1_tag_i64(ctx, chan, gen_udivd); - return; - } - break; - case 0x42: - if (is_chan_0134(chan)) { - /* fxaddsx */ - gen_alopf1_xsx(ctx, instr, gen_helper_fxaddxx); - return; - } else if (chan == 5) { - /* sdivs */ - gen_alopf1_tag_i32(ctx, chan, gen_sdivs); - return; - } - break; - case 0x43: - if (is_chan_0134(chan)) { - /* fxadddx */ - gen_alopf1_xdx(ctx, instr, gen_helper_fxaddxx); - return; - } else if (chan == 5) { - /* sdivd */ - gen_alopf1_tag_i64(ctx, chan, gen_sdivd); - return; - } - break; - case 0x44: - if (is_chan_0134(chan)) { - /* fxaddxs */ - gen_alopf1_xxs(ctx, instr, gen_helper_fxaddxx); - return; - } - break; - case 0x45: - if (is_chan_0134(chan)) { - /* fxaddxd */ - gen_alopf1_xxd(ctx, instr, gen_helper_fxaddxx); - return; - } - break; - case 0x47: - if (is_chan_0134(chan)) { - /* fxaddxx */ - gen_alopf1_xxx(ctx, instr, gen_helper_fxaddxx); - return; - } - break; - case 0x48: - if (is_chan_0134(chan)) { - /* fxsubss */ - gen_alopf1_xss(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivss */ - gen_alopf1_xss(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x49: - if (is_chan_0134(chan)) { - /* fxsubdd */ - gen_alopf1_xdd(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivdd */ - gen_alopf1_xdd(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x4a: - if (is_chan_0134(chan)) { - /* fxsubsx */ - gen_alopf1_xsx(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivsx */ - gen_alopf1_xsx(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x4b: - if (is_chan_0134(chan)) { - /* fxsubdx */ - gen_alopf1_xdx(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivdx */ - gen_alopf1_xdx(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x4c: - if (is_chan_0134(chan)) { - /* fxsubxs */ - gen_alopf1_xxs(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivxs */ - gen_alopf1_xxs(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x4d: - if (is_chan_0134(chan)) { - /* fxsubxd */ - gen_alopf1_xxd(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivxd */ - gen_alopf1_xxd(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x4f: - if (is_chan_0134(chan)) { - /* fxsubxx */ - gen_alopf1_xxx(ctx, instr, gen_helper_fxsubxx); - return; - } else if (chan == 5) { - /* fxdivxx */ - gen_alopf1_xxx(ctx, instr, gen_helper_fxdivxx); - return; - } - break; - case 0x50: - if (is_chan_0134(chan)) { - /* fxmulss */ - gen_alopf1_xss(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x51: - if (is_chan_0134(chan)) { - /* fxmuldd */ - gen_alopf1_xdd(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x52: - if (is_chan_0134(chan)) { - /* fxmulsx */ - gen_alopf1_xsx(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x53: - if (is_chan_0134(chan)) { - /* fxmuldx */ - gen_alopf1_xdx(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x54: - if (is_chan_0134(chan)) { - /* fxmulxs */ - gen_alopf1_xxs(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x55: - if (is_chan_0134(chan)) { - /* fxmulxd */ - gen_alopf1_xxd(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x57: - if (is_chan_0134(chan)) { - /* fxmulxx */ - gen_alopf1_xxx(ctx, instr, gen_helper_fxmulxx); - return; - } - break; - case 0x58: - if (is_chan_0134(chan)) { - /* fxrsubss */ - gen_alopf1_xss(ctx, instr, gen_helper_fxrsubxx); - return; - } - break; - case 0x59: - if (is_chan_0134(chan)) { - /* fxrsubdd */ - gen_alopf1_xdd(ctx, instr, gen_helper_fxrsubxx); - return; - } - break; - case 0x5a: - if (is_chan_0134(chan)) { - /* fxrsubsx */ - gen_alopf1_xsx(ctx, instr, gen_helper_fxrsubxx); - return; - } - break; - case 0x5b: - if (is_chan_0134(chan)) { - /* fxrsubdx */ - gen_alopf1_xdx(ctx, instr, gen_helper_fxrsubxx); - return; - } - break; - case 0x5c: - if (is_chan_14(chan) || (ctx->version >= 2 && is_chan_03(chan))) { - /* movfi */ - gen_movfi(ctx, instr); - return; - } - break; - case 0x5e: - if (is_chan_14(chan) || (ctx->version >= 2 && is_chan_03(chan))) { - /* movif */ - gen_movif(ctx, instr); - return; - } - break; - case 0x61: - if (is_chan_0134(chan)) { - gen_movtd(ctx, chan); - return; - } - break; - case 0x64: { - if (is_chan_0235(chan)) { - /* ldb */ - gen_ld(ctx, instr, MO_UB); - return; - } else if (is_chan_14(chan) && instr->opce1 == 0xc0 && - ctx->version >= 2) + case OP_UDIVD: gen_alopf1_dttdd(ctx, chan, gen_udivd); break; + case OP_SDIVS: gen_alopf1_sttss(ctx, chan, gen_sdivs); break; + case OP_SDIVD: gen_alopf1_dttdd(ctx, chan, gen_sdivd); break; + case OP_FXADDSS: gen_alopf1_xss(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXADDDD: gen_alopf1_xdd(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXADDSX: gen_alopf1_xsx(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXADDDX: gen_alopf1_xdx(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXADDXX: gen_alopf1_xxx(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXADDXD: gen_alopf1_xxd(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXADDXS: gen_alopf1_xxs(ctx, instr, gen_helper_fxaddxx); break; + case OP_FXSUBSS: gen_alopf1_xss(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXSUBDD: gen_alopf1_xdd(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXSUBSX: gen_alopf1_xsx(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXSUBDX: gen_alopf1_xdx(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXSUBXX: gen_alopf1_xxx(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXSUBXD: gen_alopf1_xxd(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXSUBXS: gen_alopf1_xxs(ctx, instr, gen_helper_fxsubxx); break; + case OP_FXRSUBSS: gen_alopf1_xss(ctx, instr, gen_helper_fxrsubxx); break; + case OP_FXRSUBDD: gen_alopf1_xdd(ctx, instr, gen_helper_fxrsubxx); break; + case OP_FXRSUBSX: gen_alopf1_xsx(ctx, instr, gen_helper_fxrsubxx); break; + case OP_FXRSUBDX: gen_alopf1_xdx(ctx, instr, gen_helper_fxrsubxx); break; + case OP_FXMULSS: gen_alopf1_xss(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXMULDD: gen_alopf1_xdd(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXMULSX: gen_alopf1_xsx(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXMULDX: gen_alopf1_xdx(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXMULXX: gen_alopf1_xxx(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXMULXD: gen_alopf1_xxd(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXMULXS: gen_alopf1_xxs(ctx, instr, gen_helper_fxmulxx); break; + case OP_FXDIVSS: gen_alopf1_xss(ctx, instr, gen_helper_fxdivxx); break; + case OP_FXDIVDD: gen_alopf1_xdd(ctx, instr, gen_helper_fxdivxx); break; + case OP_FXDIVSX: gen_alopf1_xsx(ctx, instr, gen_helper_fxdivxx); break; + case OP_FXDIVDX: gen_alopf1_xdx(ctx, instr, gen_helper_fxdivxx); break; + case OP_FXDIVXX: gen_alopf1_xxx(ctx, instr, gen_helper_fxdivxx); break; + case OP_FXDIVXD: gen_alopf1_xxd(ctx, instr, gen_helper_fxdivxx); break; + case OP_FXDIVXS: gen_alopf1_xxs(ctx, instr, gen_helper_fxdivxx); break; + case OP_MOVFI: gen_movfi(ctx, instr); break; + case OP_MOVIF: gen_movif(ctx, instr); break; + case OP_MOVTD: gen_movtd(ctx, chan); break; + case OP_PMAXSH: gen_alopf1_ddd(ctx, chan, gen_helper_pmaxsh); break; + case OP_PMAXUB: gen_alopf1_ddd(ctx, chan, gen_helper_pmaxub); break; + case OP_PMINSH: gen_alopf1_ddd(ctx, chan, gen_helper_pminsh); break; + case OP_PMINUB: gen_alopf1_ddd(ctx, chan, gen_helper_pminub); break; + case OP_GETTAGS: gen_gettag_i32(ctx, chan); break; + case OP_GETTAGD: gen_gettag_i64(ctx, chan); break; + case OP_PUTTAGS: gen_puttag_i32(ctx, chan); break; + case OP_PUTTAGD: gen_puttag_i64(ctx, chan); break; + case OP_PMOVMSKB: gen_alopf1_ddd(ctx, chan, gen_helper_pmovmskb); break; + case OP_PADDD: gen_alopf1_ddd(ctx, chan, tcg_gen_add_i64); break; + case OP_PSUBD: gen_alopf1_ddd(ctx, chan, tcg_gen_sub_i64); break; + case OP_PCMPEQB: gen_alopf1_ddd(ctx, chan, gen_helper_pcmpeqb); break; + case OP_STAAB: gen_staa_i32(ctx, instr, MO_8); break; + case OP_STAAH: gen_staa_i32(ctx, instr, MO_16); break; + case OP_STAAW: gen_staa_i32(ctx, instr, MO_32); break; + case OP_STAAD: gen_staa_i64(ctx, instr); break; + case OP_STAAQ: { + int pair_chan = chan == 2 ? 5 : 2; + if (!ctx->bundle.als_present[pair_chan] || + extract32(ctx->bundle.als[pair_chan], 24, 7) != 0x3f || + (instr->dst & 1) != (chan == 2 ? 0 : 1)) { - /* lzcnts */ - gen_alopf2_i32(ctx, chan, gen_lzcnts); + e2k_tr_gen_exception(ctx, E2K_EXCP_ILLOPC); return; } + gen_staa_i64(ctx, instr); break; } - case 0x65: { - if (is_chan_0235(chan)) { - /* ldh */ - gen_ld(ctx, instr, MO_UW); - return; - } else if (is_chan_14(chan) && instr->opce1 == 0xc0 && - ctx->version >= 2) - { - /* lzcntd */ - gen_alopf2_i64(ctx, chan, gen_lzcntd); - return; - } - break; - } - case 0x66: { - if (is_chan_0235(chan)) { - /* ldw */ - gen_ld(ctx, instr, MO_UL); - return; - } else if (is_chan_14(chan) && instr->opce1 == 0xc0 && - ctx->version >= 2) - { - /* popcnts */ - gen_alopf2_i32(ctx, chan, tcg_gen_ctpop_i32); - return; - } - break; - } - case 0x67: { - if (is_chan_0235(chan)) { - /* ldd */ - gen_ld(ctx, instr, MO_Q); - return; - } else if (is_chan_14(chan) && instr->opce1 == 0xc0 && - ctx->version >= 2) - { - /* popcntd */ - gen_alopf2_i64(ctx, chan, tcg_gen_ctpop_i64); - return; - } - break; - } - default: - break; - } - - e2k_tr_gen_exception(ctx, E2K_EXCP_ILLOPC); -} - -static void gen_ext(DisasContext *ctx, Instr *instr) -{ - int chan = instr->chan; - switch (instr->opc1) { - case 0x00: - if (is_chan_03(chan)) { - /* pminub */ - gen_alopf1_i64(ctx, chan, gen_helper_pminub); - return; - } - break; - case 0x01: - if (is_chan_03(chan)) { - /* pminsh */ - gen_alopf1_i64(ctx, chan, gen_helper_pminsh); - return; - } - break; - case 0x02: - if (is_chan_03(chan)) { - /* pmaxub */ - gen_alopf1_i64(ctx, chan, gen_helper_pmaxub); - return; - } - break; - case 0x03: - if (is_chan_03(chan)) { - /* pmaxsh */ - gen_alopf1_i64(ctx, chan, gen_helper_pmaxsh); - return; - } - break; - case 0x08: - if (is_chan_25(chan)) { - /* gettags */ - gen_gettag_i32(ctx, chan); - return; - } - break; - case 0x09: - if (is_chan_25(chan)) { - /* gettagd */ - gen_gettag_i64(ctx, chan); - return; - } - break; - case 0x0a: - if (is_chan_25(chan)) { - /* puttags */ - gen_puttag_i32(ctx, chan); - return; - } - break; - case 0x0b: - if (is_chan_14(chan)) { - /* pmovmskb */ - gen_alopf1_i64(ctx, chan, gen_helper_pmovmskb); - return; - } else if (is_chan_25(chan)) { - /* puttagd */ - gen_puttag_i64(ctx, chan); - return; - } - break; - case 0x0f: - if (is_chan_03(chan)) { - /* paddd */ - gen_alopf1_i64(ctx, chan, tcg_gen_add_i64); - return; - } - break; - case 0x17: - if (is_chan_03(chan)) { - /* psubd */ - gen_alopf1_i64(ctx, chan, tcg_gen_sub_i64); - return; - } - break; - case 0x18: - if (is_chan_03(chan)) { - /* pcmpeqb */ - gen_alopf1_i64(ctx, chan, gen_helper_pcmpeqb); - return; - } - break; - case 0x1c: - if (is_chan_25(chan)) { - /* staab */ - gen_staa_i32(ctx, instr, MO_8); - return; - } - break; - case 0x1d: - if (is_chan_25(chan)) { - /* staah */ - gen_staa_i32(ctx, instr, MO_16); - return; - } - break; - case 0x1e: - if (is_chan_25(chan)) { - /* staaw */ - gen_staa_i32(ctx, instr, MO_32); - return; - } - break; - case 0x1f: - if (is_chan_25(chan)) { - /* staad */ - gen_staa_i64(ctx, instr); - return; - } - break; - case 0x20: - if (is_chan_0134(chan)) { - /* muls */ - gen_alopf1_i32(ctx, chan, tcg_gen_mul_i32); - return; - } - break; - case 0x21: - if (is_chan_0134(chan)) { - /* muld */ - gen_alopf1_i64(ctx, chan, tcg_gen_mul_i64); - return; - } - break; - case 0x22: - if (is_chan_0134(chan)) { - /* umulx */ - gen_alopf1_i32_i64(ctx, chan, gen_umulx); - return; - } - break; - case 0x23: - if (is_chan_0134(chan)) { - /* smulx */ - gen_alopf1_i32_i64(ctx, chan, gen_smulx); - return; - } - break; - case 0x2c: - if (is_chan_0134(chan)) { - /* fcmp{op}s */ - void (*f)(TCGv_i32, TCGv_i32, TCGv_i32) = 0; - - GENERATE_FCMP_SWITCH_TABLE(f, instr->opce3, 0xc0, gen_, f, s); - - if(f) { - gen_alopf1_i32(ctx, chan, f); - return; - } - } - break; - case 0x2d: - if (is_chan_0134(chan)) { - /* fcmp{op}d */ - void (*f)(TCGv_i64, TCGv_i64, TCGv_i64) = 0; - - GENERATE_FCMP_SWITCH_TABLE(f, instr->opce3, 0xc0, gen_, f, d); - - if(f) { - gen_alopf1_i64(ctx, chan, f); - return; - } - } - break; - case 0x3c: - if (chan == 0) { - /* rws */ - gen_rw_i32(ctx, instr); - return; - } - break; - case 0x3d: - if (chan == 0) { - /* rwd */ - gen_rw_i64(ctx, instr); - return; - } - break; - case 0x3e: - if (chan == 0) { - /* rrs */ - gen_rr_i32(ctx, instr); - return; - } - break; - case 0x3f: - if (chan == 0) { - /* rrd */ - gen_rr_i64(ctx, instr); - return; - } else if (is_chan_25(chan)) { - /* staaq */ - int pair_chan = chan == 2 ? 5 : 2; - if (!ctx->bundle.als_present[pair_chan] || - extract32(ctx->bundle.als[pair_chan], 24, 7) != 0x3f || - (instr->dst & 1) != (chan == 2 ? 0 : 1)) - { - e2k_tr_gen_exception(ctx, E2K_EXCP_ILLOPC); - return; - } - gen_staa_i64(ctx, instr); - return; - } - break; - case 0x48: - if (chan == 5) { - /* fdivs */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fdivs); - return; - } - break; - case 0x49: - if (chan == 5) { - /* fdivd */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fdivd); - return; - } - break; - case 0x58: - if (is_chan_03(chan)) { - /* getsp */ - gen_getsp(ctx, chan); - return; - } - break; - case 0x70: - if (is_chan_0134(chan)) { - /* umulhd */ - gen_alopf1_i64(ctx, chan, gen_umulhd); - return; - } - break; - case 0x71: - if (is_chan_0134(chan)) { - /* smulhd */ - gen_alopf1_i64(ctx, chan, gen_smulhd); - return; - } - break; - default: - break; - } - - e2k_tr_gen_exception(ctx, E2K_EXCP_ILLOPC); -} - -static void gen_ext1(DisasContext *ctx, Instr *instr) -{ - int chan = instr->chan; - - switch (instr->opc1) { - case 0x30: - if (is_chan_25(chan) && ctx->version >= 4) { - /* fadds */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fadds); - return; - } - break; - case 0x31: - if (is_chan_25(chan) && ctx->version >= 4) { - /* faddd */ - gen_alopf1_i64_env(ctx, chan, gen_helper_faddd); - return; - } - break; - case 0x32: - if (is_chan_25(chan) && ctx->version >= 4) { - /* fsubs */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fsubs); - return; - } - break; - case 0x33: - if (is_chan_25(chan) && ctx->version >= 4) { - /* fsubd */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fsubd); - return; - } - break; - case 0x38: - if (is_chan_25(chan) && ctx->version >= 4) { - /* fmuls */ - gen_alopf1_i32_env(ctx, chan, gen_helper_fmuls); - return; - } - break; - case 0x39: - if (is_chan_25(chan) && ctx->version >= 4) { - /* fmuld */ - gen_alopf1_i64_env(ctx, chan, gen_helper_fmuld); - return; - } - break; - default: - e2k_todo_illop(ctx, "unknown instr %x:%x:%x\n", instr->opc1, - instr->opc2, instr->opce1); - break; + case OP_MULS: gen_alopf1_sss(ctx, chan, tcg_gen_mul_i32); break; + case OP_MULD: gen_alopf1_ddd(ctx, chan, tcg_gen_mul_i64); break; + case OP_UMULX: gen_alopf1_dss(ctx, chan, gen_umulx); break; + case OP_SMULX: gen_alopf1_dss(ctx, chan, gen_smulx); break; + case OP_RWS: gen_rw_i32(ctx, instr); break; + case OP_RWD: gen_rw_i64(ctx, instr); break; + case OP_RRS: gen_rr_i32(ctx, instr); break; + case OP_RRD: gen_rr_i64(ctx, instr); break; + case OP_FDIVS: gen_alopf1_sess(ctx, chan, gen_helper_fdivs); break; + case OP_FDIVD: gen_alopf1_dedd(ctx, chan, gen_helper_fdivd); break; + case OP_GETSP: gen_getsp(ctx, chan); break; + case OP_UMULHD: gen_alopf1_ddd(ctx, chan, gen_umulhd); break; + case OP_SMULHD: gen_alopf1_ddd(ctx, chan, gen_smulhd); break; + case OP_UDIVX: + case OP_UMODX: + case OP_SDIVX: + case OP_SMODX: + case OP_FXDIVTSS: + case OP_FXDIVTDD: + case OP_FXDIVTSX: + case OP_FXDIVTDX: + case OP_FXSQRTUSX: + case OP_FXSQRTUDX: + case OP_FXSQRTUXX: + case OP_FXSQRTTSX: + case OP_FXSQRTTDX: + case OP_FXSQRTTXX: + case OP_VFSI: + case OP_LDCSB: + case OP_LDDSB: + case OP_LDESB: + case OP_LDFSB: + case OP_LDGSB: + case OP_LDSSB: + case OP_LDCSH: + case OP_LDDSH: + case OP_LDESH: + case OP_LDFSH: + case OP_LDGSH: + case OP_LDSSH: + case OP_LDCSW: + case OP_LDDSW: + case OP_LDESW: + case OP_LDFSW: + case OP_LDGSW: + case OP_LDSSW: + case OP_LDCSD: + case OP_LDDSD: + case OP_LDESD: + case OP_LDFSD: + case OP_LDGSD: + case OP_LDSSD: + case OP_FXSQRTISX: + case OP_FXSQRTIDX: + case OP_FXSQRTIXX: + case OP_MOVTS: + case OP_MOVTCS: + case OP_MOVTRS: + case OP_MOVTRCS: + case OP_MOVTCD: + case OP_MOVTRD: + case OP_MOVTRCD: + case OP_FXTOIS: + case OP_FXTOID: + case OP_ISTOFX: + case OP_IDTOFX: + case OP_PFDTOIS: + case OP_PFSTOIS: + case OP_PFDTOISTR: + case OP_PFSTOISTR: + case OP_PISTOFS: + case OP_PFSTOFD: + case OP_PFDTOFS: + case OP_GETPL: + case OP_GETSAP: + case OP_CUDTOAP: + case OP_GDTOAP: + case OP_STCSB: + case OP_STDSB: + case OP_STESB: + case OP_STFSB: + case OP_STGSB: + case OP_STSSB: + case OP_STCSH: + case OP_STDSH: + case OP_STESH: + case OP_STFSH: + case OP_STGSH: + case OP_STSSH: + case OP_STCSW: + case OP_STDSW: + case OP_STESW: + case OP_STFSW: + case OP_STGSW: + case OP_STSSW: + case OP_STCSD: + case OP_STDSD: + case OP_STESD: + case OP_STFSD: + case OP_STGSD: + case OP_STSSD: + case OP_CCTOPO: + case OP_CCTOPB: + case OP_CCTOPE: + case OP_CCTOPBE: + case OP_CCTOPS: + case OP_CCTOPP: + case OP_CCTOPL: + case OP_CCTOPLE: + /* + case OP_AAURW: + case OP_AAURWS: + case OP_AAURWD: + case OP_AAURWQ: + case OP_AAURR: + case OP_AAURRD: + case OP_AAURRQ: + */ + case OP_FSQRTTD: + case OP_PFMULS: + case OP_PFMULD: + case OP_PADDB: + case OP_PADDH: + case OP_PADDW: + case OP_PADDSB: + case OP_PADDSH: + case OP_PADDUSB: + case OP_PADDUSH: + case OP_PSUBB: + case OP_PSUBH: + case OP_PSUBW: + case OP_PSUBSB: + case OP_PSUBSH: + case OP_PSUBUSB: + case OP_PSUBUSH: + case OP_PSADBW: + case OP_PMULHUH: + case OP_PMULHH: + case OP_PMULLH: + case OP_PMADDH: + case OP_PSLLD: + case OP_PSLLW: + case OP_PSLLH: + case OP_PSRLD: + case OP_PSRLW: + case OP_PSRLH: + case OP_PSRAW: + case OP_PSRAH: + case OP_PFADDS: + case OP_PFADDD: + case OP_PFSUBS: + case OP_PFSUBD: + case OP_APTOAP: + case OP_APTOAPB: + case OP_GETVA: + case OP_PANDD: + case OP_PANDND: + case OP_PORD: + case OP_PXORD: + case OP_LDRD: + case OP_PUTTC: + case OP_PAVGUSB: + case OP_PAVGUSH: + case OP_PFDIVS: + case OP_PFDIVD: + case OP_PFMINS: + case OP_PFMIND: + case OP_PFMAXS: + case OP_PFMAXD: + case OP_PFSQRTTD: + case OP_PEXTRH: + case OP_PINSH: + case OP_PSLLQH: + case OP_PSLLQL: + case OP_PSRLQH: + case OP_PSRLQL: + case OP_CAST: + case OP_TDTOMP: + case OP_ODTOAP: + case OP_FCMPEQS: + case OP_FCMPLTS: + case OP_FCMPLES: + case OP_FCMPUODS: + case OP_FCMPNEQS: + case OP_FCMPNLTS: + case OP_FCMPNLES: + case OP_FCMPODS: + case OP_FCMPEQD: + case OP_FCMPLTD: + case OP_FCMPLED: + case OP_FCMPUODD: + case OP_FCMPNEQD: + case OP_FCMPNLTD: + case OP_FCMPNLED: + case OP_FCMPODD: + case OP_PFCMPEQS: + case OP_PFCMPLTS: + case OP_PFCMPLES: + case OP_PFCMPUODS: + case OP_PFCMPNEQS: + case OP_PFCMPNLTS: + case OP_PFCMPNLES: + case OP_PFCMPODS: + case OP_PFCMPEQD: + case OP_PFCMPLTD: + case OP_PFCMPLED: + case OP_PFCMPUODD: + case OP_PFCMPNEQD: + case OP_PFCMPNLTD: + case OP_PFCMPNLED: + case OP_PFCMPODD: + case OP_FCMPODSF: + case OP_FCMPUDSF: + case OP_FCMPODDF: + case OP_FCMPUDDF: + case OP_FXCMPODSF: + case OP_FXCMPUDSF: + case OP_FXCMPODDF: + case OP_FXCMPUDDF: + case OP_FXCMPODXF: + case OP_FXCMPUDXF: + case OP_PCMPEQH: + case OP_PCMPEQW: + case OP_PCMPGTB: + case OP_PCMPGTH: + case OP_PCMPGTW: + case OP_PMOVMSKPS: + case OP_PMOVMSKPD: + case OP_PACKSSHB: + case OP_PACKUSHB: + case OP_PSHUFW: + case OP_PACKSSWH: + case OP_PUNPCKHBH: + case OP_PUNPCKHHW: + case OP_PUNPCKHWD: + case OP_PUNPCKLBH: + case OP_PUNPCKLHW: + case OP_PUNPCKLWD: + case OP_LDGDB: + case OP_LDGDH: + case OP_LDGDW: + case OP_LDGDD: + case OP_LDGDQ: + case OP_LDCUDB: + case OP_LDCUDH: + case OP_LDCUDW: + case OP_LDCUDD: + case OP_LDCUDQ: + case OP_LDAPB: + case OP_LDAPH: + case OP_LDAPW: + case OP_LDAPD: + case OP_LDAPQ: + case OP_LDODWB: + case OP_LDODWD: + case OP_LDODWH: + case OP_LDODWQ: + case OP_LDODWW: + case OP_LDODPB: + case OP_LDODPD: + case OP_LDODPH: + case OP_LDODPQ: + case OP_LDODPW: + case OP_LDODRB: + case OP_LDODRD: + case OP_LDODRH: + case OP_LDODRQ: + case OP_LDODRW: + case OP_LDCSQ: + case OP_LDDSQ: + case OP_LDESQ: + case OP_LDFSQ: + case OP_LDGSQ: + case OP_LDSSQ: + case OP_FRCPS: + case OP_FSQRTS: + case OP_FSQRTID: + case OP_FRSQRTS: + case OP_PFSQRTS: + case OP_GETTD: + case OP_GETTC: + case OP_INVTC: + case OP_GETSOD: + case OP_PSHUFH: + case OP_STCSQ: + case OP_STDSQ: + case OP_STESQ: + case OP_STFSQ: + case OP_STGSQ: + case OP_STSSQ: + case OP_STRD: + case OP_STGDB: + case OP_STGDH: + case OP_STGDW: + case OP_STGDD: + case OP_STGDQ: + case OP_STAPB: + case OP_STAPH: + case OP_STAPW: + case OP_STAPD: + case OP_STAPQ: + case OP_STODPB: + case OP_STODPD: + case OP_STODPH: + case OP_STODPQ: + case OP_STODPW: + case OP_STODRB: + case OP_STODRD: + case OP_STODRH: + case OP_STODRQ: + case OP_STODRW: + case OP_STODWB: + case OP_STODWD: + case OP_STODWH: + case OP_STODWQ: + case OP_STODWW: + case OP_MOVTQ: + case OP_MOVTCQ: + case OP_MOVTRQ: + case OP_MOVTRCQ: + case OP_FXTOISTR: + case OP_FXTOIDTR: + case OP_MOVX: + case OP_MOVXA: + case OP_MOVXC: + case OP_PMULUBHH: + case OP_FSTOIFS: + case OP_FDTOIFD: + case OP_PMINUW: + case OP_PMINSW: + case OP_PMAXUW: + case OP_PMAXSW: + case OP_MPSADBH: + case OP_PACKUSWH: + case OP_PCMPEQD: + case OP_PCMPGTD: + case OP_PFHADDS: + case OP_PFHSUBS: + case OP_PFADDSUBS: + case OP_PMINSB: + case OP_PMINUH: + case OP_PMAXSB: + case OP_PMAXUH: + case OP_PFSTOIFS: + case OP_PFDTOIFD: + case OP_PHADDH: + case OP_PHADDW: + case OP_PHADDSH: + case OP_PHSUBH: + case OP_PHSUBW: + case OP_PHSUBSH: + case OP_PSIGNB: + case OP_PSIGNH: + case OP_PSIGNW: + case OP_PMADDUBSH: + case OP_PMULHRSH: + case OP_PHMINPOSUH: + case OP_PUTTST: + case OP_FSCALES: + case OP_FSCALED: + case OP_FXSCALESX: + case OP_STAAQP: + case OP_QPAND: + case OP_QPANDN: + case OP_QPOR: + case OP_QPXOR: + case OP_QPADDB: + case OP_QPADDH: + case OP_QPADDSB: + case OP_QPADDSH: + case OP_QPADDUSB: + case OP_QPADDUSH: + case OP_QPADDW: + case OP_QPADDD: + case OP_QPSUBB: + case OP_QPSUBH: + case OP_QPSUBSB: + case OP_QPSUBSH: + case OP_QPSUBUSB: + case OP_QPSUBUSH: + case OP_QPSUBW: + case OP_QPSUBD: + case OP_QPFADDS: + case OP_QPFADDD: + case OP_QPFHADDS: + case OP_QPFHSUBS: + case OP_QPFADDSUBS: + case OP_QPFADDSUBD: + case OP_QPFSTOIFS: + case OP_QPFDTOIFD: + case OP_QPFMINS: + case OP_QPFMIND: + case OP_QPFMAXS: + case OP_QPFMAXD: + case OP_QPFMULS: + case OP_QPFMULD: + case OP_QPFSUBS: + case OP_QPFSUBD: + case OP_QPMSK2SGNB: + case OP_QPPACKDL: + case OP_QPSLLH: + case OP_QPSLLW: + case OP_QPSLLD: + case OP_QPSRLH: + case OP_QPSRLW: + case OP_QPSRLD: + case OP_QPSRAH: + case OP_QPSRAW: + case OP_QPACKSSHB: + case OP_QPACKSSWH: + case OP_QPACKUSHB: + case OP_QPACKUSWH: + case OP_QPAVGUSB: + case OP_QPAVGUSH: + case OP_QPCMPEQB: + case OP_QPCMPEQD: + case OP_QPCMPEQH: + case OP_QPCMPEQW: + case OP_QPCMPGTB: + case OP_QPCMPGTD: + case OP_QPCMPGTH: + case OP_QPCMPGTW: + case OP_QPHADDH: + case OP_QPHADDSH: + case OP_QPHADDW: + case OP_QPHSUBH: + case OP_QPHSUBSH: + case OP_QPHSUBW: + case OP_QPMAXSB: + case OP_QPMAXSH: + case OP_QPMAXSW: + case OP_QPMAXUB: + case OP_QPMAXUH: + case OP_QPMAXUW: + case OP_QPMINSB: + case OP_QPMINSH: + case OP_QPMINSW: + case OP_QPMINUB: + case OP_QPMINUH: + case OP_QPMINUW: + case OP_QPMULHH: + case OP_QPMULHRSH: + case OP_QPMULHUH: + case OP_QPMULLH: + case OP_QPMULUBHH: + case OP_QPSIGNB: + case OP_QPSIGNH: + case OP_QPSIGNW: + case OP_QPHMINPOSUH: + case OP_QPMADDH: + case OP_QPMADDUBSH: + case OP_QPMPSADBH: + case OP_QPSADBW: + case OP_QPSRCD: + case OP_QPSRCW: + case OP_PSRCD: + case OP_PSRCW: + case OP_GETFZS: + case OP_GETFZD: + case OP_PUTTAGQP: + case OP_PMULLW: + case OP_QPMULLW: + case OP_QPFCMPEQS: + case OP_QPFCMPLTS: + case OP_QPFCMPLES: + case OP_QPFCMPUODS: + case OP_QPFCMPNEQS: + case OP_QPFCMPNLTS: + case OP_QPFCMPNLES: + case OP_QPFCMPODS: + case OP_QPFCMPEQD: + case OP_QPFCMPLTD: + case OP_QPFCMPLED: + case OP_QPFCMPUODD: + case OP_QPFCMPNEQD: + case OP_QPFCMPNLTD: + case OP_QPFCMPNLED: + case OP_QPFCMPODD: + case OP_LDQ: + case OP_LDQP: + case OP_LDGDQP: + case OP_LDCUDQP: + case OP_LDCSQP: + case OP_LDDSQP: + case OP_LDESQP: + case OP_LDFSQP: + case OP_LDGSQP: + case OP_LDSSQP: + case OP_LDAPQP: + case OP_LDRQP: + case OP_QPSGN2MSKB: + case OP_QPSWITCHW: + case OP_QPSWITCHD: + case OP_QPFSTOIS: + case OP_QPFSTOISTR: + case OP_QPISTOFS: + case OP_QPFSTOID: + case OP_QPFSTOIDTR: + case OP_QPISTOFD: + case OP_QPFSTOFD: + case OP_QPFDTOIS: + case OP_QPFDTOISTR: + case OP_QPIDTOFS: + case OP_QPFDTOFS: + case OP_QPFDTOID: + case OP_QPFDTOIDTR: + case OP_QPIDTOFD: + case OP_STQ: + case OP_STGDMQP: + case OP_STGDQP: + case OP_STAPQP: + case OP_STAPMQP: + case OP_STMQP: + case OP_STQP: + case OP_STCSMQP: + case OP_STCSQP: + case OP_STDSMQP: + case OP_STDSQP: + case OP_STESMQP: + case OP_STESQP: + case OP_STFSMQP: + case OP_STFSQP: + case OP_STGSMQP: + case OP_STGSQP: + case OP_STSSMQP: + case OP_STSSQP: + case OP_STRQP: + case OP_ADDCD: + case OP_ADDCD_C: + case OP_SUBCD: + case OP_SUBCD_C: + case OP_VFBGV: + case OP_MKFSW: + case OP_MODBGV: + case OP_PCMPEQBOP: + case OP_PCMPEQHOP: + case OP_PCMPEQWOP: + case OP_PCMPEQDOP: + case OP_PCMPGTBOP: + case OP_PCMPGTHOP: + case OP_PCMPGTWOP: + case OP_PCMPGTDOP: + case OP_PCMPEQBAP: + case OP_PCMPEQHAP: + case OP_PCMPEQWAP: + case OP_PCMPEQDAP: + case OP_PCMPGTBAP: + case OP_PCMPGTHAP: + case OP_PCMPGTWAP: + case OP_PCMPGTDAP: + case OP_QPCMPEQBOP: + case OP_QPCMPEQHOP: + case OP_QPCMPEQWOP: + case OP_QPCMPEQDOP: + case OP_QPCMPGTBOP: + case OP_QPCMPGTHOP: + case OP_QPCMPGTWOP: + case OP_QPCMPGTDOP: + case OP_QPCMPEQBAP: + case OP_QPCMPEQHAP: + case OP_QPCMPEQWAP: + case OP_QPCMPEQDAP: + case OP_QPCMPGTBAP: + case OP_QPCMPGTHAP: + case OP_QPCMPGTWAP: + case OP_QPCMPGTDAP: + case OP_PMRGP: + case OP_QPMRGP: + case OP_CLMULH: + case OP_CLMULL: + case OP_IBRANCHD: + case OP_ICALLD: + case OP_QPCEXT_0X00: + case OP_QPCEXT_0X7F: + case OP_QPCEXT_0X80: + case OP_QPCEXT_0XFF: + case OP_FMAS: + case OP_FMSS: + case OP_FNMAS: + case OP_FNMSS: + case OP_FMAD: + case OP_FMSD: + case OP_FNMAD: + case OP_FNMSD: + case OP_QPFMAS: + case OP_QPFMSS: + case OP_QPFNMAS: + case OP_QPFNMSS: + case OP_QPFMAD: + case OP_QPFMSD: + case OP_QPFNMAD: + case OP_QPFNMSD: + case OP_QPFMASS: + case OP_QPFMSAS: + case OP_QPFMASD: + case OP_QPFMSAD: + e2k_todo_illop(ctx, "unimplemented %d\n", op); break; } } @@ -4215,9 +4210,10 @@ static void chan_execute(DisasContext *ctx, int chan) chan_check_preds(ctx, chan, l0); switch (instr.opc2) { - case NO_EXT: gen_no_ext(ctx, &instr); break; /* no ales */ - case EXT: gen_ext(ctx, &instr); break; - case EXT1: gen_ext1(ctx, &instr); break; + case SHORT: + case EXT: + case EXT1: + case EXT2: gen_op(ctx, &instr); break; case ICMB0: case ICMB1: case ICMB2: gen_icmb012(ctx, &instr); break; @@ -4412,3 +4408,23 @@ void e2k_alc_commit(DisasContext *ctx) gen_set_label(l0); } } + +void e2k_alc_init(DisasContext *ctx) +{ + int i, j; + + // TODO: symmetric alops table + /* Most alops are symmetric and can be stored in a half table. */ + for (i = 0; i < ARRAY_SIZE(alops); i++) { + AlopDesc *desc = &alops[i]; + if (desc->min_version <= ctx->version && ctx->version <= desc->max_version) { + for (j = 0; j < 6; j++) { + if (desc->channels & (1 << j)) { + int16_t *p = &alops_map[desc->opc2][desc->opc1][j]; + desc->next[j] = *p; + *p = i; + } + } + } + } +} diff --git a/target/e2k/translate/alops.inc b/target/e2k/translate/alops.inc new file mode 100644 index 0000000000..f33488ddc1 --- /dev/null +++ b/target/e2k/translate/alops.inc @@ -0,0 +1,1809 @@ +typedef enum { + OP_NONE, + OP_ANDS, + OP_ANDD, + OP_ANDNS, + OP_ANDND, + OP_ORS, + OP_ORD, + OP_ORNS, + OP_ORND, + OP_XORS, + OP_XORD, + OP_XORNS, + OP_XORND, + OP_SXT, + OP_ADDS, + OP_ADDD, + OP_SUBS, + OP_SUBD, + OP_SCLS, + OP_SCLD, + OP_SCRS, + OP_SCRD, + OP_SHLS, + OP_SHLD, + OP_SHRS, + OP_SHRD, + OP_SARS, + OP_SARD, + OP_GETFS, + OP_GETFD, + OP_MERGES, + OP_MERGED, + OP_UDIVX, + OP_UMODX, + OP_SDIVX, + OP_SMODX, + OP_UDIVS, + OP_UDIVD, + OP_SDIVS, + OP_SDIVD, + OP_FADDS, + OP_FADDD, + OP_FSUBS, + OP_FSUBD, + OP_FMINS, + OP_FMIND, + OP_FMAXS, + OP_FMAXD, + OP_FMULS, + OP_FMULD, + OP_FXADDSS, + OP_FXADDDD, + OP_FXADDSX, + OP_FXADDDX, + OP_FXADDXX, + OP_FXADDXD, + OP_FXADDXS, + OP_FXSUBSS, + OP_FXSUBDD, + OP_FXSUBSX, + OP_FXSUBDX, + OP_FXSUBXX, + OP_FXSUBXD, + OP_FXSUBXS, + OP_FXRSUBSS, + OP_FXRSUBDD, + OP_FXRSUBSX, + OP_FXRSUBDX, + OP_FXMULSS, + OP_FXMULDD, + OP_FXMULSX, + OP_FXMULDX, + OP_FXMULXX, + OP_FXMULXD, + OP_FXMULXS, + OP_FXDIVSS, + OP_FXDIVDD, + OP_FXDIVSX, + OP_FXDIVDX, + OP_FXDIVXX, + OP_FXDIVXD, + OP_FXDIVXS, + OP_FXDIVTSS, + OP_FXDIVTDD, + OP_FXDIVTSX, + OP_FXDIVTDX, + OP_FXSQRTUSX, + OP_FXSQRTUDX, + OP_FXSQRTUXX, + OP_FXSQRTTSX, + OP_FXSQRTTDX, + OP_FXSQRTTXX, + OP_MOVIF, + OP_VFSI, + OP_LDCSB, + OP_LDDSB, + OP_LDESB, + OP_LDFSB, + OP_LDGSB, + OP_LDSSB, + OP_LDCSH, + OP_LDDSH, + OP_LDESH, + OP_LDFSH, + OP_LDGSH, + OP_LDSSH, + OP_LDCSW, + OP_LDDSW, + OP_LDESW, + OP_LDFSW, + OP_LDGSW, + OP_LDSSW, + OP_LDCSD, + OP_LDDSD, + OP_LDESD, + OP_LDFSD, + OP_LDGSD, + OP_LDSSD, + OP_LDB, + OP_LDH, + OP_LDW, + OP_LDD, + OP_FXSQRTISX, + OP_FXSQRTIDX, + OP_FXSQRTIXX, + OP_MOVFI, + OP_MOVTS, + OP_MOVTCS, + OP_MOVTRS, + OP_MOVTRCS, + OP_MOVTD, + OP_MOVTCD, + OP_MOVTRD, + OP_MOVTRCD, + OP_FSTOIS, + OP_FSTOID, + OP_FDTOIS, + OP_FDTOID, + OP_FXTOIS, + OP_FXTOID, + OP_FSTOISTR, + OP_FDTOISTR, + OP_ISTOFS, + OP_ISTOFD, + OP_IDTOFS, + OP_IDTOFD, + OP_ISTOFX, + OP_IDTOFX, + OP_FSTOFD, + OP_FDTOFS, + OP_FXTOFD, + OP_FSTOFX, + OP_FXTOFS, + OP_FDTOFX, + OP_PFDTOIS, + OP_PFSTOIS, + OP_PFDTOISTR, + OP_PFSTOISTR, + OP_PISTOFS, + OP_PFSTOFD, + OP_PFDTOFS, + OP_GETPL, + OP_GETSAP, + OP_CUDTOAP, + OP_GDTOAP, + OP_STCSB, + OP_STDSB, + OP_STESB, + OP_STFSB, + OP_STGSB, + OP_STSSB, + OP_STCSH, + OP_STDSH, + OP_STESH, + OP_STFSH, + OP_STGSH, + OP_STSSH, + OP_STCSW, + OP_STDSW, + OP_STESW, + OP_STFSW, + OP_STGSW, + OP_STSSW, + OP_STCSD, + OP_STDSD, + OP_STESD, + OP_STFSD, + OP_STGSD, + OP_STSSD, + OP_STB, + OP_STH, + OP_STW, + OP_STD, + OP_CMPOSB, + OP_CMPBSB, + OP_CMPESB, + OP_CMPBESB, + OP_CMPSSB, + OP_CMPPSB, + OP_CMPLSB, + OP_CMPLESB, + OP_CMPODB, + OP_CMPBDB, + OP_CMPEDB, + OP_CMPBEDB, + OP_CMPSDB, + OP_CMPPDB, + OP_CMPLDB, + OP_CMPLEDB, + OP_CMPANDESB, + OP_CMPANDSSB, + OP_CMPANDPSB, + OP_CMPANDLESB, + OP_CMPANDEDB, + OP_CMPANDSDB, + OP_CMPANDPDB, + OP_CMPANDLEDB, + OP_FCMPEQSB, + OP_FCMPLTSB, + OP_FCMPLESB, + OP_FCMPUODSB, + OP_FCMPNEQSB, + OP_FCMPNLTSB, + OP_FCMPNLESB, + OP_FCMPODSB, + OP_FCMPEQDB, + OP_FCMPLTDB, + OP_FCMPLEDB, + OP_FCMPUODDB, + OP_FCMPNEQDB, + OP_FCMPNLTDB, + OP_FCMPNLEDB, + OP_FCMPODDB, + OP_FXCMPEQSB, + OP_FXCMPLTSB, + OP_FXCMPLESB, + OP_FXCMPUODSB, + OP_FXCMPNEQSB, + OP_FXCMPNLTSB, + OP_FXCMPNLESB, + OP_FXCMPODSB, + OP_FXCMPEQDB, + OP_FXCMPLTDB, + OP_FXCMPLEDB, + OP_FXCMPUODDB, + OP_FXCMPNEQDB, + OP_FXCMPNLTDB, + OP_FXCMPNLEDB, + OP_FXCMPODDB, + OP_FXCMPEQXB, + OP_FXCMPLTXB, + OP_FXCMPLEXB, + OP_FXCMPUODXB, + OP_FXCMPNEQXB, + OP_FXCMPNLTXB, + OP_FXCMPNLEXB, + OP_FXCMPODXB, + OP_CCTOPO, + OP_CCTOPB, + OP_CCTOPE, + OP_CCTOPBE, + OP_CCTOPS, + OP_CCTOPP, + OP_CCTOPL, + OP_CCTOPLE, + OP_STAAB, + OP_STAAH, + OP_STAAW, + OP_STAAD, + OP_STAAQ, + /* + OP_AAURW, + OP_AAURWS, + OP_AAURWD, + OP_AAURWQ, + OP_AAURR, + OP_AAURRD, + OP_AAURRQ, + */ + OP_MULS, + OP_MULD, + OP_UMULX, + OP_SMULX, + OP_FDIVS, + OP_FDIVD, + OP_FSQRTTD, + OP_PFMULS, + OP_PFMULD, + OP_PADDB, + OP_PADDH, + OP_PADDW, + OP_PADDD, + OP_PADDSB, + OP_PADDSH, + OP_PADDUSB, + OP_PADDUSH, + OP_PSUBB, + OP_PSUBH, + OP_PSUBW, + OP_PSUBD, + OP_PSUBSB, + OP_PSUBSH, + OP_PSUBUSB, + OP_PSUBUSH, + OP_PMAXSH, + OP_PMAXUB, + OP_PMINSH, + OP_PMINUB, + OP_PSADBW, + OP_PMULHUH, + OP_PMULHH, + OP_PMULLH, + OP_PMADDH, + OP_PSLLD, + OP_PSLLW, + OP_PSLLH, + OP_PSRLD, + OP_PSRLW, + OP_PSRLH, + OP_PSRAW, + OP_PSRAH, + OP_PFADDS, + OP_PFADDD, + OP_PFSUBS, + OP_PFSUBD, + OP_APTOAP, + OP_APTOAPB, + OP_GETVA, + OP_PANDD, + OP_PANDND, + OP_PORD, + OP_PXORD, + OP_LDRD, + OP_PUTTC, + OP_PAVGUSB, + OP_PAVGUSH, + OP_PFDIVS, + OP_PFDIVD, + OP_PFMINS, + OP_PFMIND, + OP_PFMAXS, + OP_PFMAXD, + OP_PFSQRTTD, + OP_PEXTRH, + OP_PINSH, + OP_PSLLQH, + OP_PSLLQL, + OP_PSRLQH, + OP_PSRLQL, + OP_CAST, + OP_TDTOMP, + OP_ODTOAP, + OP_PUTTAGS, + OP_PUTTAGD, + OP_FCMPEQS, + OP_FCMPLTS, + OP_FCMPLES, + OP_FCMPUODS, + OP_FCMPNEQS, + OP_FCMPNLTS, + OP_FCMPNLES, + OP_FCMPODS, + OP_FCMPEQD, + OP_FCMPLTD, + OP_FCMPLED, + OP_FCMPUODD, + OP_FCMPNEQD, + OP_FCMPNLTD, + OP_FCMPNLED, + OP_FCMPODD, + OP_PFCMPEQS, + OP_PFCMPLTS, + OP_PFCMPLES, + OP_PFCMPUODS, + OP_PFCMPNEQS, + OP_PFCMPNLTS, + OP_PFCMPNLES, + OP_PFCMPODS, + OP_PFCMPEQD, + OP_PFCMPLTD, + OP_PFCMPLED, + OP_PFCMPUODD, + OP_PFCMPNEQD, + OP_PFCMPNLTD, + OP_PFCMPNLED, + OP_PFCMPODD, + OP_FCMPODSF, + OP_FCMPUDSF, + OP_FCMPODDF, + OP_FCMPUDDF, + OP_FXCMPODSF, + OP_FXCMPUDSF, + OP_FXCMPODDF, + OP_FXCMPUDDF, + OP_FXCMPODXF, + OP_FXCMPUDXF, + OP_PCMPEQB, + OP_PCMPEQH, + OP_PCMPEQW, + OP_PCMPGTB, + OP_PCMPGTH, + OP_PCMPGTW, + OP_PMOVMSKB, + OP_PMOVMSKPS, + OP_PMOVMSKPD, + OP_PACKSSHB, + OP_PACKUSHB, + OP_PSHUFW, + OP_PACKSSWH, + OP_PUNPCKHBH, + OP_PUNPCKHHW, + OP_PUNPCKHWD, + OP_PUNPCKLBH, + OP_PUNPCKLHW, + OP_PUNPCKLWD, + OP_LDGDB, + OP_LDGDH, + OP_LDGDW, + OP_LDGDD, + OP_LDGDQ, + OP_LDCUDB, + OP_LDCUDH, + OP_LDCUDW, + OP_LDCUDD, + OP_LDCUDQ, + OP_LDAPB, + OP_LDAPH, + OP_LDAPW, + OP_LDAPD, + OP_LDAPQ, + OP_LDODWB, + OP_LDODWD, + OP_LDODWH, + OP_LDODWQ, + OP_LDODWW, + OP_LDODPB, + OP_LDODPD, + OP_LDODPH, + OP_LDODPQ, + OP_LDODPW, + OP_LDODRB, + OP_LDODRD, + OP_LDODRH, + OP_LDODRQ, + OP_LDODRW, + OP_LDCSQ, + OP_LDDSQ, + OP_LDESQ, + OP_LDFSQ, + OP_LDGSQ, + OP_LDSSQ, + OP_FRCPS, + OP_FSQRTS, + OP_FSQRTID, + OP_FRSQRTS, + OP_PFSQRTS, + OP_GETTD, + OP_GETTAGS, + OP_GETTAGD, + OP_GETTC, + OP_INVTC, + OP_GETSOD, + OP_GETSP, + OP_PSHUFH, + OP_STCSQ, + OP_STDSQ, + OP_STESQ, + OP_STFSQ, + OP_STGSQ, + OP_STSSQ, + OP_STRD, + OP_STGDB, + OP_STGDH, + OP_STGDW, + OP_STGDD, + OP_STGDQ, + OP_STAPB, + OP_STAPH, + OP_STAPW, + OP_STAPD, + OP_STAPQ, + OP_STODPB, + OP_STODPD, + OP_STODPH, + OP_STODPQ, + OP_STODPW, + OP_STODRB, + OP_STODRD, + OP_STODRH, + OP_STODRQ, + OP_STODRW, + OP_STODWB, + OP_STODWD, + OP_STODWH, + OP_STODWQ, + OP_STODWW, + OP_RWS, + OP_RWD, + OP_RRS, + OP_RRD, + OP_MOVTQ, + OP_MOVTCQ, + OP_MOVTRQ, + OP_MOVTRCQ, + OP_BITREVS, + OP_BITREVD, + OP_LZCNTS, + OP_LZCNTD, + OP_POPCNTS, + OP_POPCNTD, + OP_FSTOIDTR, + OP_FDTOIDTR, + OP_FXTOISTR, + OP_FXTOIDTR, + OP_MOVX, + OP_MOVXA, + OP_MOVXC, + OP_PMULUBHH, + OP_FSTOIFS, + OP_FDTOIFD, + OP_UMULHD, + OP_SMULHD, + OP_PMINUW, + OP_PMINSW, + OP_PMAXUW, + OP_PMAXSW, + OP_MPSADBH, + OP_PACKUSWH, + OP_PCMPEQD, + OP_PCMPGTD, + OP_PFHADDS, + OP_PFHSUBS, + OP_PFADDSUBS, + OP_PMINSB, + OP_PMINUH, + OP_PMAXSB, + OP_PMAXUH, + OP_PFSTOIFS, + OP_PFDTOIFD, + OP_PHADDH, + OP_PHADDW, + OP_PHADDSH, + OP_PHSUBH, + OP_PHSUBW, + OP_PHSUBSH, + OP_PSIGNB, + OP_PSIGNH, + OP_PSIGNW, + OP_PMADDUBSH, + OP_PMULHRSH, + OP_PHMINPOSUH, + OP_PUTTST, + OP_FSCALES, + OP_FSCALED, + OP_FXSCALESX, + OP_STAAQP, + OP_QPAND, + OP_QPANDN, + OP_QPOR, + OP_QPXOR, + OP_QPADDB, + OP_QPADDH, + OP_QPADDSB, + OP_QPADDSH, + OP_QPADDUSB, + OP_QPADDUSH, + OP_QPADDW, + OP_QPADDD, + OP_QPSUBB, + OP_QPSUBH, + OP_QPSUBSB, + OP_QPSUBSH, + OP_QPSUBUSB, + OP_QPSUBUSH, + OP_QPSUBW, + OP_QPSUBD, + OP_QPFADDS, + OP_QPFADDD, + OP_QPFHADDS, + OP_QPFHSUBS, + OP_QPFADDSUBS, + OP_QPFADDSUBD, + OP_QPFSTOIFS, + OP_QPFDTOIFD, + OP_QPFMINS, + OP_QPFMIND, + OP_QPFMAXS, + OP_QPFMAXD, + OP_QPFMULS, + OP_QPFMULD, + OP_QPFSUBS, + OP_QPFSUBD, + OP_QPMSK2SGNB, + OP_QPPACKDL, + OP_QPSLLH, + OP_QPSLLW, + OP_QPSLLD, + OP_QPSRLH, + OP_QPSRLW, + OP_QPSRLD, + OP_QPSRAH, + OP_QPSRAW, + OP_QPACKSSHB, + OP_QPACKSSWH, + OP_QPACKUSHB, + OP_QPACKUSWH, + OP_QPAVGUSB, + OP_QPAVGUSH, + OP_QPCMPEQB, + OP_QPCMPEQD, + OP_QPCMPEQH, + OP_QPCMPEQW, + OP_QPCMPGTB, + OP_QPCMPGTD, + OP_QPCMPGTH, + OP_QPCMPGTW, + OP_QPHADDH, + OP_QPHADDSH, + OP_QPHADDW, + OP_QPHSUBH, + OP_QPHSUBSH, + OP_QPHSUBW, + OP_QPMAXSB, + OP_QPMAXSH, + OP_QPMAXSW, + OP_QPMAXUB, + OP_QPMAXUH, + OP_QPMAXUW, + OP_QPMINSB, + OP_QPMINSH, + OP_QPMINSW, + OP_QPMINUB, + OP_QPMINUH, + OP_QPMINUW, + OP_QPMULHH, + OP_QPMULHRSH, + OP_QPMULHUH, + OP_QPMULLH, + OP_QPMULUBHH, + OP_QPSIGNB, + OP_QPSIGNH, + OP_QPSIGNW, + OP_QPHMINPOSUH, + OP_QPMADDH, + OP_QPMADDUBSH, + OP_QPMPSADBH, + OP_QPSADBW, + OP_QPSRCD, + OP_QPSRCW, + OP_PSRCD, + OP_PSRCW, + OP_GETFZS, + OP_GETFZD, + OP_PUTTAGQP, + OP_PMULLW, + OP_QPMULLW, + OP_QPFCMPEQS, + OP_QPFCMPLTS, + OP_QPFCMPLES, + OP_QPFCMPUODS, + OP_QPFCMPNEQS, + OP_QPFCMPNLTS, + OP_QPFCMPNLES, + OP_QPFCMPODS, + OP_QPFCMPEQD, + OP_QPFCMPLTD, + OP_QPFCMPLED, + OP_QPFCMPUODD, + OP_QPFCMPNEQD, + OP_QPFCMPNLTD, + OP_QPFCMPNLED, + OP_QPFCMPODD, + OP_LDQ, + OP_LDQP, + OP_LDGDQP, + OP_LDCUDQP, + OP_LDCSQP, + OP_LDDSQP, + OP_LDESQP, + OP_LDFSQP, + OP_LDGSQP, + OP_LDSSQP, + OP_LDAPQP, + OP_LDRQP, + OP_QPSGN2MSKB, + OP_QPSWITCHW, + OP_QPSWITCHD, + OP_QPFSTOIS, + OP_QPFSTOISTR, + OP_QPISTOFS, + OP_QPFSTOID, + OP_QPFSTOIDTR, + OP_QPISTOFD, + OP_QPFSTOFD, + OP_QPFDTOIS, + OP_QPFDTOISTR, + OP_QPIDTOFS, + OP_QPFDTOFS, + OP_QPFDTOID, + OP_QPFDTOIDTR, + OP_QPIDTOFD, + OP_STQ, + OP_STGDMQP, + OP_STGDQP, + OP_STAPQP, + OP_STAPMQP, + OP_STMQP, + OP_STQP, + OP_STCSMQP, + OP_STCSQP, + OP_STDSMQP, + OP_STDSQP, + OP_STESMQP, + OP_STESQP, + OP_STFSMQP, + OP_STFSQP, + OP_STGSMQP, + OP_STGSQP, + OP_STSSMQP, + OP_STSSQP, + OP_STRQP, + OP_ADDCD, + OP_ADDCD_C, + OP_SUBCD, + OP_SUBCD_C, + OP_VFBGV, + OP_MKFSW, + OP_MODBGV, + OP_PCMPEQBOP, + OP_PCMPEQHOP, + OP_PCMPEQWOP, + OP_PCMPEQDOP, + OP_PCMPGTBOP, + OP_PCMPGTHOP, + OP_PCMPGTWOP, + OP_PCMPGTDOP, + OP_PCMPEQBAP, + OP_PCMPEQHAP, + OP_PCMPEQWAP, + OP_PCMPEQDAP, + OP_PCMPGTBAP, + OP_PCMPGTHAP, + OP_PCMPGTWAP, + OP_PCMPGTDAP, + OP_QPCMPEQBOP, + OP_QPCMPEQHOP, + OP_QPCMPEQWOP, + OP_QPCMPEQDOP, + OP_QPCMPGTBOP, + OP_QPCMPGTHOP, + OP_QPCMPGTWOP, + OP_QPCMPGTDOP, + OP_QPCMPEQBAP, + OP_QPCMPEQHAP, + OP_QPCMPEQWAP, + OP_QPCMPEQDAP, + OP_QPCMPGTBAP, + OP_QPCMPGTHAP, + OP_QPCMPGTWAP, + OP_QPCMPGTDAP, + OP_PMRGP, + OP_QPMRGP, + OP_CLMULH, + OP_CLMULL, + OP_IBRANCHD, + OP_ICALLD, + OP_QPCEXT_0X00, + OP_QPCEXT_0X7F, + OP_QPCEXT_0X80, + OP_QPCEXT_0XFF, + OP_FMAS, + OP_FMSS, + OP_FNMAS, + OP_FNMSS, + OP_FMAD, + OP_FMSD, + OP_FNMAD, + OP_FNMSD, + OP_QPFMAS, + OP_QPFMSS, + OP_QPFNMAS, + OP_QPFNMSS, + OP_QPFMAD, + OP_QPFMSD, + OP_QPFNMAD, + OP_QPFNMSD, + OP_QPFMASS, + OP_QPFMSAS, + OP_QPFMASD, + OP_QPFMSAD, +} Alop; + +typedef enum { + CHAN_0 = 1 << 0, + CHAN_1 = 1 << 1, + CHAN_2 = 1 << 2, + CHAN_3 = 1 << 3, + CHAN_4 = 1 << 4, + CHAN_5 = 1 << 5, + CHAN_01 = CHAN_0 | CHAN_1, + CHAN_03 = CHAN_0 | CHAN_3, + CHAN_14 = CHAN_1 | CHAN_4, + CHAN_25 = CHAN_2 | CHAN_5, + CHAN_0134 = CHAN_03 | CHAN_14, + CHAN_0235 = CHAN_03 | CHAN_25, + CHAN_012345 = CHAN_03 | CHAN_14 | CHAN_25, +} Channels; + +typedef enum { + ALOPF1, + ALOPF1_MERGE, + ALOPF2, + ALOPF3, + ALOPF7, + ALOPF8, + ALOPF10, + ALOPF11, + ALOPF11_MERGE, + ALOPF11_LIT8, + ALOPF12, + ALOPF12_PSHUFH, + ALOPF12_IBRANCHD, + ALOPF12_ICALLD, + ALOPF13, + ALOPF15, + ALOPF16, + ALOPF17, + ALOPF21, + ALOPF22, +} Alopf; + +#define SRC1_SHIFT 0 +#define SRC2_SHIFT 8 +#define SRC3_SHIFT 16 +#define SRC4_SHIFT 24 +#define DST_SHIFT SRC4_SHIFT + +#define args2(src2, dst) \ + (src2 << SRC2_SHIFT) | \ + (dst << DST_SHIFT) + +#define args3(src1, src2, dst) \ + (src1 << SRC1_SHIFT) | \ + (src2 << SRC2_SHIFT) | \ + (dst << DST_SHIFT) + +#define args4(src1, src2, src3, dst) \ + (src1 << SRC1_SHIFT) | \ + (src2 << SRC2_SHIFT) | \ + (src3 << SRC3_SHIFT) | \ + (dst << DST_SHIFT) + +typedef enum { + I, + B, + S, + D, + X, + Q, + P, + ARGS_S = S << SRC4_SHIFT, + ARGS_D = D << SRC4_SHIFT, + ARGS_Q = Q << SRC4_SHIFT, + ARGS_P = P << SRC4_SHIFT, + ARGS_SB = args2(S, B), + ARGS_SS = args2(S, S), + ARGS_SD = args2(S, D), + ARGS_SX = args2(S, X), + ARGS_SQ = args2(S, Q), + ARGS_DS = args2(D, S), + ARGS_DD = args2(D, D), + ARGS_DX = args2(D, X), + ARGS_DP = args2(D, P), + ARGS_XS = args2(X, S), + ARGS_XD = args2(X, D), + ARGS_XX = args2(X, X), + ARGS_QQ = args2(Q, Q), + ARGS_PS = args2(P, S), + ARGS_PD = args2(P, D), + ARGS_PP = args2(P, P), + ARGS_SSB = args3(S, S, B), + ARGS_SSS = args3(S, S, S), + ARGS_SSD = args3(S, S, D), + ARGS_SSQ = args3(S, S, Q), + ARGS_SSP = args3(S, S, P), + ARGS_SDD = args3(S, D, D), + ARGS_DSS = args3(D, S, S), + ARGS_DSD = args3(D, S, D), + ARGS_DSX = args3(D, S, X), + ARGS_DDB = args3(D, D, B), + ARGS_DDS = args3(D, D, S), + ARGS_DDD = args3(D, D, D), + ARGS_DDQ = args3(D, D, Q), + ARGS_DDP = args3(D, D, P), + ARGS_DPP = args3(D, P, P), + ARGS_XSB = args3(X, S, B), + ARGS_XSS = args3(X, S, S), + ARGS_XSX = args3(X, S, X), + ARGS_XDB = args3(X, D, B), + ARGS_XDS = args3(X, D, S), + ARGS_XDD = args3(X, D, D), + ARGS_XDX = args3(X, D, X), + ARGS_XXS = args3(X, X, S), + ARGS_XXD = args3(X, X, D), + ARGS_XXX = args3(X, X, X), + ARGS_QSS = args3(Q, S, S), + ARGS_QSD = args3(Q, S, D), + ARGS_QSQ = args3(Q, S, Q), + ARGS_QSP = args3(Q, S, P), + ARGS_QDQ = args3(Q, D, Q), + ARGS_QQQ = args3(Q, Q, Q), + ARGS_PSP = args3(P, S, P), + ARGS_PDP = args3(P, D, P), + ARGS_PPD = args3(P, P, D), + ARGS_PPP = args3(P, P, P), + ARGS_SSSS = args4(S, S, S, S), + ARGS_DDSD = args4(D, D, S, D), + ARGS_DDDD = args4(D, D, D, D), + ARGS_PPPP = args4(P, P, P, P), +} AlopArgs; + +typedef enum { + SHORT = 0x0, + EXT = 0x1, + EXT1 = 0x2, + EXT2 = 0x3, + FLB = 0x4, + FLH = 0x5, + FLW = 0x6, + FLD = 0x7, + ICMB0 = 0x8, + ICMB1 = 0x9, + ICMB2 = 0xA, + ICMB3 = 0xB, + FCMB0 = 0xC, + FCMB1 = 0xD, + PFCMB0 = 0XE, + PFCMB1 = 0xF, + LCMBD0 = 0x10, + LCMBD1 = 0x11, + LCMBQ0 = 0x12, + LCMBQ1 = 0x13, + QPFCMB0 = 0x16, + QPFCMB1 = 0x17, +} AlopExt; + +typedef struct { + Alop op; + Alopf alopf; + AlopArgs format; + AlopExt opc2; + uint8_t opc1; + uint8_t min_version; + uint8_t max_version; + Channels channels; + int16_t next[6]; + uint8_t extra1; /* opce1, opce2, cmpopce */ + uint8_t extra2; /* opce2, implicit_nops, explicit_ales25_v4 */ +} AlopDesc; + +static AlopDesc alops[] = { + { OP_ADDS, ALOPF1, ARGS_SSS, SHORT, 0x10, 1, -1, CHAN_012345, { -1 } }, + { OP_ADDD, ALOPF1, ARGS_DDD, SHORT, 0x11, 1, -1, CHAN_012345, { -1 } }, + { OP_SUBS, ALOPF1, ARGS_SSS, SHORT, 0x12, 1, -1, CHAN_012345, { -1 } }, + { OP_SUBD, ALOPF1, ARGS_DDD, SHORT, 0x13, 1, -1, CHAN_012345, { -1 } }, + { OP_UDIVX, ALOPF1, ARGS_DSS, SHORT, 0x44, 1, -1, CHAN_5, { -1 } }, + { OP_UMODX, ALOPF1, ARGS_DSS, SHORT, 0x45, 1, -1, CHAN_5, { -1 } }, + { OP_SDIVX, ALOPF1, ARGS_DSS, SHORT, 0x46, 1, -1, CHAN_5, { -1 } }, + { OP_SMODX, ALOPF1, ARGS_DSS, SHORT, 0x47, 1, -1, CHAN_5, { -1 } }, + { OP_UDIVS, ALOPF1, ARGS_SSS, SHORT, 0x40, 1, -1, CHAN_5, { -1 } }, + { OP_UDIVD, ALOPF1, ARGS_DDD, SHORT, 0x41, 1, -1, CHAN_5, { -1 } }, + { OP_SDIVS, ALOPF1, ARGS_SSS, SHORT, 0x42, 1, -1, CHAN_5, { -1 } }, + { OP_SDIVD, ALOPF1, ARGS_DDD, SHORT, 0x43, 1, -1, CHAN_5, { -1 } }, + { OP_ANDS, ALOPF1, ARGS_SSS, SHORT, 0x00, 1, -1, CHAN_012345, { -1 } }, + { OP_ANDD, ALOPF1, ARGS_DDD, SHORT, 0x01, 1, -1, CHAN_012345, { -1 } }, + { OP_ANDNS, ALOPF1, ARGS_SSS, SHORT, 0x02, 1, -1, CHAN_012345, { -1 } }, + { OP_ANDND, ALOPF1, ARGS_DDD, SHORT, 0x03, 1, -1, CHAN_012345, { -1 } }, + { OP_ORS, ALOPF1, ARGS_SSS, SHORT, 0x04, 1, -1, CHAN_012345, { -1 } }, + { OP_ORD, ALOPF1, ARGS_DDD, SHORT, 0x05, 1, -1, CHAN_012345, { -1 } }, + { OP_ORNS, ALOPF1, ARGS_SSS, SHORT, 0x06, 1, -1, CHAN_012345, { -1 } }, + { OP_ORND, ALOPF1, ARGS_DDD, SHORT, 0x07, 1, -1, CHAN_012345, { -1 } }, + { OP_XORS, ALOPF1, ARGS_SSS, SHORT, 0x08, 1, -1, CHAN_012345, { -1 } }, + { OP_XORD, ALOPF1, ARGS_DDD, SHORT, 0x09, 1, -1, CHAN_012345, { -1 } }, + { OP_XORNS, ALOPF1, ARGS_SSS, SHORT, 0x0a, 1, -1, CHAN_012345, { -1 } }, + { OP_XORND, ALOPF1, ARGS_DDD, SHORT, 0x0b, 1, -1, CHAN_012345, { -1 } }, + { OP_SHLS, ALOPF1, ARGS_SSS, SHORT, 0x18, 1, -1, CHAN_012345, { -1 } }, + { OP_SHLD, ALOPF1, ARGS_DDD, SHORT, 0x19, 1, -1, CHAN_012345, { -1 } }, + { OP_SHRS, ALOPF1, ARGS_SSS, SHORT, 0x1a, 1, -1, CHAN_012345, { -1 } }, + { OP_SHRD, ALOPF1, ARGS_DDD, SHORT, 0x1b, 1, -1, CHAN_012345, { -1 } }, + { OP_SCLS, ALOPF1, ARGS_SSS, SHORT, 0x14, 1, -1, CHAN_012345, { -1 } }, + { OP_SCLD, ALOPF1, ARGS_DDD, SHORT, 0x15, 1, -1, CHAN_012345, { -1 } }, + { OP_SCRS, ALOPF1, ARGS_SSS, SHORT, 0x16, 1, -1, CHAN_012345, { -1 } }, + { OP_SCRD, ALOPF1, ARGS_DDD, SHORT, 0x17, 1, -1, CHAN_012345, { -1 } }, + { OP_SARS, ALOPF1, ARGS_SSS, SHORT, 0x1c, 1, -1, CHAN_012345, { -1 } }, + { OP_SARD, ALOPF1, ARGS_DDD, SHORT, 0x1d, 1, -1, CHAN_012345, { -1 } }, + { OP_GETFS, ALOPF1, ARGS_SSS, SHORT, 0x1e, 1, -1, CHAN_012345, { -1 } }, + { OP_GETFD, ALOPF1, ARGS_DDD, SHORT, 0x1f, 1, -1, CHAN_012345, { -1 } }, + { OP_SXT, ALOPF1, ARGS_SSD, SHORT, 0x0c, 1, -1, CHAN_012345, { -1 } }, + { OP_MERGES, ALOPF1_MERGE, ARGS_SSS, SHORT, 0x0e, 1, -1, CHAN_012345, { -1 } }, + { OP_MERGED, ALOPF1_MERGE, ARGS_DDD, SHORT, 0x0f, 1, -1, CHAN_012345, { -1 } }, + { OP_FADDS, ALOPF1, ARGS_SSS, SHORT, 0x30, 1, -1, CHAN_0134, { -1 } }, + { OP_FADDD, ALOPF1, ARGS_DDD, SHORT, 0x31, 1, -1, CHAN_0134, { -1 } }, + { OP_FSUBS, ALOPF1, ARGS_SSS, SHORT, 0x32, 1, -1, CHAN_0134, { -1 } }, + { OP_FSUBD, ALOPF1, ARGS_DDD, SHORT, 0x33, 1, -1, CHAN_0134, { -1 } }, + { OP_FMINS, ALOPF1, ARGS_SSS, SHORT, 0x34, 1, -1, CHAN_0134, { -1 } }, + { OP_FMIND, ALOPF1, ARGS_DDD, SHORT, 0x35, 1, -1, CHAN_0134, { -1 } }, + { OP_FMAXS, ALOPF1, ARGS_SSS, SHORT, 0x36, 1, -1, CHAN_0134, { -1 } }, + { OP_FMAXD, ALOPF1, ARGS_DDD, SHORT, 0x37, 1, -1, CHAN_0134, { -1 } }, + { OP_FMULS, ALOPF1, ARGS_SSS, SHORT, 0x38, 1, -1, CHAN_0134, { -1 } }, + { OP_FMULD, ALOPF1, ARGS_DDD, SHORT, 0x39, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDSS, ALOPF1, ARGS_XSS, SHORT, 0x40, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDDD, ALOPF1, ARGS_XDD, SHORT, 0x41, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDSX, ALOPF1, ARGS_XSX, SHORT, 0x42, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDDX, ALOPF1, ARGS_XDX, SHORT, 0x43, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDXX, ALOPF1, ARGS_XXX, SHORT, 0x47, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDXD, ALOPF1, ARGS_XXD, SHORT, 0x45, 1, -1, CHAN_0134, { -1 } }, + { OP_FXADDXS, ALOPF1, ARGS_XXS, SHORT, 0x44, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBSS, ALOPF1, ARGS_XSS, SHORT, 0x48, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBDD, ALOPF1, ARGS_XDD, SHORT, 0x49, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBSX, ALOPF1, ARGS_XSX, SHORT, 0x4a, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBDX, ALOPF1, ARGS_XDX, SHORT, 0x4b, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBXX, ALOPF1, ARGS_XXX, SHORT, 0x4f, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBXD, ALOPF1, ARGS_XXD, SHORT, 0x4d, 1, -1, CHAN_0134, { -1 } }, + { OP_FXSUBXS, ALOPF1, ARGS_XXS, SHORT, 0x4c, 1, -1, CHAN_0134, { -1 } }, + { OP_FXRSUBSS, ALOPF1, ARGS_XSS, SHORT, 0x58, 1, -1, CHAN_0134, { -1 } }, + { OP_FXRSUBDD, ALOPF1, ARGS_XDD, SHORT, 0x59, 1, -1, CHAN_0134, { -1 } }, + { OP_FXRSUBSX, ALOPF1, ARGS_XSX, SHORT, 0x5a, 1, -1, CHAN_0134, { -1 } }, + { OP_FXRSUBDX, ALOPF1, ARGS_XDX, SHORT, 0x5b, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULSS, ALOPF1, ARGS_XSS, SHORT, 0x50, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULDD, ALOPF1, ARGS_XDD, SHORT, 0x51, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULSX, ALOPF1, ARGS_XSX, SHORT, 0x52, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULDX, ALOPF1, ARGS_XDX, SHORT, 0x53, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULXX, ALOPF1, ARGS_XXX, SHORT, 0x57, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULXD, ALOPF1, ARGS_XXD, SHORT, 0x55, 1, -1, CHAN_0134, { -1 } }, + { OP_FXMULXS, ALOPF1, ARGS_XXS, SHORT, 0x54, 1, -1, CHAN_0134, { -1 } }, + { OP_FXDIVSS, ALOPF1, ARGS_XSS, SHORT, 0x48, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVDD, ALOPF1, ARGS_XDD, SHORT, 0x49, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVSX, ALOPF1, ARGS_XSX, SHORT, 0x4a, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVDX, ALOPF1, ARGS_XDX, SHORT, 0x4b, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVXX, ALOPF1, ARGS_XXX, SHORT, 0x4f, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVXD, ALOPF1, ARGS_XXD, SHORT, 0x4d, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVXS, ALOPF1, ARGS_XXS, SHORT, 0x4c, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVTSS, ALOPF1, ARGS_XSS, SHORT, 0x60, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVTDD, ALOPF1, ARGS_XDD, SHORT, 0x61, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVTSX, ALOPF1, ARGS_XSX, SHORT, 0x62, 1, -1, CHAN_5, { -1 } }, + { OP_FXDIVTDX, ALOPF1, ARGS_XDX, SHORT, 0x63, 1, -1, CHAN_5, { -1 } }, + { OP_FXSQRTUSX, ALOPF1, ARGS_XSX, SHORT, 0x5a, 1, -1, CHAN_5, { -1 } }, + { OP_FXSQRTUDX, ALOPF1, ARGS_XDX, SHORT, 0x5b, 1, -1, CHAN_5, { -1 } }, + { OP_FXSQRTUXX, ALOPF1, ARGS_XXX, SHORT, 0x59, 1, -1, CHAN_5, { -1 } }, + { OP_FXSQRTTSX, ALOPF1, ARGS_XSX, SHORT, 0x5e, 1, -1, CHAN_5, { -1 } }, + { OP_FXSQRTTDX, ALOPF1, ARGS_XDX, SHORT, 0x5f, 1, -1, CHAN_5, { -1 } }, + { OP_FXSQRTTXX, ALOPF1, ARGS_XXX, SHORT, 0x5d, 1, -1, CHAN_5, { -1 } }, + { OP_MOVIF, ALOPF1, ARGS_DSX, SHORT, 0x5e, 1, -1, CHAN_14, { -1 } }, + { OP_VFSI, ALOPF1, ARGS_SDD, SHORT, 0x63, 1, -1, CHAN_14, { -1 } }, + { OP_LDCSB, ALOPF1, ARGS_SSD, SHORT, 0x68, 1, -1, CHAN_0235, { -1 } }, + { OP_LDDSB, ALOPF1, ARGS_SSD, SHORT, 0x6c, 1, -1, CHAN_0235, { -1 } }, + { OP_LDESB, ALOPF1, ARGS_SSD, SHORT, 0x70, 1, -1, CHAN_0235, { -1 } }, + { OP_LDFSB, ALOPF1, ARGS_SSD, SHORT, 0x74, 1, -1, CHAN_0235, { -1 } }, + { OP_LDGSB, ALOPF1, ARGS_SSD, SHORT, 0x78, 1, -1, CHAN_0235, { -1 } }, + { OP_LDSSB, ALOPF1, ARGS_SSD, SHORT, 0x7c, 1, -1, CHAN_0235, { -1 } }, + { OP_LDCSH, ALOPF1, ARGS_SSD, SHORT, 0x69, 1, -1, CHAN_0235, { -1 } }, + { OP_LDDSH, ALOPF1, ARGS_SSD, SHORT, 0x6d, 1, -1, CHAN_0235, { -1 } }, + { OP_LDESH, ALOPF1, ARGS_SSD, SHORT, 0x71, 1, -1, CHAN_0235, { -1 } }, + { OP_LDFSH, ALOPF1, ARGS_SSD, SHORT, 0x75, 1, -1, CHAN_0235, { -1 } }, + { OP_LDGSH, ALOPF1, ARGS_SSD, SHORT, 0x79, 1, -1, CHAN_0235, { -1 } }, + { OP_LDSSH, ALOPF1, ARGS_SSD, SHORT, 0x7d, 1, -1, CHAN_0235, { -1 } }, + { OP_LDCSW, ALOPF1, ARGS_SSD, SHORT, 0x6a, 1, -1, CHAN_0235, { -1 } }, + { OP_LDDSW, ALOPF1, ARGS_SSD, SHORT, 0x6e, 1, -1, CHAN_0235, { -1 } }, + { OP_LDESW, ALOPF1, ARGS_SSD, SHORT, 0x72, 1, -1, CHAN_0235, { -1 } }, + { OP_LDFSW, ALOPF1, ARGS_SSD, SHORT, 0x76, 1, -1, CHAN_0235, { -1 } }, + { OP_LDGSW, ALOPF1, ARGS_SSD, SHORT, 0x7a, 1, -1, CHAN_0235, { -1 } }, + { OP_LDSSW, ALOPF1, ARGS_SSD, SHORT, 0x7e, 1, -1, CHAN_0235, { -1 } }, + { OP_LDCSD, ALOPF1, ARGS_SSD, SHORT, 0x6b, 1, -1, CHAN_0235, { -1 } }, + { OP_LDDSD, ALOPF1, ARGS_SSD, SHORT, 0x6f, 1, -1, CHAN_0235, { -1 } }, + { OP_LDESD, ALOPF1, ARGS_SSD, SHORT, 0x73, 1, -1, CHAN_0235, { -1 } }, + { OP_LDFSD, ALOPF1, ARGS_SSD, SHORT, 0x77, 1, -1, CHAN_0235, { -1 } }, + { OP_LDGSD, ALOPF1, ARGS_SSD, SHORT, 0x7b, 1, -1, CHAN_0235, { -1 } }, + { OP_LDSSD, ALOPF1, ARGS_SSD, SHORT, 0x7f, 1, -1, CHAN_0235, { -1 } }, + { OP_LDB, ALOPF1, ARGS_DDD, SHORT, 0x64, 1, -1, CHAN_0235, { -1 } }, + { OP_LDH, ALOPF1, ARGS_DDD, SHORT, 0x65, 1, -1, CHAN_0235, { -1 } }, + { OP_LDW, ALOPF1, ARGS_DDD, SHORT, 0x66, 1, -1, CHAN_0235, { -1 } }, + { OP_LDD, ALOPF1, ARGS_DDD, SHORT, 0x67, 1, -1, CHAN_0235, { -1 } }, + { OP_FXSQRTISX, ALOPF2, ARGS_SX, SHORT, 0x52, 1, -1, CHAN_5, { -1 }, 0xc0 }, + { OP_FXSQRTIDX, ALOPF2, ARGS_DX, SHORT, 0x53, 1, -1, CHAN_5, { -1 }, 0xc0 }, + { OP_FXSQRTIXX, ALOPF2, ARGS_XX, SHORT, 0x57, 1, -1, CHAN_5, { -1 }, 0xc0 }, + { OP_MOVFI, ALOPF2, ARGS_XS, SHORT, 0x5c, 1, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_MOVTS, ALOPF2, ARGS_SS, SHORT, 0x60, 1, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_MOVTCS, ALOPF2, ARGS_SS, SHORT, 0x60, 1, -1, CHAN_0134, { -1 }, 0xc1 }, + { OP_MOVTRS, ALOPF2, ARGS_SS, SHORT, 0x60, 1, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_MOVTRCS, ALOPF2, ARGS_SS, SHORT, 0x60, 1, -1, CHAN_0134, { -1 }, 0xc3 }, + { OP_MOVTD, ALOPF2, ARGS_DD, SHORT, 0x61, 1, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_MOVTCD, ALOPF2, ARGS_DD, SHORT, 0x61, 1, -1, CHAN_0134, { -1 }, 0xc1 }, + { OP_MOVTRD, ALOPF2, ARGS_DD, SHORT, 0x61, 1, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_MOVTRCD, ALOPF2, ARGS_DD, SHORT, 0x61, 1, -1, CHAN_0134, { -1 }, 0xc3 }, + { OP_FSTOIS, ALOPF2, ARGS_SS, SHORT, 0x3c, 1, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_FSTOID, ALOPF2, ARGS_SD, SHORT, 0x3e, 1, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_FDTOIS, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_FDTOID, ALOPF2, ARGS_DD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_FXTOIS, ALOPF2, ARGS_XS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc1 }, + { OP_FXTOID, ALOPF2, ARGS_XD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc1 }, + { OP_FSTOISTR, ALOPF2, ARGS_SS, SHORT, 0x3c, 1, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_FDTOISTR, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_ISTOFS, ALOPF2, ARGS_SS, SHORT, 0x3c, 1, -1, CHAN_0134, { -1 }, 0xc4 }, + { OP_ISTOFD, ALOPF2, ARGS_SD, SHORT, 0x3e, 1, -1, CHAN_0134, { -1 }, 0xc4 }, + { OP_IDTOFS, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc4 }, + { OP_IDTOFD, ALOPF2, ARGS_DD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc4 }, + { OP_ISTOFX, ALOPF2, ARGS_SX, SHORT, 0x3e, 1, -1, CHAN_0134, { -1 }, 0xc5 }, + { OP_IDTOFX, ALOPF2, ARGS_DX, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc5 }, + { OP_FSTOFD, ALOPF2, ARGS_SD, SHORT, 0x3e, 1, -1, CHAN_0134, { -1 }, 0xc6 }, + { OP_FDTOFS, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc6 }, + { OP_FXTOFD, ALOPF2, ARGS_XD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc6 }, + { OP_FSTOFX, ALOPF2, ARGS_SX, SHORT, 0x3e, 1, -1, CHAN_0134, { -1 }, 0xc7 }, + { OP_FXTOFS, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc7 }, + { OP_FDTOFX, ALOPF2, ARGS_DX, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc7 }, + { OP_PFDTOIS, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xc8 }, + { OP_PFSTOIS, ALOPF2, ARGS_DD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xc8 }, + { OP_PFDTOISTR, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xca }, + { OP_PFSTOISTR, ALOPF2, ARGS_DD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xca }, + { OP_PISTOFS, ALOPF2, ARGS_DD, SHORT, 0x3d, 1, -1, CHAN_0134, { -1 }, 0xcc }, + { OP_PFSTOFD, ALOPF2, ARGS_SD, SHORT, 0x3e, 1, -1, CHAN_0134, { -1 }, 0xce }, + { OP_PFDTOFS, ALOPF2, ARGS_DS, SHORT, 0x3f, 1, -1, CHAN_0134, { -1 }, 0xce }, + { OP_GETPL, ALOPF2, ARGS_SD, SHORT, 0x63, 1, -1, CHAN_03, { -1 }, 0xf0 }, + { OP_GETSAP, ALOPF2, ARGS_SQ, SHORT, 0x62, 1, -1, CHAN_01, { -1 }, 0xec }, + { OP_CUDTOAP, ALOPF2, ARGS_SQ, SHORT, 0x62, 1, -1, CHAN_0134, { -1 }, 0xf0 }, + { OP_GDTOAP, ALOPF2, ARGS_SQ, SHORT, 0x62, 1, -1, CHAN_0134, { -1 }, 0xf2 }, + { OP_STCSB, ALOPF3, ARGS_SSS, SHORT, 0x28, 1, -1, CHAN_25, { -1 } }, + { OP_STDSB, ALOPF3, ARGS_SSS, SHORT, 0x2c, 1, -1, CHAN_25, { -1 } }, + { OP_STESB, ALOPF3, ARGS_SSS, SHORT, 0x30, 1, -1, CHAN_25, { -1 } }, + { OP_STFSB, ALOPF3, ARGS_SSS, SHORT, 0x34, 1, -1, CHAN_25, { -1 } }, + { OP_STGSB, ALOPF3, ARGS_SSS, SHORT, 0x38, 1, -1, CHAN_25, { -1 } }, + { OP_STSSB, ALOPF3, ARGS_SSS, SHORT, 0x3c, 1, -1, CHAN_25, { -1 } }, + { OP_STCSH, ALOPF3, ARGS_SSS, SHORT, 0x29, 1, -1, CHAN_25, { -1 } }, + { OP_STDSH, ALOPF3, ARGS_SSS, SHORT, 0x2d, 1, -1, CHAN_25, { -1 } }, + { OP_STESH, ALOPF3, ARGS_SSS, SHORT, 0x31, 1, -1, CHAN_25, { -1 } }, + { OP_STFSH, ALOPF3, ARGS_SSS, SHORT, 0x35, 1, -1, CHAN_25, { -1 } }, + { OP_STGSH, ALOPF3, ARGS_SSS, SHORT, 0x39, 1, -1, CHAN_25, { -1 } }, + { OP_STSSH, ALOPF3, ARGS_SSS, SHORT, 0x3d, 1, -1, CHAN_25, { -1 } }, + { OP_STCSW, ALOPF3, ARGS_SSS, SHORT, 0x2a, 1, -1, CHAN_25, { -1 } }, + { OP_STDSW, ALOPF3, ARGS_SSS, SHORT, 0x2e, 1, -1, CHAN_25, { -1 } }, + { OP_STESW, ALOPF3, ARGS_SSS, SHORT, 0x32, 1, -1, CHAN_25, { -1 } }, + { OP_STFSW, ALOPF3, ARGS_SSS, SHORT, 0x36, 1, -1, CHAN_25, { -1 } }, + { OP_STGSW, ALOPF3, ARGS_SSS, SHORT, 0x3a, 1, -1, CHAN_25, { -1 } }, + { OP_STSSW, ALOPF3, ARGS_SSS, SHORT, 0x3e, 1, -1, CHAN_25, { -1 } }, + { OP_STCSD, ALOPF3, ARGS_SSD, SHORT, 0x2b, 1, -1, CHAN_25, { -1 } }, + { OP_STDSD, ALOPF3, ARGS_SSD, SHORT, 0x2f, 1, -1, CHAN_25, { -1 } }, + { OP_STESD, ALOPF3, ARGS_SSD, SHORT, 0x33, 1, -1, CHAN_25, { -1 } }, + { OP_STFSD, ALOPF3, ARGS_SSD, SHORT, 0x37, 1, -1, CHAN_25, { -1 } }, + { OP_STGSD, ALOPF3, ARGS_SSD, SHORT, 0x3b, 1, -1, CHAN_25, { -1 } }, + { OP_STSSD, ALOPF3, ARGS_SSD, SHORT, 0x3f, 1, -1, CHAN_25, { -1 } }, + { OP_STB, ALOPF3, ARGS_DDS, SHORT, 0x24, 1, -1, CHAN_25, { -1 } }, + { OP_STH, ALOPF3, ARGS_DDS, SHORT, 0x25, 1, -1, CHAN_25, { -1 } }, + { OP_STW, ALOPF3, ARGS_DDS, SHORT, 0x26, 1, -1, CHAN_25, { -1 } }, + { OP_STD, ALOPF3, ARGS_DDD, SHORT, 0x27, 1, -1, CHAN_25, { -1 } }, + { OP_CMPOSB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 0, 2 }, + { OP_CMPBSB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 1, 2 }, + { OP_CMPESB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 2, 2 }, + { OP_CMPBESB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 3, 2 }, + { OP_CMPSSB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 4, 2 }, + { OP_CMPPSB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 5, 2 }, + { OP_CMPLSB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 6, 2 }, + { OP_CMPLESB, ALOPF7, ARGS_SSB, SHORT, 0x20, 1, -1, CHAN_0134, { -1 }, 7, 2 }, + { OP_CMPODB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 0, 2 }, + { OP_CMPBDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 1, 2 }, + { OP_CMPEDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 2, 2 }, + { OP_CMPBEDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 3, 2 }, + { OP_CMPSDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 4, 2 }, + { OP_CMPPDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 5, 2 }, + { OP_CMPLDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 6, 2 }, + { OP_CMPLEDB, ALOPF7, ARGS_DDB, SHORT, 0x21, 1, -1, CHAN_0134, { -1 }, 7, 2 }, + { OP_CMPANDESB, ALOPF7, ARGS_SSB, SHORT, 0x22, 1, -1, CHAN_0134, { -1 }, 2, 2 }, + { OP_CMPANDSSB, ALOPF7, ARGS_SSB, SHORT, 0x22, 1, -1, CHAN_0134, { -1 }, 4, 2 }, + { OP_CMPANDPSB, ALOPF7, ARGS_SSB, SHORT, 0x22, 1, -1, CHAN_0134, { -1 }, 5, 2 }, + { OP_CMPANDLESB, ALOPF7, ARGS_SSB, SHORT, 0x22, 1, -1, CHAN_0134, { -1 }, 7, 2 }, + { OP_CMPANDEDB, ALOPF7, ARGS_DDB, SHORT, 0x23, 1, -1, CHAN_0134, { -1 }, 2, 2 }, + { OP_CMPANDSDB, ALOPF7, ARGS_DDB, SHORT, 0x23, 1, -1, CHAN_0134, { -1 }, 4, 2 }, + { OP_CMPANDPDB, ALOPF7, ARGS_DDB, SHORT, 0x23, 1, -1, CHAN_0134, { -1 }, 5, 2 }, + { OP_CMPANDLEDB, ALOPF7, ARGS_DDB, SHORT, 0x23, 1, -1, CHAN_0134, { -1 }, 7, 2 }, + { OP_FCMPEQSB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 0, 4 }, + { OP_FCMPLTSB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 1, 4 }, + { OP_FCMPLESB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 2, 4 }, + { OP_FCMPUODSB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 3, 4 }, + { OP_FCMPNEQSB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 4, 4 }, + { OP_FCMPNLTSB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 5, 4 }, + { OP_FCMPNLESB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 6, 4 }, + { OP_FCMPODSB, ALOPF7, ARGS_SSB, SHORT, 0x2e, 1, -1, CHAN_0134, { -1 }, 7, 4 }, + { OP_FCMPEQDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 0, 4 }, + { OP_FCMPLTDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 1, 4 }, + { OP_FCMPLEDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 2, 4 }, + { OP_FCMPUODDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 3, 4 }, + { OP_FCMPNEQDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 4, 4 }, + { OP_FCMPNLTDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 5, 4 }, + { OP_FCMPNLEDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 6, 4 }, + { OP_FCMPODDB, ALOPF7, ARGS_DDB, SHORT, 0x2f, 1, -1, CHAN_0134, { -1 }, 7, 4 }, + { OP_FXCMPEQSB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 0, 4 }, + { OP_FXCMPLTSB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 1, 4 }, + { OP_FXCMPLESB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 2, 4 }, + { OP_FXCMPUODSB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 3, 4 }, + { OP_FXCMPNEQSB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 4, 4 }, + { OP_FXCMPNLTSB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 5, 4 }, + { OP_FXCMPNLESB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 6, 4 }, + { OP_FXCMPODSB, ALOPF7, ARGS_XSB, SHORT, 0x28, 1, -1, CHAN_0134, { -1 }, 7, 4 }, + { OP_FXCMPEQDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 0, 4 }, + { OP_FXCMPLTDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 1, 4 }, + { OP_FXCMPLEDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 2, 4 }, + { OP_FXCMPUODDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 3, 4 }, + { OP_FXCMPNEQDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 4, 4 }, + { OP_FXCMPNLTDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 5, 4 }, + { OP_FXCMPNLEDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 6, 4 }, + { OP_FXCMPODDB, ALOPF7, ARGS_XDB, SHORT, 0x29, 1, -1, CHAN_0134, { -1 }, 7, 4 }, + { OP_FXCMPEQXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 0, 4 }, + { OP_FXCMPLTXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 1, 4 }, + { OP_FXCMPLEXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 2, 4 }, + { OP_FXCMPUODXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 3, 4 }, + { OP_FXCMPNEQXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 4, 4 }, + { OP_FXCMPNLTXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 5, 4 }, + { OP_FXCMPNLEXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 6, 4 }, + { OP_FXCMPODXB, ALOPF7, ARGS_XDB, SHORT, 0x2b, 1, -1, CHAN_0134, { -1 }, 7, 4 }, + { OP_CCTOPO, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 0 }, + { OP_CCTOPB, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 1 }, + { OP_CCTOPE, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 2 }, + { OP_CCTOPBE, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 3 }, + { OP_CCTOPS, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 4 }, + { OP_CCTOPP, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 5 }, + { OP_CCTOPL, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 6 }, + { OP_CCTOPLE, ALOPF8, ARGS_S, SHORT, 0x24, 1, -1, CHAN_03, { -1 }, 7 }, + { OP_STAAB, ALOPF10, ARGS_S, EXT, 0x1c, 1, -1, CHAN_25, { -1 } }, + { OP_STAAH, ALOPF10, ARGS_S, EXT, 0x1d, 1, -1, CHAN_25, { -1 } }, + { OP_STAAW, ALOPF10, ARGS_S, EXT, 0x1e, 1, -1, CHAN_25, { -1 } }, + { OP_STAAD, ALOPF10, ARGS_D, EXT, 0x1f, 1, -1, CHAN_25, { -1 } }, + { OP_STAAQ, ALOPF10, ARGS_Q, EXT, 0x3f, 1, -1, CHAN_25, { -1 } }, + /* + { OP_AAURW, ALOPF10, ARGS_S, EXT, 0x1e, 1, -1, CHAN_25, { -1 } }, + { OP_AAURWS, ALOPF10, ARGS_S, EXT, 0x1e, 1, -1, CHAN_25, { -1 } }, + { OP_AAURWD, ALOPF10, ARGS_D, EXT, 0x1f, 1, -1, CHAN_25, { -1 } }, + { OP_AAURWQ, ALOPF10, ARGS_Q, EXT, 0x3f, 1, -1, CHAN_25, { -1 } }, + { OP_AAURR, ALOPF19, ARGS_S, EXT, 0x5e, 1, -1, CHAN_25, { -1 } }, + { OP_AAURRD, ALOPF19, ARGS_D, EXT, 0x5f, 1, -1, CHAN_25, { -1 } }, + { OP_AAURRQ, ALOPF19, ARGS_Q, EXT, 0x7f, 1, -1, CHAN_25, { -1 } }, + */ + { OP_MULS, ALOPF11, ARGS_SSS, EXT, 0x20, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_MULD, ALOPF11, ARGS_DDD, EXT, 0x21, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_UMULX, ALOPF11, ARGS_SSD, EXT, 0x22, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_SMULX, ALOPF11, ARGS_SSD, EXT, 0x23, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_FDIVS, ALOPF11, ARGS_SSS, EXT, 0x48, 1, -1, CHAN_5, { -1 }, 0xc0, 0 }, + { OP_FDIVD, ALOPF11, ARGS_DDD, EXT, 0x49, 1, -1, CHAN_5, { -1 }, 0xc0, 0 }, + { OP_FSQRTTD, ALOPF11, ARGS_DDD, EXT, 0x51, 1, -1, CHAN_5, { -1 }, 0xc0, 0 }, + { OP_PFMULS, ALOPF11, ARGS_DDD, EXT, 0x38, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFMULD, ALOPF11, ARGS_DDD, EXT, 0x39, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PADDB, ALOPF11, ARGS_SSS, EXT, 0x08, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDH, ALOPF11, ARGS_SSS, EXT, 0x09, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDW, ALOPF11, ARGS_SSS, EXT, 0x0e, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDD, ALOPF11, ARGS_SSS, EXT, 0x0f, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDSB, ALOPF11, ARGS_SSS, EXT, 0x0a, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDSH, ALOPF11, ARGS_SSS, EXT, 0x0b, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDUSB, ALOPF11, ARGS_SSS, EXT, 0x0c, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PADDUSH, ALOPF11, ARGS_SSS, EXT, 0x0d, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBB, ALOPF11, ARGS_SSS, EXT, 0x10, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBH, ALOPF11, ARGS_SSS, EXT, 0x11, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBW, ALOPF11, ARGS_SSS, EXT, 0x16, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBD, ALOPF11, ARGS_SSS, EXT, 0x17, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBSB, ALOPF11, ARGS_SSS, EXT, 0x12, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBSH, ALOPF11, ARGS_SSS, EXT, 0x13, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBUSB, ALOPF11, ARGS_SSS, EXT, 0x14, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSUBUSH, ALOPF11, ARGS_SSS, EXT, 0x15, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMAXSH, ALOPF11, ARGS_SSS, EXT, 0x03, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMAXUB, ALOPF11, ARGS_SSS, EXT, 0x02, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMINSH, ALOPF11, ARGS_SSS, EXT, 0x01, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMINUB, ALOPF11, ARGS_SSS, EXT, 0x00, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSADBW, ALOPF11, ARGS_SSS, EXT, 0x1c, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMULHUH, ALOPF11, ARGS_SSS, EXT, 0x1b, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMULHH, ALOPF11, ARGS_SSS, EXT, 0x18, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMULLH, ALOPF11, ARGS_SSS, EXT, 0x19, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMADDH, ALOPF11, ARGS_SSS, EXT, 0x1a, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSLLD, ALOPF11, ARGS_SSS, EXT, 0x4e, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSLLW, ALOPF11, ARGS_SSS, EXT, 0x14, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSLLH, ALOPF11, ARGS_SSS, EXT, 0x15, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRLD, ALOPF11, ARGS_SSS, EXT, 0x4c, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRLW, ALOPF11, ARGS_SSS, EXT, 0x10, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRLH, ALOPF11, ARGS_SSS, EXT, 0x11, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRAW, ALOPF11, ARGS_SSS, EXT, 0x12, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRAH, ALOPF11, ARGS_SSS, EXT, 0x13, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PFADDS, ALOPF11, ARGS_SSS, EXT, 0x30, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFADDD, ALOPF11, ARGS_DDD, EXT, 0x31, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFSUBS, ALOPF11, ARGS_SSS, EXT, 0x32, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFSUBD, ALOPF11, ARGS_DDD, EXT, 0x33, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_APTOAP, ALOPF11, ARGS_QSQ, EXT, 0x50, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_APTOAPB, ALOPF11, ARGS_QSQ, EXT, 0x51, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_GETVA, ALOPF11, ARGS_QSD, EXT, 0x52, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PANDD, ALOPF11, ARGS_DDD, EXT, 0x48, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PANDND, ALOPF11, ARGS_DDD, EXT, 0x49, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PORD, ALOPF11, ARGS_DDD, EXT, 0x4a, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PXORD, ALOPF11, ARGS_DDD, EXT, 0x4b, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_LDRD, ALOPF11, ARGS_DDD, EXT, 0x5b, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_PUTTC, ALOPF11, ARGS_DDD, EXT, 0x25, 1, -1, CHAN_0, { -1 }, 0xc0, 0 }, + { OP_PAVGUSB, ALOPF11, ARGS_DDD, EXT, 0x1e, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PAVGUSH, ALOPF11, ARGS_DDD, EXT, 0x1f, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PFDIVS, ALOPF11, ARGS_SSS, EXT, 0x4a, 1, -1, CHAN_5, { -1 }, 0xc0, 0 }, + { OP_PFDIVD, ALOPF11, ARGS_DDD, EXT, 0x4b, 1, -1, CHAN_5, { -1 }, 0xc0, 0 }, + { OP_PFMINS, ALOPF11, ARGS_DDD, EXT, 0x34, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFMIND, ALOPF11, ARGS_DDD, EXT, 0x35, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFMAXS, ALOPF11, ARGS_DDD, EXT, 0x36, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFMAXD, ALOPF11, ARGS_DDD, EXT, 0x37, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFSQRTTD, ALOPF11, ARGS_DDD, EXT, 0x53, 1, -1, CHAN_5, { -1 }, 0xc0, 0 }, + { OP_PEXTRH, ALOPF11_LIT8, ARGS_DDS, EXT, 0x1e, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PINSH, ALOPF11_LIT8, ARGS_DDD, EXT, 0x1f, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSLLQH, ALOPF11_LIT8, ARGS_DDD, EXT, 0x0e, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSLLQL, ALOPF11_LIT8, ARGS_DDD, EXT, 0x0f, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRLQH, ALOPF11_LIT8, ARGS_DDD, EXT, 0x0c, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSRLQL, ALOPF11_LIT8, ARGS_DDD, EXT, 0x0d, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_CAST, ALOPF11, ARGS_QQQ, EXT, 0x55, 1, 1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_TDTOMP, ALOPF11, ARGS_DDD, EXT, 0x53, 1, 1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_ODTOAP, ALOPF11, ARGS_QDQ, EXT, 0x54, 1, 1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PUTTAGS, ALOPF11, ARGS_SSS, EXT, 0x0a, 1, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PUTTAGD, ALOPF11, ARGS_DSD, EXT, 0x0b, 1, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FCMPEQS, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_FCMPLTS, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc1, 0 }, + { OP_FCMPLES, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc2, 0 }, + { OP_FCMPUODS, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_FCMPNEQS, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc4, 0 }, + { OP_FCMPNLTS, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc5, 0 }, + { OP_FCMPNLES, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc6, 0 }, + { OP_FCMPODS, ALOPF11, ARGS_SSS, EXT, 0x2c, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FCMPEQD, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_FCMPLTD, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc1, 0 }, + { OP_FCMPLED, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc2, 0 }, + { OP_FCMPUODD, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_FCMPNEQD, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc4, 0 }, + { OP_FCMPNLTD, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc5, 0 }, + { OP_FCMPNLED, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc6, 0 }, + { OP_FCMPODD, ALOPF11, ARGS_DDD, EXT, 0x2d, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_PFCMPEQS, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFCMPLTS, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc1, 0 }, + { OP_PFCMPLES, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc2, 0 }, + { OP_PFCMPUODS, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_PFCMPNEQS, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc4, 0 }, + { OP_PFCMPNLTS, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc5, 0 }, + { OP_PFCMPNLES, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc6, 0 }, + { OP_PFCMPODS, ALOPF11, ARGS_DDD, EXT, 0x3a, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_PFCMPEQD, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFCMPLTD, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc1, 0 }, + { OP_PFCMPLED, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc2, 0 }, + { OP_PFCMPUODD, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_PFCMPNEQD, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc4, 0 }, + { OP_PFCMPNLTD, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc5, 0 }, + { OP_PFCMPNLED, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc6, 0 }, + { OP_PFCMPODD, ALOPF11, ARGS_DDD, EXT, 0x3b, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FCMPODSF, ALOPF11, ARGS_SSS, EXT, 0x2e, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FCMPUDSF, ALOPF11, ARGS_SSS, EXT, 0x2e, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_FCMPODDF, ALOPF11, ARGS_DDS, EXT, 0x2f, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FCMPUDDF, ALOPF11, ARGS_DDS, EXT, 0x2f, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_FXCMPODSF, ALOPF11, ARGS_XSS, EXT, 0x28, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FXCMPUDSF, ALOPF11, ARGS_XSS, EXT, 0x28, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_FXCMPODDF, ALOPF11, ARGS_XDS, EXT, 0x29, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FXCMPUDDF, ALOPF11, ARGS_XDS, EXT, 0x29, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_FXCMPODXF, ALOPF11, ARGS_XXS, EXT, 0x2b, 1, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_FXCMPUDXF, ALOPF11, ARGS_XXS, EXT, 0x2b, 1, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_PCMPEQB, ALOPF11, ARGS_DDD, EXT, 0x18, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PCMPEQH, ALOPF11, ARGS_DDD, EXT, 0x19, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PCMPEQW, ALOPF11, ARGS_DDD, EXT, 0x1a, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PCMPGTB, ALOPF11, ARGS_DDD, EXT, 0x1b, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PCMPGTH, ALOPF11, ARGS_DDD, EXT, 0x1c, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PCMPGTW, ALOPF11, ARGS_DDD, EXT, 0x1d, 1, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMOVMSKB, ALOPF11, ARGS_DDD, EXT, 0x0b, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMOVMSKPS, ALOPF11, ARGS_DDD, EXT, 0x06, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMOVMSKPD, ALOPF11, ARGS_DDD, EXT, 0x07, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PACKSSHB, ALOPF11, ARGS_DDD, EXT, 0x08, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PACKUSHB, ALOPF11, ARGS_DDD, EXT, 0x09, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PSHUFW, ALOPF11_LIT8, ARGS_DDD, EXT, 0x16, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PACKSSWH, ALOPF11, ARGS_DDD, EXT, 0x0a, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUNPCKHBH, ALOPF11, ARGS_DDD, EXT, 0x00, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUNPCKHHW, ALOPF11, ARGS_DDD, EXT, 0x02, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUNPCKHWD, ALOPF11, ARGS_DDD, EXT, 0x04, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUNPCKLBH, ALOPF11, ARGS_DDD, EXT, 0x01, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUNPCKLHW, ALOPF11, ARGS_DDD, EXT, 0x03, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUNPCKLWD, ALOPF11, ARGS_DDD, EXT, 0x05, 1, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_LDGDB, ALOPF11, ARGS_SSD, EXT, 0x64, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGDH, ALOPF11, ARGS_SSD, EXT, 0x65, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGDW, ALOPF11, ARGS_SSD, EXT, 0x66, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGDD, ALOPF11, ARGS_SSD, EXT, 0x67, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGDQ, ALOPF11, ARGS_SSQ, EXT, 0x79, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCUDB, ALOPF11, ARGS_SSD, EXT, 0x60, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCUDH, ALOPF11, ARGS_SSD, EXT, 0x61, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCUDW, ALOPF11, ARGS_SSD, EXT, 0x62, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCUDD, ALOPF11, ARGS_SSD, EXT, 0x63, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCUDQ, ALOPF11, ARGS_SSQ, EXT, 0x78, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDAPB, ALOPF11, ARGS_QSD, EXT, 0x68, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDAPH, ALOPF11, ARGS_QSD, EXT, 0x69, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDAPW, ALOPF11, ARGS_QSD, EXT, 0x6a, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDAPD, ALOPF11, ARGS_QSD, EXT, 0x6b, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDAPQ, ALOPF11, ARGS_QSQ, EXT, 0x7a, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWB, ALOPF11, ARGS_QSD, EXT, 0x70, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWD, ALOPF11, ARGS_QSD, EXT, 0x73, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWH, ALOPF11, ARGS_QSD, EXT, 0x71, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWQ, ALOPF11, ARGS_QSQ, EXT, 0x7c, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWW, ALOPF11, ARGS_QSD, EXT, 0x72, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPB, ALOPF11, ARGS_QSD, EXT, 0x74, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPD, ALOPF11, ARGS_QSD, EXT, 0x77, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPH, ALOPF11, ARGS_QSD, EXT, 0x75, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPQ, ALOPF11, ARGS_QSQ, EXT, 0x7d, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPW, ALOPF11, ARGS_QSD, EXT, 0x76, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRB, ALOPF11, ARGS_QSD, EXT, 0x6c, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRD, ALOPF11, ARGS_QSD, EXT, 0x6f, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRH, ALOPF11, ARGS_QSD, EXT, 0x6d, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRQ, ALOPF11, ARGS_QSQ, EXT, 0x7b, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRW, ALOPF11, ARGS_QSD, EXT, 0x6e, 1, 1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCSQ, ALOPF11, ARGS_DDQ, EXT, 0x42, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDDSQ, ALOPF11, ARGS_DDQ, EXT, 0x43, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDESQ, ALOPF11, ARGS_SSQ, EXT, 0x44, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDFSQ, ALOPF11, ARGS_DDQ, EXT, 0x45, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGSQ, ALOPF11, ARGS_DDQ, EXT, 0x46, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDSSQ, ALOPF11, ARGS_DDQ, EXT, 0x47, 1, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_FRCPS, ALOPF12, ARGS_SS, EXT, 0x50, 1, -1, CHAN_5, { -1 }, 0xc0, 0xc0 }, + { OP_FSQRTS, ALOPF12, ARGS_SS, EXT, 0x4c, 1, -1, CHAN_5, { -1 }, 0xc0, 0xc0 }, + { OP_FSQRTID, ALOPF12, ARGS_DD, EXT, 0x4d, 1, -1, CHAN_5, { -1 }, 0xc0, 0xc0 }, + { OP_FRSQRTS, ALOPF12, ARGS_SS, EXT, 0x54, 1, -1, CHAN_5, { -1 }, 0xc0, 0xc0 }, + { OP_PFSQRTS, ALOPF12, ARGS_SS, EXT, 0x4e, 1, -1, CHAN_5, { -1 }, 0xc0, 0xc0 }, + { OP_GETTD, ALOPF12, ARGS_DD, EXT, 0x56, 1, 1, CHAN_03, { -1 }, 0xc0, 0xc0 }, + { OP_GETTAGS, ALOPF12, ARGS_SS, EXT, 0x08, 1, -1, CHAN_25, { -1 }, 0xc0, 0xc0 }, + { OP_GETTAGD, ALOPF12, ARGS_DS, EXT, 0x09, 1, -1, CHAN_25, { -1 }, 0xc0, 0xc0 }, + { OP_GETTC, ALOPF12, ARGS_SD, EXT, 0x24, 1, -1, CHAN_0, { -1 }, 0xc0, 0xc0 }, + { OP_INVTC, ALOPF12, ARGS_SD, EXT, 0x26, 1, -1, CHAN_0, { -1 }, 0xc0, 0xc0 }, + { OP_GETSOD, ALOPF12, ARGS_QQ, EXT, 0x5a, 1, 1, CHAN_0134, { -1 }, 0xec, 0xc0 }, + { OP_GETSP, ALOPF12, ARGS_SD, EXT, 0x58, 1, -1, CHAN_0, { -1 }, 0xec, 0xc0 }, + { OP_PSHUFH, ALOPF12_PSHUFH, ARGS_DD, EXT, 0x17, 1, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_STCSQ, ALOPF13, ARGS_SSQ, EXT, 0x02, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STDSQ, ALOPF13, ARGS_SSQ, EXT, 0x03, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STESQ, ALOPF13, ARGS_SSQ, EXT, 0x04, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STFSQ, ALOPF13, ARGS_SSQ, EXT, 0x05, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGSQ, ALOPF13, ARGS_SSQ, EXT, 0x06, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STSSQ, ALOPF13, ARGS_SSQ, EXT, 0x07, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STRD, ALOPF13, ARGS_DDD, EXT, 0x1b, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDB, ALOPF13, ARGS_SSS, EXT, 0x24, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDH, ALOPF13, ARGS_SSS, EXT, 0x25, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDW, ALOPF13, ARGS_SSS, EXT, 0x26, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDD, ALOPF13, ARGS_SSD, EXT, 0x27, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDQ, ALOPF13, ARGS_SSQ, EXT, 0x39, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPB, ALOPF13, ARGS_QSS, EXT, 0x28, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPH, ALOPF13, ARGS_QSS, EXT, 0x29, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPW, ALOPF13, ARGS_QSS, EXT, 0x2a, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPD, ALOPF13, ARGS_QSD, EXT, 0x2b, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPQ, ALOPF13, ARGS_QSQ, EXT, 0x3a, 1, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPB, ALOPF13, ARGS_QSS, EXT, 0x34, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPD, ALOPF13, ARGS_QSD, EXT, 0x37, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPH, ALOPF13, ARGS_QSS, EXT, 0x35, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPQ, ALOPF13, ARGS_QSQ, EXT, 0x3d, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPW, ALOPF13, ARGS_QSS, EXT, 0x36, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRB, ALOPF13, ARGS_QSS, EXT, 0x2c, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRD, ALOPF13, ARGS_QSD, EXT, 0x2f, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRH, ALOPF13, ARGS_QSS, EXT, 0x2d, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRQ, ALOPF13, ARGS_QSQ, EXT, 0x3b, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRW, ALOPF13, ARGS_QSS, EXT, 0x2e, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWB, ALOPF13, ARGS_QSS, EXT, 0x30, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWD, ALOPF13, ARGS_QSD, EXT, 0x33, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWH, ALOPF13, ARGS_QSS, EXT, 0x31, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWQ, ALOPF13, ARGS_QSQ, EXT, 0x3c, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWW, ALOPF13, ARGS_QSS, EXT, 0x32, 1, 1, CHAN_25, { -1 }, 0xc0 }, + { OP_RWS, ALOPF15, ARGS_S, EXT, 0x3c, 1, -1, CHAN_0, { -1 }, 0xc0 }, + { OP_RWD, ALOPF15, ARGS_D, EXT, 0x3d, 1, -1, CHAN_0, { -1 }, 0xc0 }, + { OP_RRS, ALOPF16, ARGS_S, EXT, 0x3e, 1, -1, CHAN_0, { -1 }, 0xc0 }, + { OP_RRD, ALOPF16, ARGS_D, EXT, 0x3f, 1, -1, CHAN_0, { -1 }, 0xc0 }, + { OP_MOVTQ, ALOPF22, ARGS_QQ, EXT, 0x57, 1, -1, CHAN_0134, { -1 }, 0xc0, 0xc0 }, + { OP_MOVTCQ, ALOPF22, ARGS_QQ, EXT, 0x57, 1, -1, CHAN_0134, { -1 }, 0xc1, 0xc0 }, + { OP_MOVTRQ, ALOPF22, ARGS_QQ, EXT, 0x57, 1, -1, CHAN_0134, { -1 }, 0xc2, 0xc0 }, + { OP_MOVTRCQ, ALOPF22, ARGS_QQ, EXT, 0x57, 1, -1, CHAN_0134, { -1 }, 0xc3, 0xc0 }, + { OP_MOVIF, ALOPF1, ARGS_DSX, SHORT, 0x5e, 2, -1, CHAN_03, { -1 } }, + { OP_MOVFI, ALOPF2, ARGS_XS, SHORT, 0x5c, 2, -1, CHAN_03, { -1 }, 0xc0 }, + { OP_BITREVS, ALOPF2, ARGS_SS, SHORT, 0x26, 2, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_BITREVD, ALOPF2, ARGS_DD, SHORT, 0x27, 2, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_LZCNTS, ALOPF2, ARGS_SS, SHORT, 0x64, 2, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_LZCNTD, ALOPF2, ARGS_DD, SHORT, 0x65, 2, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_POPCNTS, ALOPF2, ARGS_SS, SHORT, 0x66, 2, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_POPCNTD, ALOPF2, ARGS_DD, SHORT, 0x67, 2, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_FSTOIDTR, ALOPF2, ARGS_SD, SHORT, 0x3e, 2, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_FDTOIDTR, ALOPF2, ARGS_DD, SHORT, 0x3d, 2, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_FXTOISTR, ALOPF2, ARGS_XS, SHORT, 0x3f, 2, -1, CHAN_0134, { -1 }, 0xc3 }, + { OP_FXTOIDTR, ALOPF2, ARGS_XD, SHORT, 0x3d, 2, -1, CHAN_0134, { -1 }, 0xc3 }, + { OP_MOVX, ALOPF2, ARGS_DD, SHORT, 0x5f, 2, -1, CHAN_0134, { -1 }, 0xc0 }, + { OP_MOVXA, ALOPF2, ARGS_DD, SHORT, 0x5f, 2, -1, CHAN_0134, { -1 }, 0xc1 }, + { OP_MOVXC, ALOPF2, ARGS_DD, SHORT, 0x5f, 2, -1, CHAN_0134, { -1 }, 0xc2 }, + { OP_PMULUBHH, ALOPF11, ARGS_DDD, EXT, 0x1d, 2, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_CAST, ALOPF11, ARGS_QQQ, EXT, 0x55, 2, 2, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_TDTOMP, ALOPF11, ARGS_DDD, EXT, 0x53, 2, 2, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_ODTOAP, ALOPF11, ARGS_QDQ, EXT, 0x54, 2, 2, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_LDODWB, ALOPF11, ARGS_QSD, EXT, 0x70, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWD, ALOPF11, ARGS_QSD, EXT, 0x73, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWH, ALOPF11, ARGS_QSD, EXT, 0x71, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWQ, ALOPF11, ARGS_QSQ, EXT, 0x7c, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODWW, ALOPF11, ARGS_QSD, EXT, 0x72, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPB, ALOPF11, ARGS_QSD, EXT, 0x74, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPD, ALOPF11, ARGS_QSD, EXT, 0x77, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPH, ALOPF11, ARGS_QSD, EXT, 0x75, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPQ, ALOPF11, ARGS_QSQ, EXT, 0x7d, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODPW, ALOPF11, ARGS_QSD, EXT, 0x76, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRB, ALOPF11, ARGS_QSD, EXT, 0x6c, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRD, ALOPF11, ARGS_QSD, EXT, 0x6f, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRH, ALOPF11, ARGS_QSD, EXT, 0x6d, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRQ, ALOPF11, ARGS_QSQ, EXT, 0x7b, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDODRW, ALOPF11, ARGS_QSD, EXT, 0x6e, 2, 2, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_GETTD, ALOPF12, ARGS_DD, EXT, 0x56, 2, 2, CHAN_03, { -1 }, 0xc0, 0xc0 }, + { OP_GETSOD, ALOPF12, ARGS_QQ, EXT, 0x5a, 2, 2, CHAN_0134, { -1 }, 0xec, 0xc0 }, + { OP_STODPB, ALOPF13, ARGS_QSS, EXT, 0x34, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPD, ALOPF13, ARGS_QSD, EXT, 0x37, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPH, ALOPF13, ARGS_QSS, EXT, 0x35, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPQ, ALOPF13, ARGS_QSQ, EXT, 0x3d, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODPW, ALOPF13, ARGS_QSS, EXT, 0x36, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRB, ALOPF13, ARGS_QSS, EXT, 0x2c, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRD, ALOPF13, ARGS_QSD, EXT, 0x2f, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRH, ALOPF13, ARGS_QSS, EXT, 0x2d, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRQ, ALOPF13, ARGS_QSQ, EXT, 0x3b, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODRW, ALOPF13, ARGS_QSS, EXT, 0x2e, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWB, ALOPF13, ARGS_QSS, EXT, 0x30, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWD, ALOPF13, ARGS_QSD, EXT, 0x33, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWH, ALOPF13, ARGS_QSS, EXT, 0x31, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWQ, ALOPF13, ARGS_QSQ, EXT, 0x3c, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_STODWW, ALOPF13, ARGS_QSS, EXT, 0x32, 2, 2, CHAN_25, { -1 }, 0xc0 }, + { OP_PSLLW, ALOPF11, ARGS_SSS, EXT1, 0x14, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSLLH, ALOPF11, ARGS_SSS, EXT1, 0x15, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSRLW, ALOPF11, ARGS_SSS, EXT1, 0x10, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSRLH, ALOPF11, ARGS_SSS, EXT1, 0x11, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSRAW, ALOPF11, ARGS_SSS, EXT1, 0x12, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSRAH, ALOPF11, ARGS_SSS, EXT1, 0x13, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_FSTOIFS, ALOPF11, ARGS_SSS, EXT, 0x6c, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_FDTOIFD, ALOPF11, ARGS_DDD, EXT, 0x6d, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_UMULHD, ALOPF11, ARGS_DDD, EXT, 0x70, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_SMULHD, ALOPF11, ARGS_DDD, EXT, 0x71, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PMINUW, ALOPF11, ARGS_DDD, EXT1, 0x20, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMINSW, ALOPF11, ARGS_DDD, EXT1, 0x21, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMAXUW, ALOPF11, ARGS_DDD, EXT1, 0x22, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMAXSW, ALOPF11, ARGS_DDD, EXT1, 0x23, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_MPSADBH, ALOPF11, ARGS_DDD, EXT, 0x58, 3, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PACKUSWH, ALOPF11, ARGS_DDD, EXT, 0x6b, 3, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PCMPEQD, ALOPF11, ARGS_DDD, EXT, 0x4d, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PCMPGTD, ALOPF11, ARGS_DDD, EXT, 0x4f, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PFHADDS, ALOPF11, ARGS_DDD, EXT, 0x72, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFHSUBS, ALOPF11, ARGS_DDD, EXT, 0x73, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFADDSUBS, ALOPF11, ARGS_DDD, EXT, 0x77, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PMINSB, ALOPF11, ARGS_DDD, EXT, 0x04, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMINUH, ALOPF11, ARGS_DDD, EXT, 0x05, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMAXSB, ALOPF11, ARGS_DDD, EXT, 0x06, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMAXUH, ALOPF11, ARGS_DDD, EXT, 0x07, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PFSTOIFS, ALOPF11, ARGS_DDD, EXT, 0x6e, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PFDTOIFD, ALOPF11, ARGS_DDD, EXT, 0x6f, 3, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PHADDH, ALOPF11, ARGS_DDD, EXT1, 0x29, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PHADDW, ALOPF11, ARGS_DDD, EXT1, 0x2a, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PHADDSH, ALOPF11, ARGS_DDD, EXT1, 0x2b, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PHSUBH, ALOPF11, ARGS_DDD, EXT1, 0x2d, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PHSUBW, ALOPF11, ARGS_DDD, EXT1, 0x2e, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PHSUBSH, ALOPF11, ARGS_DDD, EXT1, 0x2f, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSIGNB, ALOPF11, ARGS_DDD, EXT1, 0x30, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSIGNH, ALOPF11, ARGS_DDD, EXT1, 0x31, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PSIGNW, ALOPF11, ARGS_DDD, EXT1, 0x32, 3, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_PMADDUBSH, ALOPF11, ARGS_DDD, EXT, 0x68, 3, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PMULHRSH, ALOPF11, ARGS_DDD, EXT, 0x69, 3, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PHMINPOSUH, ALOPF11, ARGS_DDD, EXT, 0x6a, 3, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PUTTST, ALOPF12, ARGS_DD, EXT, 0x25, 3, -1, CHAN_3, { -1 }, 0xc0, 0xc0 }, + { OP_PFMULS, ALOPF11, ARGS_DDD, EXT, 0x38, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PFADDS, ALOPF11, ARGS_SSS, EXT, 0x30, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PFADDD, ALOPF11, ARGS_DDD, EXT, 0x31, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PFSUBS, ALOPF11, ARGS_SSS, EXT, 0x32, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PFSUBD, ALOPF11, ARGS_DDD, EXT, 0x33, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FSCALES, ALOPF11, ARGS_SSS, EXT, 0x24, 4, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_FSCALED, ALOPF11, ARGS_DSD, EXT, 0x25, 4, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_FXSCALESX, ALOPF11, ARGS_XSX, EXT, 0x27, 4, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_PFHADDS, ALOPF11, ARGS_DDD, EXT, 0x72, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PFHSUBS, ALOPF11, ARGS_DDD, EXT, 0x73, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_PFADDSUBS, ALOPF11, ARGS_DDD, EXT, 0x77, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FADDS, ALOPF11, ARGS_SSS, EXT1, 0x30, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FADDD, ALOPF11, ARGS_DDD, EXT1, 0x31, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FSUBS, ALOPF11, ARGS_SSS, EXT1, 0x32, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FSUBD, ALOPF11, ARGS_DDD, EXT1, 0x33, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FMULS, ALOPF11, ARGS_SSS, EXT1, 0x38, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_FMULD, ALOPF11, ARGS_DDD, EXT1, 0x39, 4, -1, CHAN_25, { -1 }, 0xc0, 0 }, + { OP_STAAQP, ALOPF10, ARGS_P, EXT, 0x20, 5, -1, CHAN_25, { -1 } }, + { OP_QPAND, ALOPF11, ARGS_PPP, EXT1, 0x08, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPANDN, ALOPF11, ARGS_PPP, EXT1, 0x09, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPOR, ALOPF11, ARGS_PPP, EXT1, 0x0a, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPXOR, ALOPF11, ARGS_PPP, EXT1, 0x0b, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPADDB, ALOPF11, ARGS_PPP, EXT1, 0x48, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDH, ALOPF11, ARGS_PPP, EXT1, 0x49, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDSB, ALOPF11, ARGS_PPP, EXT1, 0x4a, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDSH, ALOPF11, ARGS_PPP, EXT1, 0x4b, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDUSB, ALOPF11, ARGS_PPP, EXT1, 0x4c, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDUSH, ALOPF11, ARGS_PPP, EXT1, 0x4d, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDW, ALOPF11, ARGS_PPP, EXT1, 0x4e, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPADDD, ALOPF11, ARGS_PPP, EXT1, 0x4f, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBB, ALOPF11, ARGS_PPP, EXT1, 0x50, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBH, ALOPF11, ARGS_PPP, EXT1, 0x51, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBSB, ALOPF11, ARGS_PPP, EXT1, 0x52, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBSH, ALOPF11, ARGS_PPP, EXT1, 0x53, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBUSB, ALOPF11, ARGS_PPP, EXT1, 0x54, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBUSH, ALOPF11, ARGS_PPP, EXT1, 0x55, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBW, ALOPF11, ARGS_PPP, EXT1, 0x56, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSUBD, ALOPF11, ARGS_PPP, EXT1, 0x57, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPFADDS, ALOPF11, ARGS_PPP, EXT1, 0x70, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFADDD, ALOPF11, ARGS_PPP, EXT1, 0x71, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFHADDS, ALOPF11, ARGS_PPP, EXT1, 0x7c, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFHSUBS, ALOPF11, ARGS_PPP, EXT1, 0x7d, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFADDSUBS, ALOPF11, ARGS_PPP, EXT1, 0x7e, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFADDSUBD, ALOPF11, ARGS_PPP, EXT1, 0x7f, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFSTOIFS, ALOPF11, ARGS_DPP, EXT1, 0x6e, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFDTOIFD, ALOPF11, ARGS_DPP, EXT1, 0x6f, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFMINS, ALOPF11, ARGS_PPP, EXT1, 0x74, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFMIND, ALOPF11, ARGS_PPP, EXT1, 0x75, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFMAXS, ALOPF11, ARGS_PPP, EXT1, 0x76, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFMAXD, ALOPF11, ARGS_PPP, EXT1, 0x77, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFMULS, ALOPF11, ARGS_PPP, EXT1, 0x78, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFMULD, ALOPF11, ARGS_PPP, EXT1, 0x79, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFSUBS, ALOPF11, ARGS_PPP, EXT1, 0x72, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPFSUBD, ALOPF11, ARGS_PPP, EXT1, 0x73, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_QPMSK2SGNB, ALOPF11, ARGS_PSP, EXT1, 0x34, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPPACKDL, ALOPF11, ARGS_DDP, EXT1, 0x3d, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSLLH, ALOPF11, ARGS_PDP, EXT1, 0x05, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSLLW, ALOPF11, ARGS_PDP, EXT1, 0x04, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSLLD, ALOPF11, ARGS_PDP, EXT1, 0x07, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSRLH, ALOPF11, ARGS_PDP, EXT1, 0x01, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSRLW, ALOPF11, ARGS_PDP, EXT1, 0x00, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSRLD, ALOPF11, ARGS_PDP, EXT1, 0x06, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSRAH, ALOPF11, ARGS_PDP, EXT1, 0x03, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSRAW, ALOPF11, ARGS_PDP, EXT1, 0x02, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPACKSSHB, ALOPF11, ARGS_PPP, EXT1, 0x48, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPACKSSWH, ALOPF11, ARGS_PPP, EXT1, 0x4a, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPACKUSHB, ALOPF11, ARGS_PPP, EXT1, 0x49, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPACKUSWH, ALOPF11, ARGS_PPP, EXT1, 0x4b, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPAVGUSB, ALOPF11, ARGS_PPP, EXT1, 0x5e, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPAVGUSH, ALOPF11, ARGS_PPP, EXT1, 0x5f, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPEQB, ALOPF11, ARGS_PPP, EXT1, 0x58, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPEQD, ALOPF11, ARGS_PPP, EXT1, 0x18, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPEQH, ALOPF11, ARGS_PPP, EXT1, 0x59, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPEQW, ALOPF11, ARGS_PPP, EXT1, 0x5a, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPGTB, ALOPF11, ARGS_PPP, EXT1, 0x5b, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPGTD, ALOPF11, ARGS_PPP, EXT1, 0x1c, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPGTH, ALOPF11, ARGS_PPP, EXT1, 0x5c, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPCMPGTW, ALOPF11, ARGS_PPP, EXT1, 0x5d, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHADDH, ALOPF11, ARGS_PPP, EXT1, 0x19, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHADDSH, ALOPF11, ARGS_PPP, EXT1, 0x1b, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHADDW, ALOPF11, ARGS_PPP, EXT1, 0x1a, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHSUBH, ALOPF11, ARGS_PPP, EXT1, 0x1d, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHSUBSH, ALOPF11, ARGS_PPP, EXT1, 0x1f, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHSUBW, ALOPF11, ARGS_PPP, EXT1, 0x1e, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMAXSB, ALOPF11, ARGS_PPP, EXT1, 0x46, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMAXSH, ALOPF11, ARGS_PPP, EXT1, 0x43, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMAXSW, ALOPF11, ARGS_PPP, EXT1, 0x0f, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMAXUB, ALOPF11, ARGS_PPP, EXT1, 0x42, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMAXUH, ALOPF11, ARGS_PPP, EXT1, 0x47, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMAXUW, ALOPF11, ARGS_PPP, EXT1, 0x0e, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMINSB, ALOPF11, ARGS_PPP, EXT1, 0x44, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMINSH, ALOPF11, ARGS_PPP, EXT1, 0x41, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMINSW, ALOPF11, ARGS_PPP, EXT1, 0x0d, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMINUB, ALOPF11, ARGS_PPP, EXT1, 0x40, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMINUH, ALOPF11, ARGS_PPP, EXT1, 0x45, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMINUW, ALOPF11, ARGS_PPP, EXT1, 0x0c, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPMULHH, ALOPF11, ARGS_PPP, EXT1, 0x58, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMULHRSH, ALOPF11, ARGS_PPP, EXT1, 0x69, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMULHUH, ALOPF11, ARGS_PPP, EXT1, 0x5b, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMULLH, ALOPF11, ARGS_PPP, EXT1, 0x59, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMULUBHH, ALOPF11, ARGS_DPP, EXT1, 0x5d, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPSIGNB, ALOPF11, ARGS_PPP, EXT1, 0x38, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSIGNH, ALOPF11, ARGS_PPP, EXT1, 0x39, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPSIGNW, ALOPF11, ARGS_PPP, EXT1, 0x3a, 5, -1, CHAN_03, { -1 }, 0xc0, 0 }, + { OP_QPHMINPOSUH, ALOPF11, ARGS_PPD, EXT1, 0x6a, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMADDH, ALOPF11, ARGS_PPP, EXT1, 0x5a, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMADDUBSH, ALOPF11, ARGS_PPP, EXT1, 0x68, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMPSADBH, ALOPF11, ARGS_PSP, EXT1, 0x6b, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPSADBW, ALOPF11, ARGS_PPP, EXT1, 0x5c, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPSRCD, ALOPF11, ARGS_PDP, EXT1, 0x27, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPSRCW, ALOPF11, ARGS_PDP, EXT1, 0x26, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PSRCD, ALOPF11, ARGS_DDD, EXT1, 0x17, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PSRCW, ALOPF11, ARGS_DDD, EXT1, 0x16, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_GETFZS, ALOPF11, ARGS_SSS, EXT, 0x74, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_GETFZD, ALOPF11, ARGS_DDD, EXT, 0x75, 5, -1, CHAN_012345, { -1 }, 0xc0, 0 }, + { OP_PUTTAGQP, ALOPF11, ARGS_PSP, EXT1, 0x6c, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_PMULLW, ALOPF11, ARGS_DDD, EXT, 0x26, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPMULLW, ALOPF11, ARGS_PPP, EXT1, 0x5e, 5, -1, CHAN_14, { -1 }, 0xc0, 0 }, + { OP_QPFCMPEQS, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFCMPLTS, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc1, 0 }, + { OP_QPFCMPLES, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc2, 0 }, + { OP_QPFCMPUODS, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_QPFCMPNEQS, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc4, 0 }, + { OP_QPFCMPNLTS, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc5, 0 }, + { OP_QPFCMPNLES, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc6, 0 }, + { OP_QPFCMPODS, ALOPF11, ARGS_PPP, EXT1, 0x7a, 5, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_QPFCMPEQD, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPFCMPLTD, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc1, 0 }, + { OP_QPFCMPLED, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc2, 0 }, + { OP_QPFCMPUODD, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc3, 0 }, + { OP_QPFCMPNEQD, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc4, 0 }, + { OP_QPFCMPNLTD, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc5, 0 }, + { OP_QPFCMPNLED, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc6, 0 }, + { OP_QPFCMPODD, ALOPF11, ARGS_PPP, EXT1, 0x7b, 5, -1, CHAN_0134, { -1 }, 0xc7, 0 }, + { OP_LDQ, ALOPF11, ARGS_DDQ, EXT, 0x41, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDQP, ALOPF11, ARGS_DDP, EXT1, 0x61, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGDQP, ALOPF11, ARGS_SSP, EXT1, 0x69, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCUDQP, ALOPF11, ARGS_SSP, EXT1, 0x68, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDCSQP, ALOPF11, ARGS_DDP, EXT1, 0x62, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDDSQP, ALOPF11, ARGS_DDP, EXT1, 0x63, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDESQP, ALOPF11, ARGS_SSP, EXT1, 0x64, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDFSQP, ALOPF11, ARGS_DDP, EXT1, 0x65, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDGSQP, ALOPF11, ARGS_DDP, EXT1, 0x66, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDSSQP, ALOPF11, ARGS_DDP, EXT1, 0x67, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDAPQP, ALOPF11, ARGS_QSP, EXT1, 0x6a, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_LDRQP, ALOPF11, ARGS_DDP, EXT1, 0x6b, 5, -1, CHAN_0235, { -1 }, 0xc0, 0 }, + { OP_QPSGN2MSKB, ALOPF12, ARGS_PS, EXT1, 0x3c, 5, -1, CHAN_0134, { -1 }, 0xc0, 0xc0 }, + { OP_QPSWITCHW, ALOPF12, ARGS_PP, EXT1, 0x3e, 5, -1, CHAN_0134, { -1 }, 0xc0, 0xc0 }, + { OP_QPSWITCHD, ALOPF12, ARGS_PP, EXT1, 0x3f, 5, -1, CHAN_0134, { -1 }, 0xc0, 0xc0 }, + { OP_QPFSTOIS, ALOPF12, ARGS_PP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xc8, 0xc0 }, + { OP_QPFSTOISTR, ALOPF12, ARGS_PP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xca, 0xc0 }, + { OP_QPISTOFS, ALOPF12, ARGS_PP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xcc, 0xc0 }, + { OP_QPFSTOID, ALOPF12, ARGS_DP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xd8, 0xc0 }, + { OP_QPFSTOIDTR, ALOPF12, ARGS_DP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xda, 0xc0 }, + { OP_QPISTOFD, ALOPF12, ARGS_DP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xdc, 0xc0 }, + { OP_QPFSTOFD, ALOPF12, ARGS_DP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xde, 0xc0 }, + { OP_QPFDTOIS, ALOPF12, ARGS_PD, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xe8, 0xc0 }, + { OP_QPFDTOISTR, ALOPF12, ARGS_PD, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xea, 0xc0 }, + { OP_QPIDTOFS, ALOPF12, ARGS_PD, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xec, 0xc0 }, + { OP_QPFDTOFS, ALOPF12, ARGS_PD, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xee, 0xc0 }, + { OP_QPFDTOID, ALOPF12, ARGS_PP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xf8, 0xc0 }, + { OP_QPFDTOIDTR, ALOPF12, ARGS_PP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xfa, 0xc0 }, + { OP_QPIDTOFD, ALOPF12, ARGS_PP, EXT1, 0x6d, 5, -1, CHAN_0134, { -1 }, 0xfc, 0xc0 }, + { OP_STQ, ALOPF13, ARGS_DDQ, EXT, 0x01, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDMQP, ALOPF13, ARGS_SSP, EXT, 0x19, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGDQP, ALOPF13, ARGS_SSP, EXT, 0x29, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPQP, ALOPF13, ARGS_QSP, EXT, 0x2a, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STAPMQP, ALOPF13, ARGS_QSP, EXT, 0x1a, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STMQP, ALOPF13, ARGS_DDP, EXT, 0x11, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STQP, ALOPF13, ARGS_DDP, EXT, 0x21, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STCSMQP, ALOPF13, ARGS_DDP, EXT, 0x12, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STCSQP, ALOPF13, ARGS_DDP, EXT, 0x22, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STDSMQP, ALOPF13, ARGS_DDP, EXT, 0x13, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STDSQP, ALOPF13, ARGS_DDP, EXT, 0x23, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STESMQP, ALOPF13, ARGS_SSP, EXT, 0x14, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STESQP, ALOPF13, ARGS_SSP, EXT, 0x24, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STFSMQP, ALOPF13, ARGS_DDP, EXT, 0x15, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STFSQP, ALOPF13, ARGS_DDP, EXT, 0x25, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGSMQP, ALOPF13, ARGS_DDP, EXT, 0x16, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STGSQP, ALOPF13, ARGS_DDP, EXT, 0x26, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STSSMQP, ALOPF13, ARGS_DDP, EXT, 0x17, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STSSQP, ALOPF13, ARGS_DDP, EXT, 0x27, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_STRQP, ALOPF13, ARGS_DDP, EXT, 0x2b, 5, -1, CHAN_25, { -1 }, 0xc0 }, + { OP_ADDCD, ALOPF21, ARGS_DDSD, EXT, 0x60, 5, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_ADDCD_C, ALOPF21, ARGS_DDSD, EXT, 0x61, 5, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_SUBCD, ALOPF21, ARGS_DDSD, EXT, 0x62, 5, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_SUBCD_C, ALOPF21, ARGS_DDSD, EXT, 0x63, 5, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_VFBGV, ALOPF1, ARGS_SSS, SHORT, 0x68, 6, -1, CHAN_14, { -1 } }, + { OP_MKFSW, ALOPF1, ARGS_SSD, SHORT, 0x6a, 6, -1, CHAN_14, { -1 } }, + { OP_MODBGV, ALOPF2, ARGS_SS, SHORT, 0x69, 6, -1, CHAN_14, { -1 }, 0xc0 }, + { OP_PCMPEQBOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc0, 2 }, + { OP_PCMPEQHOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc1, 2 }, + { OP_PCMPEQWOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc2, 2 }, + { OP_PCMPEQDOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc3, 2 }, + { OP_PCMPGTBOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc4, 2 }, + { OP_PCMPGTHOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc5, 2 }, + { OP_PCMPGTWOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc6, 2 }, + { OP_PCMPGTDOP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc7, 2 }, + { OP_PCMPEQBAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc8, 2 }, + { OP_PCMPEQHAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xc9, 2 }, + { OP_PCMPEQWAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xca, 2 }, + { OP_PCMPEQDAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xcb, 2 }, + { OP_PCMPGTBAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xcc, 2 }, + { OP_PCMPGTHAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xcd, 2 }, + { OP_PCMPGTWAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xce, 2 }, + { OP_PCMPGTDAP, ALOPF17, ARGS_DD, EXT1, 0x28, 6, -1, CHAN_03, { -1 }, 0xcf, 2 }, + { OP_QPCMPEQBOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc0, 2 }, + { OP_QPCMPEQHOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc1, 2 }, + { OP_QPCMPEQWOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc2, 2 }, + { OP_QPCMPEQDOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc3, 2 }, + { OP_QPCMPGTBOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc4, 2 }, + { OP_QPCMPGTHOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc5, 2 }, + { OP_QPCMPGTWOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc6, 2 }, + { OP_QPCMPGTDOP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc7, 2 }, + { OP_QPCMPEQBAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc8, 2 }, + { OP_QPCMPEQHAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xc9, 2 }, + { OP_QPCMPEQWAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xca, 2 }, + { OP_QPCMPEQDAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xcb, 2 }, + { OP_QPCMPGTBAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xcc, 2 }, + { OP_QPCMPGTHAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xcd, 2 }, + { OP_QPCMPGTWAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xce, 2 }, + { OP_QPCMPGTDAP, ALOPF17, ARGS_PP, EXT1, 0x2c, 6, -1, CHAN_03, { -1 }, 0xcf, 2 }, + { OP_PMRGP, ALOPF11_MERGE, ARGS_DDD, EXT, 0x40, 6, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_QPMRGP, ALOPF11_MERGE, ARGS_PPP, EXT1, 0x60, 6, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_CLMULH, ALOPF11, ARGS_DDD, EXT2, 0x15, 6, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_CLMULL, ALOPF11, ARGS_DDD, EXT2, 0x14, 6, -1, CHAN_0134, { -1 }, 0xc0, 0 }, + { OP_IBRANCHD, ALOPF12_IBRANCHD, ARGS_DD, EXT, 0x53, 6, -1, CHAN_0, { -1 }, 0xc0, 0xc0 }, + { OP_ICALLD, ALOPF12_ICALLD, ARGS_DD, EXT, 0x54, 6, -1, CHAN_0, { -1 }, 0xc0, 0xc0 }, + { OP_QPCEXT_0X00, ALOPF12, ARGS_DP, EXT1, 0x35, 6, -1, CHAN_0134, { -1 }, 0xc0, 0xc0 }, + { OP_QPCEXT_0X7F, ALOPF12, ARGS_DP, EXT1, 0x35, 6, -1, CHAN_0134, { -1 }, 0xc0, 0xc2 }, + { OP_QPCEXT_0X80, ALOPF12, ARGS_DP, EXT1, 0x35, 6, -1, CHAN_0134, { -1 }, 0xc0, 0xc4 }, + { OP_QPCEXT_0XFF, ALOPF12, ARGS_DP, EXT1, 0x35, 6, -1, CHAN_0134, { -1 }, 0xc0, 0xc6 }, + { OP_FMAS, ALOPF21, ARGS_SSSS, EXT2, 0x00, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FMSS, ALOPF21, ARGS_SSSS, EXT2, 0x02, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FNMAS, ALOPF21, ARGS_SSSS, EXT2, 0x04, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FNMSS, ALOPF21, ARGS_SSSS, EXT2, 0x06, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FMAD, ALOPF21, ARGS_DDDD, EXT2, 0x01, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FMSD, ALOPF21, ARGS_DDDD, EXT2, 0x03, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FNMAD, ALOPF21, ARGS_DDDD, EXT2, 0x05, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_FNMSD, ALOPF21, ARGS_DDDD, EXT2, 0x07, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMAS, ALOPF21, ARGS_PPPP, EXT2, 0x08, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMSS, ALOPF21, ARGS_PPPP, EXT2, 0x0a, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFNMAS, ALOPF21, ARGS_PPPP, EXT2, 0x0c, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFNMSS, ALOPF21, ARGS_PPPP, EXT2, 0x0e, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMAD, ALOPF21, ARGS_PPPP, EXT2, 0x09, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMSD, ALOPF21, ARGS_PPPP, EXT2, 0x0b, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFNMAD, ALOPF21, ARGS_PPPP, EXT2, 0x0d, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFNMSD, ALOPF21, ARGS_PPPP, EXT2, 0x0f, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMASS, ALOPF21, ARGS_PPPP, EXT2, 0x10, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMSAS, ALOPF21, ARGS_PPPP, EXT2, 0x12, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMASD, ALOPF21, ARGS_PPPP, EXT2, 0x11, 6, -1, CHAN_012345, { -1 }, 0xc0 }, + { OP_QPFMSAD, ALOPF21, ARGS_PPPP, EXT2, 0x13, 6, -1, CHAN_012345, { -1 }, 0xc0 }, +};